SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 425/509: Motion interference: a volume it could not work out is not measured, never a sampled guess
jyvikof80b3ebc1fbf
diff --git a/crates/engine/src/cmd/motion_analysis.rs b/crates/engine/src/cmd/motion_analysis.rsindex 6ea7c814e5..2ee0668810 100644--- a/crates/engine/src/cmd/motion_analysis.rs+++ b/crates/engine/src/cmd/motion_analysis.rs@@ -30,10 +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), \- 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, \+ volume_mm3 (the most volume they share at a sample, worked out exactly from the bodies), deepest_step (the first sample \+ sharing that volume), not_measured (null, or why the volume was not worked out at every sample they overlap, such as \+ a budget it ran past: then volume_mm3 and deepest_step are null, never an estimate), 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";@@ -252,34 +252,26 @@ struct Collision {names: (String, String),/// The samples where they overlap, in order.samples: Vec<usize>,- /// The most sampled mesh depth, and the first sample reaching it.+ /// The most sampled mesh depth.depth: f64,- deepest: usize,- /// 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)>,+ /// The most exact shared volume and the first sample sharing it, or why it is not measured+ /// (a sample's volume was not worked out).+ most_volume: std::result::Result<(f64, usize), String>,}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<f64>) {- 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)+ /// Takes the exact shared volume at sample `k`, or why it was 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: std::result::Result<f64, String>) {+ if let Ok((best, at)) = self.most_volume {+ self.most_volume = volume.map(|v| if v > best + 1e-9 * best.max(1.0) { (v, k) } else { (best, at) });+ }}}-/// The volume the parts under occurrences `a` and `b` share, placed as in `doc` (`None`: not-/// worked out). Only bodies whose boxes overlap are intersected, at most `booleans` of them.-fn shared_volume(s: &Session, doc: &Document, a: u64, b: u64, booleans: &mut usize) -> Option<f64> {+/// The volume the parts under occurrences `a` and `b` share, placed as in `doc`, or why it was+/// not worked out. Only bodies whose boxes overlap are intersected, at most `booleans` of them.+fn shared_volume(s: &Session, doc: &Document, a: u64, b: u64, booleans: &mut usize) -> std::result::Result<f64, String> {let st = s.model.state();// The bodies under each (and not under the other), with their world frames and boxes.let mut sides: [Vec<(Mat, Aabb3, &solidcraft_doc::ModelBody)>; 2] = Default::default();@@ -299,24 +291,31 @@ fn shared_volume(s: &Session, doc: &Document, a: u64, b: u64, booleans: &mut usilet corner = Vec3::new(pick(1, local.min.x, local.max.x), pick(2, local.min.y, local.max.y), pick(4, local.min.z, local.max.z));world.add(apply_point(&frame, corner));}- sides.get_mut(side)?.push((frame, world, body));+ if let Some(list) = sides.get_mut(side) {+ list.push((frame, world, body));+ }}}+ let [first, second] = &sides;let mut total = 0.0;- for (fa, xa, ba) in sides.first()? {- for (fb, xb, bb) in sides.get(1)? {+ for (fa, xa, ba) in first {+ for (fb, xb, bb) in second {if xa.max.x < xb.min.x || xb.max.x < xa.min.x || xa.max.y < xb.min.y || xb.max.y < xa.min.y || xa.max.z < xb.min.z || xb.max.z < xa.min.z{continue;}- *booleans = booleans.checked_sub(1)?;- let (pa, pb) = (solidcraft_kernel::transform_matrix(&ba.body, *fa).ok()?, solidcraft_kernel::transform_matrix(&bb.body, *fb).ok()?);- if let Some(shared) = solidcraft_kernel::boolean(&pa, &pb, solidcraft_kernel::BoolOp::Intersect).ok()? {- total += solidcraft_kernel::measure(&shared).ok()?.volume;+ *booleans = booleans.checked_sub(1).ok_or_else(|| format!("the check's {MAX_BOOLEANS} body intersections ran out"))?;+ let failed = |e: &dyn std::fmt::Display| format!("the intersection of {} and {} could not be made ({e})", ba.name, bb.name);+ let (pa, pb) = (+ solidcraft_kernel::transform_matrix(&ba.body, *fa).map_err(|e| failed(&e))?,+ solidcraft_kernel::transform_matrix(&bb.body, *fb).map_err(|e| failed(&e))?,+ );+ if let Some(shared) = solidcraft_kernel::boolean(&pa, &pb, solidcraft_kernel::BoolOp::Intersect).map_err(|e| failed(&e))? {+ total += solidcraft_kernel::measure(&shared).map_err(|e| failed(&e))?.volume;}}}- Some(total)+ Ok(total)}/// Contiguous runs of samples, as study step ranges.@@ -412,17 +411,18 @@ pub(super) fn interference(s: &mut Session, p: &Value) -> Result<Value> {names: (an, bn),samples: Vec::new(),depth: 0.0,- deepest: k,- most_volume: slots.then_some((0.0, k)),+ most_volume: if slots {+ Ok((0.0, k))+ } else {+ Err(format!("more than {MAX_VOLUMES} pairs collide: only the first {MAX_VOLUMES} found have their volumes worked out"))+ },});if c.samples.last() == Some(&k) {continue;}c.samples.push(k);- if depth > c.depth {- (c.depth, c.deepest) = (depth, k);- }- if c.most_volume.is_some() {+ c.depth = c.depth.max(depth);+ if c.most_volume.is_ok() {c.take_volume(k, shared_volume(s, &t.doc, a, b, &mut booleans));}}@@ -437,11 +437,14 @@ pub(super) fn interference(s: &mut Session, p: &Value) -> Result<Value> {let collisions: Vec<Value> = list.iter().map(|(_, c)| {- let volume = c.most_volume.map(|(v, _)| v);+ let (volume, deepest, not_measured) = match &c.most_volume {+ Ok((v, at)) => (Some(*v), Some(step_of(&m, *at, n)), None),+ Err(why) => (None, None, Some(why.clone())),+ };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_sample(), n), "volume_mm3": volume})+ "depth_mm": c.depth, "deepest_step": deepest, "volume_mm3": volume, "not_measured": not_measured})}).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.rsindex c820f509b1..27b7a67b97 100644--- a/crates/engine/src/cmd/motion_analysis_tests.rs+++ b/crates/engine/src/cmd/motion_analysis_tests.rs@@ -199,6 +199,24 @@ fn interference_is_deepest_where_the_parts_share_the_most_volume() {}}+/// Pushed through A at 1000 samples, B overlaps it at about 330 of them, one intersection each:+/// past the check's 256, so the volume is not measured and no deepest step is guessed. Where+/// they overlap is still answered.+#[test]+fn interference_past_its_intersection_budget_says_the_volume_is_not_measured() {+ let mut s = rail();+ run(&mut s, "motion.study", json!({"name": "Push", "steps": 15, "keys": [{"joint": "Rail", "points": [[0, 10], [15, -5]]}]}));+ let r = run(&mut s, "motion.interference", json!({"study": "Push", "samples": 1000}));+ let c = &r["collisions"][0];+ assert!(r["clear"] == false && r["truncated"] == false && c["last_step"] == 15.0, "{r}");+ assert!(c["first_step"].as_f64().is_some_and(|f| f > 10.0 && f < 10.1), "{r}");+ assert!(c["volume_mm3"].is_null() && c["deepest_step"].is_null(), "{r}");+ assert!(c["not_measured"].as_str().is_some_and(|w| w.contains("256 body intersections ran out")), "{r}");+ // Within the budget, it is measured.+ let r = run(&mut s, "motion.interference", json!({"study": "Push"}));+ assert!(r["collisions"][0]["not_measured"].is_null() && r["collisions"][0]["deepest_step"] == 15.0, "{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/docs/book/src/guide/assemblies.md b/docs/book/src/guide/assemblies.mdindex 1dc602fbf5..dab7acf5f2 100644--- a/docs/book/src/guide/assemblies.md+++ b/docs/book/src/guide/assemblies.md@@ -323,10 +323,11 @@ so they are as smooth as the samples are dense (up to 1000, one per step by defaunwrapped, so a joint that turns on past half a turn keeps counting.`motion.interference {study, occurrences?, against?, contact_sets?, samples?}` answers eachcolliding 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+most volume they share at a sample (`volume_mm3`, worked out exactly from the bodies), 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). When the volume could not be worked out at+every sample they overlap (more than 16 colliding pairs, or past the check's 256 body+intersections), `volume_mm3` and `deepest_step` are null and `not_measured` says why. It plays the study as `motion.play` does, butcontact sets don't stop it, and parts are tested at the samples only: a part that passes rightthrough another between two samples is missed. Parts are told apart by occurrence, as contactsets tell them apart: an occurrence inside a sub-assembly placed twice is one part, so its two