SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Display tessellation: trimmed faces as four-sided patches (#303) (#1163)
Irakli Kourtise3459edea806
diff --git a/README.md b/README.mdindex 815cc4d345..c9990f2cf4 100644--- a/README.md+++ b/README.md@@ -134,6 +134,16 @@ rebuild with no errors, replayed here at 2× speed.(manifold solid B-reps, or trimmed and bounded surfaces sewn into solids) as a base featurethat later features build on — open a `.step`/`.stp`/`.igs`/`.iges` file, insert one into adesign, or drop it on the window ([docs/step-import.md](docs/step-import.md)).+- **Display meshes** from our own tessellation planner: each face becomes a plan of (u, v)+ points and triangles that shares its edge nodes with its neighbours, so the mesh is watertight.+ Facets follow the chord tolerance, the facet angle and a longest side, with cells at most 2:1+ along straight directions. Box-bounded and four-cornered faces mesh as structured grids.+ Trimmed faces are cut into four-sided patches: squares around holes, butterflies in round+ faces, motorcycle traces from concave corners (after Lyon et al. 2019). Each patch then meshes+ as a Coons grid. Intersection edges are evaluated by Newton on both surfaces. A compute shader+ evaluates the plans for the whole scene in one dispatch, with a CPU fallback when the GPU+ can't build it. Planning and evaluating the 78 reference bodies takes about 65 ms, 50–65×+ faster than the previous mesher.- **Desktop app** (egui + wgpu): toolbar with workspace tabs, browser, timeline, 3D viewport withaxis view and navigation bar, sketch tools, feature dialogs, command palette, and a JSON-linescontrol channel so agents and tests can drive it.@@ -215,7 +225,7 @@ configuration and an example session: [docs/mcp.md](docs/mcp.md).| L2 | `doc` | parameters, expressions, the feature timeline and its incremental evaluation || L3 | `io` | design files, STL/OBJ/STEP/3MF export, STEP and 3MF/STL import features || L4 | `engine` | the session and the command registry (everything is a command) |-| L5 | `ui-egui`, `mcp` | the swappable desktop front end; the MCP server (headless or bridged to the app) |+| L5 | `gpu`, `ui-egui`, `mcp` | compute-shader evaluation of display tessellation plans; the swappable desktop front end; the MCP server (headless or bridged to the app) || apps | `solidcraft`, `solidcraft-cli` | desktop app, headless CLI |<!-- ANCHOR_END: architecture -->diff --git a/crates/kernel/src/display_mesh_tests.rs b/crates/kernel/src/display_mesh_tests.rsindex f2b0a17f41..13203e9f8b 100644--- a/crates/kernel/src/display_mesh_tests.rs+++ b/crates/kernel/src/display_mesh_tests.rs@@ -337,7 +337,9 @@ fn round_faces_of_every_kind_are_divided_by_the_angle() {let check = |name: &str, b: &Body| {let coarse = b.display_mesh(3.0).unwrap();let round = b.display_mesh_angular(3.0, DISPLAY_ANGLE).unwrap();- assert!(turn(b, &coarse) > 2.0 * DISPLAY_ANGLE, "{name}: the chord tolerance leaves facets of {} degrees", turn(b, &coarse).to_degrees());+ // The chord tolerance alone leaves facets coarser than the angle (the size rules' longest+ // side and aspect limit already keep them near 40°), so the angle has work to do.+ assert!(turn(b, &coarse) > 1.5 * DISPLAY_ANGLE, "{name}: the chord tolerance leaves facets of {} degrees", turn(b, &coarse).to_degrees());// A side crosses at most one facet in each direction.assert!(turn(b, &round) <= 1.5 * DISPLAY_ANGLE, "{name}: a side turns {} degrees", turn(b, &round).to_degrees());assert_eq!(open_sides(&round, 1e-6), 0, "{name}");diff --git a/crates/kernel/src/tess/cdt.rs b/crates/kernel/src/tess/cdt.rsindex 1dfed9c073..ec0df6d462 100644--- a/crates/kernel/src/tess/cdt.rs+++ b/crates/kernel/src/tess/cdt.rs@@ -135,6 +135,69 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range<usize>Some((extra, tris))}+/// The band between a face's boundary `loops` (ranges of the first `n` points of `points`) and+/// the staircase around a block of grid cells inside it (`stairs`, sides between grid points+/// of `points`): a constrained Delaunay triangulation of both with no point added, keeping the+/// faces inside the boundary and outside the block (an odd number of constraints from the+/// outside). Distances in the metric `scale`. Triangles counter-clockwise in (u, v), indices+/// into `points`; `None` when a constraint cannot be kept (the staircase meets the boundary).+pub(crate) fn band(points: &[[f64; 2]], n: usize, loops: &[std::ops::Range<usize>], stairs: &[(u32, u32)], scale: [f64; 2]) -> Option<Vec<[u32; 3]>> {+ let to = |p: &[f64; 2]| spade::mitigate_underflow(Point2::new(p[0] * scale[0], p[1] * scale[1]));+ let mut cdt = Cdt::new();+ let mut index: HashMap<FixedVertexHandle, u32> = HashMap::new();+ let mut handle: HashMap<u32, FixedVertexHandle> = HashMap::new();+ let mut add = |cdt: &mut Cdt, i: u32| -> Option<FixedVertexHandle> {+ if let Some(h) = handle.get(&i) {+ return Some(*h);+ }+ let p = points.get(i as usize)?;+ if !p.iter().all(|x| x.is_finite()) {+ return None;+ }+ let h = cdt.insert(to(p)).ok()?;+ // Two points at one place (pole copies) share a vertex: the first index names it.+ index.entry(h).or_insert(i);+ handle.insert(i, h);+ Some(h)+ };+ let mut sides: Vec<(FixedVertexHandle, FixedVertexHandle)> = Vec::new();+ for r in loops {+ let len = r.len();+ for k in 0..len {+ let (a, b) = (u32::try_from(r.start + k).ok()?, u32::try_from(r.start + (k + 1) % len).ok()?);+ if (a as usize) >= n || (b as usize) >= n {+ return None;+ }+ sides.push((add(&mut cdt, a)?, add(&mut cdt, b)?));+ }+ }+ for &(a, b) in stairs {+ sides.push((add(&mut cdt, a)?, add(&mut cdt, b)?));+ }+ for (a, b) in sides {+ if a == b || cdt.exists_constraint(a, b) {+ continue;+ }+ if !cdt.can_add_constraint(a, b) {+ return None;+ }+ cdt.add_constraint(a, b);+ }+ let region = region(&cdt);+ let mut tris = Vec::new();+ for face in cdt.inner_faces() {+ if !region.get(face.index()).copied().unwrap_or(false) {+ continue;+ }+ let mut t = [0u32; 3];+ for (slot, v) in t.iter_mut().zip(face.vertices()) {+ *slot = *index.get(&v.fix())?;+ }+ tris.push(t);+ }+ Some(tris)+}+/// Insert the parameters of the surface point under every triangle centre that lies more than/// the tolerance from the triangle or whose corner normals turn more than the facet angle, and/// under the middle of every non-constraint side that sags more than the tolerance or isdiff --git a/crates/kernel/src/tess/collar.rs b/crates/kernel/src/tess/collar.rsnew file mode 100644index 0000000000..341271b82e--- /dev/null+++ b/crates/kernel/src/tess/collar.rs@@ -0,0 +1,224 @@+//! The cuts that make every patch of a trimmed face four-sided. Each hole gets a square around+//! it in (u, v) (sides on iso-lines, halfway to the nearest other feature), joined to the hole at+//! the hole's four 45° points: the ring between hole and square is four collar patches (a quarter+//! of the hole's edge, a straight cut, a side of the square, a straight cut), the O-grid round a+//! hole. The motorcycle graph then runs with the squares as the obstacles (Lyon et al. 2019 §4):+//! a square's corners are its concave peaks, so the traces extend the squares' sides, and every+//! patch outside the collars is a rectangle bounded by iso-lines.++use super::motorcycle::{self, End as Stop};+use super::pieces::{End, Segment};++/// The face's cuts, given its boundary loops (ranges of `uvs`), the metric `scale` and the face's+/// seed (its node spacing, mm; traces less than a quarter of it apart meet head-on). `flat`: the+/// face is a plane, whose shading does not depend on its interior: a butterfly's square sides+/// take half the facing arc's count there (each wing steps 2:1), instead of the whole count. `None` when the face has no hole, or a hole has no room+/// for a collar (it touches another feature).+pub(crate) fn segments(uvs: &[[f64; 2]], loops: &[std::ops::Range<usize>], scale: [f64; 2], seed: f64, flat: bool) -> Option<Vec<Segment>> {+ let snap = 0.25 * seed;+ let metric = |q: [f64; 2]| [q[0] * scale[0], q[1] * scale[1]];+ let unmetric = |q: [f64; 2]| [q[0] / scale[0], q[1] / scale[1]];+ let area = |r: &std::ops::Range<usize>| -> f64 {+ let m = r.len();+ (0..m)+ .filter_map(|k| {+ let (a, b) = (metric(*uvs.get(r.start + k)?), metric(*uvs.get(r.start + (k + 1) % m)?));+ Some(0.5 * (a[0] * b[1] - b[0] * a[1]))+ })+ .sum()+ };+ // The outer loop encloses the most area; the others are holes.+ let outer = loops.iter().enumerate().max_by(|a, b| area(a.1).abs().total_cmp(&area(b.1).abs()))?.0;+ let holes: Vec<&std::ops::Range<usize>> = loops.iter().enumerate().filter(|(i, _)| *i != outer).map(|(_, r)| r).collect();+ let outer = loops.get(outer)?;+ let bbox = |r: &std::ops::Range<usize>| -> Option<([f64; 2], [f64; 2])> {+ let (mut lo, mut hi) = ([f64::MAX; 2], [f64::MIN; 2]);+ for k in r.clone() {+ let q = metric(*uvs.get(k)?);+ for d in 0..2 {+ lo[d] = lo[d].min(q[d]);+ hi[d] = hi[d].max(q[d]);+ }+ }+ Some((lo, hi))+ };+ // The node of loop `r` furthest out towards each corner of its box, in the box's own+ // proportions (its 45° points on a round loop), corner by corner from (min, min).+ let supports = |r: &std::ops::Range<usize>| -> Option<[usize; 4]> {+ let (lo, hi) = bbox(r)?;+ let (w, h) = (hi[0] - lo[0], hi[1] - lo[1]);+ if !(w > 0.0 && h > 0.0) {+ return None;+ }+ let mut out = [0usize; 4];+ for (slot, dir) in out.iter_mut().zip([[-1.0, -1.0], [1.0, -1.0], [1.0, 1.0], [-1.0, 1.0]]) {+ let reach = |i: usize| {+ uvs.get(i).map_or(f64::MIN, |q| {+ let q = metric(*q);+ dir[0] * (q[0] - lo[0]) / w + dir[1] * (q[1] - lo[1]) / h+ })+ };+ *slot = (r.start..r.end).max_by(|&x, &y| reach(x).total_cmp(&reach(y)))?;+ }+ let mut distinct = out.to_vec();+ distinct.sort_unstable();+ distinct.dedup();+ (distinct.len() == 4).then_some(out)+ };+ // The arc of loop `r` (in nodes) between its support points `a` and `b`, the way that passes+ // neither of the other two.+ let side_count = |n: usize| if flat { n.div_ceil(2).max(1) } else { n.max(1) };+ let arc = |r: &std::ops::Range<usize>, p: &[usize; 4], k: usize| -> Option<usize> {+ let m = r.len();+ let (a, b) = (*p.get(k)? - r.start, *p.get((k + 1) % 4)? - r.start);+ let fwd = (b + m - a) % m;+ let others: Vec<usize> = (0..4).filter(|&j| j != k && j != (k + 1) % 4).filter_map(|j| p.get(j).map(|x| (x - r.start + m - a) % m)).collect();+ Some(if others.iter().all(|&o| o > fwd) { fwd } else { m - fwd })+ };+ // A face of one round loop (no hole, no concave peak; a disc, an ellipse): the butterfly.+ // A square inside it, its corners halfway from the loop's centre to the loop's four 45°+ // points, each joined to its point; each square side in as many segments as the arc facing+ // it. Five four-sided patches: the square and four wings.+ if holes.is_empty() {+ let alone: Vec<[f64; 2]> = outer.clone().filter_map(|k| uvs.get(k).copied()).collect();+ if !motorcycle::traces(&alone, &[std::ops::Range { start: 0, end: alone.len() }], scale, snap).is_empty() {+ return None;+ }+ let p = supports(outer)?;+ let (lo, hi) = bbox(outer)?;+ let centre = [0.5 * (lo[0] + hi[0]), 0.5 * (lo[1] + hi[1])];+ let mut corners = [[0.0; 2]; 4];+ for (c, &i) in corners.iter_mut().zip(&p) {+ let q = metric(*uvs.get(i)?);+ *c = unmetric([centre[0] + 0.5 * (q[0] - centre[0]), centre[1] + 0.5 * (q[1] - centre[1])]);+ }+ let mut segs = Vec::with_capacity(8);+ for k in 0..4 {+ segs.push(Segment {+ a: End::Point(*corners.get(k)?),+ b: End::Point(*corners.get((k + 1) % 4)?),+ count: Some(side_count(arc(outer, &p, k)?)),+ });+ }+ for (k, &i) in p.iter().enumerate() {+ segs.push(Segment { a: End::Point(*corners.get(k)?), b: End::Node(u32::try_from(i).ok()?), count: None });+ }+ return Some(segs);+ }+ // A square needs a strip at least a seed wide between it and the outer loop on every side+ // (and a seed of collar inside it): a hole with less than two seeds to the outer loop on any+ // side has no room for one, so the outer loop is its square, and the collar cuts join the+ // hole's 45° points to the outer loop's.+ let (olo, ohi) = bbox(outer)?;+ for hole in &holes {+ let (lo, hi) = bbox(hole)?;+ let gaps = [lo[0] - olo[0], lo[1] - olo[1], ohi[0] - hi[0], ohi[1] - hi[1]];+ if holes.len() == 1 && gaps.iter().any(|g| *g < 2.0 * seed) {+ let (inner, out) = (supports(hole)?, supports(outer)?);+ return inner+ .iter()+ .zip(out)+ .map(|(&a, b)| Some(Segment { a: End::Node(u32::try_from(a).ok()?), b: End::Node(u32::try_from(b).ok()?), count: None }))+ .collect();+ }+ }+ let boxes: Vec<([f64; 2], [f64; 2])> = holes.iter().map(|r| bbox(r)).collect::<Option<_>>()?;+ // Distances in the metric: point to box, point to segment, box to box.+ let to_box = |p: [f64; 2], (lo, hi): ([f64; 2], [f64; 2])| {+ let dx = (lo[0] - p[0]).max(0.0).max(p[0] - hi[0]);+ let dy = (lo[1] - p[1]).max(0.0).max(p[1] - hi[1]);+ dx.hypot(dy)+ };+ let to_segment = |p: [f64; 2], a: [f64; 2], b: [f64; 2]| {+ let (ab, ap) = ([b[0] - a[0], b[1] - a[1]], [p[0] - a[0], p[1] - a[1]]);+ let len2 = ab[0] * ab[0] + ab[1] * ab[1];+ let t = if len2 > 0.0 { ((ap[0] * ab[0] + ap[1] * ab[1]) / len2).clamp(0.0, 1.0) } else { 0.0 };+ (p[0] - a[0] - t * ab[0]).hypot(p[1] - a[1] - t * ab[1])+ };+ let corners_of = |(lo, hi): ([f64; 2], [f64; 2])| [[lo[0], lo[1]], [hi[0], lo[1]], [hi[0], hi[1]], [lo[0], hi[1]]];+ // Each square: the hole's box grown by half its clearance to the outer loop and a quarter of+ // its gap to another hole's box (both squares grow into that gap), so squares never touch.+ let m = outer.len();+ let mut squares: Vec<([f64; 2], [f64; 2])> = Vec::with_capacity(boxes.len());+ for (i, &bx) in boxes.iter().enumerate() {+ let mut clear = f64::INFINITY;+ for k in 0..m {+ let (a, b) = (metric(*uvs.get(outer.start + k)?), metric(*uvs.get(outer.start + (k + 1) % m)?));+ clear = clear.min(to_box(a, bx));+ for c in corners_of(bx) {+ clear = clear.min(to_segment(c, a, b));+ }+ }+ for (j, &other) in boxes.iter().enumerate() {+ if j != i {+ // Box to box: the gap along each axis.+ let gx = (other.0[0] - bx.1[0]).max(bx.0[0] - other.1[0]).max(0.0);+ let gy = (other.0[1] - bx.1[1]).max(bx.0[1] - other.1[1]).max(0.0);+ // Both holes' squares grow into this gap: each takes half of it.+ clear = clear.min(0.5 * gx.hypot(gy));+ }+ }+ let margin = 0.5 * clear;+ if !(margin.is_finite() && margin > 0.0) {+ return None;+ }+ squares.push(([bx.0[0] - margin, bx.0[1] - margin], [bx.1[0] + margin, bx.1[1] + margin]));+ }+ let mut segs: Vec<Segment> = Vec::new();+ // Each hole's four 45° points (towards its square's corners, in order).+ let picks: Vec<[usize; 4]> = holes.iter().map(|r| supports(r)).collect::<Option<_>>()?;+ // Square sides (four per hole, corner k to corner k + 1), each in as many segments as the+ // hole's arc facing it (between its 45° points k and k + 1, the way that passes neither+ // other point): the wings of the butterfly then have matching opposite sides.+ for ((&sq, hole), p) in squares.iter().zip(&holes).zip(&picks) {+ let c = corners_of(sq).map(unmetric);+ for k in 0..4 {+ segs.push(Segment { a: End::Point(*c.get(k)?), b: End::Point(*c.get((k + 1) % 4)?), count: Some(side_count(arc(hole, p, k)?)) });+ }+ }+ for (p, &sq) in picks.iter().zip(&squares) {+ let c = corners_of(sq).map(unmetric);+ for (k, &i) in p.iter().enumerate() {+ segs.push(Segment { a: End::Point(*c.get(k)?), b: End::Node(u32::try_from(i).ok()?), count: None });+ }+ }+ // The motorcycles, with the squares as the obstacles: the outer loop, then each square as a+ // loop of its four corners.+ let mut domain: Vec<[f64; 2]> = outer.clone().filter_map(|k| uvs.get(k).copied()).collect();+ let mut dloops = vec![std::ops::Range { start: 0, end: domain.len() }];+ for &sq in &squares {+ let start = domain.len();+ domain.extend(corners_of(sq).map(unmetric));+ dloops.push(start..start + 4);+ }+ let traces = motorcycle::traces(&domain, &dloops, scale, snap);+ let base = segs.len();+ let on_outer = |i: usize| i < outer.len();+ for (ti, t) in traces.iter().enumerate() {+ let start = if on_outer(t.start) { End::Node(u32::try_from(outer.start + t.start).ok()?) } else { End::Point(*domain.get(t.start)?) };+ let end = match t.end {+ Stop::Boundary(a, b) if on_outer(a) && on_outer(b) => {+ // The nearer end of the boundary segment it reached (a cut never adds a node to+ // the boundary).+ let (pa, pb) = (metric(*domain.get(a)?), metric(*domain.get(b)?));+ let q = metric(t.b);+ let k = if (pa[0] - q[0]).hypot(pa[1] - q[1]) <= (pb[0] - q[0]).hypot(pb[1] - q[1]) { a } else { b };+ End::Node(u32::try_from(outer.start + k).ok()?)+ }+ Stop::Boundary(a, b) => {+ // A side of a square: corners `a` and `b` of square `s`.+ let (s, la, lb) = ((a - outer.len()) / 4, (a - outer.len()) % 4, (b - outer.len()) % 4);+ let k = if (la + 1) % 4 == lb { la } else { lb };+ End::On(4 * s + k, t.b)+ }+ Stop::Trace(c) => End::On(base + c, t.b),+ Stop::HeadOn(j) => {+ let o = traces.get(j)?;+ End::Point([0.5 * (t.b[0] + o.b[0]), 0.5 * (t.b[1] + o.b[1])])+ }+ };+ let _ = ti;+ segs.push(Segment { a: start, b: end, count: None });+ }+ Some(segs)+}diff --git a/crates/kernel/src/tess/coons.rs b/crates/kernel/src/tess/coons.rsindex 6f79d51808..e803f7dc4f 100644--- a/crates/kernel/src/tess/coons.rs+++ b/crates/kernel/src/tess/coons.rs@@ -14,11 +14,20 @@ const CORNER_TURN: f64 = 0.6;struct Side {nodes: Vec<u32>,at: Vec<f64>,+ /// Its length in 3D (mm).+ len: f64,}/// The four corners of a single boundary loop, by how sharply the loop turns there in (u, v)/// scaled by `scale` (one unit per tolerance cell); `None` unless there are exactly four.fn corners(uv: &[[f64; 2]], scale: [f64; 2]) -> Option<[usize; 4]> {+ let [a, b, c, d] = candidates(uv, scale)?[..] else { return None };+ Some([a, b, c, d])+}++/// Every node where the loop turns more than [`CORNER_TURN`] (or meets a pole copy), in loop+/// order.+fn candidates(uv: &[[f64; 2]], scale: [f64; 2]) -> Option<Vec<usize>> {let n = uv.len();if n < 4 {return None;@@ -39,8 +48,60 @@ fn corners(uv: &[[f64; 2]], scale: [f64; 2]) -> Option<[usize; 4]> {found.push(i);}}- let [a, b, c, d] = found[..] else { return None };- Some([a, b, c, d])+ Some(found)+}++/// Most segments a patch's own level gives one direction.+const MAX_LEVEL: usize = 4096;++/// Most corner candidates [`coons_best`] chooses four from (8 choose 4 = 70 blends at most).+const MAX_CANDIDATES: usize = 8;++/// Like [`coons`] for a loop with more than four corners (a patch of a trimmed face with a+/// corner cut off, the wing of a butterfly around a hole): every choice of four of its corners+/// is blended, and the one whose smallest triangle angle (in the metric `scale`) is largest+/// wins. Its other corners lie on sides. `None` if no choice gives a blend that does not fold.+pub(crate) fn coons_best(uv: &[[f64; 2]], fixed: &[Vec3], scale: [f64; 2], max_points: usize, h: f64) -> Option<(Vec<[f64; 2]>, Vec<[u32; 3]>)> {+ let c = candidates(uv, scale)?;+ if c.len() < 4 || c.len() > MAX_CANDIDATES {+ return None;+ }+ let mut best: Option<(f64, (Vec<[f64; 2]>, Vec<[u32; 3]>))> = None;+ let k = c.len();+ for a in 0..k {+ for b in a + 1..k {+ for d in b + 1..k {+ for e in d + 1..k {+ let pick = [*c.get(a)?, *c.get(b)?, *c.get(d)?, *c.get(e)?];+ let Some(r) = coons_at(uv, fixed, pick, max_points, h, None) else { continue };+ let q = min_angle(uv, &r, scale);+ if best.as_ref().is_none_or(|(bq, _)| q > *bq) {+ best = Some((q, r));+ }+ }+ }+ }+ }+ best.map(|(_, r)| r)+}++/// Smallest corner angle (radians) of the triangles, in the metric.+fn min_angle(uv: &[[f64; 2]], r: &(Vec<[f64; 2]>, Vec<[u32; 3]>), scale: [f64; 2]) -> f64 {+ let at = |i: u32| {+ let i = i as usize;+ let q = if i < uv.len() { uv.get(i) } else { r.0.get(i - uv.len()) };+ q.map(|q| [q[0] * scale[0], q[1] * scale[1]])+ };+ let mut worst = std::f64::consts::PI;+ for t in &r.1 {+ let (Some(a), Some(b), Some(c)) = (at(t[0]), at(t[1]), at(t[2])) else { continue };+ for (p, q, s) in [(a, b, c), (b, c, a), (c, a, b)] {+ let (u, v) = ([q[0] - p[0], q[1] - p[1]], [s[0] - p[0], s[1] - p[1]]);+ let ang = (u[0] * v[1] - u[1] * v[0]).abs().atan2(u[0] * v[0] + u[1] * v[1]);+ worst = worst.min(ang);+ }+ }+ worst}fn side(fixed: &[Vec3], n: usize, from: usize, to: usize) -> Option<Side> {@@ -58,9 +119,9 @@ fn side(fixed: &[Vec3], n: usize, from: usize, to: usize) -> Option<Side> {if !(total > 0.0) {// A pole side: evenly along it.let m = (nodes.len() - 1).max(1) as f64;- return Some(Side { at: (0..nodes.len()).map(|k| k as f64 / m).collect(), nodes });+ return Some(Side { at: (0..nodes.len()).map(|k| k as f64 / m).collect(), nodes, len: 0.0 });}- Some(Side { nodes, at: at.into_iter().map(|x| x / total).collect() })+ Some(Side { nodes, at: at.into_iter().map(|x| x / total).collect(), len: total })}/// The point of a side at position `s` (0 to 1), linear between its nodes.@@ -72,9 +133,12 @@ fn along(side: &Side, uv: &[[f64; 2]], s: f64) -> Option<[f64; 2]> {Some([p[0] + (q[0] - p[0]) * f, p[1] + (q[1] - p[1]) * f])}-/// Interior line positions for a pair of opposite sides: the sides' own when they have the-/// same nodes (so the grid meets both node for node), else evenly as many as the denser side.-fn lines(a: &Side, b: &Side) -> Vec<f64> {+/// Interior line positions for a pair of opposite sides: the sides' own when they have as many+/// nodes as each other (so the grid meets both node for node); else evenly at the inner level a+/// GPU tessellator takes, the larger of the two sides' (outer) levels, and never coarser than the+/// size rules ask (the sides' mean length over the target side `h`). The denser side then meets+/// the grid node for node and the sparser one steps down to it through its ring.+fn lines(a: &Side, b: &Side, h: f64) -> Vec<f64> {let inner = |s: &Side| s.at.get(1..s.at.len().saturating_sub(1)).map(<[f64]>::to_vec).unwrap_or_default();if a.at.len() == b.at.len() {let l: Vec<f64> = inner(a).iter().zip(inner(b)).map(|(x, y)| 0.5 * (x + y)).collect();@@ -82,23 +146,43 @@ fn lines(a: &Side, b: &Side) -> Vec<f64> {return l;}}- let n = a.at.len().max(b.at.len()).saturating_sub(1).max(2);+ let size = if h > 0.0 { (0.5 * (a.len + b.len) / h).ceil() } else { 1.0 };+ let size = if size.is_finite() { size as usize } else { 1 };+ let outer = a.at.len().max(b.at.len()).saturating_sub(1);+ let n = outer.max(size).clamp(2, MAX_LEVEL);(1..n).map(|i| i as f64 / n as f64).collect()}/// Triangulate the loop `uv` (with its fixed 3D nodes) as a Coons patch: boundary vertices/// keep their indices, the interior grid follows. Triangles counter-clockwise in (u, v).-/// `fine(a, b)`: whether the surface between two parameter points needs no point between them-/// (the grid lines, taken from the sides, are split inside the face where it does not).+///+/// `fine(a, b)`: whether the surface between two parameter points needs no point between them.+/// Given for a whole face, whose sides are its edges' nodes: where its grid converges (towards a+/// pole) the interior can need more lines than the sides carry, and the lines are split there.+/// A motorcycle patch passes `None`: its sides are cuts seeded at the face's global seed.pub(crate) fn coons(uv: &[[f64; 2]],fixed: &[Vec3],scale: [f64; 2],max_points: usize,- fine: &dyn Fn([f64; 2], [f64; 2]) -> bool,+ h: f64,+ fine: Option<&dyn Fn([f64; 2], [f64; 2]) -> bool>,+) -> Option<(Vec<[f64; 2]>, Vec<[u32; 3]>)> {+ let pick = corners(uv, scale)?;+ coons_at(uv, fixed, pick, max_points, h, fine)+}++/// [`coons`] with the four corners given (loop indices, in loop order).+pub(crate) fn coons_at(+ uv: &[[f64; 2]],+ fixed: &[Vec3],+ pick: [usize; 4],+ max_points: usize,+ h: f64,+ fine: Option<&dyn Fn([f64; 2], [f64; 2]) -> bool>,) -> Option<(Vec<[f64; 2]>, Vec<[u32; 3]>)> {let n = uv.len();- let [c0, c1, c2, c3] = corners(uv, scale)?;+ let [c0, c1, c2, c3] = pick;// Sides in loop order; the bottom (0) and right (1) run with the loop, the top (2) and// left (3) against it, so s and t both run from corner c0.let bottom = side(fixed, n, c0, c1)?;@@ -116,8 +200,16 @@ pub(crate) fn coons(};Some([blend(0), blend(1)])};- let ss = refine(lines(&bottom, &top), max_points, &|a, b, x| Some(fine(at(a, x)?, at(b, x)?)));- let ts = refine(lines(&left, &right), max_points, &|a, b, x| Some(fine(at(x, a)?, at(x, b)?)));+ // The lines come from the sides' seeds (see [`lines`]): every side is seeded at the face's+ // global seed, which the size rules set for the whole surface, so the interior needs no finer+ // spacing than its sides.+ let (ss, ts) = (lines(&bottom, &top, h), lines(&left, &right, h));+ let (ss, ts) = match fine {+ Some(fine) => {+ (refine(ss, max_points, &|a, b, x| Some(fine(at(a, x)?, at(b, x)?))), refine(ts, max_points, &|a, b, x| Some(fine(at(x, a)?, at(x, b)?))))+ }+ None => (ss, ts),+ };if ss.len().checked_mul(ts.len())? > max_points {return None;}@@ -141,10 +233,46 @@ pub(crate) fn coons(// the bottom and right strips come out counter-clockwise, the top and left clockwise.let row = |j: usize| (0..ns).map(|i| g(i, j)).collect::<Vec<u32>>();let col = |i: usize| (0..nt).map(|j| g(i, j)).collect::<Vec<u32>>();- zip(&bottom, &row(0), &ss, false, &mut tris)?;- zip(&right, &col(ns - 1), &ts, false, &mut tris)?;- zip(&top, &row(nt - 1), &ss, true, &mut tris)?;- zip(&left, &col(0), &ts, true, &mut tris)?;+ // Where a side's segments and its grid row's differ, a transition row steps between them+ // halfway to the first grid line (its segments the two counts' geometric mean), each zipped+ // to it, with one triangle at each end closing it against the corner.+ let (s_first, s_last) = (*ss.first()?, *ss.last()?);+ let (t_first, t_last) = (*ts.first()?, *ts.last()?);+ // Each side: its grid row, the row's positions, the orientation, where the transition row+ // runs, and the point at a position along it. The row lies halfway between the side and the+ // grid row; its ends lie halfway between the diagonal from the corner to the grid row's end+ // and that end, so they are strictly inside the side's own ring.+ #[allow(clippy::type_complexity)]+ let sides: [(&Side, Vec<u32>, &[f64], bool, (f64, f64), &dyn Fn(f64) -> [f64; 2]); 4] = [+ (&bottom, row(0), &ss, false, (0.75 * s_first, 1.0 - 0.75 * (1.0 - s_last)), &|x| [x, 0.5 * t_first]),+ (&right, col(ns - 1), &ts, false, (0.75 * t_first, 1.0 - 0.75 * (1.0 - t_last)), &|x| [0.5 * (1.0 + s_last), x]),+ (&top, row(nt - 1), &ss, true, (0.75 * s_first, 1.0 - 0.75 * (1.0 - s_last)), &|x| [x, 0.5 * (1.0 + t_last)]),+ (&left, col(0), &ts, true, (0.75 * t_first, 1.0 - 0.75 * (1.0 - t_last)), &|x| [0.5 * s_first, x]),+ ];+ for (side, inner, inner_at, flip, (x0, x1), place) in sides {+ let (outer_segs, inner_segs) = (side.nodes.len().saturating_sub(1), inner.len() + 1);+ let mean = ((outer_segs * inner_segs) as f64).sqrt().round() as usize;+ if mean == outer_segs || mean == inner_segs || mean < 2 {+ zip(side, &inner, inner_at, flip, &mut tris)?;+ continue;+ }+ let k = mean - 1;+ let at_t: Vec<f64> = (0..k).map(|j| if k > 1 { x0 + (x1 - x0) * j as f64 / (k - 1) as f64 } else { 0.5 * (x0 + x1) }).collect();+ let mut mid: Vec<u32> = Vec::with_capacity(k);+ for &x in &at_t {+ let [sx, tx] = place(x);+ mid.push(u32::try_from(out.len()).ok()?);+ out.push(at(sx, tx)?);+ }+ zip(side, &mid, &at_t, flip, &mut tris)?;+ zip(&Side { nodes: mid.clone(), at: at_t.clone(), len: 0.0 }, &inner, inner_at, flip, &mut tris)?;+ // The two end triangles: corner, transition end, grid end, turned like the zips' (in+ // (s, t) the first runs with them and the last against). Never turned to fit the blend:+ // a blend that folds there leaves one inverted, and the patch is refused below.+ for t in [[*side.nodes.first()?, *mid.first()?, *inner.first()?], [*side.nodes.last()?, *inner.last()?, *mid.last()?]] {+ tris.push(if flip { [t[0], t[2], t[1]] } else { t });+ }+ }// The (s, t) square maps to (u, v) keeping or reversing orientation, with the loop: all// triangles must share one sign, which is then made counter-clockwise.let area = |t: &[u32; 3]| -> Option<f64> {@@ -188,7 +316,7 @@ fn refine(lines: Vec<f64>, max: usize, fine: &dyn Fn(f64, f64, f64) -> Option<bo}fn reversed(s: Side) -> Side {- Side { nodes: s.nodes.into_iter().rev().collect(), at: s.at.into_iter().rev().map(|x| 1.0 - x).collect() }+ Side { nodes: s.nodes.into_iter().rev().collect(), at: s.at.into_iter().rev().map(|x| 1.0 - x).collect(), len: s.len }}/// Join a side (its nodes at positions `side.at`) to a grid row at positions `inner_at`.@@ -251,7 +379,7 @@ mod tests {b.reverse();}let fixed: Vec<Vec3> = b.iter().map(|p| Vec3::new(p[0], p[1], 0.0)).collect();- let Some((extra, tris)) = coons(&b, &fixed, [1.0, 1.0], 10_000, &|_, _| true) else { panic!("meshes (k {k})") };+ let Some((extra, tris)) = coons(&b, &fixed, [1.0, 1.0], 10_000, 1.0, None) else { panic!("meshes (k {k})") };let mut uv = b.clone();uv.extend(extra);assert!((area(&uv, &tris) - 16.0).abs() < 1e-9, "k {k} reverse {reverse}: {}", area(&uv, &tris));@@ -259,10 +387,146 @@ mod tests {}}+ /// Opposite sides with different node counts (20 against 4): the interior grid takes the+ /// larger side's level (a tessellator's inner level), so the dense side meets it node for node+ /// and the sparse side steps down to it through a transition row. Covered exactly, nothing+ /// missing or doubled.+ #[test]+ fn the_interior_level_is_the_larger_sides_and_the_sparser_side_steps_down() {+ // A 4 × 4 square: bottom in 20 segments, the other sides in 4.+ let mut b: Vec<[f64; 2]> = (0..20).map(|k| [k as f64 * 0.2, 0.0]).collect();+ b.extend((0..4).map(|k| [4.0, k as f64]));+ b.extend((0..4).map(|k| [4.0 - k as f64, 4.0]));+ b.extend((0..4).map(|k| [0.0, 4.0 - k as f64]));+ let fixed: Vec<Vec3> = b.iter().map(|p| Vec3::new(p[0], p[1], 0.0)).collect();+ let Some((extra, tris)) = coons(&b, &fixed, [1.0, 1.0], 10_000, 1.0, None) else { panic!("meshes") };+ let mut uv = b.clone();+ uv.extend(extra.iter().copied());+ assert!((area(&uv, &tris) - 16.0).abs() < 1e-9);+ // Level 20 along s (the bottom's), 4 along t: 19 × 3 interior points; plus the transition+ // row by the 4-segment top (√(4 · 20) ≈ 9 segments: 8 points).+ assert_eq!(extra.len(), 19 * 3 + 8, "{}", extra.len());+ // Every inner side shared by two triangles, every boundary side used once: nothing+ // missing or doubled at the transition's ends.+ let mut sides: std::collections::HashMap<(u32, u32), i32> = std::collections::HashMap::new();+ for t in &tris {+ for e in 0..3 {+ *sides.entry((t[e], t[(e + 1) % 3])).or_default() += 1;+ }+ }+ let n = b.len() as u32;+ for (&(a, c), &k) in &sides {+ assert_eq!(k, 1, "side {a}-{c} once each way");+ let boundary = a < n && c < n && (c == (a + 1) % n);+ assert!(boundary || sides.contains_key(&(c, a)), "inner side {a}-{c} shared");+ }+ }+#[test]fn five_corners_is_not_a_coons_patch() {let b = [[0.0, 0.0], [1.0, 0.0], [1.0, 0.5], [0.5, 1.0], [0.0, 1.0]];let fixed: Vec<Vec3> = b.iter().map(|p| Vec3::new(p[0], p[1], 0.0)).collect();- assert!(coons(&b, &fixed, [1.0, 1.0], 100, &|_, _| true).is_none());+ assert!(coons(&b, &fixed, [1.0, 1.0], 100, 1.0, None).is_none());+ }++ /// A planar strip with a fillet at one end and a chamfer at the other, in mm (a face of+ /// robustness seed 33): its corners make the one-segment chamfer a side facing the long one,+ /// and at some target sides the blend folds beside the chamfer. The transition row's end+ /// triangles are turned like its zips, never to fit the blend, so a fold leaves a triangle+ /// inverted and the blend is refused; any blend given covers the loop exactly once.+ #[test]+ #[allow(clippy::approx_constant)] // measured coordinates, one of them near ln 10+ fn a_blend_folding_beside_a_short_side_is_refused_not_overlapped() {+ let b: Vec<[f64; 2]> = vec![+ [24.0000, 3.0150],+ [23.0000, 4.4292],+ [16.6667, 4.4292],+ [10.3333, 4.4292],+ [4.0000, 4.4292],+ [4.0000, 3.0150],+ [4.0002, 2.9836],+ [4.0010, 2.9520],+ [4.0023, 2.9201],+ [4.0040, 2.8880],+ [4.0064, 2.8556],+ [4.0092, 2.8231],+ [4.0127, 2.7905],+ [4.0167, 2.7577],+ [4.0213, 2.7248],+ [4.0265, 2.6919],+ [4.0322, 2.6589],+ [4.0386, 2.6259],+ [4.0456, 2.5929],+ [4.0532, 2.5600],+ [4.0614, 2.5272],+ [4.0702, 2.4945],+ [4.0797, 2.4619],+ [4.0897, 2.4295],+ [4.1004, 2.3974],+ [4.1117, 2.3655],+ [4.1236, 2.3339],+ [4.1362, 2.3026],+ [4.1493, 2.2717],+ [4.1630, 2.2412],+ [4.1773, 2.2111],+ [4.1922, 2.1814],+ [4.2076, 2.1523],+ [4.2236, 2.1237],+ [4.2402, 2.0956],+ [4.2573, 2.0681],+ [4.2748, 2.0412],+ [4.2929, 2.0150],+ [4.3114, 1.9895],+ [4.3304, 1.9646],+ [4.3499, 1.9405],+ [4.3697, 1.9171],+ [4.3899, 1.8945],+ [4.4105, 1.8726],+ [4.4315, 1.8516],+ [4.4528, 1.8313],+ [4.4744, 1.8119],+ [4.4962, 1.7934],+ [4.5184, 1.7757],+ [4.5407, 1.7588],+ [4.5633, 1.7428],+ [4.5860, 1.7277],+ [4.6089, 1.7135],+ [4.6319, 1.7001],+ [4.6550, 1.6876],+ [4.6783, 1.6760],+ [4.7015, 1.6653],+ [4.7248, 1.6554],+ [4.7482, 1.6464],+ [4.7715, 1.6382],+ [4.7948, 1.6309],+ [4.8180, 1.6244],+ [4.8412, 1.6188],+ [4.8643, 1.6139],+ [4.8873, 1.6098],+ [4.9101, 1.6065],+ [4.9329, 1.6040],+ [4.9554, 1.6022],+ [4.9778, 1.6012],+ [5.0000, 1.6008],+ [11.3333, 1.6008],+ [17.6667, 1.6008],+ [24.0000, 1.6008],+ ];+ let fixed: Vec<Vec3> = b.iter().map(|p| Vec3::new(p[0], p[1], 0.0)).collect();+ let n = b.len();+ let loop_area: f64 = (0..n).map(|k| 0.5 * (b[k][0] * b[(k + 1) % n][1] - b[(k + 1) % n][0] * b[k][1])).sum();+ for h in [0.25, 0.5, 0.75, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, 8.0] {+ let Some((extra, tris)) = coons(&b, &fixed, [1.0, 1.0], 100_000, h, None) else { continue };+ let mut uv = b.clone();+ uv.extend(extra);+ assert!((area(&uv, &tris) - loop_area).abs() < 1e-9 * loop_area, "h {h}: {} for {loop_area}", area(&uv, &tris));+ let mut sides: std::collections::HashMap<(u32, u32), usize> = std::collections::HashMap::new();+ for t in &tris {+ for k in 0..3 {+ *sides.entry((t[k], t[(k + 1) % 3])).or_default() += 1;+ }+ }+ assert!(sides.values().all(|&k| k == 1), "h {h}: a side used twice the same way");+ }}}diff --git a/crates/kernel/src/tess/cutgrid.rs b/crates/kernel/src/tess/cutgrid.rsnew file mode 100644index 0000000000..2c53dc8a7f--- /dev/null+++ b/crates/kernel/src/tess/cutgrid.rs@@ -0,0 +1,518 @@+//! A trimmed face as an iso-line T-mesh: full-length grid lines from the size rules plus the+//! face's motorcycle traces (which run only as far as they reach), whose rectangles that lie+//! well inside the face are meshed directly. The band between those rectangles (a staircase)+//! and the face's boundary nodes is triangulated with both kept as constraints and no point+//! added. The boundary stays exactly the shared edge nodes, so the face meets its neighbours+//! exactly, and only the band next to the boundary is irregular (cut-cell meshing).++use super::cdt;+use super::motorcycle::Trace;++/// A cell is kept when the boundary stays at least this fraction of its smaller side away from+/// it (in the metric): closer, the band triangle between them would be a sliver.+const CLEARANCE: f64 = 0.35;+/// Two lines closer than this fraction of a grid cell would leave a strip of slivers between+/// them: a grid line that close to a trace moves onto the trace (the trace runs through its+/// peak, which is the point of it), and a trace that close to an earlier one joins it.+const SNAP: f64 = 0.25;++/// One direction's lines: positions (increasing) and whether each runs the whole face.+struct Lines {+ at: Vec<f64>,+ full: Vec<bool>,+}++/// The full lines `grid` plus the traces' lines in this direction (see [`SNAP`]; the first and+/// last grid lines, the face's parameter box, never move). Returns the lines and, per trace+/// (in order), its line's index.+fn lines(grid: &[f64], traces: &[f64]) -> Option<(Lines, Vec<usize>)> {+ let mut at: Vec<f64> = grid.to_vec();+ let mut full = vec![true; at.len()];+ let mut place = Vec::with_capacity(traces.len());+ for &c in traces {+ // The full-grid cell around c, and every line inside it.+ let k = grid.partition_point(|g| *g < c);+ let (lo, hi) = (*grid.get(k.saturating_sub(1))?, *grid.get(k.min(grid.len().saturating_sub(1)))?);+ let w = (hi - lo).max(f64::MIN_POSITIVE);+ let last = grid.len().saturating_sub(1);+ let near = at.iter().enumerate().filter(|(_, x)| (**x - c).abs() < SNAP * w).min_by(|a, b| (a.1 - c).abs().total_cmp(&(b.1 - c).abs()));+ match near {+ // An earlier trace, or a box edge: join it.+ Some((i, _)) if !full.get(i).copied().unwrap_or(false) || i == 0 || i == last => place.push(i),+ // An inner grid line: it moves onto the trace.+ Some((i, _)) => {+ *at.get_mut(i)? = c;+ place.push(i);+ }+ None => {+ at.push(c);+ full.push(false);+ place.push(at.len() - 1);+ }+ }+ }+ // Sort, carrying the trace indices along.+ let mut order: Vec<usize> = (0..at.len()).collect();+ order.sort_by(|a, b| at.get(*a).copied().unwrap_or(0.0).total_cmp(&at.get(*b).copied().unwrap_or(0.0)));+ let mut rank = vec![0; at.len()];+ for (r, &i) in order.iter().enumerate() {+ *rank.get_mut(i)? = r;+ }+ let lines =+ Lines { at: order.iter().filter_map(|&i| at.get(i).copied()).collect(), full: order.iter().filter_map(|&i| full.get(i).copied()).collect() };+ let place = place.iter().filter_map(|&i| rank.get(i).copied()).collect::<Vec<_>>();+ (place.len() == traces.len()).then_some((lines, place))+}++/// Mesh the region bounded by `loops` (ranges of `boundary`, each closed; even–odd, so inner+/// loops are holes) with the full grid lines `us` × `vs` (increasing, spanning the region's+/// parameter box) and the motorcycle `traces`, measured in the metric `scale`. Boundary+/// vertices keep their indices; grid points follow. Triangles counter-clockwise in (u, v).+/// `None` when no cell is kept or the band cannot be triangulated (the face then goes to+/// Delaunay).+pub(crate) fn cut_grid(+ boundary: &[[f64; 2]],+ loops: &[std::ops::Range<usize>],+ us: &[f64],+ vs: &[f64],+ traces: &[Trace],+ scale: [f64; 2],+) -> Option<(Vec<[f64; 2]>, Vec<[u32; 3]>)> {+ if us.len() < 2 || vs.len() < 2 || !scale.iter().all(|s| s.is_finite() && *s > 0.0) {+ return None;+ }+ // Traces on u = c (axis 0) are lines in u; on v = c, lines in v.+ let tu: Vec<&Trace> = traces.iter().filter(|t| t.axis == 0).collect();+ let tv: Vec<&Trace> = traces.iter().filter(|t| t.axis == 1).collect();+ let (lu, pu) = lines(us, &tu.iter().map(|t| t.at).collect::<Vec<_>>())?;+ let (lv, pv) = lines(vs, &tv.iter().map(|t| t.at).collect::<Vec<_>>())?;+ let (nu, nv) = (lu.at.len(), lv.at.len());+ let (cu, cv) = (nu - 1, nv - 1);+ let cells = cu.checked_mul(cv)?;+ if cells > super::grid::MAX_FACE_GRID {+ return None;+ }+ // Which sides of the fine cells are lines: the vertical side at column i in row j, the+ // horizontal side at row j in column i. A trace covers a side it runs at least half along.+ let covers = |t: &Trace, a: f64, b: f64| (t.to.min(b) - t.from.max(a)) >= 0.5 * (b - a);+ let mut vert = vec![false; nu * cv];+ for i in 0..nu {+ let full = lu.full.get(i).copied().unwrap_or(false);+ for j in 0..cv {+ let (a, b) = (*lv.at.get(j)?, *lv.at.get(j + 1)?);+ *vert.get_mut(j * nu + i)? = full || tu.iter().zip(&pu).any(|(t, &k)| k == i && covers(t, a, b));+ }+ }+ let mut horiz = vec![false; nv * cu];+ for j in 0..nv {+ let full = lv.full.get(j).copied().unwrap_or(false);+ for i in 0..cu {+ let (a, b) = (*lu.at.get(i)?, *lu.at.get(i + 1)?);+ *horiz.get_mut(j * cu + i)? = full || tv.iter().zip(&pv).any(|(t, &k)| k == j && covers(t, a, b));+ }+ }+ // Rectangles: fine cells joined across sides that are no line. A T-mesh's faces are+ // rectangles; anything else (a trace ending in the open after snapping) falls back to+ // every line running the whole face.+ let rects = rectangles(cu, cv, &vert, &horiz).or_else(|| {+ vert.iter_mut().for_each(|s| *s = true);+ horiz.iter_mut().for_each(|s| *s = true);+ rectangles(cu, cv, &vert, &horiz)+ })?;+ // In the metric, so clearances are lengths on the surface.+ let gx: Vec<f64> = lu.at.iter().map(|u| u * scale[0]).collect();+ let gy: Vec<f64> = lv.at.iter().map(|v| v * scale[1]).collect();+ let segs: Vec<([f64; 2], [f64; 2])> = loops+ .iter()+ .flat_map(|r| {+ let n = r.len();+ (0..n).filter_map(move |k| Some((*boundary.get(r.start + k)?, *boundary.get(r.start + (k + 1) % n)?)))+ })+ .map(|(a, b)| ([a[0] * scale[0], a[1] * scale[1]], [b[0] * scale[0], b[1] * scale[1]]))+ .collect();+ let keep = clear_cells(&gx, &gy, &segs, &rects)?;+ if !keep.iter().any(|k| *k) {+ return None;+ }+ let kept = |i: isize, j: isize| -> bool {+ i >= 0+ && j >= 0+ && (i as usize) < cu+ && (j as usize) < cv+ && rects.of.get(j as usize * cu + i as usize).and_then(|r| keep.get(*r)).copied().unwrap_or(false)+ };+ // Grid points on the kept rectangles' corners, numbered after the boundary.+ let mut used = vec![false; nu * nv];+ for (r, b) in rects.boxes.iter().enumerate() {+ if keep.get(r).copied().unwrap_or(false) {+ for (i, j) in [(b[0], b[1]), (b[2], b[1]), (b[2], b[3]), (b[0], b[3])] {+ *used.get_mut(j * nu + i)? = true;+ }+ }+ }+ let n = boundary.len();+ let mut id: Vec<Option<u32>> = vec![None; nu * nv];+ let mut extra: Vec<[f64; 2]> = Vec::new();+ let mut node = |i: usize, j: usize, extra: &mut Vec<[f64; 2]>| -> Option<u32> {+ let slot = id.get_mut(j * nu + i)?;+ if let Some(k) = *slot {+ return Some(k);+ }+ let k = u32::try_from(n + extra.len()).ok()?;+ extra.push([*lu.at.get(i)?, *lv.at.get(j)?]);+ *slot = Some(k);+ Some(k)+ };+ let mut tris: Vec<[u32; 3]> = Vec::new();+ // The staircase: pieces of kept rectangles' sides with no kept rectangle across,+ // counter-clockwise around the kept region (so the band lies to their right).+ let mut stairs: Vec<(u32, u32)> = Vec::new();+ for (r, b) in rects.boxes.iter().enumerate() {+ if !keep.get(r).copied().unwrap_or(false) {+ continue;+ }+ let [i0, j0, i1, j1] = *b;+ // The perimeter counter-clockwise as grid points, each with the fine cell across the+ // side that leaves it.+ let mut ring: Vec<((usize, usize), (isize, isize))> = Vec::new();+ for i in i0..i1 {+ ring.push(((i, j0), (i as isize, j0 as isize - 1)));+ }+ for j in j0..j1 {+ ring.push(((i1, j), (i1 as isize, j as isize)));+ }+ for i in (i0 + 1..=i1).rev() {+ ring.push(((i, j1), (i as isize - 1, j1 as isize)));+ }+ for j in (j0 + 1..=j1).rev() {+ ring.push(((i0, j), (i0 as isize - 1, j as isize - 1)));+ }+ let corners = ring.iter().filter(|((i, j), _)| used.get(j * nu + i).copied().unwrap_or(false)).count();+ let mut poly: Vec<u32> = Vec::with_capacity(corners);+ let mut across: Vec<(isize, isize)> = Vec::with_capacity(corners);+ for &((i, j), c) in &ring {+ if used.get(j * nu + i).copied().unwrap_or(false) {+ poly.push(node(i, j, &mut extra)?);+ across.push(c);+ }+ }+ if poly.len() == 4 {+ let [a, b, c, d] = [*poly.first()?, *poly.get(1)?, *poly.get(2)?, *poly.get(3)?];+ tris.push([a, b, c]);+ tris.push([a, c, d]);+ } else {+ // Hanging nodes from neighbours: a fan from the rectangle's centre.+ let centre = [0.5 * (lu.at.get(i0)? + lu.at.get(i1)?), 0.5 * (lv.at.get(j0)? + lv.at.get(j1)?)];+ let m = u32::try_from(n + extra.len()).ok()?;+ extra.push(centre);+ for k in 0..poly.len() {+ tris.push([m, *poly.get(k)?, *poly.get((k + 1) % poly.len())?]);+ }+ }+ for k in 0..poly.len() {+ let (ci, cj) = *across.get(k)?;+ if !kept(ci, cj) {+ stairs.push((*poly.get(k)?, *poly.get((k + 1) % poly.len())?));+ }+ }+ }+ let mut all = boundary.to_vec();+ all.extend_from_slice(&extra);+ let band = cdt::band(&all, n, loops, &stairs, scale)?;+ tris.extend(band);+ // Every triangle counter-clockwise with some area: one that is not has folded.+ for t in &tris {+ let (a, b, c) = (all.get(t[0] as usize)?, all.get(t[1] as usize)?, all.get(t[2] as usize)?);+ let area = (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]);+ if !(area > 0.0) {+ return None;+ }+ }+ Some((extra, tris))+}++/// The rectangles of a T-mesh over `cu` × `cv` fine cells: per cell its rectangle, and per+/// rectangle its corners as grid indices `[i0, j0, i1, j1]`. `None` if a face is not a+/// rectangle.+struct Rects {+ of: Vec<usize>,+ boxes: Vec<[usize; 4]>,+}++fn rectangles(cu: usize, cv: usize, vert: &[bool], horiz: &[bool]) -> Option<Rects> {+ let nu = cu + 1;+ let mut of = vec![usize::MAX; cu * cv];+ let mut boxes = Vec::new();+ for j0 in 0..cv {+ for i0 in 0..cu {+ if *of.get(j0 * cu + i0)? != usize::MAX {+ continue;+ }+ // Grow right while no line separates, then up while the whole row is open.+ let mut i1 = i0 + 1;+ while i1 < cu && !*vert.get(j0 * nu + i1)? {+ i1 += 1;+ }+ let mut j1 = j0 + 1;+ while j1 < cv && (i0..i1).all(|i| horiz.get(j1 * cu + i).is_some_and(|h| !*h)) {+ j1 += 1;+ }+ let r = boxes.len();+ for j in j0..j1 {+ for i in i0..i1 {+ let slot = of.get_mut(j * cu + i)?;+ if *slot != usize::MAX {+ return None;+ }+ *slot = r;+ }+ }+ boxes.push([i0, j0, i1, j1]);+ }+ }+ // A rectangle: no line inside it, and lines all round it.+ for b in &boxes {+ let [i0, j0, i1, j1] = *b;+ for j in j0..j1 {+ for i in i0 + 1..i1 {+ if *vert.get(j * nu + i)? {+ return None;+ }+ }+ }+ for i in i0..i1 {+ for j in j0 + 1..j1 {+ if *horiz.get(j * cu + i)? {+ return None;+ }+ }+ }+ for j in j0..j1 {+ if (i0 > 0 && !*vert.get(j * nu + i0)?) || (i1 < cu && !*vert.get(j * nu + i1)?) {+ return None;+ }+ }+ for i in i0..i1 {+ if (j0 > 0 && !*horiz.get(j0 * cu + i)?) || (j1 < cv && !*horiz.get(j1 * cu + i)?) {+ return None;+ }+ }+ }+ Some(Rects { of, boxes })+}++/// Per rectangle: kept when every fine cell in it is inside the region and clear of the+/// boundary (see [`CLEARANCE`]). `gx`, `gy`: the lines in the metric; `segs`: the boundary.+fn clear_cells(gx: &[f64], gy: &[f64], segs: &[([f64; 2], [f64; 2])], rects: &Rects) -> Option<Vec<bool>> {+ let (cu, cv) = (gx.len().saturating_sub(1), gy.len().saturating_sub(1));+ let cells = cu * cv;+ let cell = |i: usize, j: usize| -> Option<([f64; 2], [f64; 2])> {+ let (x0, x1, y0, y1) = (*gx.get(i)?, *gx.get(i + 1)?, *gy.get(j)?, *gy.get(j + 1)?);+ // The clearance of the rectangle the cell belongs to, not of the (possibly thin) cell.+ let b = rects.boxes.get(*rects.of.get(j * cu + i)?)?;+ let (w, h) = (gx.get(b[2])? - gx.get(b[0])?, gy.get(b[3])? - gy.get(b[1])?);+ let pad = CLEARANCE * w.min(h);+ Some(([x0 - pad, y0 - pad], [x1 + pad, y1 + pad]))+ };+ // Cells the boundary comes near: each segment marks the cells whose padded box it touches.+ let mut near = vec![false; cells];+ let maxpad = rects+ .boxes+ .iter()+ .filter_map(|b| Some(CLEARANCE * (gx.get(b[2])? - gx.get(b[0])?).min(gy.get(b[3])? - gy.get(b[1])?)))+ .fold(0.0f64, f64::max);+ let span = |g: &[f64], lo: f64, hi: f64| {+ let a = g.partition_point(|t| *t < lo - maxpad).saturating_sub(1);+ let b = (g.partition_point(|t| *t <= hi + maxpad) + 1).min(g.len().saturating_sub(1));+ (a, b)+ };+ for (a, b) in segs {+ let (i0, i1) = span(gx, a[0].min(b[0]), a[0].max(b[0]));+ let (j0, j1) = span(gy, a[1].min(b[1]), a[1].max(b[1]));+ for j in j0..j1 {+ for i in i0..i1 {+ let Some((lo, hi)) = cell(i, j) else { continue };+ if segment_meets_box(*a, *b, lo, hi)+ && let Some(c) = near.get_mut(j * cu + i)+ {+ *c = true;+ }+ }+ }+ }+ // The other cells are wholly inside or wholly outside: even–odd along each row's middle.+ let mut keep = vec![true; rects.boxes.len()];+ for j in 0..cv {+ let (Some(y0), Some(y1)) = (gy.get(j), gy.get(j + 1)) else { return None };+ let ym = 0.5 * (y0 + y1);+ let mut cross: Vec<f64> =+ segs.iter().filter(|(a, b)| (a[1] > ym) != (b[1] > ym)).map(|(a, b)| a[0] + (ym - a[1]) / (b[1] - a[1]) * (b[0] - a[0])).collect();+ cross.sort_by(f64::total_cmp);+ for i in 0..cu {+ let k = j * cu + i;+ let (Some(x0), Some(x1)) = (gx.get(i), gx.get(i + 1)) else { return None };+ let xm = 0.5 * (x0 + x1);+ let inside = cross.partition_point(|c| *c < xm) % 2 == 1;+ if near.get(k).copied().unwrap_or(true) || !inside {+ *keep.get_mut(*rects.of.get(k)?)? = false;+ }+ }+ }+ Some(keep)+}++/// Whether the segment `a`–`b` meets the closed box `lo`–`hi` (Liang–Barsky clipping).+fn segment_meets_box(a: [f64; 2], b: [f64; 2], lo: [f64; 2], hi: [f64; 2]) -> bool {+ let (mut t0, mut t1) = (0.0f64, 1.0f64);+ for d in 0..2 {+ let delta = b[d] - a[d];+ for (p, q) in [(-delta, a[d] - lo[d]), (delta, hi[d] - a[d])] {+ if p == 0.0 {+ if q < 0.0 {+ return false;+ }+ } else {+ let r = q / p;+ if p < 0.0 {+ t0 = t0.max(r);+ } else {+ t1 = t1.min(r);+ }+ if t0 > t1 {+ return false;+ }+ }+ }+ }+ true+}++#[cfg(test)]+mod tests {+ use super::*;++ fn circle(c: [f64; 2], r: f64, n: usize, ccw: bool) -> Vec<[f64; 2]> {+ (0..n)+ .map(|k| {+ let a = std::f64::consts::TAU * k as f64 / n as f64 * if ccw { 1.0 } else { -1.0 };+ [c[0] + r * a.cos(), c[1] + r * a.sin()]+ })+ .collect()+ }++ /// A single loop over all `n` boundary points.+ fn one(n: usize) -> [std::ops::Range<usize>; 1] {+ [std::ops::Range { start: 0, end: n }]+ }++ fn lines(a: f64, b: f64, n: usize) -> Vec<f64> {+ (0..=n).map(|k| a + (b - a) * k as f64 / n as f64).collect()+ }++ /// Every boundary segment is the side of exactly one triangle, every inner side of two,+ /// and the triangles cover the region's area.+ fn check(boundary: &[[f64; 2]], loops: &[std::ops::Range<usize>], area: f64, out: &(Vec<[f64; 2]>, Vec<[u32; 3]>)) {+ let (extra, tris) = out;+ let mut all = boundary.to_vec();+ all.extend_from_slice(extra);+ let mut sides: std::collections::HashMap<(u32, u32), i32> = std::collections::HashMap::new();+ let mut sum = 0.0;+ for t in tris {+ let [a, b, c] = t.map(|i| all[i as usize]);+ let ar = 0.5 * ((b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]));+ assert!(ar > 0.0, "counter-clockwise");+ sum += ar;+ for e in 0..3 {+ *sides.entry((t[e], t[(e + 1) % 3])).or_default() += 1;+ }+ }+ for r in loops {+ let n = r.len();+ for k in 0..n {+ let (a, b) = ((r.start + k) as u32, (r.start + (k + 1) % n) as u32);+ assert_eq!(sides.get(&(a, b)).copied().unwrap_or(0), 1, "boundary side {a}-{b} used once, forwards");+ sides.remove(&(a, b));+ }+ }+ for (&(a, b), &k) in &sides {+ assert_eq!(k, 1);+ assert_eq!(sides.get(&(b, a)).copied(), Some(1), "inner side {a}-{b} shared");+ }+ assert!((sum - area).abs() < 1e-9 * area.max(1.0), "area {sum} vs {area}");+ }++ #[test]+ fn a_disc_is_cells_and_a_band() {+ let b = circle([0.0, 0.0], 1.0, 64, true);+ let loops = one(64);+ let poly_area = 0.5 * 64.0 * (std::f64::consts::TAU / 64.0).sin();+ let Some(out) = cut_grid(&b, &loops, &lines(-1.0, 1.0, 10), &lines(-1.0, 1.0, 10), &[], [1.0, 1.0]) else { panic!("meshes") };+ check(&b, &loops, poly_area, &out);+ // Most of the disc is grid cells (two triangles each).+ assert!(out.1.len() > 100, "{}", out.1.len());+ }++ #[test]+ fn a_square_with_a_hole() {+ let mut b = vec![[0.0, 0.0], [4.0, 0.0], [4.0, 4.0], [0.0, 4.0]];+ b.extend(circle([2.0, 2.0], 1.0, 32, false));+ let loops = [0..4, 4..36];+ let hole = 0.5 * 32.0 * (std::f64::consts::TAU / 32.0).sin();+ let Some(out) = cut_grid(&b, &loops, &lines(0.0, 4.0, 16), &lines(0.0, 4.0, 16), &[], [1.0, 1.0]) else { panic!("meshes") };+ check(&b, &loops, 16.0 - hole, &out);+ }++ #[test]+ fn a_curved_triangle_in_a_stretched_metric() {+ // A three-cornered patch (as a vertex blend in its parameters), u twice as long as v.+ let mut b: Vec<[f64; 2]> = (0..=8).map(|k| [k as f64 / 8.0, 0.0]).collect();+ b.extend((1..8).map(|k| {+ let a = std::f64::consts::FRAC_PI_2 * k as f64 / 8.0;+ [a.cos(), a.sin()]+ }));+ b.extend((1..8).rev().map(|k| [0.0, k as f64 / 8.0]));+ let n = b.len();+ let loops = one(n);+ let area: f64 = (0..n)+ .map(|k| {+ let (p, q) = (b[k], b[(k + 1) % n]);+ 0.5 * (p[0] * q[1] - q[0] * p[1])+ })+ .sum();+ let Some(out) = cut_grid(&b, &loops, &lines(0.0, 1.0, 12), &lines(0.0, 1.0, 6), &[], [2.0, 1.0]) else { panic!("meshes") };+ check(&b, &loops, area, &out);+ }++ /// The hole's motorcycle traces (lines through its four extremes) become T-mesh lines that+ /// stop where the traces stop; the mesh stays exact on the boundary and covers the region.+ #[test]+ fn a_square_with_a_hole_and_its_traces() {+ let mut b = vec![[0.0, 0.0], [4.0, 0.0], [4.0, 4.0], [0.0, 4.0]];+ b.extend(circle([1.7, 2.3], 1.0, 32, false));+ let loops = [0..4, 4..36];+ let hole = 0.5 * 32.0 * (std::f64::consts::TAU / 32.0).sin();+ let traces = super::super::motorcycle::traces(&b, &loops, [1.0, 1.0], 0.0);+ assert_eq!(traces.len(), 4, "{traces:?}");+ let Some(out) = cut_grid(&b, &loops, &lines(0.0, 4.0, 16), &lines(0.0, 4.0, 16), &traces, [1.0, 1.0]) else { panic!("meshes") };+ check(&b, &loops, 16.0 - hole, &out);+ // The traces run through the hole's extremes: along v = 2.3 from its u-extremes and+ // along u = 1.7 from its v-extremes; their lines are in the grid.+ for (d, x) in [(0, 1.7), (1, 2.3)] {+ assert!(out.0.iter().any(|p| (p[d] - x).abs() < 1e-9), "a grid point on line {d} = {x}");+ }+ }++ #[test]+ fn nothing_kept_is_refused() {+ let b = circle([0.0, 0.0], 0.1, 16, true);+ assert!(cut_grid(&b, &one(16), &lines(-1.0, 1.0, 1), &lines(-1.0, 1.0, 1), &[], [1.0, 1.0]).is_none());+ }++ #[test]+ fn segments_meet_boxes() {+ assert!(segment_meets_box([-1.0, 0.5], [2.0, 0.5], [0.0, 0.0], [1.0, 1.0]));+ assert!(!segment_meets_box([-1.0, 2.0], [2.0, 2.0], [0.0, 0.0], [1.0, 1.0]));+ assert!(segment_meets_box([0.5, 0.5], [0.6, 0.6], [0.0, 0.0], [1.0, 1.0]));+ assert!(!segment_meets_box([2.0, 0.0], [3.0, 1.0], [0.0, 0.0], [1.0, 1.0]));+ }+}diff --git a/crates/kernel/src/tess/mod.rs b/crates/kernel/src/tess/mod.rsindex 57ddce784c..a5421b542c 100644--- a/crates/kernel/src/tess/mod.rs+++ b/crates/kernel/src/tess/mod.rs@@ -17,9 +17,13 @@//! old way.pub(crate) mod cdt;+pub(crate) mod collar;pub(crate) mod coons;+pub(crate) mod cutgrid;pub(crate) mod edges;pub(crate) mod grid;+pub(crate) mod motorcycle;+pub(crate) mod pieces;pub(crate) mod size;pub(crate) mod ssi;pub(crate) mod surface;@@ -348,7 +352,7 @@ fn plan_face(let structured = match structured {None if ranges.len() == 1 => {let fine = |a: [f64; 2], b: [f64; 2]| uv::fine_between(s, rules, h, a, b);- coons::coons(&uvs, &fixed, speed, grid::MAX_FACE_GRID, &fine)+ coons::coons(&uvs, &fixed, speed, grid::MAX_FACE_GRID, h, Some(&fine))}other => other,};@@ -362,12 +366,33 @@ fn plan_face(r}None => {- if planar {- stats.planar += 1;+ // A curved face neither box nor four-cornered: cut into four-sided patches, else+ // the iso-line grid cut along its motorcycle traces and trimmed by its boundary,+ // else Delaunay. A plane: the butterfly of a round face, else Delaunay (a plane+ // is shaded the same by any triangles, and its Delaunay needs no refinement).+ let face = Region { s, uvs: &uvs, fixed: &fixed, ranges: &ranges, rules, h, speed, us: &us, vs: &vs };+ let trimmed = if planar {+ if ranges.len() == 1 { plan_pieces(&face) } else { None }} else {- stats.delaunay += 1;+ plan_pieces(&face).or_else(|| {+ let traces = motorcycle::traces(&uvs, &ranges, speed, 0.25 * h);+ cutgrid::cut_grid(&uvs, &ranges, &us, &vs, &traces, speed)+ })+ };+ match trimmed {+ Some(r) => {+ stats.structured += 1;+ r+ }+ None => {+ if planar {+ stats.planar += 1;+ } else {+ stats.delaunay += 1;+ }+ delaunay()?+ }}- delaunay()?}}};@@ -384,6 +409,211 @@ fn plan_face(Ok(FacePlan { face: u32::try_from(fi).unwrap_or(u32::MAX), surface: None, uv: all, fixed, normals: Vec::new(), flip: false, triangles })}+/// A face's (u, v) region and what meshing it needs.+struct Region<'a> {+ s: &'a EvalSurface,+ uvs: &'a [[f64; 2]],+ fixed: &'a [Vec3],+ ranges: &'a [std::ops::Range<usize>],+ rules: &'a size::Rules,+ h: f64,+ speed: [f64; 2],+ us: &'a [f64],+ vs: &'a [f64],+}++/// A trimmed face cut into patches (squares round its holes or a butterfly in a round face,+/// joined to the outer loop by motorcycle traces), each meshed on its own (a Coons blend on its+/// best four corners; else the trimmed grid; else Delaunay), all sharing the cuts' nodes. The+/// cut nodes and patch interiors follow the boundary nodes. `None` when the cuts do not make+/// patches.+fn plan_pieces(f: &Region) -> Option<(Vec<[f64; 2]>, Vec<[u32; 3]>)> {+ // The face's global seed: one spacing in every direction, the finest its size rules ask for+ // along either parameter (the median gap between the grid lines they give, in mm). On a+ // cylinder that is the spacing round it, which the cuts along its axis then get too.+ let median_gap = |lines: &[f64], speed: f64| -> f64 {+ let mut gaps: Vec<f64> = lines.windows(2).filter_map(|w| Some((w.get(1)? - w.first()?) * speed)).filter(|g| *g > 0.0).collect();+ gaps.sort_by(f64::total_cmp);+ gaps.get(gaps.len() / 2).copied().unwrap_or(f64::INFINITY)+ };+ let seed = median_gap(f.us, f.speed[0]).min(median_gap(f.vs, f.speed[1])).min(f.h);+ let segments = collar::segments(f.uvs, f.ranges, f.speed, seed, matches!(f.s, EvalSurface::Plane { .. }))?;+ let s = f.s;+ let fine = |a: [f64; 2], b: [f64; 2]| uv::fine_between(s, f.rules, f.h, a, b);+ // A cut's seeds: spaced from the boundary's own spacing at each end, growing geometrically+ // between them, never wider than the global seed, and split further wherever the surface+ // between two seeds fails the size rules.+ let seeds = |a: [f64; 2], b: [f64; 2], sa: f64, sb: f64| -> Vec<f64> { graded(a, b, sa, sb, seed, f.speed, &fine) };+ let (cut_uv, pieces) = pieces::cut(f.uvs, f.ranges, &segments, f.speed, &seeds)?;+ let n = f.uvs.len();+ let mut uv_all: Vec<[f64; 2]> = f.uvs.to_vec();+ uv_all.extend_from_slice(&cut_uv);+ let mut pos: Vec<Vec3> = f.fixed.to_vec();+ for q in &cut_uv {+ pos.push(s.derivs(q[0], q[1])?.0);+ }+ let mut extra: Vec<[f64; 2]> = cut_uv;+ let mut tris: Vec<[u32; 3]> = Vec::new();+ for pc in &pieces {+ // The patch's own loops, numbered from zero.+ let mut ids: Vec<u32> = pc.ring.clone();+ let mut ranges = vec![std::ops::Range { start: 0, end: pc.ring.len() }];+ for hole in &pc.holes {+ ranges.push(ids.len()..ids.len() + hole.len());+ ids.extend_from_slice(hole);+ }+ let luv: Vec<[f64; 2]> = ids.iter().map(|&k| uv_all.get(k as usize).copied()).collect::<Option<_>>()?;+ let lpos: Vec<Vec3> = ids.iter().map(|&k| pos.get(k as usize).copied()).collect::<Option<_>>()?;+ let mut bbox = [(f64::MAX, f64::MIN); 2];+ for p in &luv {+ for d in 0..2 {+ bbox[d] = (bbox[d].0.min(p[d]), bbox[d].1.max(p[d]));+ }+ }+ let clip = |lines: &[f64], (a, b): (f64, f64)| -> Vec<f64> {+ std::iter::once(a).chain(lines.iter().copied().filter(|x| *x > a && *x < b)).chain(std::iter::once(b)).collect()+ };+ // A patch whose outline changes between boundary and cut at exactly four nodes (a+ // quarter of a ring, a butterfly wing round a hole) takes those as its corners, so each+ // side is all boundary or all cut; any other patch takes the best four of its corners.+ let is_cut = |a: u32, b: u32| -> bool {+ let (a, b) = (a as usize, b as usize);+ a >= n || b >= n || !f.ranges.iter().any(|r| r.contains(&a) && r.contains(&b) && (a.abs_diff(b) == 1 || a.abs_diff(b) == r.len() - 1))+ };+ let ring = &pc.ring;+ let switches: Vec<usize> = (0..ring.len())+ .filter(|&k| {+ let (p, c, x) = (ring.get((k + ring.len() - 1) % ring.len()), ring.get(k), ring.get((k + 1) % ring.len()));+ matches!((p, c, x), (Some(&p), Some(&c), Some(&x)) if is_cut(p, c) != is_cut(c, x))+ })+ .collect();+ // The patch is a rectangle in (u, v) with corners cut by free boundary (Lyon et al. §4;+ // completed virtually in §4.2): its bounding box. A grid needs four real sides, so each+ // corner is the node furthest out towards the box's corner (in the box's own+ // proportions): an uncut corner is the corner itself, and on an arc cutting a corner it+ // is the arc's 45° point, so the arc becomes a rounded corner shared by two sides.+ let completed = || -> Option<[usize; 4]> {+ let m = ring.len();+ let at = |k: usize| luv.get(k).map(|q| [q[0] * f.speed[0], q[1] * f.speed[1]]);+ let (mut lo, mut hi) = ([f64::MAX; 2], [f64::MIN; 2]);+ for k in 0..m {+ let q = at(k)?;+ for d in 0..2 {+ lo[d] = lo[d].min(q[d]);+ hi[d] = hi[d].max(q[d]);+ }+ }+ let (w, h) = (hi[0] - lo[0], hi[1] - lo[1]);+ if !(w > 0.0 && h > 0.0) {+ return None;+ }+ let mut pick = [0usize; 4];+ for (slot, dir) in pick.iter_mut().zip([[-1.0, -1.0], [1.0, -1.0], [1.0, 1.0], [-1.0, 1.0]]) {+ *slot = (0..m).max_by(|&x, &y| {+ let reach = |k: usize| at(k).map_or(f64::MIN, |q| dir[0] * (q[0] - lo[0]) / w + dir[1] * (q[1] - lo[1]) / h);+ reach(x).total_cmp(&reach(y))+ })?;+ }+ // Four distinct corners in the loop's (counter-clockwise) order.+ let start = pick[0];+ let rel = pick.map(|k| (k + m - start) % m);+ (rel[0] < rel[1] && rel[1] < rel[2] && rel[2] < rel[3]).then_some(pick)+ };+ let quad = if pc.holes.is_empty() {+ // Every patch is four-sided by construction: its corners are where its outline turns.+ coons::coons(&luv, &lpos, f.speed, grid::MAX_FACE_GRID, f.h, None).or_else(|| {+ match switches[..] {+ [a, b, c, d] => coons::coons_at(&luv, &lpos, [a, b, c, d], grid::MAX_FACE_GRID, f.h, None),+ _ => None,+ }+ .or_else(|| completed().and_then(|c| coons::coons_at(&luv, &lpos, c, grid::MAX_FACE_GRID, f.h, None)))+ })+ } else {+ None+ };+ let local = quad+ .or_else(|| if pc.holes.is_empty() { coons::coons_best(&luv, &lpos, f.speed, grid::MAX_FACE_GRID, f.h) } else { None })+ .or_else(|| cutgrid::cut_grid(&luv, &ranges, &clip(f.us, bbox[0]), &clip(f.vs, bbox[1]), &[], f.speed))+ .or_else(|| {+ let polys: Vec<&[[f64; 2]]> = ranges.iter().filter_map(|r| luv.get(r.clone())).collect();+ let seeds = cdt::lattice(bbox, [f.h / f.speed[0], f.h / f.speed[1]], &polys, f.speed);+ let eval = |u: f64, v: f64| s.derivs(u, v).map(|(p, su, sv)| (p, su.cross(sv).normalized()));+ let sag = cdt::Sag { eval: &eval, tol: f.rules.tol, h: f.h, turn: f.rules.turn, scale: f.speed };+ cdt::triangulate(&luv, &ranges, cdt::Fill { seeds: &seeds, refine: Some((sag, MAX_REFINE)), shape: true })+ })?;+ let (lextra, ltris) = local;+ let base = u32::try_from(n + extra.len()).ok()?;+ let m = ids.len();+ for t in ltris {+ let map = |i: u32| -> Option<u32> {+ let i = i as usize;+ if i < m { ids.get(i).copied() } else { base.checked_add(u32::try_from(i - m).ok()?) }+ };+ tris.push([map(t[0])?, map(t[1])?, map(t[2])?]);+ }+ extra.extend(lextra);+ }+ Some((extra, tris))+}++/// Seeds on the segment `a`–`b` in (u, v) (fractions strictly between 0 and 1): node spacing+/// `sa` at `a` and `sb` at `b` (in the metric `speed`, each at most `h`), growing geometrically+/// between them (sizes `sa · q^k` summing to the length), then each interval split in half while+/// `fine` fails between its ends.+fn graded(a: [f64; 2], b: [f64; 2], sa: f64, sb: f64, h: f64, speed: [f64; 2], fine: &dyn Fn([f64; 2], [f64; 2]) -> bool) -> Vec<f64> {+ let len = ((b[0] - a[0]) * speed[0]).hypot((b[1] - a[1]) * speed[1]);+ let cap = |x: f64| {+ if x.is_finite() && x > 0.0 {+ x.min(if h > 0.0 { h } else { f64::INFINITY })+ } else if h > 0.0 {+ h+ } else {+ len+ }+ };+ let (sa, sb) = (cap(sa), cap(sb));+ let mut cuts: Vec<f64> = Vec::new();+ if len.is_finite() && len > sa.max(sb) && sa > 0.0 && sb > 0.0 {+ let q = (len - sa) / (len - sb);+ let sizes: Vec<f64> = if (q - 1.0).abs() < 1e-3 || !(q > 0.0) || !q.is_finite() {+ // Even spacing at the mean of the two.+ let k = (len / (0.5 * (sa + sb))).round().clamp(1.0, 4096.0) as usize;+ vec![len / k as f64; k]+ } else {+ let k = (1.0 + (sb / sa).ln() / q.ln()).round().clamp(1.0, 4096.0) as usize;+ let raw: Vec<f64> = (0..k).map(|j| sa * q.powi(j as i32)).collect();+ let total: f64 = raw.iter().sum();+ raw.into_iter().map(|x| x * len / total).collect()+ };+ let mut at = 0.0;+ for s in sizes.iter().take(sizes.len().saturating_sub(1)) {+ at += s;+ cuts.push(at / len);+ }+ }+ // The size rules between seeds (sag, facet angle).+ let point = |t: f64| [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];+ let mut all: Vec<f64> = std::iter::once(0.0).chain(cuts).chain(std::iter::once(1.0)).collect();+ for _ in 0..12 {+ let mut next = Vec::with_capacity(all.len() * 2);+ let mut split = false;+ for w in all.windows(2) {+ let (Some(&x), Some(&y)) = (w.first(), w.get(1)) else { continue };+ next.push(x);+ if !fine(point(x), point(y)) {+ next.push(0.5 * (x + y));+ split = true;+ }+ }+ next.push(1.0);+ all = next;+ if !split || all.len() > 4096 {+ break;+ }+ }+ 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:/// the face covers its boundary with nothing missing or doubled, so it meets its neighbours/// exactly. Pole copies of one node (consecutive in a loop, at one point) are one vertex: thediff --git a/crates/kernel/src/tess/motorcycle.rs b/crates/kernel/src/tess/motorcycle.rsnew file mode 100644index 0000000000..6dac8670d9--- /dev/null+++ b/crates/kernel/src/tess/motorcycle.rs@@ -0,0 +1,354 @@+//! The free-boundary motorcycle graph of a trimmed face (Lyon, Campen, Bommes & Kobbelt,+//! "Parametrization Quantization with Free Boundaries for Trimmed Quad Meshing", ACM TOG 38(4),+//! 2019, §4; after Eppstein, Goodrich, Kim & Tamstorf, "Motorcycle Graphs: Canonical Quad Mesh+//! Partitioning", SGP 2008).+//!+//! Peaks (Def. 4.1) are boundary nodes where u or v is a local extremum; a node in a flat run+//! counts only where the value differs on one side. A peak is concave where the face lies+//! beyond the extremum. Only concave peaks spawn motorcycles (Def. 4.2): a u-peak one along u,+//! a v-peak one along v, into the face. All move at once at the same speed (in the surface's+//! metric) along their iso-line; each stops where it reaches the boundary, a trace another+//! motorcycle laid earlier, or another motorcycle head-on (both stop where they meet). The+//! traces cut the face into patches that are rectangles with corners cut by free boundary.++/// A trace: the iso-line `axis` = `at` (0: u = at, running along v; 1: v = at, running along u)+/// from `from` to `to` in the other parameter (`from < to`).+#[derive(Clone, Copy, Debug, PartialEq)]+pub(crate) struct Trace {+ pub axis: usize,+ pub at: f64,+ pub from: f64,+ pub to: f64,+ /// The boundary node (peak) it starts from.+ pub start: usize,+ /// Its start and end points in (u, v).+ pub a: [f64; 2],+ pub b: [f64; 2],+ /// Where it stopped.+ pub end: End,+}++/// Where a motorcycle stopped.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum End {+ /// On the boundary segment between these two boundary nodes.+ Boundary(usize, usize),+ /// On the trace with this index (a T-node).+ Trace(usize),+ /// Head-on with the trace with this index (both end at one point).+ HeadOn(usize),+}++/// Most motorcycles one face spawns (the pairwise events grow with their square).+const MAX_MOTORCYCLES: usize = 512;++struct Moto {+ /// Origin (metric).+ o: [f64; 2],+ /// Direction of travel: the parameter (0: u, 1: v) and its sign.+ d: usize,+ sign: f64,+ /// Boundary node it starts on (its own segments are not a crash).+ node: usize,+ /// Distance to the boundary along its way, and the segment it reaches there.+ reach: f64,+ hit: (usize, usize),+}++/// The traces of the face bounded by `loops` (ranges of `boundary`, even–odd), in (u, v),+/// measured in the metric `scale`. Two motorcycles coming at each other on lines less than+/// `snap` apart (in the metric) meet head-on: a polygon's extreme node is only near the curve's+/// true extreme, so the two extremes facing each other across a gap (one hole above another)+/// are rarely on exactly one line. Empty when there is no concave peak.+pub(crate) fn traces(boundary: &[[f64; 2]], loops: &[std::ops::Range<usize>], scale: [f64; 2], snap: f64) -> Vec<Trace> {+ if !scale.iter().all(|s| s.is_finite() && *s > 0.0) {+ return Vec::new();+ }+ let p: Vec<[f64; 2]> = boundary.iter().map(|q| [q[0] * scale[0], q[1] * scale[1]]).collect();+ let mut lo = [f64::MAX; 2];+ let mut hi = [f64::MIN; 2];+ for q in &p {+ for d in 0..2 {+ lo[d] = lo[d].min(q[d]);+ hi[d] = hi[d].max(q[d]);+ }+ }+ let extent = (hi[0] - lo[0]).max(hi[1] - lo[1]);+ if !(extent.is_finite() && extent > 0.0) {+ return Vec::new();+ }+ // Values this close are one (a node on an iso-line edge carries projection rounding).+ let eps = extent * 1e-9;+ let segs: Vec<(usize, usize)> = loops+ .iter()+ .flat_map(|r| {+ let n = r.len();+ (0..n).map(move |k| (r.start + k, r.start + (k + 1) % n))+ })+ .collect();+ let inside = |q: [f64; 2]| {+ let mut odd = false;+ for &(a, b) in &segs {+ let (Some(a), Some(b)) = (p.get(a), p.get(b)) else { continue };+ if (a[1] > q[1]) != (b[1] > q[1]) && q[0] < a[0] + (q[1] - a[1]) / (b[1] - a[1]) * (b[0] - a[0]) {+ odd = !odd;+ }+ }+ odd+ };+ // Peaks and their motorcycles.+ let mut motos: Vec<Moto> = Vec::new();+ for r in loops {+ let n = r.len();+ if n < 3 {+ continue;+ }+ for k in 0..n {+ let (Some(&a), Some(&b), Some(&c)) = (p.get(r.start + (k + n - 1) % n), p.get(r.start + k), p.get(r.start + (k + 1) % n)) else {+ continue;+ };+ for d in 0..2 {+ let (before, after) = (a[d] - b[d], c[d] - b[d]);+ let flat = |x: f64| x.abs() <= eps;+ // A (non-strict) minimum higher on one side, or maximum lower on one side.+ let min = (before > eps || flat(before)) && (after > eps || flat(after)) && !(flat(before) && flat(after));+ let max = (before < -eps || flat(before)) && (after < -eps || flat(after)) && !(flat(before) && flat(after));+ let sign = match (min, max) {+ (true, false) => -1.0,+ (false, true) => 1.0,+ _ => continue,+ };+ // Concave: the face lies beyond the extremum.+ let mut probe = b;+ probe[d] += sign * extent * 1e-6;+ if !inside(probe) {+ continue;+ }+ if motos.len() >= MAX_MOTORCYCLES {+ return Vec::new();+ }+ motos.push(Moto { o: b, d, sign, node: r.start + k, reach: f64::INFINITY, hit: (0, 0) });+ }+ }+ }+ if motos.is_empty() {+ return Vec::new();+ }+ // Where each would reach the boundary.+ for m in &mut motos {+ let e = 1 - m.d;+ for &(ia, ib) in &segs {+ if ia == m.node || ib == m.node {+ continue;+ }+ let (Some(a), Some(b)) = (p.get(ia), p.get(ib)) else { continue };+ // The segment crosses the line other = o[e] at parameter s along d.+ let (lo_e, hi_e) = (a[e].min(b[e]), a[e].max(b[e]));+ if m.o[e] < lo_e || m.o[e] > hi_e {+ continue;+ }+ // A segment along the line itself is reached at its nearer end ahead.+ let ahead = |x: f64| (x - m.o[m.d]) * m.sign;+ let t = if (b[e] - a[e]).abs() <= eps {+ [ahead(a[m.d]), ahead(b[m.d])].into_iter().filter(|t| *t > eps).fold(f64::INFINITY, f64::min)+ } else {+ ahead(a[m.d] + (m.o[e] - a[e]) / (b[e] - a[e]) * (b[m.d] - a[m.d]))+ };+ if t > eps && t < m.reach {+ m.reach = t;+ m.hit = (ia, ib);+ }+ }+ }+ // Events in time order: (time, the motorcycle that stops, where, the one whose trace stops+ // it and when it passed there).+ struct Event {+ t: f64,+ who: usize,+ at: f64,+ cause: Option<(usize, f64)>,+ partner: Option<usize>,+ }+ let mut events: Vec<Event> = Vec::new();+ for (i, m) in motos.iter().enumerate() {+ if m.reach.is_finite() {+ events.push(Event { t: m.reach, who: i, at: m.reach, cause: None, partner: None });+ }+ for (j, n) in motos.iter().enumerate().skip(i + 1) {+ if m.d != n.d {+ // Crossing: m's line is other = m.o[1 - m.d]; n travels along n.d = 1 - m.d.+ let x_on_m = (n.o[m.d] - m.o[m.d]) * m.sign;+ let x_on_n = (m.o[n.d] - n.o[n.d]) * n.sign;+ if x_on_m > eps && x_on_m < m.reach && x_on_n > eps && x_on_n < n.reach {+ // The later one stops on the earlier one's trace (a tie stops both).+ if x_on_m >= x_on_n {+ events.push(Event { t: x_on_m, who: i, at: x_on_m, cause: Some((j, x_on_n)), partner: None });+ }+ if x_on_n >= x_on_m {+ events.push(Event { t: x_on_n, who: j, at: x_on_n, cause: Some((i, x_on_m)), partner: None });+ }+ }+ } else if m.sign != n.sign && (m.o[1 - m.d] - n.o[1 - n.d]).abs() <= eps.max(snap) {+ // Head-on on one line: they meet halfway if each would get there.+ let gap = (n.o[m.d] - m.o[m.d]) * m.sign;+ let half = 0.5 * gap;+ if gap > eps && half < m.reach && half < n.reach {+ events.push(Event { t: half, who: i, at: half, cause: None, partner: Some(j) });+ }+ }+ }+ }+ events.sort_by(|a, b| a.t.total_cmp(&b.t));+ let mut stop: Vec<Option<(f64, Stop)>> = vec![None; motos.len()];+ for ev in &events {+ if stop.get(ev.who).is_none_or(|s| s.is_some()) {+ continue;+ }+ if let Some((c, passed)) = ev.cause {+ // The trace is there only if its motorcycle got that far.+ if stop.get(c).copied().flatten().is_some_and(|(s, _)| s < passed) {+ continue;+ }+ }+ let how = match (ev.cause, ev.partner) {+ (Some((c, _)), _) => Stop::Trace(c),+ (None, Some(j)) => Stop::HeadOn(j),+ (None, None) => Stop::Boundary,+ };+ if let Some(j) = ev.partner {+ if stop.get(j).is_none_or(|s| s.is_some()) {+ continue;+ }+ if let Some(s) = stop.get_mut(j) {+ *s = Some((ev.at, Stop::HeadOn(ev.who)));+ }+ }+ if let Some(s) = stop.get_mut(ev.who) {+ *s = Some((ev.at, how));+ }+ }+ // Output indices of the motorcycles that stopped (all do: each reaches the boundary).+ let mut out_index = vec![usize::MAX; motos.len()];+ let mut k = 0;+ for (i, s) in stop.iter().enumerate() {+ if s.is_some() {+ if let Some(slot) = out_index.get_mut(i) {+ *slot = k;+ }+ k += 1;+ }+ }+ let uv = |q: [f64; 2]| [q[0] / scale[0], q[1] / scale[1]];+ motos+ .iter()+ .zip(&stop)+ .filter_map(|(m, s)| {+ let (len, how) = (*s)?;+ let (a, b) = (m.o[m.d], m.o[m.d] + m.sign * len);+ let (from, to) = (a.min(b) / scale[m.d], a.max(b) / scale[m.d]);+ // The trace runs along d, so it lies on the iso-line of the other parameter.+ let axis = 1 - m.d;+ let mut endp = m.o;+ endp[m.d] = b;+ let end = match how {+ Stop::Boundary => End::Boundary(m.hit.0, m.hit.1),+ Stop::Trace(c) => End::Trace(*out_index.get(c)?),+ Stop::HeadOn(j) => End::HeadOn(*out_index.get(j)?),+ };+ Some(Trace { axis, at: m.o[axis] / scale[axis], from, to, start: m.node, a: uv(m.o), b: uv(endp), end })+ })+ .collect()+}++#[derive(Clone, Copy, Debug)]+enum Stop {+ Boundary,+ Trace(usize),+ HeadOn(usize),+}++#[cfg(test)]+mod tests {+ use super::*;++ fn circle(c: [f64; 2], r: f64, n: usize, ccw: bool) -> Vec<[f64; 2]> {+ (0..n)+ .map(|k| {+ let a = std::f64::consts::TAU * k as f64 / n as f64 * if ccw { 1.0 } else { -1.0 };+ [c[0] + r * a.cos(), c[1] + r * a.sin()]+ })+ .collect()+ }++ #[test]+ fn a_convex_face_has_no_traces() {+ let b = circle([0.0, 0.0], 1.0, 32, true);+ assert!(traces(&b, &[std::ops::Range { start: 0, end: 32 }], [1.0, 1.0], 0.0).is_empty());+ let sq = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]];+ assert!(traces(&sq, &[std::ops::Range { start: 0, end: 4 }], [1.0, 1.0], 0.0).is_empty());+ }++ /// A centred round hole: its four extremes are concave peaks, and each motorcycle runs+ /// straight to the outer square (none meets another).+ #[test]+ fn a_hole_sends_four_traces_to_the_outside() {+ let mut b = vec![[0.0, 0.0], [4.0, 0.0], [4.0, 4.0], [0.0, 4.0]];+ b.extend(circle([2.0, 2.0], 1.0, 32, false));+ let t = traces(&b, &[0..4, 4..36], [1.0, 1.0], 0.0);+ assert_eq!(t.len(), 4, "{t:?}");+ let on = |axis: usize, at: f64, from: f64, to: f64| {+ t.iter().any(|x| x.axis == axis && (x.at - at).abs() < 1e-12 && (x.from - from).abs() < 1e-9 && (x.to - to).abs() < 1e-9)+ };+ assert!(on(1, 2.0, 0.0, 1.0), "left: v = 2 from u = 0 to the hole");+ assert!(on(1, 2.0, 3.0, 4.0), "right");+ assert!(on(0, 2.0, 0.0, 1.0), "below");+ assert!(on(0, 2.0, 3.0, 4.0), "above");+ }++ /// An L: the reflex corner is a concave peak in both u and v, and its two motorcycles+ /// cut the L into three rectangles.+ #[test]+ fn an_l_is_cut_at_its_reflex_corner() {+ let b = [[0.0, 0.0], [2.0, 0.0], [2.0, 1.0], [1.0, 1.0], [1.0, 2.0], [0.0, 2.0]];+ let t = traces(&b, &[std::ops::Range { start: 0, end: 6 }], [1.0, 1.0], 0.0);+ assert_eq!(t.len(), 2, "{t:?}");+ let has = |axis: usize| {+ t.iter().any(|x| x.axis == axis && x.at == 1.0 && x.from == 0.0 && x.to == 1.0 && x.start == 3 && matches!(x.end, End::Boundary(..)))+ };+ assert!(has(0) && has(1), "{t:?}");+ }++ /// Two holes side by side: the inner motorcycles meet head-on halfway, and a later+ /// motorcycle stops on an earlier one's trace (no crossings).+ #[test]+ fn traces_meet_head_on_and_never_cross() {+ let mut b = vec![[0.0, 0.0], [8.0, 0.0], [8.0, 4.0], [0.0, 4.0]];+ b.extend(circle([2.0, 2.0], 1.0, 32, false));+ b.extend(circle([6.0, 2.5], 1.0, 32, false));+ let t = traces(&b, &[0..4, 4..36, 36..68], [1.0, 1.0], 0.0);+ // Hole 1's right extreme (3, 2) and hole 2's left extreme (5, 2.5) are on different+ // lines; each runs on until it meets the other hole or a trace.+ for (i, a) in t.iter().enumerate() {+ for c in t.iter().skip(i + 1) {+ if a.axis != c.axis {+ // a on axis line a.at; c crosses it if c.at is strictly within a's span+ // and a.at strictly within c's.+ let cross = c.at > a.from + 1e-9 && c.at < a.to - 1e-9 && a.at > c.from + 1e-9 && a.at < c.to - 1e-9;+ assert!(!cross, "{a:?} crosses {c:?}");+ }+ }+ }+ // Same-line pair: two holes at the same height meet halfway.+ let mut b = vec![[0.0, 0.0], [8.0, 0.0], [8.0, 4.0], [0.0, 4.0]];+ b.extend(circle([2.0, 2.0], 1.0, 32, false));+ b.extend(circle([6.0, 2.0], 1.0, 32, false));+ let t = traces(&b, &[0..4, 4..36, 36..68], [1.0, 1.0], 0.0);+ assert!(t.iter().any(|x| x.axis == 1 && (x.at - 2.0).abs() < 1e-12 && (x.from - 3.0).abs() < 1e-9 && (x.to - 4.0).abs() < 1e-9), "{t:?}");+ assert!(t.iter().any(|x| x.axis == 1 && (x.at - 2.0).abs() < 1e-12 && (x.from - 4.0).abs() < 1e-9 && (x.to - 5.0).abs() < 1e-9), "{t:?}");+ // Those two ended head-on with each other.+ let i = t.iter().position(|x| x.axis == 1 && (x.from - 3.0).abs() < 1e-9).unwrap_or(usize::MAX);+ let j = t.iter().position(|x| x.axis == 1 && (x.from - 4.0).abs() < 1e-9).unwrap_or(usize::MAX);+ assert_eq!(t.get(i).map(|x| x.end), Some(End::HeadOn(j)), "{t:?}");+ assert_eq!(t.get(j).map(|x| x.end), Some(End::HeadOn(i)), "{t:?}");+ }+}diff --git a/crates/kernel/src/tess/pieces.rs b/crates/kernel/src/tess/pieces.rsnew file mode 100644index 0000000000..9aa76273c4--- /dev/null+++ b/crates/kernel/src/tess/pieces.rs@@ -0,0 +1,348 @@+//! A trimmed face cut into four-sided patches. The cuts are segments in (u, v): the squares+//! round the face's holes (each joined to its hole at four points, so the ring between them is+//! four collar patches) and the motorcycle traces that extend the squares' sides. Each cut is+//! sampled once and both patches beside it use those nodes (as faces share their edges' nodes),+//! so the patches meet exactly. A cut never adds a node to the face's boundary: it ends on a+//! boundary node, at a point inside the face (a square's corner, or where two traces met+//! head-on), or on another cut (a T-node, which that cut then passes through).++use std::collections::HashMap;++/// Where a cut segment ends.+#[derive(Clone, Copy, Debug, PartialEq)]+pub(crate) enum End {+ /// A boundary node.+ Node(u32),+ /// A point inside the face; points at the same place are one node.+ Point([f64; 2]),+ /// A point on cut segment `.0` (a T-node: that segment passes through it).+ On(usize, [f64; 2]),+}++/// A cut from `a` to `b`, straight in (u, v).+#[derive(Clone, Copy, Debug, PartialEq)]+pub(crate) struct Segment {+ pub a: End,+ pub b: End,+ /// Segments to sample it in (spread over its pieces between T-nodes by length), instead of+ /// the seed rule: a butterfly's square side takes the count of the hole arc facing it.+ pub count: Option<usize>,+}++/// A patch: its outer ring and any holes inside it, as indices into the boundary nodes followed+/// by the cut nodes, counter-clockwise (holes clockwise) in (u, v).+#[derive(Clone, Debug, PartialEq, Eq)]+pub(crate) struct Piece {+ pub ring: Vec<u32>,+ pub holes: Vec<Vec<u32>>,+}++/// Cut the face bounded by `loops` (ranges of `boundary`) along `segments`, measured in the+/// metric `scale`. `seeds(a, b, sa, sb)`: where to put nodes between two nodes of a cut (in+/// (u, v)), as fractions strictly between 0 and 1, given the spacing wanted at each (in the+/// metric): the boundary's own spacing at a boundary node, unbounded inside the face (the seed+/// rule then sets it). Returns the cut nodes (numbered after the boundary) and the patches;+/// `None` when the cuts do not make a planar subdivision (the face is then meshed whole).+pub(crate) fn cut(+ boundary: &[[f64; 2]],+ loops: &[std::ops::Range<usize>],+ segments: &[Segment],+ scale: [f64; 2],+ seeds: &dyn Fn([f64; 2], [f64; 2], f64, f64) -> Vec<f64>,+) -> Option<(Vec<[f64; 2]>, Vec<Piece>)> {+ let n = boundary.len();+ let metric = |q: [f64; 2]| [q[0] * scale[0], q[1] * scale[1]];+ let dist = |a: [f64; 2], b: [f64; 2]| {+ let (a, b) = (metric(a), metric(b));+ (a[0] - b[0]).hypot(a[1] - b[1])+ };+ let mut cut_uv: Vec<[f64; 2]> = Vec::new();+ let mut points: HashMap<[u64; 2], u32> = HashMap::new();+ // Each segment's end nodes, and the T-nodes other segments put on it.+ let mut ends: Vec<(u32, u32)> = Vec::with_capacity(segments.len());+ let mut along: Vec<Vec<u32>> = vec![Vec::new(); segments.len()];+ for s in segments {+ let mut key = |e: End| -> Option<u32> {+ let mut point = |q: [f64; 2]| -> Option<u32> {+ let bits = [q[0].to_bits(), q[1].to_bits()];+ if let Some(&k) = points.get(&bits) {+ return Some(k);+ }+ let k = u32::try_from(n + cut_uv.len()).ok()?;+ cut_uv.push(q);+ points.insert(bits, k);+ Some(k)+ };+ match e {+ End::Node(k) => ((k as usize) < n).then_some(k),+ End::Point(q) => point(q),+ End::On(on, q) => {+ let k = point(q)?;+ along.get_mut(on)?.push(k);+ Some(k)+ }+ }+ };+ let (a, b) = (key(s.a)?, key(s.b)?);+ ends.push((a, b));+ }+ let at_in = |cut_uv: &[[f64; 2]], k: u32| -> Option<[f64; 2]> {+ let k = k as usize;+ if k < n { boundary.get(k).copied() } else { cut_uv.get(k - n).copied() }+ };+ // The spacing wanted at a node: at a boundary node the mean of its two boundary segments.+ let spacing = |k: u32| -> f64 {+ let k = k as usize;+ let Some(r) = loops.iter().find(|r| r.contains(&k)) else { return f64::INFINITY };+ let m = r.len();+ let i = k - r.start;+ let (prev, next) = (r.start + (i + m - 1) % m, r.start + (i + 1) % m);+ match (boundary.get(prev), boundary.get(k), boundary.get(next)) {+ (Some(&p), Some(&q), Some(&x)) => 0.5 * (dist(p, q) + dist(q, x)),+ _ => f64::INFINITY,+ }+ };+ // Boundary sides, so a cut that is one of them is left out.+ let mut sides: std::collections::HashSet<(u32, u32)> = std::collections::HashSet::new();+ for r in loops {+ let m = r.len();+ for k in 0..m {+ let (a, b) = (u32::try_from(r.start + k).ok()?, u32::try_from(r.start + (k + 1) % m).ok()?);+ sides.insert((a.min(b), a.max(b)));+ }+ }+ let mut cuts: Vec<(u32, u32)> = Vec::new();+ let mut taken: std::collections::HashSet<(u32, u32)> = std::collections::HashSet::new();+ for (i, &(s0, s1)) in ends.iter().enumerate() {+ if s0 == s1 {+ continue;+ }+ let p0 = at_in(&cut_uv, s0)?;+ let mut nodes: Vec<(f64, u32)> = vec![(0.0, s0)];+ for &k in along.get(i)? {+ nodes.push((dist(p0, at_in(&cut_uv, k)?), k));+ }+ let total = dist(p0, at_in(&cut_uv, s1)?);+ nodes.push((total, s1));+ nodes.sort_by(|a, b| a.0.total_cmp(&b.0));+ nodes.dedup_by_key(|x| x.1);+ let count = segments.get(i).and_then(|s| s.count);+ for w in nodes.windows(2) {+ let (Some(&(_, a)), Some(&(_, b))) = (w.first(), w.get(1)) else { continue };+ if a == b {+ continue;+ }+ // The same cut twice (two segments between the same nodes) is one cut.+ let key = (a.min(b), a.max(b));+ if sides.contains(&key) || !taken.insert(key) {+ continue;+ }+ let (pa, pb) = (at_in(&cut_uv, a)?, at_in(&cut_uv, b)?);+ let fractions: Vec<f64> = match count {+ Some(k) if total > 0.0 => {+ let share = dist(pa, pb) / total;+ let k = ((k as f64 * share).round() as usize).clamp(1, 4096);+ (1..k).map(|j| j as f64 / k as f64).collect()+ }+ _ => seeds(pa, pb, spacing(a), spacing(b)),+ };+ let mut prev = a;+ for f in fractions.into_iter().take(4096) {+ let k = u32::try_from(n + cut_uv.len()).ok()?;+ cut_uv.push([pa[0] + (pb[0] - pa[0]) * f, pa[1] + (pb[1] - pa[1]) * f]);+ cuts.push((prev, k));+ prev = k;+ }+ cuts.push((prev, b));+ }+ }+ if cuts.is_empty() {+ return None;+ }+ let at = |k: u32| at_in(&cut_uv, k);+ let pos = |k: u32| at(k).map(metric);+ // Half-edges: boundary sides with the face on their left, cut sides both ways.+ let inside = |q: [f64; 2]| {+ let mut odd = false;+ for r in loops {+ let m = r.len();+ for k in 0..m {+ let (Some(a), Some(b)) = (boundary.get(r.start + k).map(|p| metric(*p)), boundary.get(r.start + (k + 1) % m).map(|p| metric(*p)))+ else {+ continue;+ };+ if (a[1] > q[1]) != (b[1] > q[1]) && q[0] < a[0] + (q[1] - a[1]) / (b[1] - a[1]) * (b[0] - a[0]) {+ odd = !odd;+ }+ }+ }+ odd+ };+ let mut half: Vec<(u32, u32)> = Vec::new();+ for r in loops {+ let m = r.len();+ let side = |k: usize| -> Option<(u32, u32)> { Some((u32::try_from(r.start + k).ok()?, u32::try_from(r.start + (k + 1) % m).ok()?)) };+ // Which way round the face lies to the left: test beside the loop's longest side.+ let longest = (0..m).max_by(|&x, &y| {+ let l = |k: usize| side(k).and_then(|(a, b)| Some(dist(at(a)?, at(b)?))).unwrap_or(0.0);+ l(x).total_cmp(&l(y))+ })?;+ let (a, b) = side(longest)?;+ let (pa, pb) = (pos(a)?, pos(b)?);+ let len = (pb[0] - pa[0]).hypot(pb[1] - pa[1]);+ if !(len > 0.0) {+ return None;+ }+ let left = [0.5 * (pa[0] + pb[0]) - (pb[1] - pa[1]) * 1e-4, 0.5 * (pa[1] + pb[1]) + (pb[0] - pa[0]) * 1e-4];+ let forward = inside(left);+ for k in 0..m {+ let (a, b) = side(k)?;+ if a == b {+ continue;+ }+ half.push(if forward { (a, b) } else { (b, a) });+ }+ }+ for &(a, b) in &cuts {+ half.push((a, b));+ half.push((b, a));+ }+ // Outgoing half-edges per node, by angle.+ let angle = |a: u32, b: u32| -> Option<f64> {+ let (p, q) = (pos(a)?, pos(b)?);+ Some((q[1] - p[1]).atan2(q[0] - p[0]))+ };+ let mut out: HashMap<u32, Vec<(f64, usize)>> = HashMap::new();+ for (h, &(a, b)) in half.iter().enumerate() {+ out.entry(a).or_default().push((angle(a, b)?, h));+ }+ for v in out.values_mut() {+ v.sort_by(|x, y| x.0.total_cmp(&y.0));+ }+ // The face on the left of u→v continues at v with the first outgoing side clockwise from+ // v→u.+ let next = |h: usize| -> Option<usize> {+ let &(u, v) = half.get(h)?;+ let back = angle(v, u)?;+ let list = out.get(&v)?;+ let before = list+ .iter()+ .rev()+ .find(|(a, e)| *a < back - 1e-12 && half.get(*e).is_some_and(|x| x.1 != u))+ .or_else(|| list.iter().rev().find(|(_, e)| half.get(*e).is_some_and(|x| x.1 != u)));+ before.map(|(_, e)| *e).or_else(|| list.iter().find(|(_, e)| half.get(*e).is_some_and(|x| x.1 == u)).map(|(_, e)| *e))+ };+ let mut seen = vec![false; half.len()];+ let mut rings: Vec<Vec<u32>> = Vec::new();+ for h0 in 0..half.len() {+ if *seen.get(h0)? {+ continue;+ }+ let mut ring = Vec::new();+ let mut h = h0;+ loop {+ *seen.get_mut(h)? = true;+ ring.push(half.get(h)?.0);+ h = next(h)?;+ if h == h0 {+ break;+ }+ if ring.len() > half.len() || *seen.get(h)? {+ return None;+ }+ }+ rings.push(ring);+ }+ let area = |ring: &[u32]| -> Option<f64> {+ let mut s = 0.0;+ for k in 0..ring.len() {+ let (a, b) = (pos(*ring.get(k)?)?, pos(*ring.get((k + 1) % ring.len())?)?);+ s += a[0] * b[1] - b[0] * a[1];+ }+ Some(0.5 * s)+ };+ let mut pieces: Vec<Piece> = Vec::new();+ let mut holes: Vec<Vec<u32>> = Vec::new();+ for r in rings {+ if area(&r)? > 0.0 {+ pieces.push(Piece { ring: r, holes: Vec::new() });+ } else {+ holes.push(r);+ }+ }+ // A loop no cut reached is a hole of the patch around it.+ for h in holes {+ let p = pos(*h.first()?)?;+ let contains = |ring: &[u32]| {+ let mut odd = false;+ for k in 0..ring.len() {+ let (Some(a), Some(b)) = (ring.get(k).and_then(|x| pos(*x)), ring.get((k + 1) % ring.len()).and_then(|x| pos(*x))) else { continue };+ if (a[1] > p[1]) != (b[1] > p[1]) && p[0] < a[0] + (p[1] - a[1]) / (b[1] - a[1]) * (b[0] - a[0]) {+ odd = !odd;+ }+ }+ odd+ };+ let host = pieces.iter_mut().filter(|pc| contains(&pc.ring)).min_by(|a, b| {+ let s = |pc: &Piece| area(&pc.ring).unwrap_or(f64::MAX);+ s(a).total_cmp(&s(b))+ })?;+ host.holes.push(h);+ }+ Some((cut_uv, pieces))+}++#[cfg(test)]+mod tests {+ use super::*;++ fn area(all: &[[f64; 2]], ring: &[u32]) -> f64 {+ (0..ring.len())+ .map(|k| {+ let (a, b) = (all[ring[k] as usize], all[ring[(k + 1) % ring.len()] as usize]);+ 0.5 * (a[0] * b[1] - b[0] * a[1])+ })+ .sum()+ }++ /// A square cut by four segments meeting at its centre (one point inside the face, shared)+ /// gives four quarters covering it.+ #[test]+ fn a_cross_cuts_a_square_into_four() {+ let b = vec![[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [2.0, 1.0], [2.0, 2.0], [1.0, 2.0], [0.0, 2.0], [0.0, 1.0]];+ let loops = [std::ops::Range { start: 0, end: 8 }];+ let c = End::Point([1.0, 1.0]);+ let segs = [+ Segment { a: End::Node(1), b: c, count: None },+ Segment { a: End::Node(3), b: c, count: None },+ Segment { a: End::Node(5), b: c, count: None },+ Segment { a: End::Node(7), b: c, count: None },+ ];+ let Some((cut_uv, pieces)) = cut(&b, &loops, &segs, [1.0, 1.0], &|_, _, _, _| vec![0.5]) else { panic!("cuts") };+ assert_eq!(pieces.len(), 4);+ let mut all = b.clone();+ all.extend(cut_uv);+ let total: f64 = pieces.iter().map(|p| area(&all, &p.ring)).sum();+ assert!((total - 4.0).abs() < 1e-12, "{total}");+ }++ /// A segment ending on another (a T-node) splits it there: three patches.+ #[test]+ fn a_t_node_splits_the_segment_it_lands_on() {+ let b = vec![[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [2.0, 1.0], [2.0, 2.0], [0.0, 2.0], [0.0, 1.0]];+ let loops = [std::ops::Range { start: 0, end: 7 }];+ let segs = [Segment { a: End::Node(6), b: End::Node(3), count: None }, Segment { a: End::Node(1), b: End::On(0, [1.0, 1.0]), count: None }];+ let Some((cut_uv, pieces)) = cut(&b, &loops, &segs, [1.0, 1.0], &|_, _, _, _| Vec::new()) else { panic!("cuts") };+ assert_eq!(pieces.len(), 3, "{pieces:?}");+ let mut all = b.clone();+ all.extend(cut_uv);+ let total: f64 = pieces.iter().map(|p| area(&all, &p.ring)).sum();+ assert!((total - 4.0).abs() < 1e-12, "{total}");+ }++ #[test]+ fn no_segments_no_cut() {+ let b = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]];+ assert!(cut(&b, &[std::ops::Range { start: 0, end: 4 }], &[], [1.0, 1.0], &|_, _, _, _| Vec::new()).is_none());+ }+}diff --git a/crates/kernel/src/tess/size.rs b/crates/kernel/src/tess/size.rsindex 37129878f8..9cbad54c3c 100644--- a/crates/kernel/src/tess/size.rs+++ b/crates/kernel/src/tess/size.rs@@ -14,10 +14,9 @@ use super::uv::Domain;/// Longest side, as a fraction of the body's extent.const MAX_LEN_FRACTION: f64 = 1.0 / 5.0;/// Longest side relative to the side the curvature asks for: along a straight direction (a-/// cylinder's axis) triangles may be this many times longer than across it. With a 30° facet-/// angle and [`MAX_LEN_FRACTION`] this puts the oracle parts' display meshes at about the-/// reference mesher's triangle count (1.2×; 5× with equilateral triangles and 15°).-const ASPECT: f64 = 4.0;+/// cylinder's axis) cells may be this many times longer than across it. 2: cells stay close to+/// square (patches mesh as grids) without doubling the rows along every straight surface.+const ASPECT: f64 = 2.0;/// Shortest side the aspect limit may ask for, as a fraction of the longest side. A bend whose/// radius is tiny next to the body (a hem) would otherwise tie the whole length of its/// straight edges to that radius; along a straight direction the normal does not turn, so@@ -172,15 +171,16 @@ mod tests {transform: [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]],swap: false,};- // A 20 mm body: sides from 0.5 mm (the floor) to 4 mm.+ // A 20 mm body: sides from 1 mm (the floor, a quarter of the longest) to 4 mm.let rules = Rules::new(0.01, 20.0, THIRTY);let (h, speed) = face_size(&s, &super::super::uv::domain(&s), &rules);- // r = 3: 30° of turn is 1.57 mm; the 0.01 mm sag chord is √(8·3·0.01) = 0.49 mm.- assert!((h - ASPECT * (8.0 * 3.0 * 0.01f64).sqrt()).abs() < 0.01, "{h}");+ // r = 3: 30° of turn is 1.57 mm; the 0.01 mm sag chord is √(8·3·0.01) = 0.49 mm, times the+ // aspect, unless that is under the floor.+ assert!((h - (ASPECT * (8.0 * 3.0 * 0.01f64).sqrt()).max(20.0 * MAX_LEN_FRACTION * MIN_LEN_FRACTION)).abs() < 0.01, "{h}");assert!((speed[0] - 40.0).abs() < 1e-6 && (speed[1] - 3.0).abs() < 1e-6, "{speed:?}");// Coarser: the turn limit governs.let (h, _) = face_size(&s, &super::super::uv::domain(&s), &Rules::new(0.5, 100.0, THIRTY));- assert!((h - ASPECT * 3.0 * std::f64::consts::PI / 6.0).abs() < 0.01, "{h}");+ assert!((h - (ASPECT * 3.0 * std::f64::consts::PI / 6.0).max(100.0 * MAX_LEN_FRACTION * MIN_LEN_FRACTION)).abs() < 0.01, "{h}");// Without a facet angle the sag alone: √(8·3·0.5) = 3.46 mm, four times along.let (h, _) = face_size(&s, &super::super::uv::domain(&s), &Rules::new(0.5, 100.0, None));assert!((h - ASPECT * (8.0 * 3.0 * 0.5f64).sqrt()).abs() < 0.01, "{h}");diff --git a/crates/kernel/src/tess/tests.rs b/crates/kernel/src/tess/tests.rsindex 6580299c6e..5587fb7d67 100644--- a/crates/kernel/src/tess/tests.rs+++ b/crates/kernel/src/tess/tests.rs@@ -108,13 +108,14 @@ fn holes_and_trimmed_faces_are_watertight() {let bx = ok(crate::box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 4.0)));let pin = ok(crate::cylinder(Vec3::new(5.0, 5.0, -1.0), Vec3::Z, 2.0, 6.0));check("box with a hole", &cut(&bx, &pin), tol, 400.0 - PI * 4.0 * 4.0);- // A cylinder with a cross hole: trimmed cylinder halves (Delaunay) and intersection-curve walls.+ // A cylinder with a cross hole: trimmed cylinder halves (an iso-line grid cut by the hole)+ // and intersection-curve walls; no face needs Delaunay.let cyl = ok(crate::cylinder(Vec3::new(5.0, 5.0, -1.0), Vec3::Z, 2.0, 6.0));let cross = ok(crate::cylinder(Vec3::new(5.0, -1.0, 2.0), Vec3::Y, 1.0, 12.0));let body = cut(&cyl, &cross);let (m, stats) = plan_body(&body, tol);assert_watertight(&m, "cross hole");- assert!(stats.delaunay > 0, "{stats:?}");+ assert_eq!(stats.delaunay, 0, "{stats:?}");// Against the reference mesher's volume (no closed form for the two-cylinder intersection).let Ok(reference) = body.tessellate(tol * 0.2) else { panic!("reference mesh") };let (a, b) = (m.measure().volume, reference.measure().volume);@@ -279,3 +280,19 @@ fn a_placed_body_meshes_like_the_original() {let (p, _) = plan_body(&placed, 0.005);assert_eq!(m.tri_face, p.tri_face);}++/// Seeds on a motorcycle trace start at the spacing of the boundary it leaves and grow+/// geometrically to the spacing at its other end (here 0.1 to 1 over 5 mm).+#[test]+fn trace_seeds_grade_from_one_end_to_the_other() {+ let t = graded([0.0, 0.0], [5.0, 0.0], 0.1, 1.0, 10.0, [1.0, 1.0], &|_, _| true);+ let all: Vec<f64> = std::iter::once(0.0).chain(t.iter().copied()).chain(std::iter::once(1.0)).map(|f| f * 5.0).collect();+ let sizes: Vec<f64> = all.windows(2).map(|w| w[1] - w[0]).collect();+ assert!((sizes[0] - 0.1).abs() < 0.03, "first {}", sizes[0]);+ assert!((sizes[sizes.len() - 1] - 1.0).abs() < 0.3, "last {}", sizes[sizes.len() - 1]);+ assert!(sizes.windows(2).all(|w| w[1] >= w[0] - 1e-12), "growing: {sizes:?}");+ // Equal ends: even; a segment no longer than its spacing: no seeds.+ let even = graded([0.0, 0.0], [4.0, 0.0], 1.0, 1.0, 10.0, [1.0, 1.0], &|_, _| true);+ assert_eq!(even.len(), 3);+ assert!(graded([0.0, 0.0], [0.5, 0.0], 1.0, 1.0, 10.0, [1.0, 1.0], &|_, _| true).is_empty());+}