def test_vtk_tetrahedralize():
sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
tet = tetgen.TetGen(sphere)
tet.tetrahedralize(order=1, mindihedral=20, minratio=1.5)
grid = tet.grid
assert grid.n_cells
assert grid.n_points
def test_tetrahedralize_swithces():
sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
tet = tetgen.TetGen(sphere)
tet.tetrahedralize(switches="pq1.1/10YQ")
grid = tet.grid
assert grid.n_cells
assert grid.n_points
def test_numpy_tetrahedralize(tmpdir):
v = np.array([
[0, 0, 0],
[1, 0, 0],
[1, 1, 0],
[0, 1, 0],
[0, 0, 1],
[1, 0, 1],
[1, 1, 1],
[0, 1, 1],
])
f = np.vstack([[0, 1, 2], [2, 3, 0], [0, 1, 5], [5, 4, 0], [1, 2, 6],
[6, 5, 1], [2, 3, 7], [7, 6, 2], [3, 0, 4], [4, 7, 3],
[4, 5, 6], [6, 7, 4]])
tgen = tetgen.TetGen(v, f)
nodes, elems = tgen.tetrahedralize()
assert np.any(nodes)
assert np.any(elems)
# test save as well
filename = str(tmpdir.mkdir("tmpdir").join("test_mesh.vtk"))
tgen.write(filename)
def test_pv_box():
box = pv.Box((-1.0, 1.0, -5.0, 5.0, -1.0, 1.0))
#box = examples.load_hexbeam()
tet = tetgen.TetGen(box.triangulate())
tet.tetrahedralize(order=1, mindihedral=20, minratio=2.0)
print("tet: ", tet.mesh.points)
grid = tet.grid
verts = grid.points
print("Cells: \n", grid.cells)
print("Points: \n", verts)
cell_arr = extract_tets(grid.cells)
print(cell_arr)
constraints = [[1, [1, 1, 1]], [3, [1, 1, 1]], [4, [1, 1, 1]],
[6, [1, 1, 1]]]
loads = [[0, 10., 0.0, 0], [2, 10., 0.0, 0], [5, 10., 0.0, 0],
[7, 10., 0.0, 0]]
poisson = 0.3
youngs = 2000
displacements = solve_full(cell_arr, verts, poisson, youngs, constraints,
loads)
print(pd.DataFrame(displacements))
magnitudes = get_displacement_magnitudes(displacements)
display_tets(verts, cell_arr, magnitudes)
def filter(self):
# TODO: check if watertight
# TODO: replace with CGAL to avoid AGPL
tetrahedralizer = tetgen.TetGen(self.mesh.pyvista.extract_surface())
tetrahedralizer.make_manifold()
tetrahedralizer.tetrahedralize(**self.kwargs)
return self.mesh.mesh_class(offset=1)(tetrahedralizer.grid,
parents=[self.mesh])
def test_nested_spheres():
spherebig = pv.Sphere(1, (0, 0, 0))
spheresmall = pv.Sphere(0.5, (0, 0, 0))
allspheres = spherebig.boolean_add(spheresmall)
v = allspheres.points
f = allspheres.faces.reshape(-1, 4)[:, 1:]
tet = tetgen.TetGen(v, f)
nodes, elems, elemattrs = tet.tetrahedralize(regionattrib=1)
return nodes, elems, elemattrs
def test_tetrahedralize():
sphere = vtki.PolyData(examples.spherefile)
tet = tetgen.TetGen(sphere)
tet.Tetrahedralize(order=1, mindihedral=20, minratio=1.5)
grid = tet.grid
assert grid.GetNumberOfCells()
assert grid.GetNumberOfPoints()
assert np.all(grid.quality > 0)
return grid
def generate_dual_tetrahedrons(mesh, internal_mesh):
# Meshes are of trimesh type
diff = trimesh.boolean.difference((mesh, internal_mesh))
new_verts = diff.vertices
new_faces = diff.faces
tet = tetgen.TetGen(new_verts, new_faces)
tet.tetrahedralize(order=1)
grid = tet.grid
tets = simplefem.extract_tets(grid.cells)
verts = grid.points
#new_tets = remove_tets_internal(internal_mesh, tets, verts)
new_tets = remove_tets_convex(internal_mesh, tets, verts)
verts = np.array(verts)
new_tets = np.array(new_tets)
#simplefem.display_tets(verts, new_tets)
return verts, new_tets
def test_numpy_tetrahedralize():
v = np.array([[0, 0, 0], [1, 0, 0],
[1, 1, 0], [0, 1, 0],
[0, 0, 1], [1, 0, 1],
[1, 1, 1], [0, 1, 1],])
f = np.vstack([[0, 1, 2], [2, 3, 0],
[0, 1, 5], [5, 4, 0],
[1, 2, 6], [6, 5, 1],
[2, 3, 7], [7, 6, 2],
[3, 0, 4], [4, 7, 3],
[4, 5, 6], [6, 7, 4]])
tgen = tetgen.TetGen(v, f)
nodes, elems = tgen.tetrahedralize()
assert np.any(nodes)
assert np.any(elems)
def functional_tet_example():
sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)
tet = tetgen.TetGen(sphere)
tet.tetrahedralize(order=1, mindihedral=20, minratio=1.5)
grid = tet.grid
assert grid.n_cells
assert grid.n_points
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)
# plot this
subgrid.plot(scalars=subgrid.quality,
stitle='quality',
cmap='bwr',
flip_scalars=True)
# advanced plotting
plotter = pv.Plotter()
plotter.set_background('w')
plotter.add_mesh(subgrid, 'lightgrey', lighting=True)
plotter.add_mesh(grid, 'r', 'wireframe')
plotter.add_legend([[' Input Mesh ', 'r'], [' Tessellated Mesh ',
'black']])
plotter.show()
plotter = pv.Plotter()
plotter.set_background('w')
plotter.add_mesh(grid, 'r', 'wireframe')
plotter.plot(auto_close=False, interactive_update=True)
for i in range(500):
single_cell = grid.extract_cells([i])
plotter.add_mesh(single_cell)
plotter.update()
plotter.close()
cow_mesh = examples.download_cow().triangulate() cpos = [(13., 7.6, -13.85), (0.44, -0.4, -0.37), (-0.28, 0.9, 0.3)] cpos=[(15.87144235049248, 4.879216382405231, -12.14248864876951), (1.1623113035352375, -0.7609060338348953, 0.3192320579894903), (-0.19477922834083672, 0.9593375398915212, 0.20428542963665386)] cow_mesh.plot(cpos=cpos) ############################################################################### tet = tetgen.TetGen(cow_mesh) tet.make_manifold() tet.tetrahedralize() cow_grid = tet.grid ############################################################################### # plot half the cow mask = np.logical_or(cow_grid.points[:, 0] < 0, cow_grid.points[:, 0] > 4) half_cow = cow_grid.extract_points(mask) ############################################################################### plotter = pv.Plotter() plotter.add_mesh(half_cow, color='w', show_edges=True)
def test_mesh_repair():
cowfile = os.path.join(path, 'cow.ply')
tet = tetgen.TetGen(cowfile)
tet.make_manifold()
tet.tetrahedralize(order=1, mindihedral=20, minratio=1.5)
def gen_mesh_from_surf(self,
raw_input=None,
filename=None,
tri=None,
points=None,
surface_mesh=None):
"""
Generates a mesh from a surface mesh or file.
"""
if filename:
self.check_compatibility(filename)
from stl import mesh
import tetgen
#put rawinput in correct place
if type(raw_input) == str:
filename = raw_input
elif isinstance(raw_input, SurfaceMesh):
surface_mesh = raw_input
assert (filename or (tri and points)
or surface_mesh), 'No input geometry specified'
if filename:
mesh = mesh.Mesh.from_file(filename)
points = np.unique(mesh.points.reshape(mesh.points.shape[0] * 3,
3),
axis=0)
tri = [[
points.tolist().index(x[0:3].tolist()),
points.tolist().index(x[3:6].tolist()),
points.tolist().index(x[6:9].tolist())
] for x in mesh.points]
elif surface_mesh:
points = surface_mesh.points
tri = surface_mesh.tri
points = np.array(points)
tri = np.array(tri)
# assert points!=None and tri!=None, 'Empty geometry, check input is specified correctly'
mesh = pv.PolyData(points, np.c_[np.tile(3, tri.shape[0]),
tri].flatten())
tet = tetgen.TetGen(mesh)
tet.make_manifold()
tet.tetrahedralize()
grid = tet.grid
# plot half
# mask = np.logical_or(grid.points[:, 0] < 0, grid.points[:, 0] > 4)
# half = grid.extract_selection_points(mask)
#
# ###############################################################################
#
# plotter = pv.BackgroundPlotter()
# plotter.add_mesh(half, color='w', show_edges=True)
# plotter.add_mesh(grid, color='r', style='wireframe', opacity=0.2)
## plotter.camera_position = cpos
# plotter.show()
self.points = grid.points
self.elements = grid.cells.reshape(-1, 11)[:, 1:5]
# return grid
return self.points, self.elements
Using external modules to create a mesh ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Tetrahedralize a sphere """ # sphinx_gallery_thumbnail_number = 2 import pyvista as pv import tetgen import numpy as np ############################################################################### # Using PyVista # ~~~~~~~~~~~~~ # Create a surface mesh using ``pyvista`` and then tetrahedralize it. sphere = pv.Sphere() tet = tetgen.TetGen(sphere) tet.tetrahedralize(order=1, mindihedral=20, minratio=1.5) grid = tet.grid grid.plot(show_edges=True) ############################################################################### # Use pyvista to plot # get cell centroids cell_center = grid.cell_centers().points # extract cells below the 0 xy plane mask = cell_center[:, 2] < 0 cell_ind = mask.nonzero()[0] subgrid = grid.extract_cells(cell_ind)
def inertia_high_fidelity(W, L, D, t, rho_sa, n_sa):
"""Hi-fidelity inertia tensor calculation using tetgen to
create a 3D tetrahedron mesh of the solar panels. Then
compute the intertia tensor from the sum of the element
interias
"""
import tetgen
I_sax = np.zeros(W.size)
I_say = np.zeros(W.size)
I_saz = np.zeros(W.size)
m_sa = np.zeros(W.size)
for i in range(W.size):
Wi = W[i]
Li = L[i]
# set vertices
verts = np.array(
[
[-Wi / 2, D, t / 2],
[Wi / 2, D, t / 2],
[Wi / 2, D, -t / 2],
[-Wi / 2, D, -t / 2],
[-Wi / 2, D + Li, t / 2],
[Wi / 2, D + Li, t / 2],
[Wi / 2, D + Li, -t / 2],
[-Wi / 2, D + Li, -t / 2],
]
)
# set facets
facets = np.array(
[
[0, 1, 2],
[0, 2, 3],
[0, 1, 5],
[0, 5, 4],
[0, 3, 7],
[0, 4, 7],
[1, 2, 5],
[2, 5, 6],
[3, 2, 6],
[3, 6, 7],
[4, 5, 6],
[4, 6, 7],
]
)
tet = tetgen.TetGen(verts, facets)
nodes, elems = tet.tetrahedralize(quality=1, verbose=0)
# Compute inertia tensor from tetrahedrons
nelem = elems.shape[0]
dIxx = np.zeros(nelem)
dIyy = np.zeros(nelem)
dIzz = np.zeros(nelem)
dMass = np.zeros(nelem)
for j, el in enumerate(elems):
# Gather element nodes
pts = nodes[el]
a = pts[0]
b = pts[1]
c = pts[2]
d = pts[3]
# Find centroid x, y, z coordinates
xx = (a[0] + b[0] + c[0] + d[0]) / 4.0
yy = (a[1] + b[1] + c[1] + d[1]) / 4.0
zz = (a[2] + b[2] + c[2] + d[2]) / 4.0
# Find element volume
dV = (
1
/ 6.0
* abs(
(a[0] - d[0])
* ((b[1] - d[1]) * (c[2] - d[2]) - (b[2] - d[2]) * (c[1] - d[1]))
+ (a[1] - d[1])
* ((b[2] - d[2]) * (c[0] - d[0]) - (b[0] - d[0]) * (c[2] - d[2]))
+ (a[2] - d[2])
* ((b[0] - d[0]) * (c[1] - d[1]) - (b[1] - d[1]) * (c[0] - d[0]))
)
)
# Compute element inertia
dMass[j] = rho_sa * dV
dIxx[j] = rho_sa * dV * (yy * yy + zz * zz)
dIyy[j] = rho_sa * dV * (xx * xx + zz * zz)
dIzz[j] = rho_sa * dV * (xx * xx + yy * yy)
I_sax[i] = np.sum(dIxx) ** 2
I_say[i] = np.sum(dIyy) ** 2
I_saz[i] = np.sum(dIzz) ** 2
m_sa[i] = np.sum(dMass)
return I_sax, I_say, I_saz, m_sa
""" Sphere ~~~~~~ Tetrahedralize a sphere """ # sphinx_gallery_thumbnail_number = 2 import pyvista as pv import tetgen import numpy as np ############################################################################### sphere = pv.Sphere() tet = tetgen.TetGen(sphere) tet.tetrahedralize(order=1, mindihedral=20, minratio=1.5) grid = tet.grid grid.plot(show_edges=True) ############################################################################### # 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()
def plot_mesh(vertices,
faces=None,
input_file_name=None,
darkmode=True,
background_color='k',
text=None,
window_size=[1280, 720],
font_color='w',
cpos=[(3.77, 3.77, 3.77), (0.0069, -0.0045, 0.0),
(0.0, 0.0, 1.0)]):
'''visualize the mesh surface using vtk and return an img.
vertices is a numpy array of vertices with faces.
faces is a numpy array of indices specifying the faces of the surface of the mesh using ^those vertices.
input_file_name is a string giving the path to a file containing ^those faces (e.g. *.ply or *.stl).
an example text=f'time={tme:.1f}'
window_size = [1280,720] is the standard aspect ratio for youtube,
'''
#visualize the mesh surface
pv.set_plot_theme('document')
#get the vtk object (wrapped by pyvista from withing tetgen. Faces recorded by trimesh))
if faces is None:
if input_file_name is None:
Exception('either faces or input_file_name must be specified')
mesh_trimesh = trimesh.load(input_file_name)
faces = mesh_trimesh.faces
tet = tetgen.TetGen(vertices, faces)
# #fault tolerant tetrahedralization
vertices_tet, elements_tet = tet.tetrahedralize(order=1,
mindihedral=0.,
minratio=10.,
nobisect=False,
steinerleft=100000) #
tet.make_manifold()
grid = tet.grid
# advanced plotting
plotter = pv.Plotter()
if darkmode:
plotter.set_background(background_color)
plotter.add_mesh(grid, 'lightgrey', lighting=True)
#looks like tron plotter.add_mesh(grid, 'r', 'wireframe')
else:
plotter.add_mesh(grid, 'lightgrey', lighting=True)
font_color = 'k'
if text is not None:
plotter.add_text(text,
position='upper_left',
font_size=24,
color=font_color,
font='times')
#font options
# FONT_KEYS = {'arial': vtk.VTK_ARIAL,
# 'courier': vtk.VTK_COURIER,
# 'times': vtk.VTK_TIMES}
#cpos is (camera position, focal point, and view up)
#for movies, just set the camera position to some constant value.
_cpos, img = plotter.show(title=None,
return_img=True,
cpos=cpos,
window_size=window_size,
use_ipyvtk=False,
interactive=False,
auto_close=True)
plotter.deep_clean()
del plotter
pv.close_all()
return img
""" Super Toroid ~~~~~~~~~~~~ Tetrahedralize a super toroid surface """ # sphinx_gallery_thumbnail_number = 2 import pyvista as pv import tetgen import numpy as np ############################################################################### toroid = pv.SuperToroid() 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()
def test_load_arrays():
sphere = pv.Sphere()
v = sphere.points
f = sphere.faces.reshape(-1, 4)[:, 1:]
tet = tetgen.TetGen(v, f)
def build_mesh_from_3Dmask(mask, STEP_SIZE, SPACING):
'''update_outlier
build a mesh from a 3D mask
mask :
STEP_SIZE :
SPACING :
surface : if true only surfacic mesh
'''
labels, n_labels = measurements.label(mask)
ls_cells = []
ls_points = []
#for i in range(1, 3):
print(n_labels)
for i in range(1, n_labels + 1):
label = (labels == i) * 1
#print('IDX {}, n vox{}'.format(i, np.sum(label)))
try:
verts, faces, normals, values = measure.marching_cubes_lewiner(
label,
step_size=STEP_SIZE,
spacing=SPACING,
allow_degenerate=True)
verts = np.round(verts)
faces_1_adapted = np.ones([faces.shape[0], faces.shape[1] + 1]) * 3
faces_1_adapted[:, 1:] = faces
surf = polyv.PolyData(verts, faces_1_adapted)
tet = tetgen.TetGen(surf)
tet.make_manifold()
tet.tetrahedralize(order=1,
mindihedral=10,
steinerleft=-1,
minratio=1.01)
grid = tet.grid
#print(grid.number_of_cells)
if i > 1:
PREVIOUS_NUMBER_OF_VERTICES = points_concat.reshape(
[-1, 3]).shape[0]
ls_points.append(grid.points)
cells = grid.cells.reshape([-1, 5])
cells[:, 1:] += PREVIOUS_NUMBER_OF_VERTICES
cells = cells.reshape([-1])
ls_cells.append(cells)
cells_concat = np.concatenate(ls_cells, axis=0)
points_concat = np.concatenate(ls_points, axis=0)
n_cells = cells_concat.reshape([-1, 5]).shape[0]
else:
ls_cells.append(grid.cells)
ls_points.append(grid.points)
# fig,ax=plt.subplots()
# ax.imshow(label[200,:,:])
cells_concat = np.concatenate(ls_cells, axis=0)
points_concat = np.concatenate(ls_points, axis=0)
n_cells = cells_concat.reshape([-1, 5]).shape[0]
except:
print('erreur {}'.format(i))
cell_type = np.array([vtk.VTK_TETRA] * n_cells)
offset = np.arange(0, n_cells * 5, step=5)
grid = polyv.UnstructuredGrid(offset, cells_concat, cell_type,
points_concat)
return grid
