Mesh a face thinner than the tolerance instead of leaving a hole (#2712)

Thanks @SiroArt.
This commit is contained in:
SiroArt
2026-10-19 03:56:28 +02:00
committed by GitHub
parent 38f6ed76c9
commit 71534117af
7 changed files with 321 additions and 1 deletions
+2
View File
@@ -132,6 +132,8 @@ mod sweep_rails_tests;
mod tangent_cylinders;
mod tess;
#[cfg(test)]
mod thin_face_tests;
#[cfg(test)]
mod thread_display_tests;
#[cfg(test)]
mod thread_tests;
+43
View File
@@ -0,0 +1,43 @@
//! A face thinner than the tolerance still meshes: the lens of a sphere's patch that pokes out
//! of a box's side has two edges that, sampled coarsely, run along one line in its parameters.
//! The shell's mesh had a hole there.
use std::collections::HashMap;
use solidcraft_geom::Vec3;
use crate::{BoolOp, build::box_solid, build::sphere, ops::boolean};
/// Triangle sides in the mesh with no triangle on the other side of them, with the points
/// within a thousandth of a millimetre taken as one.
fn open_sides(mesh: &solidcraft_geom::Mesh) -> usize {
let key = |i: u32| {
let p = mesh.positions[i as usize];
[p.x, p.y, p.z].map(|c| (c * 1e3).round() as i64)
};
let mut sides: HashMap<([i64; 3], [i64; 3]), u32> = HashMap::new();
for t in &mesh.triangles {
for (a, b) in [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])] {
*sides.entry((key(a), key(b))).or_default() += 1;
}
}
sides.keys().filter(|(a, b)| !sides.contains_key(&(*b, *a))).count()
}
/// The sphere's equator lies in the box's top and its circle on the box's side x = 22.5 dips to
/// z = 24.7, while the edge of the sphere's bottom patch bulges 0.15 mm past that side: a
/// face of about 0.35 mm² between the two. At 1 % of the body it had no triangle.
#[test]
fn a_lens_thinner_than_the_tolerance_is_meshed() {
let a = sphere(Vec3::new(20.0, 10.0, 27.5), 3.75).unwrap();
let b = box_solid(Vec3::new(15.0, 0.0, 22.5), Vec3::new(22.5, 20.0, 27.5)).unwrap();
let union = boolean(&a, &b, BoolOp::Union).unwrap().unwrap();
assert!(union.validity().is_empty(), "{:?}", union.validity());
let size = union.size();
for tol in [size * 1e-2, size * 2.5e-3, size * 1e-3] {
let mesh = union.tessellate(tol).unwrap();
let faces: std::collections::HashSet<u32> = mesh.tri_face.iter().copied().collect();
assert_eq!(faces.len(), union.face_count(), "faces with triangles at {tol}");
assert_eq!(open_sides(&mesh), 0, "open sides at {tol}");
}
}
+9
View File
@@ -303,6 +303,15 @@ fn grid_sphere_box_union_is_sound() {
check(identity(&a, &b));
}
/// A small sphere on the top of a thin box: a patch of the sphere sticks out of the box's side
/// by less than the tolerance, a face of about 0.35 mm² that had no triangle when meshed at 1 % of the body.
#[test]
fn grid_small_sphere_thin_box_union_is_sound() {
let a = Prim::Sph { at: [20.0, 10.0, 27.5], r: 3.75 };
let b = Prim::Box { at: [15.0, 0.0, 22.5], size: [7.5, 20.0, 5.0] };
check(identity(&a, &b));
}
/// Two crossing cylinders: the union moved 1000 mm away loses about a tenth of its volume.
#[test]
#[ignore = "kernel bug, #1649"]
+121
View File
@@ -0,0 +1,121 @@
//! The fallback in the vendored tessellator that triangulates the boundary loop of a face that
//! came out with no triangle (a lens thinner than the tolerance). Its ear clipping is checked on
//! the polygons it can meet: convex, concave, either winding, with collinear points, and loops
//! it must refuse.
//!
//! The vendored crates are outside the workspace, so their own tests never run in CI; the
//! function is reached through the crate's `test-hooks` feature (on only for kernel tests).
use truck_meshalgo::tessellation::loop_fill_test_hooks::ear_clipping;
fn area2(points: &[[f64; 2]]) -> f64 {
points.iter().zip(points.iter().cycle().skip(1)).map(|(p, q)| p[0] * q[1] - q[0] * p[1]).sum()
}
/// The triangles turn the same way as the polygon, there are `n - 2` of them, and they add up to
/// its area: together they cover it once, with no overlap.
fn assert_covers_once(points: &[[f64; 2]]) {
let triangles = ear_clipping(points).expect("a simple polygon is triangulated");
assert_eq!(triangles.len(), points.len() - 2);
let side = area2(points).signum();
let mut sum = 0.0;
for t in &triangles {
let t = area2(&t.map(|i| points[i]));
assert!(t * side > 0.0, "a triangle turns the other way, or has no area: {t}");
sum += t;
}
assert!((sum - area2(points)).abs() < 1e-9, "triangles cover {sum}, the polygon {}", area2(points));
}
#[test]
fn a_triangle_is_itself() {
let points = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]];
assert_eq!(ear_clipping(&points), Some(vec![[0, 1, 2]]));
}
#[test]
fn a_convex_polygon_either_way_round() {
let square = [[0.0, 0.0], [2.0, 0.0], [2.0, 2.0], [0.0, 2.0]];
assert_covers_once(&square);
let mut reversed = square;
reversed.reverse();
assert_covers_once(&reversed);
}
#[test]
fn a_concave_polygon_either_way_round() {
// An L: the reflex corner is at (1, 1).
let l = [[0.0, 0.0], [2.0, 0.0], [2.0, 1.0], [1.0, 1.0], [1.0, 2.0], [0.0, 2.0]];
assert_covers_once(&l);
let mut reversed = l;
reversed.reverse();
assert_covers_once(&reversed);
}
#[test]
fn a_thin_lens_made_of_an_arc_and_a_chord() {
let lens = [[0.0, 0.0], [1.0, -0.15], [2.0, 0.0]];
assert_covers_once(&lens);
let more = [[0.0, 0.0], [0.5, -0.1], [1.0, -0.15], [1.5, -0.1], [2.0, 0.0]];
assert_covers_once(&more);
}
#[test]
fn collinear_points_on_a_side_are_kept_as_corners() {
let square = [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [2.0, 2.0], [0.0, 2.0]];
let triangles = ear_clipping(&square).expect("triangulated");
assert_eq!(triangles.len(), 3);
let covered: f64 = triangles.iter().map(|t| area2(&t.map(|i| square[i]))).sum();
assert!((covered - area2(&square)).abs() < 1e-9);
}
#[test]
fn a_loop_without_area_is_refused() {
assert_eq!(ear_clipping(&[[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]]), None, "three collinear points");
assert_eq!(ear_clipping(&[[0.0, 0.0], [1.0, 1.0], [0.0, 0.0], [1.0, 1.0]]), None, "a line walked twice");
}
#[test]
fn fewer_than_three_points_are_refused() {
assert_eq!(ear_clipping(&[]), None);
assert_eq!(ear_clipping(&[[0.0, 0.0]]), None);
assert_eq!(ear_clipping(&[[0.0, 0.0], [1.0, 0.0]]), None);
}
/// A loop that crosses itself (the #1648 face pinched to a point is one) would get overlapping
/// triangles, and so a wrong mesh that hides the problem. It is refused, symmetric or not.
#[test]
fn a_loop_crossing_itself_is_refused() {
let bowtie = [[0.0, 0.0], [2.0, 2.0], [2.0, 0.0], [0.0, 2.0]];
assert_eq!(ear_clipping(&bowtie), None);
let lopsided = [[0.0, 0.0], [3.0, 2.0], [3.0, 0.0], [0.0, 1.0]];
assert_eq!(ear_clipping(&lopsided), None);
let pinched = [[0.0, 0.0], [5.0, 0.0], [5.0, 0.3], [3.0, -0.1], [2.0, -0.1], [0.0, 0.3]];
assert_eq!(ear_clipping(&pinched), None);
}
/// The loop of a face closes on its first point: a point given twice in a row is a corner with no
/// area, and the polygon is still triangulated on the rest.
#[test]
fn a_repeated_point_is_handled_without_a_wrong_mesh() {
let points = [[0.0, 0.0], [2.0, 0.0], [2.0, 2.0], [0.0, 2.0], [0.0, 0.0]];
if let Some(triangles) = ear_clipping(&points) {
let covered: f64 = triangles.iter().map(|t| area2(&t.map(|i| points[i]))).sum();
assert!((covered - area2(&points)).abs() < 1e-9, "triangles cover {covered}");
}
}
/// The largest loop the fallback takes, as a circle with a bite out of it: all of it is covered
/// exactly once.
#[test]
fn the_largest_loop_is_triangulated() {
let n = 256;
let points: Vec<[f64; 2]> = (0..n)
.map(|i| {
let t = std::f64::consts::TAU * i as f64 / n as f64;
let r = if i % 16 == 0 { 0.6 } else { 1.0 };
[r * t.cos(), r * t.sin()]
})
.collect();
assert_covers_once(&points);
}
+11
View File
@@ -191,6 +191,17 @@ Changes:
the face, many degrees round: those triangles cut through the surface and folded over each
other (a cone face with a small hole meshed several mm² too large, and the boolean that made
it was refused for its volume).
- `tessellation/triangulation.rs`: a face that comes out of the triangulation with no triangle
at all, though the points of its one boundary loop enclose an area in space, is given the
triangles of that loop (ears clipped on the plane of the loop, no point added, so the faces on
either side of its edges still meet it). Its two edges can be different curves that, sampled
as they are, run along the same line in the face's parameters (a lens thinner than the
tolerance), and the loop then has no area there. The shell's mesh had a hole. Faces that
mesh are untouched, and so are preview meshes (they have their own step grid). Only a face
with one loop of at most 256 points is filled, and not one whose loop crosses itself, whose
ears would overlap (the pinched face of #1648 is one): it stays as it was.
`crates/kernel/src/thin_face_tests.rs` holds it, `crates/kernel/tests/tess_loop_fill.rs` the
ear clipping (through the `test-hooks` feature).
## matext4cgmath 0.1.0 (Apache-2.0, © RICOS Co. Ltd., https://github.com/ricosjp/matext4cgmath)
+1 -1
View File
@@ -524,4 +524,4 @@ mod closed;
mod triangulation;
#[cfg(feature = "test-hooks")]
#[doc(hidden)]
pub use triangulation::include_test_hooks;
pub use triangulation::{include_test_hooks, loop_fill_test_hooks};
+134
View File
@@ -967,10 +967,130 @@ fn trimming_with_steps<S: PreMeshableSurface>(surface: &S, polyboundary: &PolyBo
surface,
polyboundary,
);
// SolidCraft: a face that came out with no triangles at all, though its boundary encloses
// an area in space (a lens thinner than the tolerance: its two edges are different curves,
// but sampled as they are, in the face's parameters they run along the same line), left a
// hole in the shell's mesh. Its boundary points are triangulated as they are, so it still
// meets the faces on either side of it.
if steps.is_none() && mesh.faces().is_empty() {
if let Some(filled) = loop_triangles(surface, polyboundary) {
mesh = filled;
}
}
mesh.make_face_compatible_to_normal();
mesh
}
/// SolidCraft: most points of a loop [`loop_triangles`] triangulates.
const MAX_LOOP_POINTS: usize = 256;
/// SolidCraft: the triangles of a face's one boundary loop, taken in space on the plane the loop
/// lies near and with no point added, for a face whose parameters give none (see
/// [`trimming_with_steps`]). `None` when the face has several loops, too many points, or no
/// area in space.
fn loop_triangles(surface: &impl ParametricSurface3D, polyline: &PolyBoundary) -> Option<PolygonMesh> {
let [curve] = polyline.0.as_slice() else { return None };
if !(3..=MAX_LOOP_POINTS).contains(&curve.len()) {
return None;
}
let positions: Vec<Point3> = curve.iter().map(|p| surface.subs(p.x, p.y)).collect();
if positions.iter().any(|p| !(p.x.is_finite() && p.y.is_finite() && p.z.is_finite())) {
return None;
}
let normal = newell_normal(&positions);
if normal.magnitude() * 0.5 <= TOLERANCE {
return None;
}
// The loop seen along the axis its normal points along most.
let axis = (0..3).max_by(|&i, &j| normal[i].abs().total_cmp(&normal[j].abs()))?;
let flat: Vec<[f64; 2]> = positions
.iter()
.map(|p| match axis {
0 => [p.y, p.z],
1 => [p.z, p.x],
_ => [p.x, p.y],
})
.collect();
let triangles: Vec<[StandardVertex; 3]> = ear_clipping(&flat)?
.into_iter()
.filter(|&[a, b, c]| (positions[b] - positions[a]).cross(positions[c] - positions[a]).magnitude() * 0.5 > TOLERANCE)
.map(|corners| corners.map(|i| (i, Some(i), Some(i)).into()))
.collect();
if triangles.is_empty() {
return None;
}
// The normals orient the triangles ([`NormalFilters::make_face_compatible_to_normal`]).
let normals = curve.iter().map(|p| surface.normal(p.x, p.y)).collect();
let uv_coords = curve.iter().map(|p| Vector2::new(p.x, p.y)).collect();
Some(PolygonMesh::debug_new(
StandardAttributes { positions, uv_coords, normals },
Faces::from_tri_and_quad_faces(triangles, Vec::new()),
))
}
/// SolidCraft: twice the vector area of a closed polygon: the direction of its plane, as long as
/// it is large.
fn newell_normal(points: &[Point3]) -> Vector3 {
let next = points.iter().cycle().skip(1);
points.iter().zip(next).fold(Vector3::zero(), |sum, (p, q)| {
sum + Vector3::new((p.y - q.y) * (p.z + q.z), (p.z - q.z) * (p.x + q.x), (p.x - q.x) * (p.y + q.y))
})
}
/// SolidCraft: twice the signed area of the triangle `a b c`: positive when it turns left.
fn turn(a: [f64; 2], b: [f64; 2], c: [f64; 2]) -> f64 {
(b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
}
/// SolidCraft: whether two sides of the closed polygon that do not share a corner cross each other.
/// Ears of a polygon that crosses itself overlap, so it is not triangulated.
fn crosses_itself(points: &[[f64; 2]]) -> bool {
let n = points.len();
let side = |i: usize| (points[i], points[(i + 1) % n]);
(0..n).any(|i| {
let (a, b) = side(i);
(i + 2..n).filter(|&j| !(i == 0 && j == n - 1)).any(|j| {
let (c, d) = side(j);
turn(a, b, c) * turn(a, b, d) < 0.0 && turn(c, d, a) * turn(c, d, b) < 0.0
})
})
}
/// SolidCraft: the triangles of a simple polygon, as indices into its points, by clipping ears.
/// `None` when no ear is left to clip (the polygon crosses itself) or it has no area.
fn ear_clipping(points: &[[f64; 2]]) -> Option<Vec<[usize; 3]>> {
if points.len() < 3 {
return None;
}
let next = points.iter().cycle().skip(1);
let area2: f64 = points.iter().zip(next).map(|(p, q)| p[0] * q[1] - q[0] * p[1]).sum();
if area2 == 0.0 || crosses_itself(points) {
return None;
}
// Every turn of an ear, and of a point inside it, is on the polygon's own side.
let side = area2.signum();
let is_ear = |left: &[usize], k: usize| {
let m = left.len();
let corner = [left[(k + m - 1) % m], left[k], left[(k + 1) % m]];
let [a, b, c] = corner.map(|i| points[i]);
turn(a, b, c) * side > 0.0
&& left.iter().filter(|q| !corner.contains(q)).all(|&q| {
let p = points[q];
[turn(a, b, p), turn(b, c, p), turn(c, a, p)].iter().any(|t| t * side < 0.0)
})
};
let mut left: Vec<usize> = (0..points.len()).collect();
let mut triangles = Vec::with_capacity(points.len() - 2);
while left.len() > 3 {
let m = left.len();
let k = (0..m).find(|&k| is_ear(&left, k))?;
triangles.push([left[(k + m - 1) % m], left[k], left[(k + 1) % m]]);
left.remove(k);
}
triangles.push([left[0], left[1], left[2]]);
Some(triangles)
}
/// Inserts parameter divisions into triangulation.
fn insert_surface(
triangulation: &mut Cdt,
@@ -1550,3 +1670,17 @@ pub mod include_test_hooks {
assert!(matches!(n, Ok(n) if n > 100_000), "{n:?}");
}
}
/// SolidCraft: the fallback that triangulates a face's boundary loop when the face has no
/// triangle, for kernel tests (the vendored crates' own tests do not run in CI).
///
/// Not part of the API. Built only for tests, or with the `test-hooks` feature.
#[cfg(any(test, feature = "test-hooks"))]
#[doc(hidden)]
pub mod loop_fill_test_hooks {
/// The triangles of a closed polygon, as indices into its points, or `None` when it has no
/// area, fewer than three points, or crosses itself.
pub fn ear_clipping(points: &[[f64; 2]]) -> Option<Vec<[usize; 3]>> {
super::ear_clipping(points)
}
}