def test_multi_io_erros(tmpdir):
fdir = tmpdir.mkdir("tmpdir")
multi = pyvista.MultiBlock()
# Check saving with bad extension
bad_ext_name = str(fdir.join('tmp.%s' % 'npy'))
with pytest.raises(Exception):
multi.save(bad_ext_name)
arr = np.random.rand(10, 10)
np.save(bad_ext_name, arr)
# Load non existing file
with pytest.raises(Exception):
_ = pyvista.MultiBlock('foo.vtm')
# Load bad extension
with pytest.raises(IOError):
_ = pyvista.MultiBlock(bad_ext_name)
def test_extract_geometry():
multi = pyvista.MultiBlock()
# Add examples
multi.append(ex.load_ant())
multi.append(ex.load_sphere())
multi.append(ex.load_uniform())
nested = pyvista.MultiBlock()
nested.append(ex.load_airplane())
nested.append(ex.load_globe())
multi.append(nested)
# Now check everything
assert multi.n_blocks == 4
# Now apply the geometry filter to combine a plethora of data blocks
geom = multi.extract_geometry()
assert isinstance(geom, pyvista.PolyData)
def test_combine_filter():
multi = pyvista.MultiBlock()
# Add examples
multi.append(ex.load_ant())
multi.append(ex.load_sphere())
multi.append(ex.load_uniform())
nested = pyvista.MultiBlock()
nested.append(ex.load_airplane())
nested.append(ex.load_globe())
multi.append(nested)
# Now check everything
assert multi.n_blocks == 4
# Now apply the append filter to combine a plethora of data blocks
geom = multi.combine()
assert isinstance(geom, pyvista.UnstructuredGrid)
def test_cell_picking():
with pytest.raises(AttributeError, match="mesh"):
plotter = pyvista.Plotter(off_screen=False)
plotter.enable_cell_picking(mesh=None)
sphere = pyvista.Sphere()
for through in (False, True):
plotter = pyvista.Plotter(window_size=(100, 100), )
plotter.enable_cell_picking(
mesh=sphere,
start=True,
show=True,
callback=lambda: None,
through=through,
)
plotter.add_mesh(sphere)
# simulate the pick
renderer = plotter.renderer
picker = plotter.iren.get_picker()
picker.Pick(50, 50, 0, renderer)
# pick nothing
picker.Pick(0, 0, 0, renderer)
plotter.get_pick_position()
plotter.close()
# multiblock
plotter = pyvista.Plotter()
multi = pyvista.MultiBlock([sphere])
plotter.add_mesh(multi)
plotter.enable_cell_picking()
plotter.close()
def load_well_db():
"""
WELLS = gdc19.load_well_db()
"""
if not os.path.exists(gdc19.get_well_vtm_file()):
return pyvista.MultiBlock()
return pyvista.read(gdc19.get_well_vtm_file())
def visible_pick_call_back(picker, event_id):
x0, y0, x1, y1 = renderer.get_pick_position()
selector = vtk.vtkOpenGLHardwareSelector()
selector.SetFieldAssociation(
vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS)
selector.SetRenderer(renderer)
selector.SetArea(x0, y0, x1, y1)
selection = selector.Select()
picked = pyvista.MultiBlock()
for node in range(selection.GetNumberOfNodes()):
cellids = selection.GetNode(node)
if cellids is None:
# No selection
continue
smesh = cellids.GetProperties().Get(vtk.vtkSelectionNode.PROP(
)).GetMapper().GetInputAsDataSet()
selection_filter = vtk.vtkSelection()
selection_filter.AddNode(cellids)
extract = vtk.vtkExtractSelectedIds()
extract.SetInputData(0, smesh)
extract.SetInputData(1, selection_filter)
extract.Update()
picked.append(pyvista.wrap(extract.GetOutput()))
if len(picked) == 1:
self.picked_cells = picked[0]
else:
self.picked_cells = picked
return end_pick_helper(picker, event_id)
def test_multi_block_init_list():
data = [ex.load_rectilinear(), ex.load_airplane()]
multi = pyvista.MultiBlock(data)
assert isinstance(multi, pyvista.MultiBlock)
assert multi.n_blocks == 2
assert isinstance(multi.GetBlock(0), pyvista.RectilinearGrid)
assert isinstance(multi.GetBlock(1), pyvista.PolyData)
def download_kitchen(split=False):
"""Download structured grid of kitchen with velocity field. Use the
``split`` argument to extract all of the furniture in the kitchen.
"""
mesh = _download_and_read('kitchen.vtk')
if not split:
return mesh
extents = {
'door' : (27, 27, 14, 18, 0, 11),
'window1' : (0, 0, 9, 18, 6, 12),
'window2' : (5, 12, 23, 23, 6, 12),
'klower1' : (17, 17, 0, 11, 0, 6),
'klower2' : (19, 19, 0, 11, 0, 6),
'klower3' : (17, 19, 0, 0, 0, 6),
'klower4' : (17, 19, 11, 11, 0, 6),
'klower5' : (17, 19, 0, 11, 0, 0),
'klower6' : (17, 19, 0, 7, 6, 6),
'klower7' : (17, 19, 9, 11, 6, 6),
'hood1' : (17, 17, 0, 11, 11, 16),
'hood2' : (19, 19, 0, 11, 11, 16),
'hood3' : (17, 19, 0, 0, 11, 16),
'hood4' : (17, 19, 11, 11, 11, 16),
'hood5' : (17, 19, 0, 11, 16, 16),
'cookingPlate' : (17, 19, 7, 9, 6, 6),
'furniture' : (17, 19, 7, 9, 11, 11),
}
kitchen = pyvista.MultiBlock()
for key, extent in extents.items():
alg = vtk.vtkStructuredGridGeometryFilter()
alg.SetInputDataObject(mesh)
alg.SetExtent(extent)
alg.Update()
result = pyvista.filters._get_output(alg)
kitchen[key] = result
return kitchen
def get_coastlines(resolution="110m"):
"""
Modified version of
https://github.com/bjlittle/poc-ngvat/blob/master/poc-3/utils.py
"""
fname = shp.natural_earth(resolution=resolution,
category="physical",
name="coastline")
reader = shp.Reader(fname)
dtype = np.float32
blocks = pv.MultiBlock()
for i, record in enumerate(reader.records()):
for geometry in record.geometry:
xy = np.array(geometry.coords[:], dtype=dtype)
x = xy[:, 0].reshape(-1, 1)
y = xy[:, 1].reshape(-1, 1)
z = np.zeros_like(x)
xyz = np.hstack((x, y, z))
poly = pv.lines_from_points(xyz, close=False)
blocks.append(poly)
return blocks
def test_multi_block_save_lines(tmpdir):
radius = 1
xr = np.random.random(10)
yr = np.random.random(10)
x = radius * np.sin(yr) * np.cos(xr)
y = radius * np.sin(yr) * np.sin(xr)
z = radius * np.cos(yr)
xyz = np.stack((x, y, z), axis=1)
poly = pyvista.lines_from_points(xyz, close=False)
blocks = pyvista.MultiBlock()
for _ in range(2):
blocks.append(poly)
path = tmpdir.mkdir("tmpdir")
line_filename = str(path.join('lines.vtk'))
block_filename = str(path.join('blocks.vtmb'))
poly.save(line_filename)
blocks.save(block_filename)
poly_load = pyvista.read(line_filename)
assert np.allclose(poly_load.points, poly.points)
blocks_load = pyvista.read(block_filename)
assert np.allclose(blocks_load[0].points, blocks[0].points)
def test_volume_rendering():
# Really just making sure no errors are thrown
vol = examples.load_uniform()
vol.plot(off_screen=OFF_SCREEN, volume=True, opacity='linear')
plotter = pyvista.Plotter(off_screen=OFF_SCREEN)
plotter.add_volume(vol, opacity='sigmoid', cmap='jet', n_colors=15)
plotter.show()
# Now test MultiBlock rendering
data = pyvista.MultiBlock(
dict(
a=examples.load_uniform(),
b=examples.load_uniform(),
c=examples.load_uniform(),
d=examples.load_uniform(),
))
data['a'].rename_array('Spatial Point Data', 'a')
data['b'].rename_array('Spatial Point Data', 'b')
data['c'].rename_array('Spatial Point Data', 'c')
data['d'].rename_array('Spatial Point Data', 'd')
data.plot(
off_screen=OFF_SCREEN,
volume=True,
multi_colors=True,
)
# Check that NumPy arrays work
arr = vol["Spatial Point Data"].reshape(vol.dimensions)
pyvista.plot(arr, off_screen=OFF_SCREEN, volume=True, opacity='linear')
def visible_pick_call_back(picker, event_id):
picked = pyvista.MultiBlock()
x0, y0, x1, y1 = renderer_().get_pick_position()
if x0 >= 0: # initial pick position is (-1, -1, -1, -1)
selector = _vtk.vtkOpenGLHardwareSelector()
selector.SetFieldAssociation(_vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS)
selector.SetRenderer(renderer_())
selector.SetArea(x0, y0, x1, y1)
selection = selector.Select()
for node in range(selection.GetNumberOfNodes()):
selection_node = selection.GetNode(node)
if selection_node is None:
# No selection
continue
cids = pyvista.convert_array(selection_node.GetSelectionList())
actor = selection_node.GetProperties().Get(_vtk.vtkSelectionNode.PROP())
if actor.GetProperty().GetRepresentation() != 2: # surface
logging.warning("Display representations other than `surface` will result in incorrect results.")
smesh = actor.GetMapper().GetInputAsDataSet()
smesh = smesh.copy()
smesh["original_cell_ids"] = np.arange(smesh.n_cells)
tri_smesh = smesh.extract_surface().triangulate()
cids_to_get = tri_smesh.extract_cells(cids)["original_cell_ids"]
picked.append(smesh.extract_cells(cids_to_get))
if len(picked) == 1:
self_().picked_cells = picked[0]
else:
self_().picked_cells = picked
return end_pick_helper(picker, event_id)
def correlations(fname, data, label):
blocks = pv.MultiBlock()
points = np.column_stack((data[0], data[1], data[2]))
vectors = ['Correlation', 'Collinearity']
scalars = ['Correlation']
if (label == 'vector-pair'):
datasets = [data[3], data[4]]
pairs = data[5]
elif (label == 'scalar-pair'):
datasets = [data[3]]
pairs = data[4]
elif (label == 'vector'):
datasets = [data[3], data[4]]
elif (label == 'scalar'):
datasets = [data[3]]
form = vectors if label.startswith('vector') else scalars
if label.endswith('pair'):
labels = np.unique(pairs)
for t, array in zip(form, datasets):
for label in labels:
mask = pairs == label
blocks[t + '-' + label] = pv.PolyData(points[mask])
blocks[t + '-' + label].point_arrays[t] = array[mask]
else:
for t, array in zip(form, datasets):
blocks[t] = pv.PolyData(points)
blocks[t].point_data[t] = array
blocks.save(fname, binary=False)
def get_drawing_arrow(
start: Sequence[float] | None = None,
direction: Sequence[float] | None = None,
length: float = 1,
shaft_radius: float = 0.05,
shaft_resolution: int = 20,
tip_length: float = 0.25,
tip_radius: float = 0.1,
tip_resolution: int = 20,
) -> "pv.MultiBlock":
"""Creates PyVista 3D arrow from cone and cylider.
Args:
start: Starting point (Å)
direction: Direction vector (Å)
length: Length (Å)
shaft_radius: Shaft radius (Å)
shaft_resolution: Shaft resolution
tip_length: Tip length (Å)
tip_radius:: Tip radius (Å)
tip_resolution: Tip resoluation
Returns:
arrow: 3D arrow
"""
# Set start and direction
if start is None:
start = [0, 0, 0]
if direction is None:
direction = [1, 0, 0]
start: Array1DFloat = np.array(start)
direction = np.array(direction) / np.linalg.norm(direction)
# Create cylinder
cylinder_length = length - tip_length
cylinder_center = start + length * direction / 2
cyl = pv.Cylinder(
center=cylinder_center,
direction=direction,
radius=shaft_radius,
height=cylinder_length,
resolution=shaft_resolution,
)
# Create cone
cone_center = start + (cylinder_length + tip_length / 2) * direction
cone = get_drawing_cone(
center=cone_center,
direction=direction,
radius=tip_radius,
height=tip_length,
resolution=tip_resolution,
)
# Assemble to arrow
arrow = pv.MultiBlock()
arrow.append(cyl)
arrow.append(cone)
return arrow
def test_multi_slice_index():
multi = pyvista.MultiBlock()
# Add examples
multi.append(ex.load_ant())
multi.append(ex.load_sphere())
multi.append(ex.load_uniform())
multi.append(ex.load_airplane())
multi.append(ex.load_globe())
# Now check everything
sub = multi[0:3]
assert len(sub) == 3
for i in range(3):
assert id(sub[i]) == id(multi[i])
assert sub.get_block_name(i) == multi.get_block_name(i)
sub = multi[0:-1]
assert len(sub) == len(multi) == multi.n_blocks
for i in range(multi.n_blocks):
assert id(sub[i]) == id(multi[i])
assert sub.get_block_name(i) == multi.get_block_name(i)
sub = multi[0:-1:2]
assert len(sub) == 3
for i in range(3):
j = i * 2
assert id(sub[i]) == id(multi[j])
assert sub.get_block_name(i) == multi.get_block_name(j)
def coastline(resolution="110m", radius=1.0, geocentric=True):
fname = shp.natural_earth(resolution=resolution,
category="physical",
name="coastline")
reader = shp.Reader(fname)
dtype = np.float32
blocks = pv.MultiBlock()
for i, record in enumerate(reader.records()):
for geometry in record.geometry:
xy = np.array(geometry.coords[:], dtype=dtype)
if geocentric:
xr = np.radians(xy[:, 0]).reshape(-1, 1)
yr = np.radians(90 - xy[:, 1]).reshape(-1, 1)
x = radius * np.sin(yr) * np.cos(xr)
y = radius * np.sin(yr) * np.sin(xr)
z = radius * np.cos(yr)
else:
# otherwise, geodetic
x = xy[:, 0].reshape(-1, 1)
y = xy[:, 1].reshape(-1, 1)
z = np.zeros_like(x)
xyz = np.hstack((x, y, z))
poly = pv.lines_from_points(xyz, close=False)
blocks.append(poly)
return blocks
def test_multi_block_io(extension, binary, tmpdir):
filename = str(tmpdir.mkdir("tmpdir").join('tmp.%s' % extension))
multi = pyvista.MultiBlock()
# Add examples
multi.append(ex.load_ant())
multi.append(ex.load_sphere())
multi.append(ex.load_uniform())
multi.append(ex.load_airplane())
multi.append(ex.load_globe())
# Now check everything
assert multi.n_blocks == 5
# Save it out
multi.save(filename, binary)
foo = pyvista.MultiBlock(filename)
assert foo.n_blocks == multi.n_blocks
foo = pyvista.read(filename)
assert foo.n_blocks == multi.n_blocks
def test_multi_block_keys():
data = dict()
data['grid'] = ex.load_rectilinear()
data['poly'] = ex.load_airplane()
multi = pyvista.MultiBlock(data)
assert len(multi.keys()) == 2
assert 'grid' in multi.keys()
assert 'poly' in multi.keys()
def test_multi_block_init_vtk():
multi = vtk.vtkMultiBlockDataSet()
multi.SetBlock(0, vtk.vtkRectilinearGrid())
multi.SetBlock(1, vtk.vtkTable())
multi = pyvista.MultiBlock(multi)
assert isinstance(multi, pyvista.MultiBlock)
assert multi.n_blocks == 2
assert isinstance(multi[0], pyvista.RectilinearGrid)
assert isinstance(multi[1], vtk.vtkTable)
multi = vtk.vtkMultiBlockDataSet()
multi.SetBlock(0, vtk.vtkRectilinearGrid())
multi.SetBlock(1, vtk.vtkTable())
multi = pyvista.MultiBlock(multi, deep=True)
assert isinstance(multi, pyvista.MultiBlock)
assert multi.n_blocks == 2
assert isinstance(multi[0], pyvista.RectilinearGrid)
assert isinstance(multi[1], vtk.vtkTable)
def test_multi_block_length():
multi = pyvista.MultiBlock()
# Add examples
multi.append(ex.load_ant())
multi.append(ex.load_sphere())
multi.append(ex.load_uniform())
multi.append(ex.load_airplane())
multi.append(None)
assert multi.length
def pv_save(meshes, fp):
''' simple import safe pyvista writer '''
if pv is None: return
if not isinstance(meshes, list):
meshes.save(fp)
elif len(meshes) == 1:
meshes[0].save(fp)
else:
pv.MultiBlock(meshes).save(fp)
def project_to_vtk(project):
"""Converts an OMF project (:class:`omf.base.Project`) to a
:class:`pyvista.MultiBlock` data boject
"""
# Iterate over the elements and add converted VTK objects a MultiBlock
data = pyvista.MultiBlock()
for i, e in enumerate(project.elements):
d = omfvista.wrap(e)
data[i, e.name] = d
return data
def test_multi_block_plot():
multi = pyvista.MultiBlock()
multi.append(examples.load_rectilinear())
uni = examples.load_uniform()
arr = np.random.rand(uni.n_cells)
uni._add_cell_array(arr, 'Random Data')
multi.append(uni)
# And now add a data set without the desired array and a NULL component
multi[3] = examples.load_airplane()
multi.plot(scalars='Random Data', off_screen=OFF_SCREEN, multi_colors=True)
def test_multi_block_repr():
multi = pyvista.MultiBlock()
# Add examples
multi.append(ex.load_ant())
multi.append(ex.load_sphere())
multi.append(ex.load_uniform())
multi.append(ex.load_airplane())
multi.append(None)
# Now check everything
assert multi.n_blocks == 5
assert multi._repr_html_() is not None
def read(self):
"""Read data from PVD timepoint.
Overrides :func:`pyvista.BaseReader.read`.
Returns
-------
pyvista.MultiBlock
"""
return pyvista.MultiBlock(
[reader.read() for reader in self.active_readers])
def download_tetra_dc_mesh():
"""Download two meshes defining an electrical inverse problem. This contains
a high resolution forward modeled mesh and a coarse inverse modeled mesh
"""
local_path, _ = _download_file('dc-inversion.zip')
filename = os.path.join(local_path, 'mesh-forward.vtu')
fwd = pyvista.read(filename)
fwd.set_active_scalar('Resistivity(log10)-fwd')
filename = os.path.join(local_path, 'mesh-inverse.vtu')
inv = pyvista.read(filename)
inv.set_active_scalar('Resistivity(log10)')
return pyvista.MultiBlock({'forward':fwd, 'inverse':inv})
def test_multi_block_init_dict():
data = dict()
data['grid'] = ex.load_rectilinear()
data['poly'] = ex.load_airplane()
multi = pyvista.MultiBlock(data)
assert isinstance(multi, pyvista.MultiBlock)
assert multi.n_blocks == 2
# Note that disctionaries do not maintain order
assert isinstance(multi[0], (pyvista.RectilinearGrid, pyvista.PolyData))
assert multi.get_block_name(0) in ['grid', 'poly']
assert isinstance(multi[1], (pyvista.RectilinearGrid, pyvista.PolyData))
assert multi.get_block_name(1) in ['grid', 'poly']
def test_multi_block_plot():
multi = pyvista.MultiBlock()
multi.append(examples.load_rectilinear())
uni = examples.load_uniform()
arr = np.random.rand(uni.n_cells)
uni.cell_arrays.append(arr, 'Random Data')
multi.append(uni)
# And now add a data set without the desired array and a NULL component
multi[3] = examples.load_airplane()
with pytest.raises(ValueError):
# The scalars are not available in all datasets so raises ValueError
multi.plot(scalars='Random Data', multi_colors=True)
multi.plot(multi_colors=True, before_close_callback=verify_cache_image)
def test_mutli_block_clean():
# now test a clean of the null values
multi = pyvista.MultiBlock()
multi[1, 'rect'] = ex.load_rectilinear()
multi[5, 'uni'] = ex.load_uniform()
# perfromt he clean to remove all Null elements
multi.clean()
assert multi.n_blocks == 2
assert multi.GetNumberOfBlocks() == 2
assert isinstance(multi[0], pyvista.RectilinearGrid)
assert isinstance(multi[1], pyvista.UniformGrid)
assert multi.get_block_name(0) == 'rect'
assert multi.get_block_name(1) == 'uni'
def test_xmlmultiblockreader(tmpdir):
tmpfile = tmpdir.join("temp.vtm")
mesh = pyvista.MultiBlock([pyvista.Sphere() for i in range(5)])
mesh.save(tmpfile.strpath)
reader = pyvista.get_reader(tmpfile.strpath)
assert reader.filename == tmpfile.strpath
new_mesh = reader.read()
assert isinstance(new_mesh, pyvista.MultiBlock)
assert new_mesh.n_blocks == mesh.n_blocks
for i in range(new_mesh.n_blocks):
assert new_mesh[i].n_points == mesh[i].n_points
assert new_mesh[i].n_cells == mesh[i].n_cells
