def main(): args = parse_arguments() input_mesh = pymesh.load_mesh(str(args.input)) if input_mesh.num_voxels == 0: # tetrahedralize the mesh output_mesh = pymesh.tetrahedralize(input_mesh, args.cell_size) else: # mesh is already a tet mesh, just convert to IPC compatible output_mesh = input_mesh # pymesh.save_mesh(str(args.output), output_mesh, ascii=True) with open(args.output, mode='w') as f: f.write("$MeshFormat\n4 0 8\n$EndMeshFormat\n") f.write("$Entities\n0 0 0 1\n") f.write("0 {:g} {:g} {:g} {:g} {:g} {:g} 0 0\n".format( *output_mesh.nodes.min(axis=0), *output_mesh.nodes.max(axis=0))) f.write("$EndEntities\n") f.write("$Nodes\n") f.write("1 {0:d}\n0 3 0 {0:d}\n".format(output_mesh.num_nodes)) for i, node in enumerate(output_mesh.nodes): f.write("{:d} {:g} {:g} {:g}\n".format(i + 1, *node)) f.write("$EndNodes\n") f.write("$Elements\n") f.write("1 {0:d}\n0 3 4 {0:d}\n".format(output_mesh.num_elements)) f.write("\n") for i, element in enumerate(output_mesh.elements): f.write("{:d} {:d} {:d} {:d} {:d}\n".format(i + 1, *(element + 1))) f.write("$EndElements\n") f.write("$Surface\n") f.write("{:d}\n".format(output_mesh.num_faces)) for face in output_mesh.faces: f.write("{:d} {:d} {:d}\n".format(*(face + 1))) f.write("$EndSurface\n")
def main(): args = parse_args() mesh = pymesh.load_mesh(args.in_mesh) tet_mesh = pymesh.tetrahedralize(mesh, args.face_size, args.cell_size, args.engine) pymesh.save_mesh(args.out_mesh, tet_mesh)
def generate_tet_mesh(mesh): bbox_min, bbox_max = mesh.bbox; l = norm(bbox_max - bbox_min) / 20; mesh, t = pymesh.tetrahedralize(mesh, l, # cell size 2.0, # max radius/edge ratio -1, # facet distance 120, # feature angle "tetwild", # engine True); # with timing return mesh;
def main(): args = parse_args() numeric_level = getattr(logging, args.log, None) if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % loglevel) logging.basicConfig(level=numeric_level) mesh = pymesh.load_mesh(args.in_mesh) tet_mesh = pymesh.tetrahedralize(mesh, args.cell_size, args.radius_edge_ratio, args.engine) pymesh.save_mesh(args.out_mesh, tet_mesh)
def generate_tet_mesh(mesh): bbox_min, bbox_max = mesh.bbox l = norm(bbox_max - bbox_min) / 20 mesh, t = pymesh.tetrahedralize( mesh, l, # cell size 2.0, # max radius/edge ratio -1, # facet distance 120, # feature angle "tetwild", # engine True) # with timing return mesh
def draw_mesh(meshname, mesh, refinement): # Generate the tetrahedral 3d mesh for the particle. Note that optimal # refinement can be hard to automatize with tetgen! Previously, quartet was # used, but it has since been broken... tetramesh = pymesh.tetrahedralize(gellip, refinement, engine='tetgen') print('Number of tetras: ' + str(tetramesh.num_elements)) param_r = eps_r * np.ones(tetramesh.voxels.shape[0]) param_i = eps_i * np.ones(tetramesh.voxels.shape[0]) with h5py.File(meshname + ".h5", "w") as f: dset1 = f.create_dataset("coord", tetramesh.vertices.shape, dtype='double') dset1[...] = tetramesh.vertices dset2 = f.create_dataset("etopol", tetramesh.voxels.shape, dtype='int32') dset2[...] = tetramesh.voxels + 1 dset3 = f.create_dataset("param_r", param_r.shape, dtype='double') dset3[...] = param_r dset4 = f.create_dataset("param_i", param_i.shape, dtype='double') dset4[...] = param_i fig = plt.figure(figsize=(6, 6), frameon=False) ax = mplot3d.Axes3D(fig) # Collect face data as vectors for plotting F = boundary_faces(tetramesh.elements) facevectors = np.zeros((F.shape[0], 3, 3)) for i, face in enumerate(F): for j in range(3): facevectors[i][j] = tetramesh.vertices[face[j], :] ax.add_collection3d( mplot3d.art3d.Poly3DCollection(facevectors, facecolor=[0.5, 0.5, 0.5], lw=0.5, edgecolor=[0, 0, 0], alpha=0.66)) scale = tetramesh.vertices.flatten() ax.auto_scale_xyz(scale, scale, scale) plt.setp(ax.get_xticklabels(), visible=False) plt.setp(ax.get_yticklabels(), visible=False) plt.setp(ax.get_zticklabels(), visible=False) plt.savefig(meshname) return tetramesh
def create_calc_mesh(geometry_id, file_format_out="ply"): trimesh, mesh_name = get_trimesh(geometry_id) # trimesh = pymesh.load_mesh(io.BytesIO(r.content)) # Regenerating trimesh for calculation compliance trimesh = fix_mesh(trimesh, detail="normal") # trimesh.add_attribute("vertex_normal") # trimesh.get_attribute("vertex_normal") # trimesh.add_attribute("face_normal") # trimesh.get_attribute("face_normal") cell_size = 10 ## TOOD should be fraction of total mesh size tetmesh = pymesh.tetrahedralize(trimesh, cell_size, with_timing=False) # print("#"*40, dir(tetmesh)) tetmesh.add_attribute("voxels") tetmesh.get_attribute("voxels") # print("#"*40, tetmesh.voxels) # tetmesh.add_attribute("face_normal") # tetmesh.get_attribute("face_normal") tri_filename = f"{int(time.time() * 1000)}_{mesh_name.split('.')[0][14:]}_tri.{file_format_out}" tet_filename = f"{int(time.time() * 1000)}_{mesh_name.split('.')[0][14:]}_tet.{file_format_out}" pymesh.meshio.save_mesh(tri_filename, trimesh, *trimesh.get_attribute_names()) pymesh.meshio.save_mesh(tet_filename, tetmesh, *tetmesh.get_attribute_names(), ascii=True) client = storage.Client.from_service_account_json( "FLINCKSolid-ed5cf9e81eb7.json") bucket = client.get_bucket("flinck-dev") tri_blob = bucket.blob(tri_filename) tet_blob = bucket.blob(tet_filename) # TODO don't create file, but filestream tri_blob.upload_from_filename(filename=tri_filename) tet_blob.upload_from_filename(filename=tet_filename) return tri_filename, tet_filename
def main(): args = parse_args() numeric_level = getattr(logging, args.log, None) if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % loglevel) logging.basicConfig(level=numeric_level) logger = logging.getLogger("tet.py") mesh = pymesh.load_mesh(args.in_mesh) if mesh.vertex_per_face == 4: logger.info("Spliting quad mesh into triangle mesh") mesh = pymesh.quad_to_tri(mesh) tet_mesh, t = pymesh.tetrahedralize(mesh, args.cell_size, args.radius_edge_ratio, args.facet_distance, args.feature_angle, args.engine, with_timing=True) pymesh.save_mesh(args.out_mesh, tet_mesh) logger.info("Running time: {}".format(t))
def main(): args = parse_args(); numeric_level = getattr(logging, args.log, None); if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % loglevel); logging.basicConfig(level=numeric_level); logger = logging.getLogger("tet.py"); mesh = pymesh.load_mesh(args.in_mesh); if mesh.vertex_per_face == 4: logger.info("Spliting quad mesh into triangle mesh"); mesh = pymesh.quad_to_tri(mesh); tet_mesh, t = pymesh.tetrahedralize(mesh, args.cell_size, args.radius_edge_ratio, args.facet_distance, args.feature_angle, args.engine, with_timing=True); pymesh.save_mesh(args.out_mesh, tet_mesh); logger.info("Running time: {}".format(t));
def tetrahedralise(mesh, cell_size): """Tetrahedralise input mesh""" return pymesh.tetrahedralize(mesh, cell_size)
if __name__ == "__main__": meshname, gid, refinement = args(sys.argv[1:]) seed(gid) ellipsoid = genellip() print('genellip() done') # Discrete triangle representation for a sample G-sphere. node = deform_mesh(ellipsoid) print('deform_mesh() done') gellip = pymesh.form_mesh(node, ellipsoid.elements) gellip = fix_mesh(gellip, detail="high") print('fix_mesh() done') # plot_mesh(gellip.vertices, gellip.elements) # Generate the tetrahedral 3d mesh for the particle. Note that optimal # refinement can be hard to automatize with tetgen, so quartet is used! tetramesh = pymesh.tetrahedralize(gellip, refinement, engine='quartet') F2 = boundary_faces(tetramesh.elements) # print('Number of tetras: ' + str(tetramesh.num_elements)) V = get_tetra_vol(tetramesh) gellip_s = pymesh.form_mesh( gellip.vertices * aeff / (3. * V / 4. / np.pi)**(1. / 3.), gellip.elements) write_msh(meshname + "_s.msh", gellip_s) print('Use l_max = ', truncation_order(lmbda, aeff)) draw_mesh(meshname, gellip, refinement) save_h5(meshname, tetramesh) pymesh.save_mesh(meshname + ".mesh", tetramesh)
# Generate initial meshes. rigid_mesh = pymesh.generate_tube( [0., 0., -thickness/2.], [0., 0., thickness/2.], radius_inner_rigid, radius_inner_rigid, radius_outer_rigid, radius_outer_rigid, num_segments=angular_resolution_rigid) growth_mesh = pymesh.generate_tube( [0., 0., -thickness/2.], [0., 0., thickness/2.], radius_inner_growth, radius_inner_growth, radius_outer_growth, radius_outer_growth, num_segments=angular_resolution_growth) # Tessellate the mesh a bit more in order to get smoother deformations rigid_mesh = pymesh.tetrahedralize(rigid_mesh, 1./density, radius_edge_ratio=3., engine='cgal') growth_mesh = pymesh.tetrahedralize(growth_mesh, 1./density, engine='cgal') rigid_points = torch.tensor(rigid_mesh.vertices, dtype=torch.get_default_dtype()) growth_points = torch.tensor(growth_mesh.vertices, dtype=torch.get_default_dtype()) rigid_faces = rigid_mesh.faces growth_faces = growth_mesh.faces print("Rigid points count={count}".format(count=len(rigid_mesh.vertices))) print("Growth points count={count}".format(count=len(growth_mesh.vertices))) ############################################################################### # Plot the disc that will get deformed. #
if __name__ == "__main__": meshname, gid, refinement = args(sys.argv[1:]) seed(gid) ellipsoid = genellip() print('genellip() done') # Discrete triangle representation for a sample G-sphere. node = deform_mesh(ellipsoid) print('deform_mesh() done') gellip = pymesh.form_mesh(node, ellipsoid.elements) gellip = fix_mesh(gellip, detail="low") print('fix_mesh() done') # plot_mesh(gellip.vertices, gellip.elements) # Generate the tetrahedral 3d mesh for the particle. Note that optimal # refinement can be hard to automatize with tetgen! Previously, quartet was # used, but it has since been broken... tetramesh = pymesh.tetrahedralize(gellip, refinement, engine='tetgen') F2 = boundary_faces(tetramesh.elements) # print('Number of tetras: ' + str(tetramesh.num_elements)) V = get_tetra_vol(tetramesh) gellip_s = pymesh.form_mesh( gellip.vertices * aeff / (3. * V / 4. / np.pi)**(1. / 3.), gellip.elements) write_msh(meshname + "_s.msh", gellip_s) print('Use l_max = ', truncation_order(lmbda, aeff)) draw_mesh(meshname, gellip, refinement) save_h5(meshname, tetramesh) pymesh.save_mesh(meshname + ".mesh", tetramesh)