diff --git a/crates/engine/src/cmd/motion_analysis.rs b/crates/engine/src/cmd/motion_analysis.rs index ab3c51d3f..6ea7c814e 100644 --- a/crates/engine/src/cmd/motion_analysis.rs +++ b/crates/engine/src/cmd/motion_analysis.rs @@ -4,7 +4,6 @@ //! answers the pairs of parts that pass through each other along the way. use std::collections::BTreeMap; -use std::sync::Arc; use serde_json::{Value, json}; use solidcraft_doc::joints; @@ -31,8 +30,10 @@ pub const INTERFERENCE_DOC: &str = "study: id|name; occurrences?: [ids or names] default every occurrence), with against?: [ids or names] (then each of `occurrences` is checked only against these, such \ as an arm against the parts it must miss), or contact_sets?: true (the pairs of the design's contact sets); samples? \ (2…1000, default the study's steps + 1) → collisions: [{a, b, first_step, last_step, steps: [[from, to]…] (the step ranges where they overlap), \ - depth_mm (how far into each other, the most at deepest_step), volume_mm3 (their overlap there; null when it was not \ - cheap to work out)}], clear, \ + volume_mm3 (the most volume they share at a sample, worked out exactly from the bodies; null when it was not cheap to \ + work out at every sample they overlap), deepest_step (the first sample sharing that volume; with volume_mm3 null, the \ + one of the greatest depth_mm), depth_mm (how far into each other at most: an estimate from points of the bodies' \ + contact meshes, not exact)}], clear, \ pairs (checked), samples (taken), truncated (the work budget ran out; checked_to: the last step checked), stopped_at, \ stopped_by_loop. The study plays as motion.play plays it but contact sets do not stop it, on a copy (the design is not \ changed). Parts are tested at the samples only: one that passes wholly through another between two samples is missed"; @@ -43,9 +44,10 @@ const MAX_SAMPLES: usize = 1000; const MAX_SERIES: usize = 256; /// Most collision work over a whole study (see `ContactGeometry::hits`). const MAX_WORK: usize = 500_000_000; -/// Most colliding pairs whose overlap volume is worked out, and most body booleans that takes. +/// Most colliding pairs whose overlap volume is worked out, and most body booleans that takes +/// over the whole study (one per pair of overlapping bodies at each sample a pair collides). const MAX_VOLUMES: usize = 16; -const MAX_BOOLEANS: usize = 64; +const MAX_BOOLEANS: usize = 256; /// How many samples `p` asks for (`min`…`MAX_SAMPLES`, default the study's steps + 1). fn samples(p: &Value, m: &MotionStudy, min: usize, cmd: &str) -> Result { @@ -250,10 +252,29 @@ struct Collision { names: (String, String), /// The samples where they overlap, in order. samples: Vec, + /// The most sampled mesh depth, and the first sample reaching it. depth: f64, deepest: usize, - /// The design at the deepest sample (its placements). - at_deepest: Arc, + /// The most exact shared volume and the first sample sharing it; `None` once a sample's + /// volume was not worked out (the pair got no volume slot, or the booleans ran out). + most_volume: Option<(f64, usize)>, +} + +impl Collision { + /// Takes the exact shared volume at sample `k` (`None`: not worked out). A volume larger by + /// no more than the booleans' rounding is a tie, which keeps the earlier sample. + fn take_volume(&mut self, k: usize, volume: Option) { + self.most_volume = match (self.most_volume, volume) { + (Some((best, at)), Some(v)) => Some(if v > best + 1e-9 * best.max(1.0) { (v, k) } else { (best, at) }), + _ => None, + }; + } + + /// The sample the collision is deepest at: where they share the most volume, else (no + /// volume) where the sampled depth is greatest. + fn deepest_sample(&self) -> usize { + self.most_volume.map_or(self.deepest, |(_, at)| at) + } } /// The volume the parts under occurrences `a` and `b` share, placed as in `doc` (`None`: not @@ -358,12 +379,14 @@ pub(super) fn checked_pairs(s: &Session, p: &Value, cmd: &str) -> Result Result { + let s: &Session = s; let cmd = "motion.interference"; let m = s.doc.assembly.studies.get(study_index(s, p, cmd)?).cloned().ok_or_else(|| bad(cmd, "study"))?; let n = samples(p, &m, 2, cmd)?; let geometry = checked_pairs(s, p, cmd)?; let mut found: BTreeMap<(u64, u64), Collision> = BTreeMap::new(); let (mut work, mut checked, mut truncated) = (0usize, 0usize, false); + let mut booleans = MAX_BOOLEANS; let stop = play(s, &m, n, false, |t, k| { // Placing the meshes is work too, also where nothing comes near. work = work.saturating_add(geometry.vertex_count()); @@ -383,18 +406,24 @@ pub(super) fn interference(s: &mut Session, p: &Value) -> Result { for ((a, an), (b, bn), depth) in hits { // Each pair once, the older occurrence (the lower id) first. let ((a, an), (b, bn)) = if a <= b { ((a, an), (b, bn)) } else { ((b, bn), (a, an)) }; + // The first MAX_VOLUMES pairs found have their shared volume worked out. + let slots = found.len() < MAX_VOLUMES; let c = found.entry((a, b)).or_insert_with(|| Collision { names: (an, bn), samples: Vec::new(), depth: 0.0, deepest: k, - at_deepest: t.doc.clone(), + most_volume: slots.then_some((0.0, k)), }); - if c.samples.last() != Some(&k) { - c.samples.push(k); + if c.samples.last() == Some(&k) { + continue; } + c.samples.push(k); if depth > c.depth { - (c.depth, c.deepest, c.at_deepest) = (depth, k, t.doc.clone()); + (c.depth, c.deepest) = (depth, k); + } + if c.most_volume.is_some() { + c.take_volume(k, shared_volume(s, &t.doc, a, b, &mut booleans)); } } Ok(true) @@ -405,16 +434,14 @@ pub(super) fn interference(s: &mut Session, p: &Value) -> Result { } let mut list: Vec<(&(u64, u64), &Collision)> = found.iter().collect(); list.sort_by_key(|(_, c)| c.samples.first().copied().unwrap_or(usize::MAX)); - let mut booleans = MAX_BOOLEANS; let collisions: Vec = list .iter() - .enumerate() - .map(|(i, ((a, b), c))| { - let volume = if i < MAX_VOLUMES { shared_volume(s, &c.at_deepest, *a, *b, &mut booleans) } else { None }; + .map(|(_, c)| { + let volume = c.most_volume.map(|(v, _)| v); let first = c.samples.first().map(|k| step_of(&m, *k, n)); let last = c.samples.last().map(|k| step_of(&m, *k, n)); json!({"a": c.names.0, "b": c.names.1, "first_step": first, "last_step": last, "steps": ranges(&m, &c.samples, n), - "depth_mm": c.depth, "deepest_step": step_of(&m, c.deepest, n), "volume_mm3": volume}) + "depth_mm": c.depth, "deepest_step": step_of(&m, c.deepest_sample(), n), "volume_mm3": volume}) }) .collect(); let mut out = json!({"study": m.name, "steps": m.steps, "clear": collisions.is_empty(), "collisions": collisions, diff --git a/crates/engine/src/cmd/motion_analysis_tests.rs b/crates/engine/src/cmd/motion_analysis_tests.rs index 88c2cd41c..c820f509b 100644 --- a/crates/engine/src/cmd/motion_analysis_tests.rs +++ b/crates/engine/src/cmd/motion_analysis_tests.rs @@ -147,10 +147,9 @@ fn interference_names_the_step_two_parts_start_to_collide() { assert_eq!((c["a"].as_str(), c["b"].as_str()), (Some("A:1"), Some("B:1")), "{r}"); assert_eq!((c["first_step"].as_f64(), c["last_step"].as_f64()), (Some(11.0), Some(15.0)), "{r}"); assert_eq!(c["steps"], json!([[11.0, 15.0]]), "{r}"); - let deepest = c["deepest_step"].as_f64().unwrap_or(f64::NAN); - assert!(c["depth_mm"].as_f64().unwrap_or(0.0) > 1.0 && (11.0..=15.0).contains(&deepest), "{r}"); - let volume = c["volume_mm3"].as_f64().unwrap_or(f64::NAN); - assert!((volume - 100.0 * (deepest - 10.0)).abs() < 1e-6, "{r}"); + // Deepest where they share the most: 5 mm of the 10 x 10 face at the end. + assert!(c["depth_mm"].as_f64().unwrap_or(0.0) > 1.0 && c["deepest_step"] == 15.0, "{r}"); + assert!((c["volume_mm3"].as_f64().unwrap_or(f64::NAN) - 500.0).abs() < 1e-6, "{r}"); } // B against a far block C only: B's pass through A is not asked about. run(&mut s, "component.create", json!({"name": "C"})); @@ -167,6 +166,39 @@ fn interference_names_the_step_two_parts_start_to_collide() { assert!(r["clear"] == true && r["collisions"] == json!([]), "{r}"); } +/// An arm (40 x 10 x 10 from (0, -5, 0)) turns on a hinge at the origin from 0 to 90 degrees in +/// 9 steps into a grounded block (50 x 10 x 10 from (-10, 30, 0)). Its corner (40, 5) reaches +/// y = 40 sin θ + 5 cos θ, past 30 from 40.97 degrees, so it overlaps from step 5. Every point of +/// the slab is within 5 mm of z = 0 or z = 10, so from 60 degrees on (where the arm's side +/// crosses y = 35) the depth is 5 mm at every step: only the shared volume, which grows to the +/// arm's 10 x 10 x 10 end inside the block at 90 degrees, tells the deepest step. Sampled twice +/// as densely (5 degrees a sample), the overlap is seen from step 4.5 (45 degrees) and is still +/// deepest at the end. +#[test] +fn interference_is_deepest_where_the_parts_share_the_most_volume() { + let mut s = Session::default(); + for (name, size, corner) in [("Base", [20, 20, 10], [-10, -10, -10]), ("Arm", [40, 10, 10], [0, -5, 0]), ("Stop", [50, 10, 10], [-10, 30, 0])] { + run(&mut s, "component.activate", json!({"component": "root"})); + run(&mut s, "component.create", json!({"name": name})); + run(&mut s, "solid.box", json!({"length": size[0], "width": size[1], "height": size[2], "corner": corner})); + } + run(&mut s, "component.activate", json!({"component": "root"})); + for name in ["Base", "Stop"] { + let o = occ(&s, name); + run(&mut s, "occurrence.ground", json!({"occurrence": o, "grounded": true})); + } + let end = |o: &str| json!({"occurrence": o, "point": [0, 0, 0], "z": [0, 0, 1]}); + run(&mut s, "joint.create", json!({"type": "revolute", "name": "Hinge", "flip": true, "a": end("Base"), "b": end("Arm"), "quiet": true})); + run(&mut s, "motion.study", json!({"name": "Open", "steps": 9, "keys": [{"joint": "Hinge", "points": [[0, 0], [9, 90]]}]})); + for (samples, first) in [(10, 5.0), (19, 4.5)] { + let r = run(&mut s, "motion.interference", json!({"study": "Open", "samples": samples, "occurrences": ["Arm"], "against": ["Stop"]})); + let c = &r["collisions"][0]; + assert!(r["clear"] == false && c["first_step"] == first && c["last_step"] == 9.0 && c["deepest_step"] == 9.0, "{samples}: {r}"); + assert!((c["volume_mm3"].as_f64().unwrap_or(f64::NAN) - 1000.0).abs() < 1e-6, "{samples}: {r}"); + assert!(c["depth_mm"].as_f64().is_some_and(|d| d > 0.0 && d <= 5.0 + 1e-9), "{samples}: {r}"); + } +} + /// A number names a study by its id first, text by its name first: a study may be named like /// another's id. #[test] diff --git a/crates/kernel/src/tess/edges.rs b/crates/kernel/src/tess/edges.rs index 5208c7d07..52c48fc4c 100644 --- a/crates/kernel/src/tess/edges.rs +++ b/crates/kernel/src/tess/edges.rs @@ -15,7 +15,7 @@ const MAX_DEPTH: u32 = 24; /// The most of its curve's turn one segment may span (a quarter turn, with rounding room): the /// boundary of every face stays a polygon with the face's area, as a closed curve's first four /// segments keep it. -const QUARTER_TURN: f64 = std::f64::consts::FRAC_PI_2 * (1.0 + 1e-9); +pub(crate) const QUARTER_TURN: f64 = std::f64::consts::FRAC_PI_2 * (1.0 + 1e-9); /// An edge's nodes, from its start vertex (interval min) to its end vertex (interval max). pub(crate) struct Nodes { @@ -23,6 +23,10 @@ pub(crate) struct Nodes { /// The curve's parameter at each node (the edge's interval, ends included): where each /// face's pcurve of the edge gives the node's (u, v). pub params: Vec, + /// The parameters of the nodes that are another edge's node, where the two edges touch + /// within the chord tolerance (see [`snap`]): in a face that runs both edges such a node is + /// the other's point of the face, a pinch, not a crossing. + pub snapped: Vec, } /// Nodes of edge `ei` of `b` from its start to its end: every chord within the tolerance of @@ -56,7 +60,7 @@ pub(crate) fn sample_edge(b: &brep::Brep, ei: usize, rules: &Rules, h: f64) -> R *p = back; *t = t1; } - return Ok(Nodes { points: pts, params }); + return Ok(Nodes { points: pts, params, snapped: Vec::new() }); } let curve = CurveEval::new(edge.parameters()).map_err(|e| fail(e.to_string()))?; let at = @@ -115,7 +119,7 @@ pub(crate) fn sample_edge(b: &brep::Brep, ei: usize, rules: &Rules, h: f64) -> R if let Some(p) = out.last_mut() { *p = (t1, back); } - Ok(Nodes { points: out.iter().map(|p| p.1).collect(), params: out.iter().map(|p| p.0).collect() }) + Ok(Nodes { points: out.iter().map(|p| p.1).collect(), params: out.iter().map(|p| p.0).collect(), snapped: Vec::new() }) } /// Edge `ei`'s nodes with each of its segments `segs` (counted from its start) halved at the @@ -158,12 +162,50 @@ pub(crate) fn split_segments(b: &brep::Brep, ei: usize, nodes: &mut Nodes, segs: points.push(pm); params.push(m); } - *nodes = Nodes { points, params }; + nodes.points = points; + nodes.params = params; + Ok(()) +} + +/// Edge `ei`'s nodes with `add` (each a parameter strictly inside a segment and the point there) +/// put in, in order, each marked as snapped: the point is another edge's node within the chord +/// tolerance of this edge's chord there (the edges touch), so the two edges share it. A parameter +/// that is not strictly between its segment's two (a node already there) is left out. More than +/// [`MAX_EDGE_NODES`] nodes is an error naming the edge. +pub(crate) fn snap(ei: usize, nodes: &mut Nodes, add: &[(f64, Vec3)]) -> Result<()> { + let mut add: Vec<(f64, Vec3)> = add.iter().copied().filter(|(t, p)| t.is_finite() && p.is_finite()).collect(); + add.sort_by(|a, b| a.0.total_cmp(&b.0)); + add.dedup_by(|a, b| a.0 == b.0); + if nodes.points.len() + add.len() > MAX_EDGE_NODES { + return Err(KernelError::Failed(format!("tessellation: edge {ei}: more than {MAX_EDGE_NODES} nodes"))); + } + let n = nodes.points.len().min(nodes.params.len()); + let (mut points, mut params) = (Vec::with_capacity(n + add.len()), Vec::with_capacity(n + add.len())); + let mut next = add.iter().peekable(); + for k in 0..n { + let (Some(&p), Some(&t)) = (nodes.points.get(k), nodes.params.get(k)) else { continue }; + points.push(p); + params.push(t); + let Some(&u) = nodes.params.get(k + 1) else { continue }; + while let Some(&&(m, q)) = next.peek() { + if m >= u { + break; + } + next.next(); + if m > t { + points.push(q); + params.push(m); + nodes.snapped.push(m); + } + } + } + nodes.points = points; + nodes.params = params; Ok(()) } /// Angle (radians) between two directions; zero when either is empty. -fn turn(a: Vec3, b: Vec3) -> f64 { +pub(crate) fn turn(a: Vec3, b: Vec3) -> f64 { let (la, lb) = (a.len(), b.len()); if !(la > 0.0 && lb > 0.0) { return 0.0; diff --git a/crates/kernel/src/tess/mod.rs b/crates/kernel/src/tess/mod.rs index a912b3097..bd831a5b4 100644 --- a/crates/kernel/src/tess/mod.rs +++ b/crates/kernel/src/tess/mod.rs @@ -196,7 +196,7 @@ pub(crate) fn plan(b: &brep::Brep, tol: f64, turn: Option) -> Result }; let mut boundaries: Vec = crate::par::map("face boundaries", &indexed, curved >= PARALLEL_FACES, |&fi| face_boundary(fi, &nodes)).into_iter().collect::>()?; - let tangled = untangle(b, &evals, &edge_faces, &mut nodes, &mut boundaries, &face_boundary)?; + let tangled = untangle(b, &evals, &edge_faces, rules.tol, &mut nodes, &mut boundaries, &face_boundary)?; let planned = crate::par::map("face tessellation", &indexed, curved >= PARALLEL_FACES, |&fi| { let (Some(face), Some(eval), Some(size), Some(fb)) = (faces.get(fi), evals.get(fi), sizes.get(fi), boundaries.get(fi)) else { return Err(unsupported(format!("face {fi}: missing"))); @@ -288,10 +288,19 @@ fn boundary( let mut out = Boundary { loops: Vec::with_capacity(face.loops.len()), segments: Vec::with_capacity(face.loops.len()), reach }; // Each vertex's parameters, from the first edge use of the face to start there. let mut at_vertex: std::collections::HashMap = std::collections::HashMap::new(); + // The vertex pairs an edge of the face joins. + let joined: std::collections::HashSet<(u32, u32)> = face_edges(face) + .filter_map(|oe| b.edges.get(oe.edge as usize)) + .map(|e| (e.vertices[0].min(e.vertices[1]), e.vertices[0].max(e.vertices[1]))) + .collect(); + let vertex_point = |v: u32| b.vertices.get(v as usize).map(|x| (Vec3::new(x.point[0], x.point[1], x.point[2]), x.tolerance.max(0.0))); + // Each loop's nodes that are another edge's node (see [`edges::snap`]). + let mut snapped: Vec> = Vec::with_capacity(face.loops.len()); for l in &face.loops { let Loop::Edges { edges } = l else { continue }; let (mut pts, mut uvs): (Vec, Vec<[f64; 2]>) = (Vec::new(), Vec::new()); let mut segs: Vec<(u32, u32)> = Vec::new(); + let mut shared: Vec = Vec::new(); // Where the previous edge ended, and the periods its pcurve was moved by. let (mut end, mut shift): (Option<[f64; 2]>, [f64; 2]) = (None, [0.0; 2]); for oe in edges { @@ -306,6 +315,7 @@ fn boundary( // The edge's own tolerance: how far its curve may stand off the face. let accept = (rules.tol * 10.0).max(1e-6) + edge.tolerance.max(0.0); let mut ep: Vec = n.points.clone(); + let mut es: Vec = n.params.iter().map(|t| n.snapped.contains(t)).collect(); let mut eq: Vec<[f64; 2]> = Vec::with_capacity(ep.len()); for (k, (t, p)) in n.params.iter().zip(&n.points).enumerate() { let q = oe.pcurve.eval(t.clamp(p0, p1)).ok_or_else(|| fail(oe.edge, format!("its pcurve does not evaluate at t = {t}")))?; @@ -320,6 +330,7 @@ fn boundary( if !oe.forward { ep.reverse(); eq.reverse(); + es.reverse(); } if let (Some(e), Some(&start)) = (end, eq.first()) { for d in 0..2 { @@ -341,6 +352,24 @@ fn boundary( } } None => { + // Another vertex of the face within the tolerance of both (and of the + // chord tolerance), and not joined to this one by an edge (which makes + // them two points however near: a step that small), is the same point: + // the record's corners a hair apart (a planar boolean's, where a cut-out's + // corner touches another loop's corner) are one point of the face, so its + // loops touch there instead of crossing. + let same = vertex_point(v).and_then(|(p, tv)| { + at_vertex.iter().filter(|(w, _)| **w != v && !joined.contains(&(v.min(**w), v.max(**w)))).find_map(|(w, wq)| { + let (pw, tw) = vertex_point(*w)?; + (p.dist(pw) <= tv.max(tw).min(rules.tol)).then_some(*wq) + }) + }); + if let Some(mut w) = same.filter(|w| !(0..2).any(|d| pole_along(*w, d) || pole_along(*q, d))) { + for d in 0..2 { + w[d] = uv::unwrap(w[d], q[d], dom.period[d]); + } + *q = w; + } at_vertex.insert(v, *q); } } @@ -348,11 +377,13 @@ fn boundary( end = eq.last().copied(); ep.pop(); eq.pop(); + es.pop(); // The segment from each node on: the edge's own, counted from its start. let m = ep.len() as u32; segs.extend((0..m).map(|j| (oe.edge, if oe.forward { j } else { m - 1 - j }))); pts.extend(ep); uvs.extend(eq); + shared.extend(es); } let n = uvs.len(); let pole = |q: &[f64; 2]| (0..2).any(|d| pole_along(*q, d)); @@ -367,10 +398,37 @@ fn boundary( uvs.rotate_left(k); pts.rotate_left(k); segs.rotate_left(k); + shared.rotate_left(k); } if pts.len() >= 2 { out.loops.push(seam::Loop { uv: uvs, pts }); out.segments.push(segs); + snapped.push(shared); + } + } + // A node snapped from another edge is that edge's node, the same point: where the face runs + // that edge too, the node takes the other's parameters, so the face's boundary passes one + // point of its (u, v) twice (a pinch) and does not cross itself there. Its own pcurve puts it + // within the chord tolerance of that point, not on it. + for (l, flags) in snapped.iter().enumerate() { + for (k, _) in flags.iter().enumerate().filter(|(_, f)| **f) { + let Some((&p, &q)) = out.loops.get(l).and_then(|lp| lp.pts.get(k).zip(lp.uv.get(k))) else { continue }; + let partner = out + .loops + .iter() + .zip(&snapped) + .flat_map(|(lp, fs)| lp.pts.iter().zip(&lp.uv).zip(fs)) + .filter(|((r, _), f)| !**f && **r == p) + .map(|((_, w), _)| *w) + .min_by(|a, b| (a[0] - q[0]).hypot(a[1] - q[1]).total_cmp(&(b[0] - q[0]).hypot(b[1] - q[1]))); + if let (Some(mut w), Some(slot)) = (partner, out.loops.get_mut(l).and_then(|lp| lp.uv.get_mut(k))) { + for d in 0..2 { + if dom.period[d].is_some() { + w[d] = uv::unwrap(w[d], q[d], dom.period[d]); + } + } + *slot = w; + } } } Ok(out) @@ -394,10 +452,12 @@ struct Boundary { /// so every face of the edge gets the new nodes; the faces of every edge split are checked again, /// until no chords cross. Boundaries that still cross after [`MAX_UNTANGLE`] rounds, or would /// put more than [`edges::MAX_EDGE_NODES`] on an edge, are an error naming the face and edges. +#[allow(clippy::too_many_arguments)] fn untangle( b: &brep::Brep, evals: &[EvalSurface], edge_faces: &[Vec], + tol: f64, nodes: &mut [edges::Nodes], boundaries: &mut [Boundary], face_boundary: &(dyn Fn(usize, &[edges::Nodes]) -> Result + Sync), @@ -419,6 +479,10 @@ fn untangle( return Ok(Vec::new()); } if round == MAX_UNTANGLE { + // Halving cannot part two curves that touch or cross: where they come within the chord + // tolerance of each other, they share nodes. + let faces: Vec = tangled.iter().map(|(fi, _)| *fi).collect(); + tangled = snap_touches(evals, edge_faces, tol, nodes, boundaries, face_boundary, &faces)?; // Each face still crossing, with why: planned leniently, and named (`plan_or_fill`). return Ok(tangled .iter() @@ -459,6 +523,161 @@ fn untangle( Ok(Vec::new()) } +/// Rounds of [`snap_touches`] before a face that still crosses itself is refused. +const MAX_SNAP: u32 = 8; + +/// The faces `faces` whose boundaries cross themselves where two curves touch or cross (halving +/// their chords does not part them, see [`untangle`]), with every node that lies within the chord +/// tolerance `tol` of a crossing chord of another edge put onto that edge as well (see +/// [`edges::snap`]): the two edges share the point, the face's boundary passes it twice (a pinch, +/// as at a vertex two loops share), and the chords meet there instead of crossing. Where the +/// curves run within the tolerance of each other for a stretch (a sliver between two touches), +/// the nodes on either side are shared in turn, so the boundary runs out and back along one +/// polyline there: a slit, which bounds the face on neither side. A node is not snapped where the +/// pinch would turn part of its loop inside out by more than the tolerance (two curves crossing +/// at an angle: the boundary is wrong there, not within the tolerance). Every face of a changed +/// edge has its boundary built again. Returns the faces whose boundaries still cross, with the +/// crossing segments. +#[allow(clippy::too_many_arguments)] +fn snap_touches( + evals: &[EvalSurface], + edge_faces: &[Vec], + tol: f64, + nodes: &mut [edges::Nodes], + boundaries: &mut [Boundary], + face_boundary: &(dyn Fn(usize, &[edges::Nodes]) -> Result + Sync), + faces: &[usize], +) -> Result)>> { + let crossing = |fi: usize, fb: &Boundary| -> Vec<(usize, usize)> { + let Some(s) = evals.get(fi) else { return Vec::new() }; + tangle::crossing(s, fb.reach, &fb.loops) + }; + let mut tangled: Vec = faces.to_vec(); + for _ in 0..MAX_SNAP { + let mut add: HashMap> = HashMap::new(); + for &fi in &tangled { + let Some(fb) = boundaries.get(fi) else { continue }; + for (l, k) in crossing(fi, fb) { + let Some(&(e, j)) = fb.segments.get(l).and_then(|s| s.get(k)) else { continue }; + if let Some((t, p)) = touch(fb, nodes, (l, k), (e, j), tol) { + add.entry(e).or_default().push((t, p)); + } + } + } + if add.is_empty() { + break; + } + let mut redo: Vec = Vec::new(); + for (e, points) in &add { + let Some(slot) = nodes.get_mut(*e as usize) else { continue }; + edges::snap(*e as usize, slot, points)?; + redo.extend(edge_faces.get(*e as usize).into_iter().flatten().copied()); + } + redo.extend(tangled.iter().copied()); + redo.sort_unstable(); + redo.dedup(); + tangled.clear(); + for fi in redo { + let fb = face_boundary(fi, nodes)?; + let crosses = !crossing(fi, &fb).is_empty(); + if let Some(slot) = boundaries.get_mut(fi) { + *slot = fb; + } + if crosses { + tangled.push(fi); + } + } + if tangled.is_empty() { + return Ok(Vec::new()); + } + } + Ok(tangled + .into_iter() + .filter_map(|fi| { + let fb = boundaries.get(fi)?; + let c: Vec<(u32, u32)> = crossing(fi, fb).into_iter().filter_map(|(l, k)| fb.segments.get(l)?.get(k).copied()).collect(); + (!c.is_empty()).then_some((fi, c)) + }) + .collect()) +} + +/// The node of face boundary `fb` nearest the crossing chord `at` (loop, node) of its boundary, +/// segment `seg` (edge, segment from its start) of that edge, within `tol` of the chord strictly +/// between its ends, on another edge, and not yet on this one; with the parameter on the edge +/// where it projects onto the chord. `None` when there is none, or snapping it would turn part +/// of its loop inside out by more than the tolerance (see [`snap_touches`]). +fn touch(fb: &Boundary, nodes: &[edges::Nodes], at: (usize, usize), seg: (u32, u32), tol: f64) -> Option<(f64, Vec3)> { + let (e, j) = seg; + let n = nodes.get(e as usize)?; + let j = j as usize; + let (a, c) = (*n.points.get(j)?, *n.points.get(j + 1)?); + let (ta, tc) = (*n.params.get(j)?, *n.params.get(j + 1)?); + let ac = c - a; + let len2 = ac.dot(ac); + if !(len2 > 0.0) { + return None; + } + let mut best: Option<(f64, f64, Vec3)> = None; + for (l, lp) in fb.loops.iter().enumerate() { + let segs = fb.segments.get(l)?; + let m = lp.pts.len(); + for (k, &p) in lp.pts.iter().enumerate() { + // The node's edges: the segment starting at it and the one ending there. + let edges_at = [segs.get(k).map(|s| s.0), segs.get((k + m - 1) % m).map(|s| s.0)]; + if edges_at.contains(&Some(e)) || n.points.contains(&p) { + continue; + } + let f = (p - a).dot(ac) / len2; + let d = p.dist_to_segment(a, c); + if !(f > 1e-6 && f < 1.0 - 1e-6 && d <= tol) || best.is_some_and(|(bd, _, _)| bd <= d) { + continue; + } + if l == at.0 && inside_out(lp, at.1, k, tol) { + continue; + } + best = Some((d, ta + f * (tc - ta), p)); + } + } + best.map(|(_, t, p)| (t, p)) +} + +/// Whether pinching loop `lp` at node `k` and a new node (the same point) on its chord from node +/// `at` would turn either part inside out by more than `tol`: a part whose winding in (u, v) is +/// against the loop's, and whose area is more than `tol` across (twice its area in 3D over its +/// length). +fn inside_out(lp: &seam::Loop, at: usize, k: usize, tol: f64) -> bool { + let m = lp.uv.len(); + if m < 3 { + return false; + } + // The two parts: from the node after the chord's start round to `k`, and from `k` round to the + // chord's start. + let part = |from: usize, to: usize| -> Vec { + let mut out = Vec::new(); + let mut i = from % m; + loop { + out.push(i); + if i == to % m || out.len() > m { + break; + } + i = (i + 1) % m; + } + out + }; + let whole = area2(&lp.uv); + [part(at + 1, k), part(k, at)].iter().any(|ids| { + let uv: Vec<[f64; 2]> = ids.iter().filter_map(|&i| lp.uv.get(i).copied()).collect(); + let pts: Vec = ids.iter().filter_map(|&i| lp.pts.get(i).copied()).collect(); + if uv.len() < 3 || area2(&uv) * whole >= 0.0 { + return false; + } + // Newell's vector: twice the area of the polygon in 3D. + let twice = pts.iter().zip(pts.iter().cycle().skip(1)).fold(Vec3::ZERO, |acc, (p, q)| acc + p.cross(*q)).len(); + let length: f64 = pts.iter().zip(pts.iter().cycle().skip(1)).map(|(p, q)| p.dist(*q)).sum(); + twice > tol * length + }) +} + /// Bounded work for the facet angle: a face whose boundary would get more than /// [`size::MAX_ANGLE_BOUNDARY`] segments has its curved edges sampled again at twice the angle, /// as often as it takes, down to the tolerance alone (a plate with a thousand small holes is diff --git a/crates/kernel/src/tess/uv.rs b/crates/kernel/src/tess/uv.rs index 7ee1b0f23..b51b23b17 100644 --- a/crates/kernel/src/tess/uv.rs +++ b/crates/kernel/src/tess/uv.rs @@ -5,6 +5,7 @@ use solidcraft_geom::tess::EvalSurface; pub(crate) use solidcraft_geom::tess::uv::{Domain, degenerate_within, domain, unwrap}; +use super::edges::{QUARTER_TURN, turn}; use super::size::Rules; /// Division of `range` along direction `d` so that between neighbouring lines the surface sags @@ -16,19 +17,10 @@ pub(crate) fn divide(s: &EvalSurface, d: usize, range: (f64, f64), across: (f64, if !(a1 > a0) { return vec![a0, a1]; } - let flat = limits(s, d, across, rules, h); - // Start from quarter turns at most, so a closed iso-line is not taken for a flat one (a - // plane's parameters are lengths and its lines are never closed). - let initial = if matches!(s, EvalSurface::Plane { .. }) { 1 } else { ((a1 - a0) / std::f64::consts::FRAC_PI_2).ceil().clamp(1.0, 64.0) as u32 }; - // Both ends exactly (a0 + (a1 − a0) · 1 may round away from a1): the end lines are the - // face's own parameter box, which the boundary nodes sit on. - let starts: Vec = (0..=initial) - .map(|i| { - let t = f64::from(i) / f64::from(initial); - a0 * (1.0 - t) + a1 * t - }) - .collect(); - split(&starts, &flat, max_lines) + // The whole range first: the limits split it, and no interval spans more than a quarter + // turn of its iso-lines, so a closed iso-line is never taken for a flat one. Both ends + // exactly: the end lines are the face's own parameter box, which the boundary nodes sit on. + split(&[a0, a1], &limits(s, d, across, rules, h), max_lines) } /// `lines` (increasing, ends included) with every interval that fails the same limits as @@ -80,8 +72,14 @@ pub(crate) fn fine_between(s: &EvalSurface, rules: &Rules, h: f64, a: [f64; 2], } } +/// An iso-line's extent below which it is a point, as a fraction of the chord tolerance (which +/// is never finer than a millionth of the body, so this is far above rounding). +const POINT: f64 = 1e-6; + /// Whether the surface between the iso-lines at `a` and `b` (direction `d`, sampled along -/// iso-lines across `across`) is within the tolerance, the side length `h` and the facet angle. +/// iso-lines across `across`) is within the tolerance, the side length `h` and the facet angle, +/// and spans at most a quarter turn of each iso-line (as an edge segment does, see +/// [`QUARTER_TURN`]): a turn read from the points, since a spline's parameter is no angle. fn limits<'a>(s: &'a EvalSurface, d: usize, across: (f64, f64), rules: &'a Rules, h: f64) -> impl Fn(f64, f64) -> bool + 'a { let tol = rules.tol; let uv = move |x: f64, y: f64| if d == 0 { (x, y) } else { (y, x) }; @@ -105,6 +103,15 @@ fn limits<'a>(s: &'a EvalSurface, d: usize, across: (f64, f64), rules: &'a Rules if sag > tol { return false; } + // The two half chords of an arc turning θ differ by θ/2; a closed iso-line's by π. + // An iso-line within a millionth of the tolerance of one point (a pole) turns no + // amount: its directions are rounding. + if let Some(pm) = at(0.5 * (a + b), y) + && pa.dist(pm).max(pm.dist(pb)) > POINT * tol + && 2.0 * turn(pm - pa, pb - pm) > QUARTER_TURN + { + return false; + } // At a pole the normal is undefined: take it from just inside the segment. let na = normal(a, y).or_else(|| normal(a + 1e-4 * (b - a), y)); let nb = normal(b, y).or_else(|| normal(b - 1e-4 * (b - a), y)); @@ -147,6 +154,26 @@ mod tests { assert_eq!(along.len(), 9); } + /// A quarter of a cylinder as a rational quadratic spline (as SMLib holds a bend), its range a + /// rounding over π/2 as a boundary's pcurves give it: the quarter turn is read from the + /// surface, not the parameter, so at a tolerance above its sag it is one interval; and a whole + /// turn is still divided into quarters however coarse the tolerance. + #[test] + fn a_quarter_turn_is_read_from_the_surface_not_the_parameter() { + let w = std::f64::consts::FRAC_1_SQRT_2; + let q = std::f64::consts::FRAC_PI_2; + let s = EvalSurface::nurbs( + [1, 2], + [vec![0.0, 0.0, 40.0, 40.0], vec![0.0, 0.0, 0.0, q, q, q]], + [2, 3], + vec![[1.0, 0.0, 0.0, 1.0], [1.0, 0.0, 40.0, 1.0], [w, w, 0.0, w], [w, w, 40.0 * w, w], [0.0, 1.0, 0.0, 1.0], [0.0, 1.0, 40.0, 1.0]], + ); + let coarse = Rules { tol: 3.0, max_len: f64::INFINITY, turn: None }; + assert_eq!(divide(&s, 1, (-6.7e-13, q), (0.0, 40.0), &coarse, f64::INFINITY, 10_000), vec![-6.7e-13, q]); + let whole = divide(&cylinder(), 1, (0.0, std::f64::consts::TAU), (0.0, 1.0), &Rules { tol: 100.0, ..coarse }, f64::INFINITY, 10_000); + assert_eq!(whole.len(), 5, "{whole:?}"); + } + /// The first and last lines are the range's ends to the last bit: the boundary nodes sit on /// them, and a line a rounding inside would be taken for an interior one (a drill point's /// cone, where a0 + (a1 − a0) is not a1). diff --git a/crates/kernel/src/thread_display_tests.rs b/crates/kernel/src/thread_display_tests.rs index 63f5f3cf8..f8107f0b0 100644 --- a/crates/kernel/src/thread_display_tests.rs +++ b/crates/kernel/src/thread_display_tests.rs @@ -144,12 +144,14 @@ fn thread_display_mesh_stays_on_its_surfaces() { 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)); + // An end disc is flat: its triangles are its boundary's, and one with its three + // corners on the rim (at r = rc) lies on the disc, not on a cylinder. + 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); for want in [rc, rm] { - if [ra, rb, rcn].iter().all(|x| (x - want).abs() < 1e-4) { + if !end_disc && [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. diff --git a/docs/book/src/guide/assemblies.md b/docs/book/src/guide/assemblies.md index 505ddf853..1dc602fbf 100644 --- a/docs/book/src/guide/assemblies.md +++ b/docs/book/src/guide/assemblies.md @@ -322,9 +322,11 @@ accelerations are finite differences between samples, central inside and one-sid so they are as smooth as the samples are dense (up to 1000, one per step by default). Angles are unwrapped, so a joint that turns on past half a turn keeps counting. `motion.interference {study, occurrences?, against?, contact_sets?, samples?}` answers each -colliding pair with its `first_step`, `last_step`, the `steps` ranges where they overlap, how -far into each other (`depth_mm`, the most at `deepest_step`) and their shared `volume_mm3` -there (null when it is not cheap to work out). It plays the study as `motion.play` does, but +colliding pair with its `first_step`, `last_step`, the `steps` ranges where they overlap, the +most volume they share at a sample (`volume_mm3`, worked out exactly from the bodies; null when +it is not cheap to work out at every sample they overlap), the first sample sharing that much +(`deepest_step`) and how far into each other they reach (`depth_mm`, an estimate from points of +the bodies' contact meshes). It plays the study as `motion.play` does, but contact sets don't stop it, and parts are tested at the samples only: a part that passes right through another between two samples is missed. Parts are told apart by occurrence, as contact sets tell them apart: an occurrence inside a sub-assembly placed twice is one part, so its two