Wave 425/509: Motion interference: a volume it could not work out is not measured, never a sampled guess

1 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.

- b6d3c8b80 jyviko: Motion interference: a volume it could not work out is not measured, never a sampled guess

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
jyvikoandClaude Opus 5.5 committed 2026-10-30 07:02:41 -04:00
1 parent db9897fda7
commit f80b3ebc1f
3 files changed
+67 -45

No files matched your search

+44 -41
View File
@@ -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 usi
let 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,
@@ -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]
+5 -4
View File
@@ -323,10 +323,11 @@ so they are as smooth as the samples are dense (up to 1000, one per step by defa
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, 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, 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