Composite Datasets

Container to mimic vtkMultiBlockDataSet objects.

These classes hold many VTK datasets in one object that can be passed to VTK algorithms and PyVista filtering/plotting routines.

MultiBlock Datasets

Attributes

bounds	Find min/max for bounds across blocks.
center	Return the center of the bounding box.
length	Return the length of the diagonal of the bounding box.
n_blocks	Return the total number of blocks set.
volume	Return the total volume of all meshes in this dataset.

Methods

append(data)	Add a data set to the next block index.
clean([empty])	Remove any null blocks in place.
copy([deep])	Return a copy of the object.
copy_meta_from(ido)	Copy pyvista meta data onto this object from another object.
get(index)	Get a block by its index or name.
get_block_name(index)	Return the string name of the block at the given index.
get_data_range(name)	Get the min/max of an array given its name across all blocks.
get_index_by_name(name)	Find the index number by block name.
keys()	Get all the block names in the dataset.
next()	Get the next block from the iterator.
plot([off_screen, full_screen, screenshot, …])	Plot a vtk or numpy object.
pop(index)	Pop off a block at the specified index.
set_block_name(index, name)	Set a block’s string name at the specified index.
wrap_nested()	Ensure that all nested data structures are wrapped as PyVista datasets.

class pyvista.MultiBlock(*args, **kwargs)

Bases: vtkmodules.vtkCommonDataModel.vtkMultiBlockDataSet, pyvista.core.filters.CompositeFilters, pyvista.core.dataobject.DataObject

A composite class to hold many data sets which can be iterated over.

This wraps/extends the vtkMultiBlockDataSet class in VTK so that we can easily plot these data sets and use the composite in a Pythonic manner.

You can think of MultiBlock like lists or dictionaries as we can iterate over this data structure by index and we can also access blocks by their string name.

Examples

>>> import pyvista as pv

>>> # Create empty composite dataset
>>> blocks = pv.MultiBlock()
>>> # Add a dataset to the collection
>>> sphere = pv.Sphere()
>>> blocks.append(sphere)
>>> # Or add a named block
>>> blocks["cube"] = pv.Cube()

>>> # instantiate from a list of objects
>>> data = [pv.Sphere(), pv.Cube(), pv.Cone()]
>>> blocks = pv.MultiBlock(data)

>>> # instantiate from a dictionary
>>> data = {"cube": pv.Cube(), "sphere": pv.Sphere()}
>>> blocks = pv.MultiBlock(data)

>>> # now iterate over the collection
>>> for name in blocks.keys():
...     block = blocks[name] # do something!

>>> for block in blocks:
...     surf = block.extract_surface() # Do something with each dataset

append(data: pyvista.core.dataset.DataSet)

Add a data set to the next block index.

property bounds: List[float]

Find min/max for bounds across blocks.

Returns

length 6 tuple of floats containing min/max along each axis

Return type

tuple(float)

property center: Any

Return the center of the bounding box.

clean(empty=True)

Remove any null blocks in place.

Parameters

empty (bool) – Remove any meshes that are empty as well (have zero points).

copy(deep=True)

Return a copy of the object.

Parameters

deep (bool, optional) – When True makes a full copy of the object.

Returns

newobject – Deep or shallow copy of the input.

Return type

same as input

copy_meta_from(ido)

Copy pyvista meta data onto this object from another object.

get(index: Union[int, str]) → Optional[pyvista.core.composite.MultiBlock]

Get a block by its index or name.

If the name is non-unique then returns the first occurrence.

get_block_name(index: int) → Optional[str]

Return the string name of the block at the given index.

get_data_range(name: str) → Tuple[float, float]

Get the min/max of an array given its name across all blocks.

get_index_by_name(name: str) → int

Find the index number by block name.

keys() → List[Optional[str]]

Get all the block names in the dataset.

property length: float

Return the length of the diagonal of the bounding box.

property n_blocks: int

Return the total number of blocks set.

next() → Optional[pyvista.core.composite.MultiBlock]

Get the next block from the iterator.

plot(off_screen=None, full_screen=False, screenshot=None, interactive=True, cpos=None, window_size=None, show_bounds=False, show_axes=None, notebook=None, background=None, text='', return_img=False, eye_dome_lighting=False, volume=False, parallel_projection=False, use_ipyvtk=None, jupyter_backend=None, return_viewer=False, jupyter_kwargs={}, theme=None, **kwargs)

Plot a vtk or numpy object.

Parameters

• item (vtk or numpy object) – VTK object or numpy array to be plotted.

• off_screen (bool) – Plots off screen when True. Helpful for saving screenshots without a window popping up.

• full_screen (bool, optional) – Opens window in full screen. When enabled, ignores window_size. Default False.

• screenshot (str or bool, optional) –

  Saves screenshot to file when enabled. See: help(pyvista.Plotter.screenshot). Default False.

  When True, takes screenshot and returns numpy array of image.

• window_size (list, optional) – Window size in pixels. Defaults to [1024, 768]

• show_bounds (bool, optional) – Shows mesh bounds when True. Default False. Alias show_grid also accepted.

• notebook (bool, optional) – When True, the resulting plot is placed inline a jupyter notebook. Assumes a jupyter console is active.

• show_axes (bool, optional) – Shows a vtk axes widget. If None, enabled according to pyvista.global_theme.axes.show.

• text (str, optional) – Adds text at the bottom of the plot.

• volume (bool, optional) – Use the add_volume method for volume rendering.

• use_ipyvtk (bool, optional) – Deprecated. Instead, set the backend either globally with pyvista.set_jupyter_backend('ipyvtklink') or with backend='ipyvtklink'.

• jupyter_backend (str, optional) –

  Jupyter notebook plotting backend to use. One of the following:

  • 'none' : Do not display in the notebook.

  • 'static' : Display a static figure.

  • 'ipygany' : Show a ipygany widget

  • 'panel' : Show a panel widget.

  This can also be set globally with pyvista.set_jupyter_backend

• jupyter_kwargs (dict, optional) – Keyword arguments for the Jupyter notebook plotting backend.

• theme (pyvista.themes.DefaultTheme, optional) – Plot-specific theme.

• **kwargs (optional keyword arguments) – See help(pyvista.Plotter.add_mesh) for additional options.

Returns

• cpos (list) – List of camera position, focal point, and view up.

• img (numpy.ndarray) – Array containing pixel RGB and optionally 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.

  Returned only when screenshot=True.

Examples

Plot a simple sphere while showing its edges.

>>> import pyvista
>>> mesh = pyvista.Sphere()
>>> mesh.plot(show_edges=True)  

pop(index: Union[int, str]) → Optional[pyvista.core.composite.MultiBlock]

Pop off a block at the specified index.

set_block_name(index: int, name: str)

Set a block’s string name at the specified index.

property volume: float

Return the total volume of all meshes in this dataset.

Returns

volume – Total volume of the mesh.

Return type

float

wrap_nested()

Ensure that all nested data structures are wrapped as PyVista datasets.

This is performed in place.