From be583dbfd79137c32984a9f1d76c102277e32db1 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Wed, 28 Oct 2026 22:15:19 -0400 Subject: [PATCH] Wave 335/509: Tessellation: the band beside a slit and the sag refinement keep the face on both sides of it (and 3 more) 4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - fcd5f7997 jyviko: Tessellation: a node lying on another chord is untangled like a crossing - 43ad9d0b0 jyviko: Tessellation: a slit (a side the loops run along both ways) bounds the face on neither side - 534dffa96 jyviko: Tessellation: the band beside a slit and the sag refinement keep the face on both sides of it - 7b984936a jyviko: kernel: an emboss's arcs run on their wall's own frame, and its seam is read from the circle's angles Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ --- crates/kernel/src/emboss.rs | 26 ++++++++++---- crates/kernel/src/tess/cdt.rs | 58 ++++++++++++++++++++++++++------ crates/kernel/src/tess/mod.rs | 20 +++++++---- crates/kernel/src/tess/tangle.rs | 35 +++++++++++++++++++ crates/kernel/src/tess/tests.rs | 52 ++++++++++++++++++++++++++++ 5 files changed, 167 insertions(+), 24 deletions(-) diff --git a/crates/kernel/src/emboss.rs b/crates/kernel/src/emboss.rs index e4b200f36..be32fce8b 100644 --- a/crates/kernel/src/emboss.rs +++ b/crates/kernel/src/emboss.rs @@ -9,7 +9,7 @@ use crate::numbered::NumberedRegion; use crate::offset::{Surf, face_edges, surf_of}; use crate::{KernelError, Result, guard}; use solidcraft_geom::brep::eval::CurveEval; -use solidcraft_geom::brep::{Brep, Curve, Frame, Loop, Surface}; +use solidcraft_geom::brep::{Brep, Curve, Frame, Loop, Surface, form}; use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3}; fn fail(s: &str) -> KernelError { @@ -40,10 +40,11 @@ fn wall_angles(b: &Brep, face: usize, o: Vec3, axis: Vec3, radial: Vec3, tangent if z.dot(axis).abs() < 1.0 - 1e-9 { continue; } - // The circle's parameter is its angle: the wall spans the edge's interval about the - // angle of its middle (a whole turn, from the seam, for a wall in one piece). - let c = CurveEval::new(e.parameters()).ok()?; - let [t0, t1] = e.interval; + // The circle's parameter is its angle: the wall spans the edge's angles on the circle + // (`interval` is on its NURBS form where it has one) about the angle of its middle (a + // whole turn, from the seam, for a wall in one piece). + let c = CurveEval::new(&e.curve).ok()?; + let [t0, t1] = e.curve_interval()?; let am = angle(c.point(0.5 * (t0 + t1))?, o, axis, radial, tangent); let half = 0.5 * (t1 - t0); return Some((am - half, am + half)); @@ -327,9 +328,12 @@ fn emboss_impl(body: &Body, anchor: Option, plane: &Plane, regions: &[Regi let at = o + axis * p.y + (radial * (p.x / r).cos() + tangent * (p.x / r).sin()) * r; return Ok(EmbossOutcome::Anchor(fi, at)); } - let wall = Wrap { o, axis, radial, tangent, r }; let mut asm = Assembly::from_record(&rec)?; let selected = asm.faces.get_mut(fi).and_then(Option::take).ok_or_else(|| fail("face"))?; + // The footprint's arcs lie on the wall face and are labelled on its frame, so their NURBS + // forms run on the face's own quarter grid and their pcurves there are exact. + let label = form::frame_of(&selected.surface); + let wall = Wrap { o, axis, radial, tangent, r, label, tol }; // The wall's pieces left around the footprints: the face itself, then one per profile // hole (the original radius inside it). let mut base_patches: Vec>> = vec![selected.loops.clone()]; @@ -416,6 +420,9 @@ struct Wrap { radial: Vec3, tangent: Vec3, r: f64, + /// The wall face's own frame, which the arcs at its radius are labelled on. + label: Option, + tol: f64, } impl Wrap { @@ -441,7 +448,12 @@ impl Wrap { let (ta, tb) = (p.x / self.r, q.x / self.r); let forward = ta < tb; let (interval, ends) = if forward { ([ta, tb], (a, b)) } else { ([tb, ta], (b, a)) }; - Ok(AUse { edge: asm.edge(Curve::Circle { frame, radius }, interval, ends.0, ends.1)?, forward, given: None }) + let circle = Curve::Circle { frame, radius }; + let (circle, interval) = match &self.label { + Some(label) if (radius - self.r).abs() <= self.tol => form::on_frame(&circle, interval, label, self.tol).unwrap_or((circle, interval)), + _ => (circle, interval), + }; + Ok(AUse { edge: asm.edge(circle, interval, ends.0, ends.1)?, forward, given: None }) } /// A profile loop wrapped onto the wall: its footprint at the wall's radius and its cap's diff --git a/crates/kernel/src/tess/cdt.rs b/crates/kernel/src/tess/cdt.rs index 60c3dca0d..e7d80f9b4 100644 --- a/crates/kernel/src/tess/cdt.rs +++ b/crates/kernel/src/tess/cdt.rs @@ -79,6 +79,16 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range index.entry(h).or_insert(u32::try_from(i).ok()?); handles.push(h); } + // A side the loops run along both ways (a slit, where a face's boundary goes out along a + // line its two sides share and back) bounds the face on neither. + let mut sides: Vec<(FixedVertexHandle, FixedVertexHandle)> = Vec::new(); + for r in loops { + let n = r.len(); + for k in 0..n { + sides.push((*handles.get(r.start + k)?, *handles.get(r.start + (k + 1) % n)?)); + } + } + let slits = slits(&sides); for r in loops { let n = r.len(); for k in 0..n { @@ -102,7 +112,7 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range } if let Some((sag, budget)) = &fill.refine { let constraints = cdt.num_constraints(); - let added = refine_sag(&mut cdt, sag, *budget, &from); + let added = refine_sag(&mut cdt, sag, *budget, &from, &slits); if fill.shape { let params = RefinementParameters::::new() .keep_constraint_edges() @@ -115,7 +125,7 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range // Shaping flips sides and adds points of its own; the triangles it leaves may // sag again (a long strip round a cylinder), so the sag is checked once more. if shaped > 0 { - refine_sag(&mut cdt, sag, budget.saturating_sub(added + shaped), &from); + refine_sag(&mut cdt, sag, budget.saturating_sub(added + shaped), &from, &slits); } } // A split constraint would put a point on the boundary the neighbour does not have. @@ -125,7 +135,7 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range } let mut uv: Vec<[f64; 2]> = boundary.to_vec(); let mut tris = Vec::new(); - let region = region(&cdt); + let region = region(&cdt, &slits); for face in cdt.inner_faces() { if !region.get(face.index()).copied().unwrap_or(false) { continue; @@ -185,6 +195,8 @@ pub(crate) fn band(points: &[[f64; 2]], n: usize, loops: &[std::ops::Range) -> [f64; 2]) -> usize { +/// `slits`: constraint sides the loops run along both ways, inside the region on both sides. +fn refine_sag( + cdt: &mut Cdt, + sag: &Sag, + budget: usize, + from: &dyn Fn(Point2) -> [f64; 2], + slits: &std::collections::HashSet<(FixedVertexHandle, FixedVertexHandle)>, +) -> usize { let mut added = 0; let mut cache: HashMap)>> = HashMap::new(); // The widest turn between two corner normals. @@ -232,7 +251,7 @@ fn refine_sag(cdt: &mut Cdt, sag: &Sag, budget: usize, from: &dyn Fn(Point2 (sag.eval)(q[0], q[1]) }) }; - let region = region(cdt); + let region = region(cdt, slits); for face in cdt.inner_faces() { if !region.get(face.index()).copied().unwrap_or(false) { continue; @@ -304,18 +323,35 @@ fn refine_sag(cdt: &mut Cdt, sag: &Sag, budget: usize, from: &dyn Fn(Point2 added } +/// The sides a boundary runs along an even number of times (a slit: out along a line and back), +/// each as its vertices in index order: the region lies on both sides of them. +fn slits(sides: &[(FixedVertexHandle, FixedVertexHandle)]) -> std::collections::HashSet<(FixedVertexHandle, FixedVertexHandle)> { + let mut runs: HashMap<(FixedVertexHandle, FixedVertexHandle), usize> = HashMap::new(); + for &(a, b) in sides { + if a != b { + *runs.entry(if a.index() < b.index() { (a, b) } else { (b, a) }).or_insert(0) += 1; + } + } + runs.into_iter().filter(|(_, n)| n % 2 == 0).map(|(e, _)| e).collect() +} + /// Per face (by index): inside the region the constraint loops bound. A flood fill from the -/// outer face that flips parity each time it crosses a constraint edge (holes are out), linear -/// in the number of triangles. -fn region(cdt: &Cdt) -> Vec { +/// outer face that flips parity each time it crosses a constraint edge (holes are out), but for +/// the sides in `slits` (run along both ways, the region on both sides), linear in the number of +/// triangles. +fn region(cdt: &Cdt, slits: &std::collections::HashSet<(FixedVertexHandle, FixedVertexHandle)>) -> Vec { use spade::handles::{FixedFaceHandle, InnerTag}; + let counts = |e: spade::handles::DirectedEdgeHandle<'_, _, _, _, _>| { + let [a, b] = e.vertices().map(|v| v.fix()); + e.is_constraint_edge() && !slits.contains(&if a.index() < b.index() { (a, b) } else { (b, a) }) + }; let mut parity: Vec> = vec![None; cdt.num_all_faces()]; let mut todo: Vec<(FixedFaceHandle, bool)> = Vec::new(); for e in cdt.convex_hull() { // Hull edges have the outer face on one side; the other side is an inner face. for side in [e, e.rev()] { if let Some(inner) = side.face().as_inner() { - todo.push((inner.fix(), e.is_constraint_edge())); + todo.push((inner.fix(), counts(e))); } } } @@ -326,7 +362,7 @@ fn region(cdt: &Cdt) -> Vec { } for e in cdt.face(h).adjacent_edges() { if let Some(next) = e.rev().face().as_inner() { - todo.push((next.fix(), odd ^ e.is_constraint_edge())); + todo.push((next.fix(), odd ^ counts(e))); } } } diff --git a/crates/kernel/src/tess/mod.rs b/crates/kernel/src/tess/mod.rs index 204a8b298..a912b3097 100644 --- a/crates/kernel/src/tess/mod.rs +++ b/crates/kernel/src/tess/mod.rs @@ -1133,7 +1133,8 @@ fn graded(a: [f64; 2], b: [f64; 2], sa: f64, sb: f64, h: f64, speed: [f64; 2], f all.into_iter().filter(|t| *t > 0.0 && *t < 1.0).collect() } -/// Every boundary segment (consecutive nodes of a loop) is the side of exactly one triangle: +/// Every boundary segment (consecutive nodes of a loop) is the side of exactly one triangle (two +/// for a slit the loops run along both ways): /// the face covers its boundary with nothing missing or doubled, so it meets its neighbours /// exactly. Some boundary nodes are one vertex, a side ending on any of them the same side: pole /// copies of one node (consecutive in a loop, at one point, the segment between them of no @@ -1186,12 +1187,19 @@ fn closed_boundary(ranges: &[std::ops::Range], fixed: &[Vec3], uvs: &[[f6 } } } - ranges.iter().all(|r| { - (0..r.len()).all(|k| { + // Each boundary side has a triangle for every time the loops run along it: one, or two for + // a slit (a side run out and back, where the face meets itself along a line: a hole's wall + // touching the wall round it), one triangle either side. + let mut runs: HashMap<(u32, u32), u32> = HashMap::new(); + for r in ranges { + for k in 0..r.len() { let (a, b) = segment(r, k); - side(a, b).is_none_or(|k| sides.get(&k).copied() == Some(1)) - }) - }) + if let Some(k) = side(a, b) { + *runs.entry(k).or_default() += 1; + } + } + } + runs.iter().all(|(k, n)| sides.get(k).copied() == Some(*n)) } #[cfg(test)] diff --git a/crates/kernel/src/tess/tangle.rs b/crates/kernel/src/tess/tangle.rs index c53a982ce..877b65627 100644 --- a/crates/kernel/src/tess/tangle.rs +++ b/crates/kernel/src/tess/tangle.rs @@ -95,6 +95,19 @@ pub(crate) fn crossing(s: &EvalSurface, reach: f64, loops: &[seam::Loop]) -> Vec out.push(x.at); out.push(y.at); } + // A node of one chord lying on the other (inside it, not at its ends) is no crossing, + // but no triangulation can keep both as constraints either: where two curves leave a + // vertex they touch at along one tangent (a circle touching another from inside), the + // inner one's node can fall on the outer one's chord (with the outer chord twice the + // inner, exactly so but for the next order). The chord the node lies on is halved. + // (Not where the two chords run along one line: a seam's two uses, a period apart, + // lie on each other as copies.) + if !along(x.a, x.b, y.a, y.b) && [y.a, y.b].iter().any(|q| on(x.a, x.b, *q)) { + out.push(x.at); + } + if !along(y.a, y.b, x.a, x.b) && [x.a, x.b].iter().any(|q| on(y.a, y.b, *q)) { + out.push(y.at); + } } } out.sort_unstable(); @@ -102,6 +115,28 @@ pub(crate) fn crossing(s: &EvalSurface, reach: f64, loops: &[seam::Loop]) -> Vec out } +/// Whether `q` lies on the segment `ab` within [`STRADDLE`] (of the segment's squared length, +/// off its line) strictly between its ends (not at either, by the same measure along it). +fn on(a: [f64; 2], b: [f64; 2], q: [f64; 2]) -> bool { + let (dx, dy) = (b[0] - a[0], b[1] - a[1]); + let len2 = dx * dx + dy * dy; + if !(len2 > 0.0) { + return false; + } + let (qx, qy) = (q[0] - a[0], q[1] - a[1]); + let off = (dx * qy - dy * qx).abs(); + let along = (dx * qx + dy * qy) / len2; + off <= 1e3 * STRADDLE * len2 && along > 1e-6 && along < 1.0 - 1e-6 +} + +/// Whether `c` and `d` both lie on the line of `ab` (within [`on`]'s measure). +fn along(a: [f64; 2], b: [f64; 2], c: [f64; 2], d: [f64; 2]) -> bool { + let (dx, dy) = (b[0] - a[0], b[1] - a[1]); + let len2 = dx * dx + dy * dy; + let off = |q: [f64; 2]| (dx * (q[1] - a[1]) - dy * (q[0] - a[0])).abs(); + len2 > 0.0 && off(c) <= 1e3 * STRADDLE * len2 && off(d) <= 1e3 * STRADDLE * len2 +} + /// Whether the segments `ab` and `cd` cross: each one's ends strictly either side of the other. fn cross(a: [f64; 2], b: [f64; 2], c: [f64; 2], d: [f64; 2]) -> bool { let orient = |p: [f64; 2], q: [f64; 2], r: [f64; 2]| (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]); diff --git a/crates/kernel/src/tess/tests.rs b/crates/kernel/src/tess/tests.rs index a98fe87e0..81730249d 100644 --- a/crates/kernel/src/tess/tests.rs +++ b/crates/kernel/src/tess/tests.rs @@ -669,6 +669,39 @@ fn loops_touching_at_a_shared_vertex_bound_the_face() { assert!(closed_boundary(&ranges, &fixed, &uvs, &triangles), "the triangles follow both holes through their shared vertex"); } +/// A face meeting itself along a line (a hole's wall tangent inside the wall round it, cut from +/// the boss side's top rim down to the hole's bottom): its loop runs up the slit and back down +/// it, with the face on both sides. The iso-line grid's band beside the slit is the face on +/// either side of it, and the triangles follow the slit both ways and cover the whole square. +#[test] +fn a_slit_in_a_trimmed_face_has_the_face_on_both_sides() { + // The square [0, 8] × [0, 4], its loop starting at the slit's tip (3, 1) up to the top, round + // the square and back down the slit. + let mut uvs: Vec<[f64; 2]> = (1..=4).map(|k| [3.0, k as f64]).collect(); + uvs.extend((0..3).rev().map(|k| [k as f64, 4.0])); + uvs.extend((0..4).rev().map(|k| [0.0, k as f64])); + uvs.extend((1..=8).map(|k| [k as f64, 0.0])); + uvs.extend((1..=4).map(|k| [8.0, k as f64])); + uvs.extend((3..8).rev().map(|k| [k as f64, 4.0])); + uvs.extend((2..4).rev().map(|k| [3.0, k as f64])); + let fixed: Vec = uvs.iter().map(|q| Vec3::new(q[0], q[1], 0.0)).collect(); + let ranges = [std::ops::Range { start: 0, end: uvs.len() }]; + let traces = motorcycle::traces(&uvs, &ranges, [1.0, 1.0], 0.0); + let lines = |n: usize, top: f64| (0..=n).map(|k| top * k as f64 / n as f64).collect::>(); + let Some((extra, triangles)) = cutgrid::cut_grid(&uvs, &ranges, &lines(16, 8.0), &lines(8, 4.0), &traces, [1.0, 1.0]) else { panic!("meshes") }; + assert!(closed_boundary(&ranges, &fixed, &uvs, &triangles), "the triangles follow the slit both ways"); + let mut all = uvs.clone(); + all.extend(extra); + let area: f64 = triangles + .iter() + .map(|t| { + let [a, b, c] = t.map(|i| all[i as usize]); + 0.5 * ((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])) + }) + .sum(); + assert!((area - 32.0).abs() < 1e-12, "area {area}"); +} + /// A face whose loop is a thin lune meshes: a half disc of radius 2.5 less a circle through the /// same ends 0.03 mm inside it at the middle, its inner side split at 11.25°. Each edge is /// sampled to the 0.1 mm chord on its own: the outer arc's chords (every 22.5°) sag 0.048 mm, @@ -1001,3 +1034,22 @@ fn triangles_standing_across_a_curved_sheet_are_flipped_along_it() { assert!(sides.contains(&(2, 3)) && !sides.contains(&(0, 1)), "{tris:?}"); assert!(after < 0.5 * before, "{before} -> {after}"); } + +/// A disc with a boss standing on it tangent inside its rim: the disc's top is a ring whose inner +/// circle touches the outer one, one loop through the touching vertex. There both circles leave +/// along one tangent, and with the outer chord twice the inner (as their samplings fall) the inner +/// circle's first node lies on the outer's last chord: no triangulation keeps both. That chord is +/// halved, and the ring meshes strictly, to its area (300 pi), not the inner disc's. +#[test] +fn a_ring_touching_itself_at_a_vertex_meshes_strictly() { + use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; + let prism = |c: Vec2, r: f64, z0: f64, z1: f64| { + ok(crate::extrude(&Plane::XY, &[Region2 { outer: Loop2::circle(c, r), holes: vec![] }], z0, z1)).pop().unwrap() + }; + let stepped = + ok(crate::boolean(&prism(Vec2::ZERO, 20.0, 0.0, 5.0), &prism(Vec2::new(10.0, 0.0), 10.0, 5.0, 15.0), crate::BoolOp::Union)).unwrap(); + let (_, stats) = ok(plan(&record(&stepped), 1e-4, None)); + assert!(stats.lenient.is_empty(), "{:?}", stats.lenient.iter().map(|r| &r.reason).collect::>()); + let ring = ok(stepped.faces(1e-4)).into_iter().find(|f| (f.centroid.z - 5.0).abs() < 1e-6).unwrap(); + assert!((ring.area - 300.0 * PI).abs() < 0.05, "ring area {}", ring.area); +}