SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Display helical-trimmed faces from imported threads correctly (#1289) (#1300)
bherbruck8535d229ff97
diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex 775841b0b9..d38f03a9fd 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -1043,6 +1043,17 @@ impl Body {if let Some(m) = &self.mesh {return Ok(m.to_mesh());}+ // A face trimmed by a helix (a modelled thread from another CAD system) turns more than+ // once around its cylinder; truck meshes it with triangles across the solid (#1289).+ // Such a body is meshed from its display plan, which cuts the face along a seam.+ if guard("tessellate", || Ok(crate::tess::seam::turns_more_than_once(&self.solid))).unwrap_or(false) {+ let turn = (angle.is_finite() && angle > 0.0)+ .then(|| crate::tess::size::Turn { angle: angle.max(MIN_DISPLAY_ANGLE), floor: tol * DISPLAY_ANGLE_FLOOR });+ match guard("tessellate", || crate::tess::plan(&self.solid, tol, turn)) {+ Ok((plan, _)) => return Ok(plan.evaluate()),+ Err(e) => log::debug!("helical faces: no display plan ({e}); meshing the reference way"),+ }+ }let deflection = if angle.is_finite() && angle > 0.0 {Deflection { chord: tol, angle: angle.max(MIN_DISPLAY_ANGLE), floor: tol * DISPLAY_ANGLE_FLOOR, rulings: true }} else {diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex 9a3c4e296b..89bc7bbe8b 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -103,6 +103,8 @@ mod sweep_path;mod tangent_cylinders;mod tess;#[cfg(test)]+mod thread_display_tests;+#[cfg(test)]mod thread_tests;mod topo;mod tspline;diff --git a/crates/kernel/src/tess/cdt.rs b/crates/kernel/src/tess/cdt.rsindex ec0df6d462..17a547fee9 100644--- a/crates/kernel/src/tess/cdt.rs+++ b/crates/kernel/src/tess/cdt.rs@@ -102,7 +102,14 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range<usize>.exclude_outer_faces(true).with_angle_limit(AngleLimit::from_deg(MIN_ANGLE_DEG)).with_max_additional_vertices(budget.saturating_sub(added));+ let before = cdt.num_vertices();cdt.refine(params);+ let shaped = cdt.num_vertices().saturating_sub(before);+ // Shaping flips sides and adds points of its own; the triangles it leaves may+ // sag again (a long strip round a cylinder), so the sag is checked once more.+ if shaped > 0 {+ refine_sag(&mut cdt, sag, budget.saturating_sub(added + shaped), &from);+ }}// A split constraint would put a point on the boundary the neighbour does not have.if cdt.num_constraints() != constraints {diff --git a/crates/kernel/src/tess/mod.rs b/crates/kernel/src/tess/mod.rsindex a5421b542c..8c1cfc731b 100644--- a/crates/kernel/src/tess/mod.rs+++ b/crates/kernel/src/tess/mod.rs@@ -24,6 +24,7 @@ pub(crate) mod edges;pub(crate) mod grid;pub(crate) mod motorcycle;pub(crate) mod pieces;+pub(crate) mod seam;pub(crate) mod size;pub(crate) mod ssi;pub(crate) mod surface;@@ -237,10 +238,8 @@ fn plan_face(let dom = uv::domain(s);let accept = (tol * 10.0).max(1e-6);let fail = |why: &str| unsupported(format!("face {fi}: {why}"));- // Project every loop, unwrapping periodic parameters along it and splitting poles.- let mut fixed: Vec<Vec3> = Vec::new();- let mut uvs: Vec<[f64; 2]> = Vec::new();- let mut ranges: Vec<std::ops::Range<usize>> = Vec::new();+ // Project every loop, unwrapping periodic parameters along it.+ let mut projected: Vec<seam::Loop> = Vec::with_capacity(loops3.len());for (li, pts) in loops3.iter().enumerate() {let mut luv: Vec<[f64; 2]> = Vec::with_capacity(pts.len());let mut prev: Option<[f64; 2]> = None;@@ -260,16 +259,28 @@ fn plan_face(luv.push(q);prev = Some(q);}- // A loop that winds once around a periodic direction does not close in (u, v).- if let (Some(first), Some(last)) = (luv.first(), luv.last()) {- for d in 0..2 {- if let Some(per) = dom.period[d]- && (uv::unwrap(first[d], last[d], Some(per)) - first[d]).abs() > per * 0.25- {- return Err(fail("boundary winds around the surface"));- }- }+ projected.push(seam::Loop { uv: luv, pts: pts.clone() });+ }+ // A loop that winds around a periodic direction does not close in (u, v): the face is cut+ // along a parameter line into one period (a seamless cylinder face, a helical trim).+ let wound: Vec<usize> = (0..2).filter(|&d| dom.period[d].is_some_and(|per| seam::winds(&projected, d, per))).collect();+ // A face cut along a seam is a long winding strip whose sides are the cut lines and the+ // boundary in turn: Delaunay with sag refinement meshes it (the patch layouts below assume+ // boundary all round, and leave fans across the strip's corners off the surface).+ let seamed = !wound.is_empty();+ match wound.as_slice() {+ [] => {}+ [d] => {+ let per = dom.period[*d].unwrap_or(std::f64::consts::TAU);+ projected = seam::cut(s, &projected, *d, per, rules, h).ok_or_else(|| fail("boundary winds around the surface"))?;}+ _ => return Err(fail("boundary winds around the surface both ways")),+ }+ // Split poles.+ let mut fixed: Vec<Vec3> = Vec::new();+ let mut uvs: Vec<[f64; 2]> = Vec::new();+ let mut ranges: Vec<std::ops::Range<usize>> = Vec::new();+ for seam::Loop { uv: luv, pts } in &projected {let start = uvs.len();let n = luv.len();for (k, (q, p)) in luv.iter().zip(pts).enumerate() {@@ -325,7 +336,7 @@ fn plan_face(let mut us = uv::divide(s, 0, bbox[0], bbox[1], rules, h, MAX_LINES);let mut vs = uv::divide(s, 1, bbox[1], bbox[0], rules, h, MAX_LINES);thin(&mut us, &mut vs, grid::MAX_FACE_GRID);- let structured = match (ranges.len(), grid::quad(&uvs)) {+ let structured = match (ranges.len(), if seamed { None } else { grid::quad(&uvs) }) {(1, Some(q)) => {// Interior lines: the boundary's own where opposite sides agree (refined where the// surface turns more between them inside the face), else the division.@@ -350,7 +361,7 @@ fn plan_face(_ => None,};let structured = match structured {- None if ranges.len() == 1 => {+ None if ranges.len() == 1 && !seamed => {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, h, Some(&fine))}@@ -371,7 +382,9 @@ fn plan_face(// 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 {+ let trimmed = if seamed {+ None+ } else if planar {if ranges.len() == 1 { plan_pieces(&face) } else { None }} else {plan_pieces(&face).or_else(|| {diff --git a/crates/kernel/src/tess/seam.rs b/crates/kernel/src/tess/seam.rsnew file mode 100644index 0000000000..21cb6ef13d--- /dev/null+++ b/crates/kernel/src/tess/seam.rs@@ -0,0 +1,405 @@+//! Faces on a closed surface whose boundary winds around it: a cylinder face bounded by two+//! circles and no seam edge, or one trimmed by a helix that turns several times (a modelled+//! thread, as other CAD systems write them to STEP). In the surface's unwrapped parameters such+//! a face repeats every period, and its loops do not close. It is cut along a parameter line+//! (the seam it never had) into one period: every loop, and every copy of it a whole number of+//! periods along, is clipped to the strip between the line and its next copy, and the parts of+//! the two lines inside the face join the pieces into closed loops. Both lines are one curve+//! on the surface, so their nodes are made once and shared: the face stays closed across it.++use solidcraft_geom::Vec3;+use solidcraft_geom::tess::EvalSurface;++use super::size::Rules;++/// One loop of a face: parameters (unwrapped along the loop) and the 3D node each stands for.+#[derive(Clone, Debug, Default)]+pub(crate) struct Loop {+ pub uv: Vec<[f64; 2]>,+ pub pts: Vec<Vec3>,+}++/// Most loop copies one face may be clipped into (a helix of this many turns).+const MAX_COPIES: i64 = 2048;+/// Most nodes a cut line may get between two crossings.+const MAX_SEAM_NODES: usize = 4096;++/// How far `l` drifts along `d` going once around it (a whole number of periods for a closed+/// loop: zero unless it winds around the surface).+pub(crate) fn drift(l: &Loop, d: usize, per: f64) -> f64 {+ let (Some(first), Some(last)) = (l.uv.first(), l.uv.last()) else { return 0.0 };+ let close = super::uv::unwrap(first[d], last[d], Some(per)) - last[d];+ last[d] - first[d] + close+}++/// Whether any loop winds around the closed direction `d`.+pub(crate) fn winds(loops: &[Loop], d: usize, per: f64) -> bool {+ loops.iter().any(|l| drift(l, d, per).abs() > per * 0.5)+}++/// A point where the boundary crosses a cut line: its place along the line, its 3D point, and+/// whether the face lies above it (towards larger parameters across the line) or below.+#[derive(Clone, Copy, Debug)]+struct Crossing {+ y: f64,+ p: Vec3,+ above: bool,+}++/// A boundary run across the strip: it enters through one cut line and leaves through one.+struct Piece {+ uv: Vec<[f64; 2]>,+ pts: Vec<Vec3>,+}++/// Cut a face whose loops wind around direction `d` (period `per`) into one period. The face+/// lies left of its loops in (u, v). `None` when the loops cannot be cut cleanly (the face would+/// be unbounded along the line, or the two lines disagree); the caller then fails as before.+pub(crate) fn cut(s: &EvalSurface, loops: &[Loop], d: usize, per: f64, rules: &Rules, h: f64) -> Option<Vec<Loop>> {+ if !(per > 0.0 && per.is_finite()) || loops.is_empty() {+ return None;+ }+ // Work in (x, y) with x along the closed direction; swapping (u, v) mirrors the plane, so the+ // loops are reversed to keep the face on their left.+ let swap = d == 1;+ let local: Vec<Loop> = loops+ .iter()+ .map(|l| {+ let mut uv: Vec<[f64; 2]> = l.uv.iter().map(|q| if swap { [q[1], q[0]] } else { *q }).collect();+ let mut pts = l.pts.clone();+ if swap {+ uv.reverse();+ pts.reverse();+ }+ Loop { uv, pts }+ })+ .collect();+ let x0 = cut_position(&local, per)?;+ let x1 = x0 + per;+ let mut closed: Vec<Loop> = Vec::new();+ let mut pieces: Vec<Piece> = Vec::new();+ for l in &local {+ let n = l.uv.len();+ if n < 2 || l.pts.len() != n {+ return None;+ }+ let w = drift(l, 0, per);+ let (lo, hi) = l.uv.iter().fold((f64::MAX, f64::MIN), |(a, b), q| (a.min(q[0]), b.max(q[0])));+ if !(lo.is_finite() && hi.is_finite()) {+ return None;+ }+ if w.abs() <= per * 0.5 {+ // A closed loop: each copy along x that reaches into the strip.+ let k0 = ((x0 - hi) / per).floor() as i64;+ let k1 = ((x1 - lo) / per).ceil() as i64;+ if k1 - k0 > MAX_COPIES {+ return None;+ }+ for k in k0..=k1 {+ let shift = per * k as f64;+ let uv: Vec<[f64; 2]> = l.uv.iter().map(|q| [q[0] + shift, q[1]]).collect();+ if uv.iter().all(|q| q[0] > x0 && q[0] < x1) {+ closed.push(Loop { uv, pts: l.pts.clone() });+ } else if uv.iter().any(|q| q[0] > x0 && q[0] < x1) || crosses(&uv, x0, x1) {+ // Start at a node outside the strip, so every run inside is whole.+ let start = uv.iter().position(|q| !(q[0] > x0 && q[0] < x1))?;+ let idx: Vec<usize> = (0..=n).map(|i| (start + i) % n).collect();+ let path: Vec<[f64; 2]> = idx.iter().filter_map(|&i| uv.get(i).copied()).collect();+ let pts: Vec<Vec3> = idx.iter().filter_map(|&i| l.pts.get(i).copied()).collect();+ clip(&path, &pts, x0, x1, &mut pieces);+ }+ }+ } else {+ // A loop winding around: the endless path it repeats along, over enough turns to+ // start and end outside the strip.+ let turns = (w / per).round();+ if turns.abs() != 1.0 {+ return None;+ }+ let reach = (hi - lo) / per;+ let span = (reach.ceil() as i64) + 2;+ if span > MAX_COPIES {+ return None;+ }+ // Copies j with lo + j·w ≤ x1 and hi + j·w ≥ x0, plus one each side.+ let (ja, jb) = if w > 0.0 {+ (((x0 - hi) / w).floor() as i64 - 1, ((x1 - lo) / w).ceil() as i64 + 1)+ } else {+ (((x1 - lo) / w).floor() as i64 - 1, ((x0 - hi) / w).ceil() as i64 + 1)+ };+ if jb - ja > MAX_COPIES {+ return None;+ }+ let mut path = Vec::new();+ let mut pts = Vec::new();+ for j in ja..=jb {+ let shift = w * j as f64;+ path.extend(l.uv.iter().map(|q| [q[0] + shift, q[1]]));+ pts.extend(l.pts.iter().copied());+ }+ let (Some(a), Some(b)) = (path.first(), path.last()) else { return None };+ if (a[0] > x0 && a[0] < x1) || (b[0] > x0 && b[0] < x1) {+ return None;+ }+ clip(&path, &pts, x0, x1, &mut pieces);+ }+ }+ // The crossings on each line, sorted along it; both lines must see the same ones.+ let mut left: Vec<(Crossing, usize, bool)> = Vec::new();+ let mut right: Vec<(Crossing, usize, bool)> = Vec::new();+ for (i, p) in pieces.iter().enumerate() {+ let (Some(a), Some(b), Some(pa), Some(pb)) = (p.uv.first(), p.uv.last(), p.pts.first(), p.pts.last()) else { return None };+ // Entering through the left line (moving +x): the face is above; through the right+ // line (moving −x): below. Leaving through the left (−x): below; the right (+x): above.+ let enter = Crossing { y: a[1], p: *pa, above: a[0] == x0 };+ let leave = Crossing { y: b[1], p: *pb, above: b[0] == x1 };+ if a[0] == x0 {+ left.push((enter, i, true))+ } else {+ right.push((enter, i, true))+ }+ if b[0] == x0 { left.push((leave, i, false)) } else { right.push((leave, i, false)) }+ }+ left.sort_by(|a, b| a.0.y.total_cmp(&b.0.y));+ right.sort_by(|a, b| a.0.y.total_cmp(&b.0.y));+ if left.len() != right.len() || !left.len().is_multiple_of(2) {+ return None;+ }+ let scale = loops.iter().flat_map(|l| l.uv.iter()).fold(1.0f64, |m, q| m.max(q[0].abs()).max(q[1].abs()));+ for (a, b) in left.iter().zip(&right) {+ if a.0.above != b.0.above || (a.0.y - b.0.y).abs() > 1e-7 * scale {+ return None;+ }+ }+ // The same crossing on both lines is one point.+ for (a, b) in left.clone().iter().zip(right.iter_mut()) {+ b.0.y = a.0.y;+ b.0.p = a.0.p;+ }+ for (c, i, start) in left.iter().chain(&right) {+ let p = pieces.get_mut(*i)?;+ let k = if *start { 0 } else { p.uv.len().checked_sub(1)? };+ if let (Some(q), Some(pt)) = (p.uv.get_mut(k), p.pts.get_mut(k)) {+ q[1] = c.y;+ *pt = c.p;+ }+ }+ // Inside the face along each line: from a crossing with the face above to the next one+ // up (which must have it below).+ let mut links: Vec<(usize, Vec<[f64; 2]>, Vec<Vec3>, usize)> = Vec::new();+ for pair in left.chunks(2).zip(right.chunks(2)) {+ let (lp, rp) = pair;+ let (Some(la), Some(lb), Some(ra), Some(rb)) = (lp.first(), lp.get(1), rp.first(), rp.get(1)) else { return None };+ if !(la.0.above && !lb.0.above) {+ return None;+ }+ // Nodes strictly between, made once for both lines.+ let inner = seam_nodes(s, swap, x0, la.0.y, lb.0.y, rules, h)?;+ // Left line, downwards: from the piece leaving at the top to the one entering at the bottom.+ let (top_leave, bottom_enter) = (lb.1, la.1);+ let down_uv: Vec<[f64; 2]> = inner.iter().rev().map(|(y, _)| [x0, *y]).collect();+ let down_pts: Vec<Vec3> = inner.iter().rev().map(|(_, p)| *p).collect();+ if lb.2 || !la.2 {+ return None;+ }+ links.push((top_leave, down_uv, down_pts, bottom_enter));+ // Right line, upwards: from the piece leaving at the bottom to the one entering at the top.+ if ra.2 || !rb.2 {+ return None;+ }+ let up_uv: Vec<[f64; 2]> = inner.iter().map(|(y, _)| [x1, *y]).collect();+ let up_pts: Vec<Vec3> = inner.iter().map(|(_, p)| *p).collect();+ links.push((ra.1, up_uv, up_pts, rb.1));+ }+ // Chain pieces through the links into closed loops.+ let mut next: Vec<Option<usize>> = vec![None; pieces.len()];+ let mut via: Vec<Option<usize>> = vec![None; pieces.len()];+ for (li, (from, _, _, to)) in links.iter().enumerate() {+ if next.get(*from).copied().flatten().is_some() {+ return None;+ }+ *next.get_mut(*from)? = Some(*to);+ *via.get_mut(*from)? = Some(li);+ }+ let mut used = vec![false; pieces.len()];+ for start in 0..pieces.len() {+ if used.get(start).copied().unwrap_or(true) {+ continue;+ }+ let mut out = Loop::default();+ let mut at = start;+ for _ in 0..=pieces.len() {+ if *used.get(at)? {+ break;+ }+ *used.get_mut(at)? = true;+ let p = pieces.get(at)?;+ out.uv.extend(&p.uv);+ out.pts.extend(&p.pts);+ let (_, luv, lpts, _) = links.get((*via.get(at)?)?)?;+ out.uv.extend(luv);+ out.pts.extend(lpts);+ at = (*next.get(at)?)?;+ }+ if at != start {+ return None;+ }+ closed.push(out);+ }+ // Back to (u, v).+ let out: Vec<Loop> = closed+ .into_iter()+ .map(|mut l| {+ if swap {+ l.uv = l.uv.iter().rev().map(|q| [q[1], q[0]]).collect();+ l.pts.reverse();+ }+ l+ })+ .collect();+ // The face must come out with positive area (left of its loops).+ let area: f64 = out+ .iter()+ .map(|l| {+ let n = l.uv.len();+ (0..n)+ .map(|i| {+ let (a, b) = (l.uv[i], l.uv[(i + 1) % n]);+ a[0] * b[1] - b[0] * a[1]+ })+ .sum::<f64>()+ })+ .sum();+ (area > 0.0).then_some(out)+}++/// Where to cut: the middle of the widest gap between the loops' nodes around the period, as+/// far from any node as can be.+fn cut_position(loops: &[Loop], per: f64) -> Option<f64> {+ let mut xs: Vec<f64> = loops.iter().flat_map(|l| l.uv.iter().map(|q| q[0].rem_euclid(per))).collect();+ if xs.is_empty() {+ return None;+ }+ xs.sort_by(f64::total_cmp);+ let mut best = (0.0, f64::NEG_INFINITY);+ for (i, x) in xs.iter().enumerate() {+ let next = xs.get(i + 1).copied().unwrap_or(xs[0] + per);+ if next - x > best.1 {+ best = (0.5 * (x + next), next - x);+ }+ }+ (best.1 > 0.0).then_some(best.0)+}++/// Whether a path jumps over the strip in one segment.+fn crosses(uv: &[[f64; 2]], x0: f64, x1: f64) -> bool {+ uv.windows(2).any(|w| (w[0][0] <= x0 && w[1][0] >= x1) || (w[1][0] <= x0 && w[0][0] >= x1))+}++/// The runs of an open path (starting and ending outside the strip) inside the strip, each+/// from the point where it enters to the one where it leaves. The crossing points lie on the+/// boundary's own straight 3D segments, so the neighbouring face's edge passes through them.+fn clip(path: &[[f64; 2]], pts: &[Vec3], x0: f64, x1: f64, out: &mut Vec<Piece>) {+ let inside = |q: &[f64; 2]| q[0] > x0 && q[0] < x1;+ let mut cur: Option<Piece> = None;+ for k in 0..path.len().saturating_sub(1) {+ let (Some(a), Some(b), Some(pa), Some(pb)) = (path.get(k), path.get(k + 1), pts.get(k), pts.get(k + 1)) else { break };+ let at = |x: f64| {+ let t = ((x - a[0]) / (b[0] - a[0])).clamp(0.0, 1.0);+ ([x, a[1] + (b[1] - a[1]) * t], *pa + (*pb - *pa) * t)+ };+ // Lines crossed by this segment, in order along it.+ let mut hits: Vec<f64> = [x0, x1].into_iter().filter(|x| (a[0] - x) * (b[0] - x) < 0.0).collect();+ if b[0] < a[0] {+ hits.reverse();+ }+ for x in hits {+ let (q, p) = at(x);+ match cur.take() {+ Some(mut piece) => {+ piece.uv.push(q);+ piece.pts.push(p);+ out.push(piece);+ }+ None => cur = Some(Piece { uv: vec![q], pts: vec![p] }),+ }+ }+ if inside(b)+ && let Some(piece) = cur.as_mut()+ {+ piece.uv.push(*b);+ piece.pts.push(*pb);+ }+ }+}++/// Nodes along the cut line between two crossings (`y0` < `y1`, ends excluded): within the+/// tolerance, the side length and the facet angle of the surface along the line.+fn seam_nodes(s: &EvalSurface, swap: bool, x: f64, y0: f64, y1: f64, rules: &Rules, h: f64) -> Option<Vec<(f64, Vec3)>> {+ let uv = |y: f64| if swap { [y, x] } else { [x, y] };+ let mut ys = vec![y0, y1];+ let mut i = 0;+ while i + 1 < ys.len() {+ let (a, b) = (ys[i], ys[i + 1]);+ if ys.len() < MAX_SEAM_NODES && !super::uv::fine_between(s, rules, h, uv(a), uv(b)) && b - a > 1e-12 * (1.0 + a.abs()) {+ ys.insert(i + 1, 0.5 * (a + b));+ } else {+ i += 1;+ }+ }+ let inner = ys.get(1..ys.len() - 1)?;+ Some(inner.iter().map(|&y| (y, s.eval(uv(y)[0], uv(y)[1]).0)).collect())+}++/// Whether a face of `solid` lies on a surface of revolution and has a boundary loop turning+/// more than once around its axis (a helical trim). Truck's mesher cannot mesh such a face (its+/// triangles cut across the solid), so the reference mesh is made from the display plan instead.+pub(crate) fn turns_more_than_once(solid: &crate::body::Solid) -> bool {+ use truck_meshalgo::prelude::*;+ use truck_modeling as mt;+ let tau = std::f64::consts::TAU;+ for face in solid.face_iter() {+ let mt::Surface::RevolutedCurve(proc) = face.surface() else { continue };+ let rev = proc.entity();+ let m = *proc.transform();+ let o = crate::body::from_p3(m.transform_point(rev.origin()));+ let a = m.transform_vector(rev.axis());+ let Some(k) = Vec3::new(a.x, a.y, a.z).normalized() else { continue };+ let e1 = k.cross(if k.x.abs() < 0.9 { Vec3::X } else { Vec3::Y }).normalized().unwrap_or(Vec3::X);+ let e2 = k.cross(e1);+ let angle = |p: mt::Point3| {+ let d = crate::body::from_p3(p) - o;+ d.dot(e2).atan2(d.dot(e1))+ };+ for wire in face.boundaries() {+ let (mut total, mut lo, mut hi) = (0.0f64, 0.0f64, 0.0f64);+ let mut prev: Option<f64> = None;+ for e in wire.edge_iter() {+ let c = e.oriented_curve();+ let (t0, t1) = c.range_tuple();+ // Samples dense enough that no step turns half way round.+ let mut n = 16usize;+ let steps = loop {+ let xs: Vec<f64> = (0..=n).map(|i| angle(c.subs(t0 + (t1 - t0) * i as f64 / n as f64))).collect();+ let ok = xs.windows(2).all(|w| ((w[1] - w[0] + std::f64::consts::PI).rem_euclid(tau) - std::f64::consts::PI).abs() < 1.0);+ if ok || n >= 4096 {+ break xs;+ }+ n *= 4;+ };+ for x in steps {+ if let Some(p) = prev {+ total += (x - p + std::f64::consts::PI).rem_euclid(tau) - std::f64::consts::PI;+ lo = lo.min(total);+ hi = hi.max(total);+ }+ prev = Some(x);+ }+ }+ if hi - lo > tau * 1.01 {+ return true;+ }+ }+ }+ false+}diff --git a/crates/kernel/src/thread_display_tests.rs b/crates/kernel/src/thread_display_tests.rsnew file mode 100644index 0000000000..2b696b2f5d--- /dev/null+++ b/crates/kernel/src/thread_display_tests.rs@@ -0,0 +1,258 @@+//! Issue 1289: the display mesh of a modelled screw thread (helical B-spline flanks).++use solidcraft_geom::tess::TessPlan;+use solidcraft_geom::{Mesh, Vec3};++use std::f64::consts::{PI, TAU};+use std::sync::Arc;++use crate::{Body, DISPLAY_ANGLE, EdgeSpec, FaceSpec, SurfSpec, sew};++/// A helix about Z of radius `r` from angle `a0` to `a1`, rising `pitch` per turn from `z0` at+/// angle 0, as cubic Bézier pieces of at most `TAU / 16`.+fn helix(r: f64, z0: f64, pitch: f64, a0: f64, a1: f64) -> EdgeSpec {+ let n = (((a1 - a0).abs() / (TAU / 16.0)).ceil() as usize).max(1);+ let h = (a1 - a0) / n as f64;+ let k = 4.0 / 3.0 * (h / 4.0).tan();+ let at = |a: f64| Vec3::new(r * a.cos(), r * a.sin(), z0 + pitch * a / TAU);+ let rise = Vec3::new(0.0, 0.0, pitch * h / TAU / 3.0);+ let turn = |a: f64| Vec3::new(-a.sin(), a.cos(), 0.0) * (r * k);+ let mut ctrl = vec![at(a0)];+ for i in 0..n {+ let (s, e) = (a0 + h * i as f64, a0 + h * (i + 1) as f64);+ ctrl.extend([at(s) + turn(s) + rise, at(e) - turn(e) - rise, at(e)]);+ }+ EdgeSpec::Chain { ctrl: ctrl.into() }+}++fn rev(e: &EdgeSpec) -> EdgeSpec {+ match e {+ EdgeSpec::Chain { ctrl } => EdgeSpec::Chain { ctrl: ctrl.iter().rev().copied().collect::<Arc<[Vec3]>>() },+ EdgeSpec::Line { a, b } => EdgeSpec::Line { a: *b, b: *a },+ EdgeSpec::Arc { a, b, mid } => EdgeSpec::Arc { a: *b, b: *a, mid: *mid },+ }+}++fn line(a: Vec3, b: Vec3) -> EdgeSpec {+ EdgeSpec::Line { a, b }+}++fn ends(e: &EdgeSpec) -> (Vec3, Vec3) {+ match e {+ EdgeSpec::Chain { ctrl } => (ctrl[0], ctrl[ctrl.len() - 1]),+ EdgeSpec::Line { a, b } | EdgeSpec::Arc { a, b, .. } => (*a, *b),+ }+}++/// A full circle about Z at height `z`, as two arcs.+fn circle(r: f64, z: f64) -> Vec<EdgeSpec> {+ let p = |a: f64| Vec3::new(r * a.cos(), r * a.sin(), z);+ vec![EdgeSpec::Arc { a: p(0.3), b: p(0.3 + PI), mid: p(0.3 + PI / 2.0) }, EdgeSpec::Arc { a: p(0.3 + PI), b: p(0.3), mid: p(0.3 + 1.5 * PI) }]+}++/// A threaded shaft the way a modelled thread usually comes out of a CAD system: an ISO metric+/// ridge (60° flanks, P/8 crest) of `turns` turns wound on a core of the minor diameter, the+/// flanks ruled B-spline surfaces between helices, the crest and the core cylinders trimmed by+/// those helices.+fn ridge_thread(major: f64, pitch: f64, turns: f64) -> Body {+ let h = pitch * 3f64.sqrt() / 2.0;+ let (rc, rm) = (major / 2.0 - 5.0 * h / 8.0, major / 2.0);+ let (foot, crest) = ((pitch - pitch / 4.0) / 2.0, pitch / 16.0);+ let z0 = pitch;+ let len = z0 + pitch * turns + pitch;+ let end = TAU * turns;+ let fl = helix(rc, z0 - foot, pitch, 0.0, end);+ let fu = helix(rc, z0 + foot, pitch, 0.0, end);+ let cl = helix(rm, z0 - crest, pitch, 0.0, end);+ let cu = helix(rm, z0 + crest, pitch, 0.0, end);+ let (fl0, fl1) = ends(&fl);+ let (fu0, fu1) = ends(&fu);+ let (cl0, cl1) = ends(&cl);+ let (cu0, cu1) = ends(&cu);+ let at = |r: f64, a: f64, z: f64| Vec3::new(r * a.cos(), r * a.sin(), z);+ let mid = z0 + pitch / 2.0;+ let out = |a: f64| Vec3::new(a.cos(), a.sin(), 0.0);+ let flank = 0.5f64;+ let faces = vec![+ FaceSpec { loops: vec![circle(rc, 0.0).iter().rev().map(rev).collect()], surface: SurfSpec::Plane, probe: None },+ FaceSpec { loops: vec![circle(rc, len)], surface: SurfSpec::Plane, probe: None },+ FaceSpec {+ loops: vec![circle(rc, 0.0), circle(rc, len).iter().rev().map(rev).collect(), vec![line(fl0, fu0), fu.clone(), line(fu1, fl1), rev(&fl)]],+ surface: SurfSpec::Revolved {+ a: Vec3::new(rc, 0.0, -1.0),+ b: Vec3::new(rc, 0.0, len + 1.0),+ axis_origin: Vec3::ZERO,+ axis: Vec3::Z,+ angle: TAU,+ },+ probe: Some((at(rc, PI, z0 * 0.5), out(PI))),+ },+ FaceSpec {+ loops: vec![vec![fl.clone(), line(fl1, cl1), rev(&cl), line(cl0, fl0)]],+ surface: SurfSpec::Ruled { a: fl.clone(), b: cl.clone() },+ probe: Some((at((rc + rm) / 2.0, PI, mid - (foot + crest) / 2.0), out(PI) * flank - Vec3::Z * 0.866)),+ },+ FaceSpec {+ loops: vec![vec![cu.clone(), line(cu1, fu1), rev(&fu), line(fu0, cu0)]],+ surface: SurfSpec::Ruled { a: fu.clone(), b: cu.clone() },+ probe: Some((at((rc + rm) / 2.0, PI, mid + (foot + crest) / 2.0), out(PI) * flank + Vec3::Z * 0.866)),+ },+ FaceSpec {+ loops: vec![vec![cl.clone(), line(cl1, cu1), rev(&cu), line(cu0, cl0)]],+ surface: SurfSpec::Revolved {+ a: Vec3::new(rm, 0.0, -1.0),+ b: Vec3::new(rm, 0.0, len + 1.0),+ axis_origin: Vec3::ZERO,+ axis: Vec3::Z,+ angle: TAU,+ },+ probe: Some((at(rm, PI, mid), out(PI))),+ },+ FaceSpec { loops: vec![vec![line(fl0, cl0), line(cl0, cu0), line(cu0, fu0), line(fu0, fl0)]], surface: SurfSpec::Plane, probe: None },+ FaceSpec { loops: vec![vec![line(fl1, fu1), line(fu1, cu1), line(cu1, cl1), line(cl1, fl1)]], surface: SurfSpec::Plane, probe: None },+ ];+ sew(&faces).unwrap()+}++fn tol(b: &Body) -> f64 {+ (b.size() * 1e-3).max(1e-3)+}++struct Quality {+ tris: usize,+ slivers: usize,+ flipped: usize,+ worst_sag: f64,+ min_angle: f64,+}++/// Triangles thinner than 1e-3 of their longest side; triangles whose winding disagrees with+/// their vertex normals; the largest gap between a triangle's centre and the surface at the+/// centre's parameters.+fn quality(plan: &TessPlan, mesh: &Mesh) -> Quality {+ let mut q = Quality { tris: mesh.triangles.len(), slivers: 0, flipped: 0, worst_sag: 0.0, min_angle: 180.0 };+ for t in &mesh.triangles {+ let [a, b, c] = t.map(|i| mesh.positions[i as usize]);+ let n = (b - a).cross(c - a);+ let longest = (b - a).len().max((c - b).len()).max((a - c).len());+ let ang = |p: Vec3, q: Vec3, r: Vec3| {+ ((q - p).normalized().unwrap_or(Vec3::X)).dot((r - p).normalized().unwrap_or(Vec3::X)).clamp(-1.0, 1.0).acos()+ };+ let mina = ang(a, b, c).min(ang(b, c, a)).min(ang(c, a, b)).to_degrees();+ if mina < q.min_angle {+ q.min_angle = mina;+ }+ if n.len() < 1e-3 * longest * longest {+ q.slivers += 1;+ continue;+ }+ let vn = t.iter().fold(Vec3::ZERO, |s, &i| s + mesh.normals[i as usize]);+ if n.dot(vn) < 0.0 {+ q.flipped += 1;+ }+ }+ for f in &plan.faces {+ let Some(s) = f.surface.and_then(|i| plan.surfaces.get(i as usize)) else { continue };+ let pos = |k: u32| f.fixed.get(k as usize).copied().unwrap_or_else(|| s.eval(f.uv[k as usize][0], f.uv[k as usize][1]).0);+ for t in &f.triangles {+ let uv = t.iter().fold([0.0, 0.0], |m, &k| [m[0] + f.uv[k as usize][0] / 3.0, m[1] + f.uv[k as usize][1] / 3.0]);+ let mid = (pos(t[0]) + pos(t[1]) + pos(t[2])) * (1.0 / 3.0);+ let (on, n) = s.eval(uv[0], uv[1]);+ let sag = (on - mid).dot(n).abs();+ q.worst_sag = q.worst_sag.max(sag);+ }+ }+ q+}++/// Volume of the ridge thread: the core, and per turn of the ridge 2π ∫ r · width(r) dr (a+/// screw motion of a section in an axial plane).+fn ridge_volume(major: f64, pitch: f64, turns: f64) -> f64 {+ let h = pitch * 3f64.sqrt() / 2.0;+ let (rc, rm) = (major / 2.0 - 5.0 * h / 8.0, major / 2.0);+ let (foot, crest) = ((pitch - pitch / 4.0) / 2.0, pitch / 16.0);+ let len = pitch * turns + 2.0 * pitch;+ let n = 1000;+ let ridge: f64 = (0..n)+ .map(|i| rc + (rm - rc) * (i as f64 + 0.5) / n as f64)+ .map(|r| TAU * r * 2.0 * (foot + (crest - foot) * (r - rc) / (rm - rc)) * (rm - rc) / n as f64)+ .sum();+ PI * rc * rc * len + ridge * turns+}++/// The thread, as made and after a STEP round trip (which is how such a thread reaches us).+fn threads() -> Vec<(String, Body, f64, f64, f64)> {+ let mut out = Vec::new();+ for (d, p, turns) in [(10.0, 1.5, 6.0), (12.0, 1.75, 8.0)] {+ let b = ridge_thread(d, p, turns);+ let step = crate::step_import(&crate::step_export(&[&b], "thread").unwrap()).unwrap().bodies.remove(0).body;+ out.push((format!("M{d}x{p}"), b, d, p, turns));+ out.push((format!("M{d}x{p} from STEP"), step, d, p, turns));+ }+ out+}++/// Issue 1289: a modelled thread's faces turn several times around the shaft. The core and the+/// crest cylinders, trimmed by helices (and the core bounded by two circles without a seam+/// edge), had no display plan, and the reference mesher drew them with triangles across the+/// solid. They are now cut along a seam: the display mesh stays on the surfaces.+#[test]+fn thread_display_mesh_stays_on_its_surfaces() {+ for (name, b, d, p, turns) in threads() {+ let tol = tol(&b);+ let plan = b.display_plan_angular(tol, DISPLAY_ANGLE).unwrap_or_else(|e| panic!("{name}: no display plan: {e}"));+ let mesh = plan.evaluate();+ let q = quality(&plan, &mesh);+ assert!(q.worst_sag <= 1.5 * tol, "{name}: a triangle lies {} mm off its surface (tolerance {tol})", q.worst_sag);+ // Every vertex of the cylinders on its cylinder, every triangle centre within the+ // tolerance inside it.+ let h = p * 3f64.sqrt() / 2.0;+ let (rc, rm) = (d / 2.0 - 5.0 * h / 8.0, d / 2.0);+ for (ti, t) in mesh.triangles.iter().enumerate() {+ let r = |v: Vec3| (v.x * v.x + v.y * v.y).sqrt();+ let [a, b2, c] = t.map(|i| mesh.positions[i as usize]);+ let (ra, rb, rcn) = (r(a), r(b2), r(c));+ let centre = r((a + b2 + c) * (1.0 / 3.0));+ for want in [rc, rm] {+ if [ra, rb, rcn].iter().all(|x| (x - want).abs() < 1e-4) {+ assert!(centre > want - 2.0 * tol, "{name}: triangle {ti} on the r = {want} cylinder cuts in to {centre}");+ }+ }+ let end_disc = [a, b2, c].iter().all(|v| v.z.abs() < 1e-9) || [a, b2, c].iter().all(|v| (v.z - (turns + 2.0) * p).abs() < 1e-9);+ assert!(end_disc || (centre > rc - 2.0 * tol && centre < rm + 1e-6), "{name}: triangle {ti} at radius {centre}, outside {rc}…{rm}");+ }+ // A mesh within the tolerance of the surfaces is within area × tolerance of the volume.+ let m = mesh.measure();+ let want = ridge_volume(d, p, turns);+ assert!((m.volume - want).abs() < m.area * tol, "{name}: display mesh volume {}, the thread's {want}", m.volume);+ // The reference mesh (picking, measuring, the viewport without GPU tessellation) is the same.+ let reference = b.reference_display_mesh_angular(tol, DISPLAY_ANGLE).unwrap();+ assert_eq!(reference.triangles.len(), mesh.triangles.len(), "{name}");+ let measured = b.tessellate(tol * 0.1).unwrap().measure().volume;+ assert!((measured - want).abs() < want * 1e-3, "{name}: measured volume {measured}, the thread's {want}");+ }+}++/// Issue 1289: no triangle of the thread's display mesh is degenerate, a sliver or turned+/// against its surface's normal.+#[test]+fn thread_display_mesh_has_no_degenerate_or_flipped_triangles() {+ for (name, b, ..) in threads() {+ let plan = b.display_plan_angular(tol(&b), DISPLAY_ANGLE).unwrap_or_else(|e| panic!("{name}: no display plan: {e}"));+ let mesh = plan.evaluate();+ let q = quality(&plan, &mesh);+ assert!(q.tris > 1000, "{name}: {} triangles", q.tris);+ assert_eq!(q.slivers, 0, "{name}: degenerate triangles");+ assert_eq!(q.flipped, 0, "{name}: triangles facing against their normals");+ assert!(q.min_angle > 1.0, "{name}: a triangle with a {:.3} degree corner", q.min_angle);+ }+}++/// Writes the M10 thread as STEP to `$THREAD_STEP` (for looking at it in the app).+#[test]+#[ignore]+fn write_thread_step() {+ if let Ok(path) = std::env::var("THREAD_STEP") {+ std::fs::write(path, crate::step_export(&[&ridge_thread(10.0, 1.5, 6.0)], "M10x1.5 thread").unwrap()).unwrap();+ }+}