def glyphs(grid_sz=3, **kwargs): """Create several parametric supertoroids using VTK's glyph table functionality.""" n = 10 values = np.arange(n) # values for scalars to look up glyphs by # taken from: rng = np.random.default_rng() params = rng.uniform(0.5, 2, size=(n, 2)) # (n1, n2) parameters for the toroids geoms = [pv.ParametricSuperToroid(n1=n1, n2=n2) for n1, n2 in params] # get dataset where to put glyphs x, y, z = np.mgrid[:grid_sz, :grid_sz, :grid_sz] mesh = pv.StructuredGrid(x, y, z) # add random scalars rng_int = rng.integers(0, n, size=x.size) mesh.point_arrays['scalars'] = rng_int # construct the glyphs on top of the mesh; don't scale by scalars now return mesh.glyph(geom=geoms, indices=values, scale=False, factor=0.3, rng=(0, n - 1))
def test_glyph(): for i, dataset in enumerate(DATASETS): result = dataset.glyph() assert result is not None assert isinstance(result, pyvista.PolyData) # Test different options for glyph filter sphere = pyvista.Sphere(radius=3.14) sphere_sans_arrays = sphere.copy() # make cool swirly pattern vectors = np.vstack((np.sin(sphere.points[:, 0]), np.cos(sphere.points[:, 1]), np.cos(sphere.points[:, 2]))).T # add and scale sphere.vectors = vectors * 0.3 sphere.point_arrays['foo'] = np.random.rand(sphere.n_points) sphere.point_arrays['arr'] = np.ones(sphere.n_points) result = sphere.glyph(scale=False) result = sphere.glyph(scale='arr') result = sphere.glyph(scale='arr', orient='Normals', factor=0.1) result = sphere.glyph(scale='arr', orient='Normals', factor=0.1, tolerance=0.1) result = sphere.glyph(scale='arr', orient='Normals', factor=0.1, tolerance=0.1, clamping=False, rng=[1, 1]) # passing one or more custom glyphs; many cases for full coverage geoms = [ pyvista.Sphere(), pyvista.Arrow(), pyvista.ParametricSuperToroid() ] indices = range(len(geoms)) result = sphere.glyph(geom=geoms[0]) result = sphere.glyph(geom=geoms, indices=indices, rng=(0, len(geoms))) result = sphere.glyph(geom=geoms) result = sphere.glyph(geom=geoms, scale='arr', orient='Normals', factor=0.1, tolerance=0.1) result = sphere.glyph(geom=geoms[:1], indices=[None]) result = sphere_sans_arrays.glyph(geom=geoms) with pytest.raises(TypeError): # wrong type for the glyph sphere.glyph(geom=pyvista.StructuredGrid()) with pytest.raises(TypeError): # wrong type for the indices sphere.glyph(geom=geoms, indices=set(indices)) with pytest.raises(ValueError): # wrong length for the indices sphere.glyph(geom=geoms, indices=indices[:-1])
def supertorus(yScale, xScale, Height, InternalRadius, Vertical, Horizontal, deltaX=0, deltaY=0, deltaZ=0): grid = pv.ParametricSuperToroid(ringradius=xScale, crosssectionradius=InternalRadius, xradius=xScale, yradius=yScale, zradius=Height, n1=Vertical, n2=Horizontal) grid.translate([deltaX + 5, deltaY + 5, deltaZ]) return grid
def glyphs(grid_sz=3): """Create several parametric supertoroids using VTK's glyph table functionality. Parameters ---------- grid_sz : int, optional Create ``grid_sz x grid_sz`` supertoroids. Returns ------- pyvista.PolyData Mesh of supertoroids. See Also -------- plot_glyphs Examples -------- >>> from pyvista import demos >>> mesh = demos.glyphs() >>> mesh.plot() """ n = 10 values = np.arange(n) # values for scalars to look up glyphs by # taken from: rng = np.random.default_rng() params = rng.uniform(0.5, 2, size=(n, 2)) # (n1, n2) parameters for the toroids geoms = [pv.ParametricSuperToroid(n1=n1, n2=n2) for n1, n2 in params] # get dataset where to put glyphs x, y, z = np.mgrid[:grid_sz, :grid_sz, :grid_sz] mesh = pv.StructuredGrid(x, y, z) # add random scalars rng_int = rng.integers(0, n, size=x.size) mesh.point_data['scalars'] = rng_int # construct the glyphs on top of the mesh; don't scale by scalars now return mesh.glyph(geom=geoms, indices=values, scale=False, factor=0.3, rng=(0, n - 1))
def glyphs(grid_sz=3, **kwargs): """Plot several parametric supertoroids using VTK's glyph table functionality.""" n = 10 values = np.arange(n) # values for scalars to look up glyphs by # taken from: rng = np.random.default_rng() params = rng.uniform(0.5, 2, size=(n, 2)) # (n1, n2) parameters for the toroids geoms = [pv.ParametricSuperToroid(n1=n1, n2=n2) for n1, n2 in params] # get dataset where to put glyphs x, y, z = np.mgrid[:grid_sz, :grid_sz, :grid_sz] mesh = pv.StructuredGrid(x, y, z) # add random scalars rng_int = rng.integers(0, n, size=x.size) mesh.point_arrays['scalars'] = rng_int # construct the glyphs on top of the mesh; don't scale by scalars now glyphs = mesh.glyph(geom=geoms, indices=values, scale=False, factor=0.3, rng=(0, n - 1)) # create plotter and add our glyphs with some nontrivial lighting plotter = pv.Plotter() plotter.add_mesh(glyphs, specular=1, specular_power=15, smooth_shading=True, show_scalar_bar=False, **kwargs) plotter.show()
# the table, and it has to be the same length as ``geom`` if specified. If it is # absent a default value of ``range(len(geom))`` is assumed. # get dataset for the glyphs: supertoroids in xy plane # use N random kinds of toroids over a mesh with 27 points N = 5 values = np.arange(N) # values for scalars to look up glyphs by # taken from: # rng = np.random.default_rng() # params = rng.uniform(0.5, 2, size=(N, 2)) # (n1, n2) parameters for the toroids params = np.array([[1.56821334, 0.99649769], [1.08247844, 1.83758874], [1.49598881, 0.83495047], [1.52442129, 0.89600688], [1.92212387, 0.78096621]]) geoms = [pv.ParametricSuperToroid(n1=n1, n2=n2) for n1, n2 in params] # get dataset where to put glyphs x, y, z = np.mgrid[:3, :3, :3] mesh = pv.StructuredGrid(x, y, z) # add random scalars # rng_int = rng.integers(0, N, size=x.size) rng_int = np.array([ 4, 1, 2, 0, 4, 0, 1, 4, 3, 1, 1, 3, 3, 4, 3, 4, 4, 3, 3, 2, 2, 1, 1, 1, 2, 0, 3 ]) mesh.point_data['scalars'] = rng_int # construct the glyphs on top of the mesh; don't scale by scalars now glyphs = mesh.glyph(geom=geoms,
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Creating parametric objects """ # sphinx_gallery_thumbnail_number = 12 import pyvista as pv from math import pi ############################################################################### # This example demonstrates how to plot parametric objects using pyvista # # Supertoroid # +++++++++++ supertoroid = pv.ParametricSuperToroid(n1=0.5) supertoroid.plot(color='tan', smooth_shading=True) ################################################################################ # Parametric Ellipsoid # ++++++++++++++++++++ # Ellipsoid with a long x axis ellipsoid = pv.ParametricEllipsoid(10, 5, 5) ellipsoid.plot(color='tan') ################################################################################ # Partial Parametric Ellipsoid # ++++++++++++++++++++++++++++ # cool plotting direction
def test_ParametricSuperToroid(): geom = pyvista.ParametricSuperToroid() assert geom.n_points
~~~~~~~~~~~~ Tetrahedralize a super toroid surface. """ # sphinx_gallery_thumbnail_number = 2 import pyvista as pv import tetgen import numpy as np ############################################################################### # Create and tetrahedralize a super torid. # # We merge the points here to make sure that the surface is manifold. toroid = pv.ParametricSuperToroid(u_res=50, v_res=50, w_res=50).clean(tolerance=1E-9) tet = tetgen.TetGen(toroid) tet.tetrahedralize(order=1, mindihedral=20, minratio=1.5) grid = tet.grid grid.plot() ############################################################################### # Plot the tesselated mesh. # get cell centroids cells = grid.cells.reshape(-1, 5)[:, 1:] cell_center = grid.points[cells].mean(1) # extract cells below the 0 xy plane mask = cell_center[:, 2] < 0 cell_ind = mask.nonzero()[0]
""" Super Toroid ~~~~~~~~~~~~ Tetrahedralize a super toroid surface """ # sphinx_gallery_thumbnail_number = 2 import pyvista as pv import tetgen import numpy as np ############################################################################### toroid = pv.ParametricSuperToroid() tet = tetgen.TetGen(toroid) tet.tetrahedralize(order=1, mindihedral=20, minratio=1.5) grid = tet.grid grid.plot() ############################################################################### # get cell centroids cells = grid.cells.reshape(-1, 5)[:, 1:] cell_center = grid.points[cells].mean(1) # extract cells below the 0 xy plane mask = cell_center[:, 2] < 0 cell_ind = mask.nonzero()[0] subgrid = grid.extract_cells(cell_ind) # advanced plotting plotter = pv.Plotter()
# ringradius (double, optional) – The radius from the center to the middle of # the ring of the supertoroid. Default is 1. # crosssectionradius (double, optional) – The radius of the cross section of # ring of the supertoroid. Default = 0.5. # xradius (double, optional) – The scaling factor for the x-axis. Default is 1. # yradius (double, optional) – The scaling factor for the y-axis. Default is 1. # zradius (double, optional) – The scaling factor for the z-axis. Default is 1. # n1 (double, optional) – The shape of the torus ring. Default is 1. # n2 (double, optional) – The shape of the cross section of the ring. # Default is 1. import pyvista as pv # create supertorus #1 supertoroid = pv.ParametricSuperToroid(ringradius=1, crosssectionradius=0.5, xradius=1, yradius=1, zradius=3, n1=1, n2=1) # create supertorus #2 and translate it to another position # Note: to keep the heights OK, crosssectionradius*zradius should be the same supertoroid2 = pv.ParametricSuperToroid(ringradius=1, crosssectionradius=0.1, xradius=1, yradius=1, zradius=15, n1=1, n2=1) supertoroid2.translate([0, 0, 3]) # create plotting objects plotter = pv.Plotter() plotter.add_mesh(supertoroid, 'r') plotter.add_mesh(supertoroid2, 'b') # show plotted objects
import numpy as np import pyvista as pv # get dataset for the glyphs: supertoroid in xy plane saucer = pv.ParametricSuperToroid(ringradius=1, n2=1, zradius=1) saucer.rotate_y(90) # saucer.plot() # <-- check how a single saucer looks like # get dataset where to put glyphs x,y,z = np.mgrid[-10:10, -10:10, :1] mesh = pv.StructuredGrid(x, y, z) # construct the glyphs on top of the mesh glyphs = mesh.glyph(geom=saucer, factor=0.3) # glyphs.plot() # <-- simplest way to plot it # create Plotter and add our glyphs with some nontrivial lighting plotter = pv.Plotter(window_size=(1000, 800)) plotter.add_mesh(glyphs, color=[0.5, 0.2, 0.2], specular=1, specular_power=15) plotter.show()