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