def test_icosa_sphere(n=16): points, cells = meshzoo.icosa_sphere(n) # import meshio # meshio.write_points_cells("out.vtk", points, {"triangle": cells}) assert len(points) == 2562 assert _near_equal(numpy.sum(points, axis=0), [0.0, 0.0, 0.0]) assert len(cells) == 5120
def generate_triangular_mesh(): if pathlib.Path.is_file("sphere.xdmf"): mesh = meshio.read("sphere.xdmf") else: points, cells = meshzoo.icosa_sphere(300) mesh = meshio.Mesh(points, {"triangle": cells}) mesh.write("sphere.xdmf") return mesh
def test_icosa_sphere(n=16): points, cells = meshzoo.icosa_sphere(n) # import meshio # meshio.write_points_cells("out.vtk", points, {"triangle": cells}) assert len(points) == 2562 assert _near_equal(numpy.sum(points, axis=0), [0.0, 0.0, 0.0]) assert len(cells) == 5120 assert (_compute_cells_normals_dir(points, cells) > 0.0).all() assert numpy.all( numpy.abs(numpy.einsum("ij,ij->i", points, points) - 1.0) < 1.0e-10)
def test_sphere(): points, cells = meshzoo.icosa_sphere(5) mesh = meshplex.Mesh(points, cells) run( mesh, 12.413437988936916, [0.7864027242108207, 0.05524648209283611], [128.70115197256447, 0.3605511489598192], [0.5593675314375034, 0.02963260270642986], )
def test_euler_characteristic(): points = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]] cells = [[0, 1, 2]] mesh = meshplex.MeshTri(points, cells) assert mesh.euler_characteristic == 1 assert mesh.genus == 0 points, cells = meshzoo.icosa_sphere(5) mesh = meshplex.MeshTri(points, cells) assert mesh.euler_characteristic == 2 assert mesh.genus == 0 points, cells = meshzoo.moebius(num_twists=1, nl=21, nw=6) mesh = meshplex.MeshTri(points, cells) assert mesh.euler_characteristic == 0 with pytest.raises(RuntimeError): mesh.genus
def get_regular_points(self, npoints=None, device="gpu0"): """ Get regular points on a Sphere Return Tensor of Size [x, 3] """ if not self.npoints == npoints: import meshzoo verts, faces = meshzoo.icosa_sphere(4) self.mesh = ms.Mesh( verts, faces ) #psymesh.generate_icosphere(1, [0, 0, 0], 4) # 2562 vertices # print('t') # print(self.mesh.vertices ) self.vertex = torch.from_numpy( self.mesh.vertices).to(device).float() self.num_vertex = self.vertex.size(0) self.vertex = self.vertex.transpose(0, 1).contiguous().unsqueeze(0) self.npoints = npoints return Variable(self.vertex.to(device))
def write_tree(filename, n, scaling, res=20, colors_enhancement=2.5): import cplot import meshio import meshzoo points, cells = meshzoo.icosa_sphere(res) evaluator = EvalCartesian(points.T, scaling, complex_valued=True) meshes = [] for L, level in enumerate(itertools.islice(evaluator, n)): for k, vals in enumerate(level): srgb1_vals = cplot.get_srgb1(vals, colorspace="cam16") # exaggerate colors a bit srgb1_vals *= colors_enhancement srgb1_vals[srgb1_vals > 1] = 1 srgb1_vals[srgb1_vals < 0] = 0 pts = points.copy() pts[:, 0] += 2.2 * (k - L) pts[:, 2] -= 2.7 * L meshes.append( meshio.Mesh(pts, {"triangle": cells}, point_data={"srgb1": srgb1_vals}) ) # merge meshes points = numpy.concatenate([mesh.points for mesh in meshes]) srgb1_vals = numpy.concatenate([mesh.point_data["srgb1"] for mesh in meshes]) # cells = [] k = 0 for mesh in meshes: cells.append(mesh.cells[0].data + k) k += mesh.points.shape[0] cells = numpy.concatenate(cells) meshio.write_points_cells( filename, points, {"triangle": cells}, point_data={"srgb1": srgb1_vals} )
def write_single(filename, n, r, scaling, res=20, colors_enhancement=2.5): """This function creates a sphere mesh with "srgb1" values. Can be views in ParaView by disabling "Map Scalars". """ import cplot import meshio import meshzoo points, cells = meshzoo.icosa_sphere(res) evaluator = EvalCartesian(points.T, scaling, complex_valued=True) vals = next(itertools.islice(evaluator, n, None))[r] srgb1_vals = cplot.get_srgb1(vals, colorspace="cam16") # exaggerate colors a bit srgb1_vals *= colors_enhancement srgb1_vals[srgb1_vals > 1] = 1 srgb1_vals[srgb1_vals < 0] = 0 meshio.write_points_cells( filename, points, {"triangle": cells}, point_data={"srgb1": srgb1_vals} )
self.x_pred_tf: xyz[:, 0:1], self.y_pred_tf: xyz[:, 1:2], self.z_pred_tf: xyz[:, 2:3] } u = self.sess.run(self.u_pred, tf_dict) return u if __name__ == "__main__": # Domain bounds r = 1. xa, xb, ya, yb, za, zb = -r, r, -r, r, -r, r lb = np.array([xa, ya, za]) ub = np.array([xb, yb, zb]) # geometry P, T = meshzoo.icosa_sphere(40) # plot_mesh_3D(P, T) # adjacency matrix amat = adjacency_mat(T) # degree of polynomials to train the finite difference operator deg_hard = [0, 1] # hard constraints deg_soft = [2] # soft constraints w_A_hard = 20 w_A_soft = 1 layers = [3, 100, 100, 100, 1] x_var, y_var, z_var = sp.symbols('x, y, z') u_exa = lambda x, y, z: x * np.sin(y) + z rhs_exa = lambda x, y, z: -(3 * z + 4 * x * y * np.cos(y) + x * (4 - y**2) * np.sin(y))
Spheres ======= Display two spheres with Surface layers """ try: from meshzoo import icosa_sphere except ModuleNotFoundError as e: raise ModuleNotFoundError( "This example uses a meshzoo but meshzoo is not installed. " "To install try 'pip install meshzoo'." ) from e import napari vert, faces = icosa_sphere(10) vert *= 100 sphere1 = (vert + 30, faces) sphere2 = (vert - 30, faces) viewer = napari.Viewer(ndisplay=3) surface1 = viewer.add_surface(sphere1) surface2 = viewer.add_surface(sphere2) viewer.reset_view() if __name__ == '__main__': napari.run()
labels_layer = viewer.add_labels( labeled, name='labels', blending='translucent', experimental_clipping_planes=[plane_parameters], ) # POINTS points_layer = viewer.add_points( np.random.rand(20, 3) * 64, size=5, experimental_clipping_planes=[plane_parameters], ) # SPHERE sphere_vert, sphere_faces = icosa_sphere(10) sphere_vert *= 20 sphere_vert += 32 surface_layer = viewer.add_surface( (sphere_vert, sphere_faces), experimental_clipping_planes=[plane_parameters], ) # SHAPES shapes_data = np.random.rand(3, 4, 3) * 64 shapes_layer = viewer.add_shapes( shapes_data, face_color=['magenta', 'green', 'blue'], experimental_clipping_planes=[plane_parameters], )
approximate 1. It appears that this holds on average, but not for all test vectors. ''' import matplotlib.pyplot as plt import meshzoo import numpy as np import flux.compressed_form_factors as cff from flux.shape import TrimeshShapeModel tol = 1e-2 V, F = meshzoo.icosa_sphere(15) # stretch out the sphere V[:, 0] *= 3 V[:, 1] *= 2 V[:, 2] *= 1 shape_model = TrimeshShapeModel(V, F) # make surface normals inward facing outward = (shape_model.P*shape_model.N).sum(1) > 0 shape_model.N[outward] *= -1 FF = cff.CompressedFormFactorMatrix(shape_model, tol=1e-2, max_rank=30, min_size=400, max_depth=1, RootBlock=cff.FormFactorOctreeBlock)
def sphere(h): # edge length of regular icosahedron with radius 1 l = 1 / numpy.sin(0.4 * numpy.pi) n = int(l / h) return meshzoo.icosa_sphere(n)
def create_sphere(n_subdivide=3): # 3 makes 642 verts, 1280 faces, # 4 makes 2562 verts, 5120 faces verts, faces = meshzoo.icosa_sphere(2**n_subdivide) return verts, faces
def generate_unity_sphere(n): xyz, v = meshzoo.icosa_sphere(n) return {'points': xyz, 'vertices': v}, xyz.shape[0]