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)