def test_for_breakdown(seed):
np.random.seed(seed)
n = np.random.randint(10, 20)
pts, cells = create_random_circle(n=n, radius=1.0)
optimesh.optimize_points_cells(pts,
cells,
"lloyd",
omega=1.0,
tol=1.0e-10,
max_num_steps=10)
def xy_gamut_mesh(lcar):
import optimesh
import pygmsh
observer = observers.cie_1931_2()
# Gather all points on the horseshoe outline
lmbda = 1.0e-9 * np.arange(380, 701)
all_points = np.empty((len(lmbda), 2))
for k in range(len(lmbda)):
data = np.zeros(len(lmbda))
data[k] = 1.0
all_points[k] = _xyy_from_xyz100(
spectrum_to_xyz100((lmbda, data), observer))[:2]
# Generate gmsh geometry: spline + straight line
all_points = np.column_stack([all_points, np.zeros(len(all_points))])
with pygmsh.geo.Geometry() as geom:
gmsh_points = [geom.add_point(pt, lcar) for pt in all_points]
s1 = geom.add_spline(gmsh_points)
s2 = geom.add_line(gmsh_points[-1], gmsh_points[0])
ll = geom.add_curve_loop([s1, s2])
geom.add_plane_surface(ll)
mesh = geom.generate_mesh()
# Work around numpy bug <https://github.com/numpy/numpy/issues/17760>
cells = mesh.get_cells_type("triangle").astype(int)
points, cells = optimesh.optimize_points_cells(mesh.points,
cells,
"lloyd",
1.0e-2,
100,
omega=2.0)
return points, cells
def test_surface():
points, cells = meshzoo.tetra_sphere(20)
# points, cells = meshzoo.octa_sphere(10)
# points, cells = meshzoo.icosa_sphere(10)
class Sphere:
def f(self, x):
return 1.0 - (x[0]**2 + x[1]**2 + x[2]**2)
def grad(self, x):
return -2 * x
# points, cells = optimesh.cpt.fixed_point_uniform(
# points, cells = optimesh.odt.fixed_point_uniform(
points, cells = optimesh.optimize_points_cells(
points,
cells,
"cvt (full)",
1.0e-2,
100,
verbose=False,
implicit_surface=Sphere(),
step_filename_format="out{:03d}.vtk",
)
def optimize(self,
*,
method='CVT (block-diagonal)',
tol: float = 1.0e-3,
max_num_steps: int = 10,
**kwargs) -> TriangleMesh:
"""Optimize mesh using `optimesh`.
Parameters
----------
method : str, optional
Method name
tol : float, optional
Tolerance
max_num_steps : int, optional
Maximum number of optimization steps.
**kwargs
Arguments to pass to `optimesh.optimize_points_cells`
Returns
-------
TriangleMesh
"""
import optimesh
points, cells = optimesh.optimize_points_cells(
X=self.points,
cells=self.cells,
method=method,
tol=tol,
max_num_steps=max_num_steps,
**kwargs,
)
return TriangleMesh(points=points, cells=cells)
def test_cvt_lloyd(mesh, num_steps, ref):
print(num_steps)
m = copy.deepcopy(mesh)
optimesh.optimize(m, "Lloyd", 1.0e-2, num_steps, verbose=False)
assert_norm_equality(m.points, ref, 1.0e-12)
# try the other way of calling optimesh
X, c = mesh.points.copy(), mesh.cells("points").copy()
X, _ = optimesh.optimize_points_cells(X, c, "lloyd", 1.0e-2, num_steps)
assert_norm_equality(X, ref, 1.0e-12)
def test_methods(method, mesh, ref):
X_in, cells_in = mesh.points, mesh.cells("points")
# X_before = X_in.copy()
# cells_before = cells_in.copy()
X, _ = optimesh.optimize_points_cells(X_in, cells_in, method, 1.0e-12, 100)
# assert np.all(cells_in == cells_before)
# assert np.all(np.abs(X_in == X_before) < 1.0e-15)
# Test if we're dealing with the mesh we expect.
assert_norm_equality(X, ref, 1.0e-12)
def test_circle():
def boundary_step(x):
x0 = [0.0, 0.0]
r = 1.0
# simply project onto the circle
y = (x.T - x0).T
r = np.sqrt(np.einsum("ij,ij->j", y, y))
return ((y / r * r).T + x0).T
X, cells = meshes.circle_random2(150, 1.0)
X, cells = optimesh.optimize_points_cells(X,
cells,
"cpt (fixed-point)",
1.0e-3,
100,
boundary_step=boundary_step)
def smoothPoints(self):
pts, cells = self.__pts.copy(), self.__triangles.copy()
pts, cells = optimesh.optimize_points_cells(pts, cells, "cpt (fixed-point)", 0.0, 100, omega=.8)
if not numpy.isnan(pts).any():
isv = self.__materData.s1.internal_state_variables.copy() # Elastic strain tensor (4), plastic strain (1)
#sig = self.__materData.s1.thermodynamic_forces.copy() # Stress (4)
grad = self.__materData.s1.gradients.copy() # Total strain (4)
acc = self.__acc.reshape(-1,2)
vel = self.__vel.reshape(-1,2)
disp = self.__disp.reshape(-1,2)
var = numpy.column_stack([isv, grad, acc, vel, disp])
interp = LinearNDInterpolator(self.__pts, var)
res = interp(pts)
self.__pts = pts.copy()
self.__updateMaterialData(res[:,:9])
self.__acc = res[:,9:11].reshape(-1)
self.__vel = res[:,11:13].reshape(-1)
self.__disp = res[:,13:].reshape(-1)
self.__dt = self.__updateMeshBmatrixFint()
def test_circle():
def boundary_step(x):
x0 = [0.0, 0.0]
r = 1.0
# simply project onto the circle
y = (x.T - x0).T
r = np.sqrt(np.einsum("ij,ij->j", y, y))
return ((y / r * r).T + x0).T
# ODT can't handle the random circle; some cells too flat near the boundary lead to
# a breakdown.
# X, cells = circle_random2(150, 1.0, seed=1)
X, cells = meshes.circle_gmsh2()
X, cells = optimesh.optimize_points_cells(X,
cells,
"ODT (fixed-point)",
1.0e-3,
100,
boundary_step=boundary_step)
def test_comparison():
plt.style.use(dufte.style)
X, cells = circle_random(40, 1.0)
# Do a few steps of a robust method to avoid too crazy meshes.
tol = 0.0
n = 10
# X, cells = optimesh.cpt.fixed_point_uniform(X, cells, tol, n)
# X, cells = optimesh.odt.fixed_point_uniform(X, cells, tol, n)
X, cells = optimesh.optimize_points_cells(X,
cells,
"lloyd",
tol,
n,
omega=2.0)
# from meshplex import MeshTri
# mesh = MeshTri(X, cells)
# mesh.write("out.vtk")
# exit(1)
num_steps = 50
names = [
"cpt-fixed-point",
"cpt-quasi-newton",
#
"lloyd",
"lloyd(2.0)",
"cvt-block-diagonal",
"cvt-full",
#
"odt-fixed-point",
"odt-bfgs",
]
avg_quality = np.empty((len(names), num_steps + 1))
for i, name in enumerate(names):
def callback(k, mesh):
avg_quality[i, k] = np.average(mesh.q_radius_ratio)
return
X_in = X.copy()
cells_in = cells.copy()
if name == "lloyd(2.0)":
optimesh.optimize_points_cells(X_in,
cells_in,
"lloyd",
0.0,
num_steps,
omega=2.0,
callback=callback)
else:
optimesh.optimize_points_cells(X_in,
cells_in,
name,
0.0,
num_steps,
callback=callback)
# sort by best final quality
idx = np.argsort(avg_quality[:, -1])[::-1]
sorted_labels = [names[i] for i in idx]
for i, label, values in zip(idx, sorted_labels, avg_quality[idx]):
plt.plot(values, "-", label=label, zorder=i)
plt.xlim(0, num_steps)
plt.ylim(0.93, 1.0)
plt.xlabel("step")
plt.title("average cell quality")
dufte.legend()
plt.savefig("comparison.svg", transparent=True, bbox_inches="tight")
def test_density_preserving(mesh, ref):
X, cells = mesh.points, mesh.cells("points")
X, cells = optimesh.optimize_points_cells(X, cells, "cpt (linear solve)",
0.0, 10)
assert_norm_equality(X, ref, 1.0e-12)
import numpy as np
import optimesh
import dmsh
def save(X, cells, filename):
meshio.Mesh(X, {"triangle": cells}).write(
filename, image_width=100, stroke_width=0.5
)
geo = dmsh.Circle([0.0, 0.0], 1.0)
X, cells = dmsh.generate(geo, 0.1)
# optionally optimize the mesh
X, cells = optimesh.optimize_points_cells(X, cells, "CVT (full)", 1.0e-10, 100)
save(X, cells, "circle.svg")
geo = dmsh.Rectangle(-1.0, +2.0, -1.0, +1.0)
X, cells = dmsh.generate(geo, 0.1)
save(X, cells, "rectangle.svg")
geo = dmsh.Polygon(
[
[0.0, 0.0],
[1.1, 0.0],
[1.2, 0.5],
[0.7, 0.6],
[2.0, 1.0],
[1.0, 2.0],