Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

inspect.compare: where two versions of a part differ, without a boolean of the two (#1423)

NOWN-DEVd0a4443939a1
diff --git a/assets/locales/de.json b/assets/locales/de.json
index 45a7fa3d0e..e76befe458 100644
--- a/assets/locales/de.json
+++ b/assets/locales/de.json
@@ -555,6 +555,7 @@
"cmd.file_slicers": "Installierte Slicer",
"cmd.inspect_accessibility": "Zugänglichkeitsanalyse",
"cmd.inspect_center_of_mass": "Massenschwerpunkt",
+ "cmd.inspect_compare": "Körper vergleichen",
"cmd.inspect_curvature_comb": "Krümmungskamm-Analyse",
"cmd.inspect_curvature_map": "Krümmungskartenanalyse",
"cmd.inspect_draft": "Auswinkelanalyse",
diff --git a/assets/locales/en.json b/assets/locales/en.json
index bebf39f4ec..5c57abe95e 100644
--- a/assets/locales/en.json
+++ b/assets/locales/en.json
@@ -108,6 +108,7 @@
"cmd.file_slicers": "Installed Slicers",
"cmd.inspect_accessibility": "Accessibility Analysis",
"cmd.inspect_center_of_mass": "Center of Mass",
+ "cmd.inspect_compare": "Compare Bodies",
"cmd.inspect_curvature_comb": "Curvature Comb Analysis",
"cmd.inspect_curvature_map": "Curvature Map Analysis",
"cmd.inspect_draft": "Draft Analysis",
diff --git a/assets/locales/fr.json b/assets/locales/fr.json
index fbc04e6669..b1abe9879f 100644
--- a/assets/locales/fr.json
+++ b/assets/locales/fr.json
@@ -108,6 +108,7 @@
"cmd.file_slicers": "Slicers installés",
"cmd.inspect_accessibility": "Analyse d'accessibilité",
"cmd.inspect_center_of_mass": "Centre de gravité",
+ "cmd.inspect_compare": "Comparer les corps",
"cmd.inspect_curvature_comb": "Analyse par peigne de courbure",
"cmd.inspect_curvature_map": "Analyse par carte de courbure",
"cmd.inspect_draft": "Analyse de dépouille",
diff --git a/assets/locales/ja.json b/assets/locales/ja.json
index a7ec8fb417..05c731fe48 100644
--- a/assets/locales/ja.json
+++ b/assets/locales/ja.json
@@ -108,6 +108,7 @@
"cmd.file_slicers": "インストール済みのスライサー",
"cmd.inspect_accessibility": "アクセシビリティ解析",
"cmd.inspect_center_of_mass": "重心",
+ "cmd.inspect_compare": "ボディを比較",
"cmd.inspect_curvature_comb": "曲率コーム解析",
"cmd.inspect_curvature_map": "曲率マップ解析",
"cmd.inspect_draft": "勾配解析",
diff --git a/assets/locales/ko.json b/assets/locales/ko.json
index 9b29f58c7d..b7dd3f8e50 100644
--- a/assets/locales/ko.json
+++ b/assets/locales/ko.json
@@ -555,6 +555,7 @@
"cmd.file_slicers": "설치된 슬라이서",
"cmd.inspect_accessibility": "접근성 분석",
"cmd.inspect_center_of_mass": "무게중심",
+ "cmd.inspect_compare": "바디 비교",
"cmd.inspect_curvature_comb": "곡률빗 분석",
"cmd.inspect_curvature_map": "곡률맵 분석",
"cmd.inspect_draft": "블록각 분석",
diff --git a/assets/locales/ru.json b/assets/locales/ru.json
index 1e6ad545a3..28ab0481da 100644
--- a/assets/locales/ru.json
+++ b/assets/locales/ru.json
@@ -97,6 +97,7 @@
"cmd.file_slicers": "Установленные слайсеры",
"cmd.inspect_accessibility": "Анализ доступности",
"cmd.inspect_center_of_mass": "Центр масс",
+ "cmd.inspect_compare": "Сравнить тела",
"cmd.inspect_curvature_comb": "Анализ кривизны (гребёнка)",
"cmd.inspect_curvature_map": "Карта кривизны",
"cmd.inspect_draft": "Анализ уклонов",
diff --git a/assets/locales/uk.json b/assets/locales/uk.json
index df4694b4b2..c80375687e 100644
--- a/assets/locales/uk.json
+++ b/assets/locales/uk.json
@@ -98,6 +98,7 @@
"cmd.file_save_mesh": "Зберегти як сітку",
"cmd.inspect_accessibility": "Аналіз доступності",
"cmd.inspect_center_of_mass": "Центр мас",
+ "cmd.inspect_compare": "Порівняти тіла",
"cmd.inspect_curvature_comb": "Аналіз гребеня кривизни",
"cmd.inspect_curvature_map": "Аналіз карти кривизни",
"cmd.inspect_draft": "Аналіз ухилу",
diff --git a/assets/locales/zh.json b/assets/locales/zh.json
index 5df4f23303..65331f4c38 100644
--- a/assets/locales/zh.json
+++ b/assets/locales/zh.json
@@ -108,6 +108,7 @@
"cmd.file_slicers": "已安装的切片软件",
"cmd.inspect_accessibility": "可达性分析",
"cmd.inspect_center_of_mass": "质心",
+ "cmd.inspect_compare": "比较实体",
"cmd.inspect_curvature_comb": "曲率梳分析",
"cmd.inspect_curvature_map": "曲率图分析",
"cmd.inspect_draft": "拔模分析",
diff --git a/crates/engine/src/cmd/compare.rs b/crates/engine/src/cmd/compare.rs
new file mode 100644
index 0000000000..be888746ed
--- /dev/null
+++ b/crates/engine/src/cmd/compare.rs
@@ -0,0 +1,309 @@
+//! Compare Bodies: two versions of one part laid over each other. Both are measured, each
+//! surface's distance to the other is sampled, and the places where only one of them has
+//! material are found, measured and, on request, coloured. It works from the surfaces
+//! ([`solidcraft_geom::compare`]), not from a boolean of the two bodies, so bodies that share
+//! almost every face compare as well as any.
+
+use serde_json::{Value, json};
+use solidcraft_geom::Vec3;
+use solidcraft_geom::compare::{self, CompareOptions, Side};
+
+use super::CommandSpec;
+use crate::params::bad;
+use crate::{Result, Sel, Session};
+
+pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("inspect.compare", "Compare Bodies", compare_bodies).params(
+ "a, b: body names (default: the two selected bodies, or the design's only two), in world placement; tolerance?: mm (0.001 to 10, default 0.01): \
+ surfaces closer than this agree; spacing?: mm (default 0.5): the largest piece of a face sampled as one point, coarser for a body that would need \
+ more than max_points? (default 8 million, up to 50 million) samples; max_regions? (default 50); color?: true | {only_in_a?, only_in_b?: \"#rrggbb\"} \
+ (colours the faces that hold a region, red where only a has material and green where only b has: the faces mostly beyond the tolerance, else the \
+ one with the largest share; an undo step) → a, b: volume_mm3, area_mm2, center_of_mass, bbox; difference: b − a; \
+ deviation: a_to_b, b_to_a (max_mm, mean_mm, at, area_beyond_mm2); regions, largest first: side (only_in_a | only_in_b), volume_mm3 (integrated along \
+ lines through the region: resolution), area_mm2, max_deviation_mm, at, center, bbox, faces_a, faces_b (face indices, as model.faces lists them); \
+ identical; verdict; warnings (a body whose surface does not enclose what it measures, lines left out). Works from the two surfaces, without a boolean of the bodies, so near-identical bodies compare too",
+)];
+
+/// Default colours: red for material only `a` has, green for material only `b` has.
+const ONLY_IN_A: [u8; 3] = [0xe0, 0x31, 0x31];
+const ONLY_IN_B: [u8; 3] = [0x2f, 0x9e, 0x44];
+
+fn side_name(s: Side) -> &'static str {
+ match s {
+ Side::OnlyInA => "only_in_a",
+ Side::OnlyInB => "only_in_b",
+ }
+}
+
+/// A number parameter in `range`, `default` when absent.
+fn number(cmd: &str, p: &Value, key: &str, default: f64, range: std::ops::RangeInclusive<f64>) -> Result<f64> {
+ match p.get(key) {
+ None | Some(Value::Null) => Ok(default),
+ Some(v) => v
+ .as_f64()
+ .filter(|x| x.is_finite() && range.contains(x))
+ .ok_or_else(|| bad(cmd, format!("`{key}` must be a number from {} to {}", range.start(), range.end()))),
+ }
+}
+
+/// The two bodies: `a` and `b`, else the two selected bodies, else the design's only two.
+fn pair(s: &Session, st: &solidcraft_doc::ModelState, p: &Value, cmd: &str) -> Result<(String, String)> {
+ let given = |k: &str| -> Result<Option<String>> {
+ match p.get(k) {
+ None | Some(Value::Null) => Ok(None),
+ Some(Value::String(n)) => Ok(Some(n.clone())),
+ Some(_) => Err(bad(cmd, format!("`{k}` must be a body name"))),
+ }
+ };
+ let (a, b) = match (given("a")?, given("b")?) {
+ (Some(a), Some(b)) => (a, b),
+ (None, None) => {
+ let selected: Vec<String> =
+ s.selection.iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.clone()) } else { None }).collect();
+ let all: Vec<String> = st.bodies.iter().map(|b| b.name.clone()).collect();
+ match (selected.as_slice(), all.as_slice()) {
+ ([a, b], _) | (_, [a, b]) => (a.clone(), b.clone()),
+ _ => return Err(bad(cmd, "give `a` and `b` (or select two bodies)")),
+ }
+ }
+ _ => return Err(bad(cmd, "give both `a` and `b`")),
+ };
+ for n in [&a, &b] {
+ if st.body(n).is_none() {
+ return Err(bad(cmd, format!("no body `{n}`")));
+ }
+ }
+ if a == b {
+ return Err(bad(cmd, "`a` and `b` must be two different bodies"));
+ }
+ Ok((a, b))
+}
+
+fn colours(cmd: &str, p: &Value) -> Result<Option<[[u8; 3]; 2]>> {
+ match p.get("color") {
+ None | Some(Value::Null) | Some(Value::Bool(false)) => Ok(None),
+ Some(Value::Bool(true)) => Ok(Some([ONLY_IN_A, ONLY_IN_B])),
+ Some(Value::Object(o)) => {
+ let pick = |k: &str, d: [u8; 3]| match o.get(k) {
+ None | Some(Value::Null) => Ok(d),
+ Some(v) => {
+ super::inspect::color_param(v).ok_or_else(|| bad(cmd, format!("`color.{k}` must be \"#rrggbb\" or [r, g, b] with values 0–255")))
+ }
+ };
+ Ok(Some([pick("only_in_a", ONLY_IN_A)?, pick("only_in_b", ONLY_IN_B)?]))
+ }
+ Some(_) => Err(bad(cmd, "`color` must be true or {only_in_a, only_in_b}")),
+ }
+}
+
+fn v3(v: &Value) -> Option<Vec3> {
+ crate::params::vec3(v)
+}
+
+/// b − a of the two bodies' measures.
+fn difference(ma: &Value, mb: &Value) -> Value {
+ let f = |m: &Value, k: &str| m.get(k).and_then(Value::as_f64);
+ let sub = |x: Option<f64>, y: Option<f64>| x.zip(y).map(|(x, y)| y - x);
+ let (va, vb) = (f(ma, "volume_mm3"), f(mb, "volume_mm3"));
+ let com = v3(&ma["center_of_mass"]).zip(v3(&mb["center_of_mass"])).map(|(a, b)| b - a);
+ let corner = |k: &str| v3(&ma["bbox"][k]).zip(v3(&mb["bbox"][k])).map(|(a, b)| b - a);
+ json!({
+ "volume_mm3": sub(va, vb),
+ "volume_percent": va.zip(vb).filter(|(a, _)| a.abs() > 0.0).map(|(a, b)| 100.0 * (b - a) / a),
+ "area_mm2": sub(f(ma, "area_mm2"), f(mb, "area_mm2")),
+ "center_of_mass": com,
+ "center_of_mass_distance_mm": com.map(Vec3::len),
+ "bbox_min": corner("min"),
+ "bbox_max": corner("max"),
+ })
+}
+
+/// The volume a closed mesh encloses (divergence theorem, about its box's centre).
+fn enclosed_volume(m: &solidcraft_geom::Mesh) -> f64 {
+ let o = m.bounds().center();
+ m.triangles.iter().filter_map(|t| m.tri(t)).map(|[a, b, c]| (a - o).dot((b - o).cross(c - o)) / 6.0).sum()
+}
+
+/// What makes the comparison less certain: a body whose surface does not enclose what it
+/// measures (open, or faces that failed), lines left out of region volumes.
+fn warnings(bodies: [(&str, &Value, &solidcraft_geom::Mesh); 2], chord: f64, c: &compare::Comparison) -> Vec<String> {
+ let mut out = Vec::new();
+ for (name, measure, mesh) in bodies {
+ let (Some(v), area) = (measure["volume_mm3"].as_f64(), measure["area_mm2"].as_f64().unwrap_or(0.0)) else { continue };
+ let enclosed = enclosed_volume(mesh);
+ // A mesh within `chord` of the surface encloses the volume to within chord × area.
+ if !((enclosed - v).abs() <= chord * area.abs() + 1e-6 * v.abs()) {
+ out.push(format!(
+ "`{name}`: its surface encloses {enclosed:.3} mm³ but the body measures {v:.3} mm³: it is open or has faces that failed, so its measures and the regions near the gap are unreliable"
+ ));
+ }
+ }
+ let skipped: usize = c.regions.iter().map(|r| r.lines.skipped).sum();
+ if skipped > 0 {
+ out.push(format!("{skipped} line(s) through the regions crossed a gap in a surface and were left out of their volumes"));
+ }
+ out
+}
+
+fn deviation_json(d: &compare::Deviation) -> Value {
+ json!({"max_mm": d.max, "mean_mm": d.mean, "at": d.at, "area_beyond_mm2": d.beyond_area, "area_mm2": d.area, "points": d.points})
+}
+
+fn compare_bodies(s: &mut Session, p: &Value) -> Result<Value> {
+ let cmd = "inspect.compare";
+ let tolerance = number(cmd, p, "tolerance", 0.01, 0.001..=10.0)?;
+ let spacing = number(cmd, p, "spacing", 0.5, 0.01..=1000.0)?;
+ let max_points = number(cmd, p, "max_points", 8e6, 1e4..=5e7)? as usize;
+ let max_regions = number(cmd, p, "max_regions", 50.0, 1.0..=1000.0)? as usize;
+ let colors = colours(cmd, p)?;
+ let st = s.world_state();
+ let (na, nb) = pair(s, &st, p, cmd)?;
+ let (Some(ba), Some(bb)) = (st.body(&na), st.body(&nb)) else { return Err(bad(cmd, "no such body")) };
+ // Meshed within a quarter of the tolerance (the kernel goes no finer than a millionth of a
+ // body's size), so two meshes of one surface agree well within it.
+ let chord = tolerance / 4.0;
+ let mut done = solidcraft_kernel::map_on_threads(&[ba, bb], 2, |b| (super::inspect::measure_json(b), b.body.tessellate_with(chord, true)))
+ .into_iter()
+ .zip([&na, &nb]);
+ let mut next = || -> Result<(Value, solidcraft_geom::Mesh)> {
+ let Some((r, name)) = done.next() else { return Err(bad(cmd, "no such body")) };
+ let (m, mesh) = r.ok_or_else(|| bad(cmd, format!("`{name}`: measuring it failed")))?;
+ let mesh = mesh.map_err(|e| bad(cmd, format!("`{name}`: {e}")))?;
+ if mesh.triangles.is_empty() {
+ return Err(bad(cmd, format!("`{name}` has no surface")));
+ }
+ Ok((m, mesh))
+ };
+ let ((measure_a, mesh_a), (measure_b, mesh_b)) = (next()?, next()?);
+ let options = CompareOptions { tolerance, spacing, max_points, max_regions, ..CompareOptions::default() };
+ let each = |n: usize, job: &(dyn Fn(usize) + Sync)| {
+ let jobs: Vec<usize> = (0..n).collect();
+ solidcraft_kernel::for_each_on_threads(&jobs, 16, |i| job(*i));
+ };
+ let c = compare::compare(&mesh_a, &mesh_b, &options, &each);
+ let axis = |k: usize| ["X", "Y", "Z"].get(k).copied().unwrap_or("?");
+ let regions: Vec<Value> = c
+ .regions
+ .iter()
+ .enumerate()
+ .map(|(i, r)| {
+ json!({
+ "index": i + 1,
+ "side": side_name(r.side),
+ "material_of": if r.side == Side::OnlyInA { &na } else { &nb },
+ "volume_mm3": r.volume,
+ "area_mm2": r.area_a + r.area_b,
+ "area_a_mm2": r.area_a,
+ "area_b_mm2": r.area_b,
+ "max_deviation_mm": r.max_deviation,
+ "at": r.at,
+ "center": r.center,
+ "bbox": {"min": r.bbox.min, "max": r.bbox.max},
+ "faces_a": r.faces_a.iter().map(|x| x.0).collect::<Vec<u32>>(),
+ "faces_b": r.faces_b.iter().map(|x| x.0).collect::<Vec<u32>>(),
+ "resolution": {"along": axis(r.lines.axis), "line_spacing_mm": r.lines.spacing, "lines": r.lines.count, "skipped_lines": r.lines.skipped},
+ })
+ })
+ .collect();
+ let total = |side: Side| {
+ let rs: Vec<&compare::Region> = c.regions.iter().filter(|r| r.side == side).collect();
+ // `+ 0.0`: an empty sum is -0.0.
+ (rs.len(), rs.iter().map(|r| r.volume).filter(|v| v.is_finite()).sum::<f64>() + 0.0)
+ };
+ let ((ca, va), (cb, vb)) = (total(Side::OnlyInA), total(Side::OnlyInB));
+ let worst = c.a_to_b.max.max(c.b_to_a.max);
+ let identical = c.regions.is_empty() && c.unlisted == 0;
+ let warnings = warnings([(na.as_str(), &measure_a, &mesh_a), (nb.as_str(), &measure_b, &mesh_b)], chord, &c);
+ let mut verdict = if identical {
+ format!("identical within {tolerance} mm (largest deviation {worst:.4} mm)")
+ } else {
+ let more = if c.unlisted > 0 { format!(" (and {} more, not measured)", c.unlisted) } else { String::new() };
+ format!(
+ "{} {} by more than {tolerance} mm: {ca} with material only in `{na}` ({va:.3} mm³), {cb} only in `{nb}` ({vb:.3} mm³){more}",
+ c.regions.len(),
+ if c.regions.len() == 1 { "region differs" } else { "regions differ" }
+ )
+ };
+ if !warnings.is_empty() {
+ verdict += &format!(" ({} warning{})", warnings.len(), if warnings.len() == 1 { "" } else { "s" });
+ }
+ let mut out = json!({
+ "a": measure_a,
+ "b": measure_b,
+ "difference": difference(&measure_a, &measure_b),
+ "tolerance_mm": tolerance,
+ "deviation": {"a_to_b": deviation_json(&c.a_to_b), "b_to_a": deviation_json(&c.b_to_a), "max_mm": worst},
+ "identical": identical,
+ "verdict": verdict,
+ "regions": regions,
+ "only_in_a": {"regions": ca, "volume_mm3": va},
+ "only_in_b": {"regions": cb, "volume_mm3": vb},
+ "unlisted_regions": c.unlisted,
+ "warnings": warnings,
+ "sampling": {"spacing_mm": c.spacing, "chord_mm": chord, "triangles_a": mesh_a.triangles.len(), "triangles_b": mesh_b.triangles.len()},
+ });
+ if let Some(colors) = colors {
+ out["colored_faces"] = json!(color_regions(s, &c, [&na, &nb], colors)?);
+ }
+ Ok(out)
+}
+
+/// A face is coloured for a region when at least this share of it deviates there.
+const MOSTLY: f64 = 0.5;
+
+/// The faces to colour for a region, as (body: 0 = a, 1 = b; face): those mostly beyond the
+/// tolerance (a small difference on a large face would colour all of it), or, when it has none,
+/// the one with the largest share.
+fn faces_to_color(c: &compare::Comparison, r: &compare::Region) -> Vec<(usize, u32)> {
+ let share = |m: usize, &(f, beyond): &(u32, f64)| {
+ let all = c.face_area.get(m).and_then(|x| x.get(&f)).copied().unwrap_or(0.0);
+ (m, f, if all > 0.0 { beyond / all } else { 0.0 })
+ };
+ let all: Vec<(usize, u32, f64)> = r.faces_a.iter().map(|x| share(0, x)).chain(r.faces_b.iter().map(|x| share(1, x))).collect();
+ let mostly: Vec<(usize, u32)> = all.iter().filter(|x| x.2 >= MOSTLY).map(|x| (x.0, x.1)).collect();
+ if !mostly.is_empty() {
+ return mostly;
+ }
+ all.iter().max_by(|x, y| x.2.total_cmp(&y.2)).map(|x| vec![(x.0, x.1)]).unwrap_or_default()
+}
+
+/// Give the faces holding each region the colour of its side (a face holding several takes the
+/// largest one's); returns how many face appearances were set.
+fn color_regions(s: &mut Session, c: &compare::Comparison, names: [&String; 2], colors: [[u8; 3]; 2]) -> Result<usize> {
+ use solidcraft_doc::appearance::{FaceLook, Look};
+ let st = s.model.state();
+ // Where each face of the two bodies is, as the design file names and finds it. A body placed
+ // by an occurrence is coloured where it is defined, if at all.
+ let found: Vec<_> =
+ names.iter().map(|n| st.body(n).map(|b| (solidcraft_doc::naming::face_spots(b), solidcraft_doc::naming::face_names(b)))).collect();
+ let mut picks: Vec<(String, Vec3, Option<String>, Look)> = Vec::new();
+ // Smallest region first, so the largest one's colour is the one that stays.
+ for r in c.regions.iter().rev() {
+ let colour = if r.side == Side::OnlyInA { colors[0] } else { colors[1] };
+ let mut look = Look::custom(colour, 1.0);
+ look.name = if r.side == Side::OnlyInA { "Only in a".into() } else { "Only in b".into() };
+ for (m, f) in faces_to_color(c, r) {
+ let (Some(Some((spots, face_names))), Some(name)) = (found.get(m), names.get(m)) else { continue };
+ let Some(spot) = spots.get(f as usize).copied().flatten() else { continue };
+ picks.retain(|(b, pt, _, _)| !(b == *name && pt.dist(spot.point) < 1e-9));
+ picks.push(((*name).clone(), spot.point, face_names.get(f as usize).cloned(), look.clone()));
+ }
+ }
+ if picks.is_empty() {
+ return Ok(0);
+ }
+ let a = &mut s.doc_mut().appearances;
+ let mut n = 0;
+ for (body, point, name, look) in picks {
+ a.faces.retain(|f| !(f.body == body && f.point.dist(point) < 1e-9));
+ if a.faces.len() >= 100_000 {
+ return Err(bad("inspect.compare", "too many face appearances"));
+ }
+ a.faces.push(FaceLook { body, point, look, name, strict_name: false, certificate: None });
+ n += 1;
+ }
+ Ok(n)
+}
+
+#[cfg(test)]
+#[path = "compare_tests.rs"]
+mod tests;
diff --git a/crates/engine/src/cmd/compare_tests.rs b/crates/engine/src/cmd/compare_tests.rs
new file mode 100644
index 0000000000..f0066db8e9
--- /dev/null
+++ b/crates/engine/src/cmd/compare_tests.rs
@@ -0,0 +1,212 @@
+use serde_json::{Value, json};
+
+use crate::Session;
+
+fn run(s: &mut Session, id: &str, p: Value) -> Value {
+ match s.execute(id, &p) {
+ Ok(v) => v,
+ Err(e) => panic!("{id} {p}: {e}"),
+ }
+}
+
+fn regions(r: &Value) -> Vec<Value> {
+ r["regions"].as_array().cloned().unwrap_or_default()
+}
+
+fn f(v: &Value) -> f64 {
+ v.as_f64().unwrap_or(f64::NAN)
+}
+
+fn close(got: f64, want: f64, rel: f64) -> bool {
+ (got - want).abs() <= rel * want.abs()
+}
+
+/// A 40 x 30 x 10 box `A` and its copy `A (2)`, in the same place.
+fn two_boxes() -> Session {
+ let mut s = Session::default();
+ run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 10, "body_name": "A"}));
+ run(&mut s, "solid.move", json!({"bodies": ["A"], "translate": [0, 0, 0], "copy": true}));
+ s
+}
+
+#[test]
+fn a_box_and_its_copy_are_identical() {
+ let mut s = two_boxes();
+ let r = run(&mut s, "inspect.compare", json!({"a": "A", "b": "A (2)"}));
+ assert_eq!(r["identical"], true, "{r}");
+ assert_eq!(r["warnings"], json!([]), "{r}");
+ assert!(regions(&r).is_empty());
+ assert!(f(&r["deviation"]["max_mm"]) < 1e-9, "{}", r["deviation"]);
+ assert_eq!(f(&r["difference"]["volume_mm3"]), 0.0);
+ assert!(close(f(&r["a"]["volume_mm3"]), 12_000.0, 1e-9));
+ assert!(r["verdict"].as_str().unwrap_or_default().starts_with("identical within 0.01 mm"), "{}", r["verdict"]);
+ // Without names: the design's only two bodies. Comparing changes nothing.
+ let before = s.doc.clone();
+ let r = run(&mut s, "inspect.compare", json!({}));
+ assert_eq!(r["identical"], true);
+ assert!(std::sync::Arc::ptr_eq(&before, &s.doc));
+}
+
+#[test]
+fn a_pocket_is_material_only_the_plain_box_has() {
+ // b has a 10 x 8 x 0.5 pocket in its top: 40 mm³ that only a has.
+ let mut s = two_boxes();
+ run(&mut s, "solid.box", json!({"length": 10, "width": 8, "height": 0.5, "corner": [10, 10, 9.5], "operation": "cut", "targets": ["A (2)"]}));
+ let r = run(&mut s, "inspect.compare", json!({"a": "A", "b": "A (2)"}));
+ let rs = regions(&r);
+ assert_eq!(rs.len(), 1, "{r}");
+ let g = &rs[0];
+ assert_eq!(g["side"], "only_in_a");
+ assert_eq!(g["material_of"], "A");
+ assert!(close(f(&g["volume_mm3"]), 40.0, 0.01), "{g}");
+ assert!((f(&g["max_deviation_mm"]) - 0.5).abs() < 1e-6, "{g}");
+ let (lo, hi) = (&g["bbox"]["min"], &g["bbox"]["max"]);
+ for (k, (want_lo, want_hi)) in [(10.0, 20.0), (10.0, 18.0), (9.5, 10.0)].into_iter().enumerate() {
+ assert!((f(&lo[k]) - want_lo).abs() < 0.05 && (f(&hi[k]) - want_hi).abs() < 0.05, "{g}");
+ }
+ let c = &g["center"];
+ assert!((f(&c[0]) - 15.0).abs() < 0.02 && (f(&c[1]) - 14.0).abs() < 0.02 && (f(&c[2]) - 9.75).abs() < 1e-6, "{g}");
+ // The pocket's floor and walls, and a's top.
+ assert_eq!(g["faces_b"].as_array().map(Vec::len), Some(5), "{g}");
+ assert_eq!(g["faces_a"].as_array().map(Vec::len), Some(1), "{g}");
+ assert!(close(f(&r["difference"]["volume_mm3"]), -40.0, 1e-6), "{}", r["difference"]);
+ assert!(close(f(&r["only_in_a"]["volume_mm3"]), 40.0, 0.01));
+ assert_eq!(r["only_in_b"]["regions"], 0);
+ // The other way round, the same material is only in b.
+ let r = run(&mut s, "inspect.compare", json!({"a": "A (2)", "b": "A"}));
+ assert_eq!(regions(&r).len(), 1);
+ assert_eq!(regions(&r)[0]["side"], "only_in_b");
+ assert_eq!(regions(&r)[0]["material_of"], "A");
+}
+
+#[test]
+fn a_boss_is_material_only_the_box_with_it_has() {
+ // b has a 6 x 5 x 2 boss on its top: 60 mm³ that only b has.
+ let mut s = two_boxes();
+ run(&mut s, "solid.box", json!({"length": 6, "width": 5, "height": 2, "corner": [5, 5, 10], "operation": "join", "targets": ["A (2)"]}));
+ let r = run(&mut s, "inspect.compare", json!({"a": "A", "b": "A (2)", "color": true}));
+ let rs = regions(&r);
+ assert_eq!(rs.len(), 1, "{r}");
+ assert_eq!(rs[0]["side"], "only_in_b");
+ assert!(close(f(&rs[0]["volume_mm3"]), 60.0, 0.01), "{}", rs[0]);
+ assert!((f(&rs[0]["max_deviation_mm"]) - 2.0).abs() < 1e-6);
+ assert!(close(f(&r["difference"]["volume_mm3"]), 60.0, 1e-6));
+ // Coloured green: the boss's top and four sides, all of them beyond the tolerance; not a's top,
+ // of which only the boss's footprint is. One undo step.
+ assert_eq!(r["colored_faces"], 5, "{r}");
+ let green = |s: &Session, body: &str| s.doc.appearances.faces.iter().filter(|x| x.body == body && x.look.color == [0x2f, 0x9e, 0x44]).count();
+ assert_eq!((green(&s, "A (2)"), green(&s, "A")), (5, 0));
+ run(&mut s, "edit.undo", json!({}));
+ assert_eq!(s.doc.appearances.faces.len(), 0);
+ // Own colours.
+ let r = run(&mut s, "inspect.compare", json!({"color": {"only_in_b": "#0000ff"}}));
+ assert_eq!(r["colored_faces"], 5);
+ assert_eq!(s.doc.appearances.faces.iter().filter(|x| x.look.color == [0, 0, 255]).count(), 5);
+}
+
+/// A 100 x 60 sheet-metal plate with a 20 mm flange along y = 0 and a 5 mm hole at (x, 40).
+fn bracket(s: &mut Session, name: &str, x: f64) {
+ run(s, "sketch.create", json!({"plane": "XY", "name": format!("{name} base")}));
+ run(s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [100, 60]}));
+ run(s, "sketch.finish", json!({}));
+ run(s, "sheet.flange", json!({"sketch": format!("{name} base"), "body_name": name}));
+ run(s, "sheet.flange", json!({"edges": [[50, 0, 2.5]], "height": 20, "body": name}));
+ run(s, "sketch.create", json!({"plane": "XY", "name": format!("{name} hole")}));
+ run(s, "sketch.circle.center", json!({"center": [x, 40], "diameter": 5}));
+ run(s, "sketch.finish", json!({}));
+ run(s, "solid.extrude", json!({"sketch": format!("{name} hole"), "through_all": true, "operation": "cut", "targets": [name]}));
+}
+
+#[test]
+fn a_hole_moved_2_mm_leaves_two_crescents() {
+ let mut s = Session::default();
+ bracket(&mut s, "Before", 50.0);
+ bracket(&mut s, "After", 52.0);
+ let r = run(&mut s, "inspect.compare", json!({"a": "Before", "b": "After"}));
+ let rs = regions(&r);
+ assert_eq!(rs.len(), 2, "{r}");
+ // Each is a disk of 2.5 mm radius less its overlap with the other, centres 2 mm apart, through
+ // the 2.5 mm sheet: (π r² − 2 r² acos(d / 2r) + (d / 2) √(4 r² − d²)) · t.
+ let (rr, d, t) = (2.5f64, 2.0f64, 2.5);
+ let crescent = (std::f64::consts::PI * rr * rr - 2.0 * rr * rr * (d / (2.0 * rr)).acos() + d / 2.0 * (4.0 * rr * rr - d * d).sqrt()) * t;
+ assert!((crescent - 24.316_34).abs() < 1e-4);
+ for g in &rs {
+ assert!(close(f(&g["volume_mm3"]), crescent, 0.02), "{g}");
+ let c = &g["center"];
+ assert!((f(&c[1]) - 40.0).abs() < 0.05 && (f(&c[2]) - 1.25).abs() < 0.01, "{g}");
+ // Material only Before has is where After's hole is (beyond x = 51), and the reverse.
+ match g["side"].as_str() {
+ Some("only_in_a") => assert!(f(&c[0]) > 51.5, "{g}"),
+ Some("only_in_b") => assert!(f(&c[0]) < 50.5, "{g}"),
+ _ => panic!("{g}"),
+ }
+ }
+ assert_ne!(rs[0]["side"], rs[1]["side"]);
+ assert!(f(&r["difference"]["volume_mm3"]).abs() < 1e-3, "{}", r["difference"]);
+ // Coloured: the hole walls, not the plate's faces, of which only the crescents deviate.
+ let r = run(&mut s, "inspect.compare", json!({"a": "Before", "b": "After", "color": true}));
+ let n = r["colored_faces"].as_u64().unwrap_or(0) as usize;
+ assert!((2..=8).contains(&n), "{r}");
+ let looks = &s.doc.appearances.faces;
+ assert_eq!(looks.len(), n);
+ for l in looks {
+ assert!(((l.point.x - 51.0).powi(2) + (l.point.y - 40.0).powi(2)).sqrt() < 4.0, "{:?}", l.point);
+ }
+}
+
+#[test]
+fn a_part_and_its_step_round_trips_are_identical() {
+ // Curved faces too: a hole and a rounded edge.
+ let mut s = Session::default();
+ run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 10, "body_name": "Part"}));
+ run(&mut s, "solid.cylinder", json!({"diameter": 8, "height": 10, "base": [20, 15, 0], "operation": "cut", "targets": ["Part"]}));
+ run(&mut s, "solid.fillet", json!({"edges": [[40, 15, 10]], "radius": 3}));
+ let dir = std::env::temp_dir().join(format!("solidcraft-compare-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let path = dir.join("part.step");
+ run(&mut s, "file.export", json!({"path": path, "bodies": ["Part"]}));
+ let mut inserted = Vec::new();
+ for _ in 0..2 {
+ let r = run(&mut s, "file.insert_step", json!({"path": path}));
+ inserted.push(r["created_bodies"][0].as_str().unwrap().to_string());
+ }
+ let _ = std::fs::remove_dir_all(&dir);
+ for (a, b) in [("Part", inserted[0].as_str()), (inserted[0].as_str(), inserted[1].as_str())] {
+ let r = run(&mut s, "inspect.compare", json!({"a": a, "b": b}));
+ assert_eq!(r["identical"], true, "{a} vs {b}: {r}");
+ assert!(f(&r["deviation"]["max_mm"]) < 0.005, "{a} vs {b}: {}", r["deviation"]);
+ assert!(f(&r["difference"]["volume_mm3"]).abs() < 0.05, "{a} vs {b}: {}", r["difference"]);
+ }
+}
+
+#[test]
+fn bad_parameters_are_refused() {
+ let mut s = two_boxes();
+ run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "body_name": "C"}));
+ for p in [
+ json!({}),
+ json!({"a": "A"}),
+ json!({"a": "A", "b": "A"}),
+ json!({"a": "A", "b": "nope"}),
+ json!({"a": "A", "b": 3}),
+ json!({"a": "A", "b": "C", "tolerance": 0}),
+ json!({"a": "A", "b": "C", "tolerance": -1}),
+ json!({"a": "A", "b": "C", "tolerance": "a lot"}),
+ json!({"a": "A", "b": "C", "tolerance": 1e300}),
+ json!({"a": "A", "b": "C", "spacing": 0}),
+ json!({"a": "A", "b": "C", "max_regions": 0}),
+ json!({"a": "A", "b": "C", "max_points": 10}),
+ json!({"a": "A", "b": "C", "color": "blue"}),
+ json!({"a": "A", "b": "C", "color": {"only_in_a": "#12345"}}),
+ ] {
+ assert!(s.execute("inspect.compare", &p).is_err(), "{p}");
+ }
+ // Two selected bodies are the pair.
+ s.selection = vec![crate::Sel::Body { name: "A".into() }, crate::Sel::Body { name: "C".into() }];
+ let r = run(&mut s, "inspect.compare", json!({}));
+ assert_eq!(r["a"]["name"], "A");
+ assert_eq!(r["b"]["name"], "C");
+ assert_eq!(r["only_in_a"]["regions"], 1, "{r}");
+ assert!(close(f(&r["only_in_a"]["volume_mm3"]), 12_000.0 - 125.0, 0.01), "{r}");
+ assert!(r["verdict"].as_str().unwrap_or_default().starts_with("1 region differs by more than 0.01 mm"), "{}", r["verdict"]);
+}
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index c4d2d0c201..18c3f10311 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -22,6 +22,7 @@ macro_rules! planned {
mod browser;
mod clipboard;
+mod compare;
mod component;
mod component_clone;
mod component_clone_assembly;
@@ -256,6 +257,7 @@ pub fn command_specs() -> Vec<&'static CommandSpec> {
v.extend(file::COMMANDS.iter());
v.extend(metadata::COMMANDS.iter());
v.extend(inspect::COMMANDS.iter());
+ v.extend(compare::COMMANDS.iter());
v.extend(materials::COMMANDS.iter());
v.extend(material_properties::COMMANDS.iter());
v.extend(libraries::COMMANDS.iter());
diff --git a/crates/geom/src/compare.rs b/crates/geom/src/compare.rs
new file mode 100644
index 0000000000..e79995790e
--- /dev/null
+++ b/crates/geom/src/compare.rs
@@ -0,0 +1,927 @@
+//! Comparing two closed triangle meshes without a boolean of the two: how far each surface strays
+//! from the other, and the places where only one of them has material.
+//!
+//! Each surface is sampled: the corners of its triangles, and inside the larger ones the corners
+//! and centres of pieces at most `spacing` across. Every sample measures its distance to the other
+//! surface (a [`TriangleTree`] over the other's triangles). Samples further away than the
+//! tolerance are the deviating surface. One that lies outside the other mesh bounds material
+//! only its own mesh has; one inside it bounds material only the other mesh has. The deviating
+//! samples are clustered by distance into regions, and each region's volume is integrated along
+//! a grid of parallel lines through its box: on each line, the stretches inside one mesh and
+//! outside the other, found from where the line crosses the two surfaces. Nothing here
+//! intersects the two surfaces, so bodies that share almost every face (two versions of one
+//! part) compare as well as any others.
+
+use std::collections::{HashMap, HashSet};
+use std::sync::OnceLock;
+
+use crate::{Aabb3, Mesh, Vec3};
+
+/// Runs a job for every index below `n`: the jobs are independent, so any order and any number
+/// of threads will do. [`serial`] runs them one after another; a caller with threads passes one
+/// that spreads them. A job that did not run (it panicked on another thread) runs again on the
+/// calling thread.
+pub type Each<'a> = &'a (dyn Fn(usize, &(dyn Fn(usize) + Sync)) + Sync);
+
+/// [`Each`] on the calling thread.
+pub fn serial(n: usize, job: &(dyn Fn(usize) + Sync)) {
+ (0..n).for_each(job);
+}
+
+/// How [`compare`] samples and measures.
+#[derive(Clone, Copy, Debug)]
+pub struct CompareOptions {
+ /// Distances up to this are agreement (mm).
+ pub tolerance: f64,
+ /// The largest size of the pieces a triangle is sampled in (mm); raised when a mesh would
+ /// need more than `max_points` samples.
+ pub spacing: f64,
+ /// Sample points per mesh, about (a mesh of more triangles than two thirds of this is
+ /// sampled once per triangle, at its centre and corners, anyway).
+ pub max_points: usize,
+ /// Lines through a region for its volume, at most.
+ pub max_lines: usize,
+ /// Regions measured and listed, largest first; the rest are counted in
+ /// [`Comparison::unlisted`].
+ pub max_regions: usize,
+}
+
+impl Default for CompareOptions {
+ fn default() -> Self {
+ CompareOptions { tolerance: 0.01, spacing: 0.5, max_points: 8_000_000, max_lines: 40_000, max_regions: 50 }
+ }
+}
+
+/// Which mesh has the material of a region.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Side {
+ /// Material of `a` where `b` has none.
+ OnlyInA,
+ /// Material of `b` where `a` has none.
+ OnlyInB,
+}
+
+/// How far one mesh's surface lies from the other's, over its samples.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Deviation {
+ /// The largest distance (mm) and the sample where it was found.
+ pub max: f64,
+ pub at: Vec3,
+ /// The mean distance, weighted by the surface each sample stands for (mm).
+ pub mean: f64,
+ /// The surface further than the tolerance from the other mesh, and all of it (mm²).
+ pub beyond_area: f64,
+ pub area: f64,
+ /// Sample points measured.
+ pub points: usize,
+}
+
+/// The lines a region's volume was integrated along.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Lines {
+ /// The lines run along this axis (0 = X, 1 = Y, 2 = Z): the region box's shortest.
+ pub axis: usize,
+ /// Distance between neighbouring lines across the axis, along the next two axes in turn
+ /// (for Z: X, then Y) (mm).
+ pub spacing: [f64; 2],
+ pub count: usize,
+ /// Lines left out because they crossed a mesh an odd number of times (a gap in it).
+ pub skipped: usize,
+}
+
+/// A place where only one mesh has material.
+#[derive(Clone, Debug)]
+pub struct Region {
+ pub side: Side,
+ /// The volume of the material only one mesh has here, integrated along [`Region::lines`]
+ /// (mm³; NaN when it would take too long to measure).
+ pub volume: f64,
+ /// That volume's centre and box; the deviating surface's when the lines found none.
+ pub center: Vec3,
+ pub bbox: Aabb3,
+ /// The deviating surface of each mesh here (mm²).
+ pub area_a: f64,
+ pub area_b: f64,
+ /// The largest distance between the surfaces here (mm), and where.
+ pub max_deviation: f64,
+ pub at: Vec3,
+ /// The faces (the meshes' `tri_face` ids) the deviating surface lies on, each with its
+ /// deviating area here (mm²); [`Comparison::face_area`] has each face's whole area.
+ pub faces_a: Vec<(u32, f64)>,
+ pub faces_b: Vec<(u32, f64)>,
+ pub lines: Lines,
+}
+
+/// What [`compare`] found.
+#[derive(Clone, Debug, Default)]
+pub struct Comparison {
+ pub a_to_b: Deviation,
+ pub b_to_a: Deviation,
+ /// Largest volume first.
+ pub regions: Vec<Region>,
+ /// Regions found beyond [`CompareOptions::max_regions`] (not measured).
+ pub unlisted: usize,
+ /// The sample spacing used (mm).
+ pub spacing: f64,
+ /// The sampled area of each face of `a` and of `b`, by `tri_face` id (mm²).
+ pub face_area: [HashMap<u32, f64>; 2],
+}
+
+/// The point of triangle `abc` nearest `p` (Ericson, Real-Time Collision Detection, 5.1.5).
+pub fn closest_on_triangle(p: Vec3, a: Vec3, b: Vec3, c: Vec3) -> Vec3 {
+ let (ab, ac, ap) = (b - a, c - a, p - a);
+ let (d1, d2) = (ab.dot(ap), ac.dot(ap));
+ if d1 <= 0.0 && d2 <= 0.0 {
+ return a;
+ }
+ let bp = p - b;
+ let (d3, d4) = (ab.dot(bp), ac.dot(bp));
+ if d3 >= 0.0 && d4 <= d3 {
+ return b;
+ }
+ let vc = d1 * d4 - d3 * d2;
+ if vc <= 0.0 && d1 >= 0.0 && d3 <= 0.0 {
+ let den = d1 - d3;
+ return if den > 0.0 { a + ab * (d1 / den) } else { a };
+ }
+ let cp = p - c;
+ let (d5, d6) = (ab.dot(cp), ac.dot(cp));
+ if d6 >= 0.0 && d5 <= d6 {
+ return c;
+ }
+ let vb = d5 * d2 - d1 * d6;
+ if vb <= 0.0 && d2 >= 0.0 && d6 <= 0.0 {
+ let den = d2 - d6;
+ return if den > 0.0 { a + ac * (d2 / den) } else { a };
+ }
+ let va = d3 * d6 - d5 * d4;
+ if va <= 0.0 && (d4 - d3) >= 0.0 && (d5 - d6) >= 0.0 {
+ let den = (d4 - d3) + (d5 - d6);
+ return if den > 0.0 { b + (c - b) * ((d4 - d3) / den) } else { b };
+ }
+ let den = va + vb + vc;
+ if den.abs() < 1e-300 {
+ return a;
+ }
+ a + ab * (vb / den) + ac * (vc / den)
+}
+
+fn comp(v: Vec3, k: usize) -> f64 {
+ match k {
+ 0 => v.x,
+ 1 => v.y,
+ _ => v.z,
+ }
+}
+
+/// The point with coordinate `ck` on axis `k`, and `cu`, `cv` on the next two axes in turn.
+fn from_axes(k: usize, cu: f64, cv: f64, ck: f64) -> Vec3 {
+ match k {
+ 0 => Vec3::new(ck, cu, cv),
+ 1 => Vec3::new(cv, ck, cu),
+ _ => Vec3::new(cu, cv, ck),
+ }
+}
+
+fn box_of(t: &[Vec3; 3]) -> Aabb3 {
+ let mut b = Aabb3::EMPTY;
+ t.iter().for_each(|p| b.add(*p));
+ b
+}
+
+/// Squared distance from `p` to the box (0 inside it).
+fn box_dist2(b: &Aabb3, p: Vec3) -> f64 {
+ (b.min - p).max(p - b.max).max(Vec3::ZERO).len2()
+}
+
+/// Do the boxes overlap on every axis but `skip` (none when `skip > 2`)?
+fn boxes_meet(a: &Aabb3, b: &Aabb3, skip: usize) -> bool {
+ (0..3).filter(|&k| k != skip).all(|k| comp(a.min, k) <= comp(b.max, k) && comp(b.min, k) <= comp(a.max, k))
+}
+
+/// Triangles in a leaf of [`TriangleTree`], at most (unless they all share a centre).
+const LEAF: usize = 4;
+
+/// A bounding-volume hierarchy over a mesh's triangles: the nearest point of the surface, and
+/// the triangles a line can cross.
+pub struct TriangleTree {
+ /// The mesh's triangles with finite corners, in tree order.
+ tris: Vec<[Vec3; 3]>,
+ /// Each one's index in the mesh.
+ ids: Vec<u32>,
+ nodes: Vec<Node>,
+}
+
+#[derive(Clone, Copy)]
+struct Node {
+ bbox: Aabb3,
+ /// A leaf holds `tris[a..b]`; an inner node has the children `a` and `b`.
+ a: u32,
+ b: u32,
+ leaf: bool,
+}
+
+impl TriangleTree {
+ pub fn new(mesh: &Mesh) -> TriangleTree {
+ let mut tris = Vec::with_capacity(mesh.triangles.len());
+ let mut ids = Vec::with_capacity(mesh.triangles.len());
+ for (i, t) in mesh.triangles.iter().enumerate() {
+ if let (Some(tri), Ok(i)) = (mesh.tri(t), u32::try_from(i))
+ && tri.iter().all(|p| p.is_finite())
+ {
+ tris.push(tri);
+ ids.push(i);
+ }
+ }
+ let centres: Vec<Vec3> = tris.iter().map(|t| (t[0] + t[1] + t[2]) / 3.0).collect();
+ let mut order: Vec<u32> = (0..u32::try_from(tris.len()).unwrap_or(u32::MAX)).collect();
+ let n = order.len();
+ let empty = Node { bbox: Aabb3::EMPTY, a: 0, b: 0, leaf: true };
+ let mut nodes = vec![empty];
+ let mut work = vec![(0usize, 0usize, n)];
+ while let Some((ni, lo, hi)) = work.pop() {
+ let Some(range) = order.get_mut(lo..hi) else { continue };
+ let (mut bbox, mut cb) = (Aabb3::EMPTY, Aabb3::EMPTY);
+ for &i in range.iter() {
+ if let (Some(t), Some(c)) = (tris.get(i as usize), centres.get(i as usize)) {
+ bbox = bbox.union(&box_of(t));
+ cb.add(*c);
+ }
+ }
+ let size = cb.size();
+ let axis = if size.x >= size.y && size.x >= size.z {
+ 0
+ } else if size.y >= size.z {
+ 1
+ } else {
+ 2
+ };
+ let node = if hi - lo <= LEAF || comp(size, axis) <= 0.0 {
+ Node { bbox, a: lo as u32, b: hi as u32, leaf: true }
+ } else {
+ let mid = (hi - lo) / 2;
+ range.select_nth_unstable_by(mid, |x, y| {
+ let c = |i: &u32| centres.get(*i as usize).map_or(0.0, |c| comp(*c, axis));
+ c(x).total_cmp(&c(y))
+ });
+ let (left, right) = (nodes.len(), nodes.len() + 1);
+ nodes.push(empty);
+ nodes.push(empty);
+ work.push((left, lo, lo + mid));
+ work.push((right, lo + mid, hi));
+ Node { bbox, a: left as u32, b: right as u32, leaf: false }
+ };
+ if let Some(slot) = nodes.get_mut(ni) {
+ *slot = node;
+ }
+ }
+ let tris_in_order = order.iter().filter_map(|&i| tris.get(i as usize).copied()).collect();
+ let ids_in_order = order.iter().filter_map(|&i| ids.get(i as usize).copied()).collect();
+ TriangleTree { tris: tris_in_order, ids: ids_in_order, nodes }
+ }
+
+ pub fn len(&self) -> usize {
+ self.tris.len()
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.tris.is_empty()
+ }
+
+ /// The distance from `p` to the nearest point of the surface, and the index in the mesh of
+ /// the triangle it lies on (`None` for an empty mesh or a point that isn't finite).
+ pub fn nearest(&self, p: Vec3) -> Option<(f64, u32)> {
+ if !p.is_finite() || self.tris.is_empty() {
+ return None;
+ }
+ let (mut best2, mut hit) = (f64::INFINITY, None);
+ let mut stack: Vec<u32> = Vec::with_capacity(64);
+ stack.push(0);
+ while let Some(ni) = stack.pop() {
+ let Some(node) = self.nodes.get(ni as usize) else { continue };
+ if box_dist2(&node.bbox, p) >= best2 {
+ continue;
+ }
+ if node.leaf {
+ for k in node.a..node.b {
+ let Some([a, b, c]) = self.tris.get(k as usize).copied() else { continue };
+ let d2 = (closest_on_triangle(p, a, b, c) - p).len2();
+ if d2 < best2 {
+ best2 = d2;
+ hit = self.ids.get(k as usize).copied();
+ }
+ }
+ continue;
+ }
+ let d = |i: u32| self.nodes.get(i as usize).map_or(f64::INFINITY, |n| box_dist2(&n.bbox, p));
+ let (da, db) = (d(node.a), d(node.b));
+ // The nearer child is searched first (pushed last).
+ let (near, far, dn, df) = if da <= db { (node.a, node.b, da, db) } else { (node.b, node.a, db, da) };
+ if df < best2 {
+ stack.push(far);
+ }
+ if dn < best2 {
+ stack.push(near);
+ }
+ }
+ hit.map(|i| (best2.sqrt(), i))
+ }
+
+ /// Every triangle (by its place in the tree) whose box overlaps `bx` on the two axes other
+ /// than `axis`: the triangles a line along `axis` through `bx` can cross.
+ fn column(&self, bx: &Aabb3, axis: usize) -> Vec<usize> {
+ let mut out = Vec::new();
+ let mut stack: Vec<u32> = if self.tris.is_empty() { Vec::new() } else { vec![0] };
+ while let Some(ni) = stack.pop() {
+ let Some(node) = self.nodes.get(ni as usize) else { continue };
+ if !boxes_meet(&node.bbox, bx, axis) {
+ continue;
+ }
+ if node.leaf {
+ out.extend((node.a..node.b).map(|k| k as usize).filter(|&k| self.tris.get(k).is_some_and(|t| boxes_meet(&box_of(t), bx, axis))));
+ } else {
+ stack.push(node.a);
+ stack.push(node.b);
+ }
+ }
+ out
+ }
+}
+
+fn longest_edge(t: &[Vec3; 3]) -> f64 {
+ t[0].dist(t[1]).max(t[1].dist(t[2])).max(t[2].dist(t[0]))
+}
+
+/// Pieces one triangle is sampled in, at most.
+const MAX_PIECES: usize = 1 << 22;
+
+/// About how many pieces [`for_each_sample`] cuts the triangle into.
+fn pieces_estimate(t: &[Vec3; 3], h: f64) -> f64 {
+ let l = longest_edge(t);
+ if !(l > h) {
+ return 1.0;
+ }
+ let area = (t[1] - t[0]).cross(t[2] - t[0]).len() * 0.5;
+ (4.0 * area / (h * h)).max(2.0 * l / h).clamp(1.0, MAX_PIECES as f64)
+}
+
+/// Calls `f` with every sample point of the triangle and the area it stands for. The triangle is
+/// halved across its longest side until every piece's sides are at most `h` long; the centre of
+/// each piece stands for the piece, its corners (which find what lies along the edges) for none.
+fn for_each_sample(t: &[Vec3; 3], h: f64, stack: &mut Vec<[Vec3; 3]>, mut f: impl FnMut(Vec3, f64)) {
+ stack.clear();
+ stack.push(*t);
+ let mut pieces = 0usize;
+ while let Some([a, b, c]) = stack.pop() {
+ let (lab, lbc, lca) = (a.dist(b), b.dist(c), c.dist(a));
+ let l = lab.max(lbc).max(lca);
+ pieces += 1;
+ if !(l > h) || pieces + stack.len() >= MAX_PIECES {
+ for p in [a, b, c] {
+ f(p, 0.0);
+ }
+ f((a + b + c) / 3.0, (b - a).cross(c - a).len() * 0.5);
+ continue;
+ }
+ // Midpoints are computed from the same two corners on both sides of an inner edge, so
+ // the pieces either side share them exactly.
+ if lab >= lbc && lab >= lca {
+ let m = (a + b) * 0.5;
+ stack.push([a, m, c]);
+ stack.push([m, b, c]);
+ } else if lbc >= lca {
+ let m = (b + c) * 0.5;
+ stack.push([a, b, m]);
+ stack.push([a, m, c]);
+ } else {
+ let m = (c + a) * 0.5;
+ stack.push([a, b, m]);
+ stack.push([m, b, c]);
+ }
+ }
+}
+
+/// The spacing at which `mesh` needs about `max` sample points (at least `want`; a mesh whose
+/// triangles alone need more gets one piece per triangle).
+fn spacing_for(mesh: &Mesh, want: f64, max: usize) -> f64 {
+ let tris: Vec<[Vec3; 3]> = mesh.triangles.iter().filter_map(|t| mesh.tri(t)).filter(|t| t.iter().all(|p| p.is_finite())).collect();
+ // Every piece is sampled at its centre and its corners, each corner once: a triangulated
+ // surface has about half as many corners as triangles, so 1.5 samples a piece.
+ let fewest = 1.5 * tris.len() as f64;
+ let max = max.max(1) as f64;
+ let coarser = |h: f64, total: f64| h * (total / max).sqrt() * 1.02;
+ let mut h = if want.is_finite() && want > 0.0 { want } else { 1.0 };
+ // A spacing known to need too many, to close in on from above.
+ let mut over = None;
+ // First from the estimate, cheaply; then from the exact count, which the estimate can be
+ // a few times under (long thin triangles, the halving's steps).
+ for _ in 0..40 {
+ let total = tris.iter().map(|t| 1.5 * pieces_estimate(t, h)).sum::<f64>();
+ if total <= max || total <= fewest * 1.001 {
+ break;
+ }
+ over = Some(h);
+ h = coarser(h, total);
+ }
+ let mut stack = Vec::new();
+ let mut count = |h: f64| {
+ let mut pieces = 0usize;
+ for t in &tris {
+ for_each_sample(t, h, &mut stack, |_, w| pieces += usize::from(w > 0.0));
+ }
+ 1.5 * pieces as f64
+ };
+ let mut total = count(h);
+ for _ in 0..12 {
+ if total <= max || total <= fewest * 1.001 {
+ break;
+ }
+ over = Some(h);
+ h = coarser(h, total);
+ total = count(h);
+ }
+ // The count falls in steps (each halving doubles a triangle's pieces), so the last step may
+ // have gone a step too far: the finest spacing within the budget lies between.
+ if let Some(mut lo) = over.filter(|_| total <= max) {
+ for _ in 0..10 {
+ let mid = (lo * h).sqrt();
+ if count(mid) <= max {
+ h = mid;
+ } else {
+ lo = mid;
+ }
+ }
+ }
+ h
+}
+
+/// Triangles one job samples.
+const CHUNK: usize = 1024;
+
+/// A sample further than the tolerance from the other surface.
+#[derive(Clone, Copy)]
+struct Off {
+ p: Vec3,
+ d: f64,
+ w: f64,
+ face: u32,
+}
+
+#[derive(Default)]
+struct Part {
+ max: f64,
+ at: Vec3,
+ sum: f64,
+ weight: f64,
+ beyond: f64,
+ points: usize,
+ off: Vec<Off>,
+ face_area: HashMap<u32, f64>,
+}
+
+/// Runs `job` for every index below `n` through `each` and returns the results in order.
+fn gather<T: Send + Sync>(n: usize, each: Each, job: impl Fn(usize) -> T + Sync) -> Vec<T> {
+ let slots: Vec<OnceLock<T>> = (0..n).map(|_| OnceLock::new()).collect();
+ each(n, &|i| {
+ if let Some(slot) = slots.get(i) {
+ let _ = slot.set(job(i));
+ }
+ });
+ slots.into_iter().enumerate().map(|(i, s)| s.into_inner().unwrap_or_else(|| job(i))).collect()
+}
+
+/// How far the samples of `from` lie from the surface in `to` (distances capped at `cap`).
+fn deviate(from: &Mesh, to: &TriangleTree, h: f64, tol: f64, cap: f64, each: Each) -> Part {
+ let n = from.triangles.len();
+ let parts = gather(n.div_ceil(CHUNK), each, |k| {
+ let mut part = Part::default();
+ let mut seen: HashSet<[u64; 3]> = HashSet::new();
+ let mut stack = Vec::new();
+ for ti in k * CHUNK..((k + 1) * CHUNK).min(n) {
+ let Some(t) = from.triangles.get(ti).and_then(|t| from.tri(t)) else { continue };
+ if !t.iter().all(|p| p.is_finite()) {
+ continue;
+ }
+ let face = from.tri_face.get(ti).copied().unwrap_or(0);
+ for_each_sample(&t, h, &mut stack, |p, w| {
+ // A corner is shared by the pieces around it: measured once.
+ if w == 0.0 && !seen.insert([p.x.to_bits(), p.y.to_bits(), p.z.to_bits()]) {
+ return;
+ }
+ let d = to.nearest(p).map_or(cap, |(d, _)| d.min(cap));
+ part.points += 1;
+ if w > 0.0 {
+ *part.face_area.entry(face).or_default() += w;
+ }
+ part.sum += w * d;
+ part.weight += w;
+ if d > part.max {
+ part.max = d;
+ part.at = p;
+ }
+ if d > tol {
+ part.beyond += w;
+ part.off.push(Off { p, d, w, face });
+ }
+ });
+ }
+ part
+ });
+ let mut all = Part::default();
+ for p in parts {
+ if p.max > all.max {
+ all.max = p.max;
+ all.at = p.at;
+ }
+ all.sum += p.sum;
+ all.weight += p.weight;
+ all.beyond += p.beyond;
+ all.points += p.points;
+ all.off.extend(p.off);
+ for (f, w) in p.face_area {
+ *all.face_area.entry(f).or_default() += w;
+ }
+ }
+ all
+}
+
+fn deviation(p: &Part) -> Deviation {
+ Deviation {
+ max: p.max,
+ at: p.at,
+ mean: if p.weight > 0.0 { p.sum / p.weight } else { 0.0 },
+ beyond_area: p.beyond,
+ area: p.weight,
+ points: p.points,
+ }
+}
+
+/// Deviating samples kept for the regions, at most (beyond it, every k-th, standing for k).
+const MAX_OFF: usize = 4_000_000;
+
+/// A deviating sample and the side of the material it bounds.
+#[derive(Clone, Copy)]
+struct Pt {
+ off: Off,
+ from_a: bool,
+ side: Side,
+}
+
+/// The deviating samples of `from` with their sides: outside the other mesh, they bound
+/// material only `from` has; inside it, material only the other has.
+fn sided(mut off: Vec<Off>, other: &Mesh, from_a: bool, each: Each) -> Vec<Pt> {
+ if off.len() > MAX_OFF {
+ let k = off.len().div_ceil(MAX_OFF);
+ off = off.into_iter().step_by(k).map(|o| Off { w: o.w * k as f64, ..o }).collect();
+ }
+ if off.is_empty() {
+ return Vec::new();
+ }
+ let inside = other.inside_index();
+ let off = &off;
+ let parts = gather(off.len().div_ceil(CHUNK), each, |k| {
+ off.iter()
+ .skip(k * CHUNK)
+ .take(CHUNK)
+ .map(|o| {
+ let within = inside.contains(o.p);
+ let side = if within == from_a { Side::OnlyInB } else { Side::OnlyInA };
+ Pt { off: *o, from_a, side }
+ })
+ .collect::<Vec<_>>()
+ });
+ parts.into_iter().flatten().collect()
+}
+
+fn find(parent: &mut [usize], mut i: usize) -> usize {
+ for _ in 0..parent.len() {
+ let Some(&p) = parent.get(i) else { return i };
+ if p == i {
+ return i;
+ }
+ let gp = parent.get(p).copied().unwrap_or(p);
+ if let Some(slot) = parent.get_mut(i) {
+ *slot = gp;
+ }
+ i = gp;
+ }
+ i
+}
+
+fn union(parent: &mut [usize], a: usize, b: usize) -> bool {
+ let (ra, rb) = (find(parent, a), find(parent, b));
+ if ra == rb {
+ return false;
+ }
+ if let Some(slot) = parent.get_mut(ra.max(rb)) {
+ *slot = ra.min(rb);
+ }
+ true
+}
+
+/// Groups of samples (indices into `pts`), one side each: samples in the same or neighbouring
+/// cells of a grid of `cell` join, and so do groups of one side whose boxes, grown by `cell`,
+/// overlap (so that no two regions measure the same material).
+fn clusters(pts: &[Pt], cell: f64) -> Vec<Vec<usize>> {
+ let key = |p: Vec3| ((p.x / cell).floor() as i64, (p.y / cell).floor() as i64, (p.z / cell).floor() as i64);
+ let mut cells: HashMap<(bool, i64, i64, i64), usize> = HashMap::new();
+ let mut of_point = Vec::with_capacity(pts.len());
+ for pt in pts {
+ let (x, y, z) = key(pt.off.p);
+ let next = cells.len();
+ of_point.push(*cells.entry((pt.side == Side::OnlyInA, x, y, z)).or_insert(next));
+ }
+ let mut parent: Vec<usize> = (0..cells.len()).collect();
+ for (&(s, x, y, z), &id) in &cells {
+ for dx in -1..=1 {
+ for dy in -1..=1 {
+ for dz in -1..=1 {
+ if let Some(&o) = cells.get(&(s, x + dx, y + dy, z + dz)) {
+ union(&mut parent, id, o);
+ }
+ }
+ }
+ }
+ }
+ let groups_of = |parent: &mut [usize]| -> Vec<usize> { of_point.iter().map(|&c| find(parent, c)).collect() };
+ let grow = Vec3::new(cell, cell, cell);
+ // Join groups of one side whose grown boxes overlap, until none do (sort and sweep along X).
+ for _ in 0..16 {
+ let groups = groups_of(&mut parent);
+ let mut boxes: HashMap<usize, (Side, Aabb3)> = HashMap::new();
+ for (pt, g) in pts.iter().zip(&groups) {
+ boxes.entry(*g).or_insert((pt.side, Aabb3::EMPTY)).1.add(pt.off.p);
+ }
+ let mut list: Vec<(usize, Side, Aabb3)> =
+ boxes.into_iter().map(|(g, (s, b))| (g, s, Aabb3 { min: b.min - grow, max: b.max + grow })).collect();
+ list.sort_by(|a, b| a.2.min.x.total_cmp(&b.2.min.x).then(a.0.cmp(&b.0)));
+ let mut joined = false;
+ for (k, (ga, sa, ba)) in list.iter().enumerate() {
+ for (gb, sb, bb) in list.iter().skip(k + 1) {
+ if bb.min.x > ba.max.x {
+ break;
+ }
+ if sa == sb && boxes_meet(ba, bb, 3) {
+ joined |= union(&mut parent, *ga, *gb);
+ }
+ }
+ }
+ if !joined {
+ break;
+ }
+ }
+ let mut by: HashMap<usize, Vec<usize>> = HashMap::new();
+ for (i, g) in groups_of(&mut parent).into_iter().enumerate() {
+ by.entry(g).or_default().push(i);
+ }
+ let mut out: Vec<Vec<usize>> = by.into_values().collect();
+ out.sort_by_key(|g| g.first().copied().unwrap_or(0));
+ out
+}
+
+/// Line and triangle pairs tested for one region, at most; beyond it, its volume is not measured.
+const MAX_LINE_WORK: usize = 200_000_000;
+
+/// Where the lines lie in their cells, across the axis (off the middle, so that lines through
+/// the edges and corners of a mesh are rare).
+const LINE_OFFSET: [f64; 2] = [0.513_72, 0.527_18];
+
+/// The volume of the material only `side`'s mesh has inside `bx`, from lines along the box's
+/// shortest axis: (volume, centre, box, lines), or `None` when that would take too much work.
+fn region_volume(trees: [&TriangleTree; 2], bx: &Aabb3, side: Side, max_lines: usize) -> Option<(f64, Vec3, Aabb3, Lines)> {
+ let size = bx.size();
+ let k = if size.x <= size.y && size.x <= size.z {
+ 0
+ } else if size.y <= size.z {
+ 1
+ } else {
+ 2
+ };
+ let (ku, kv) = ((k + 1) % 3, (k + 2) % 3);
+ let (eu, ev) = (comp(size, ku), comp(size, kv));
+ let max_lines = max_lines.max(1);
+ let ds = (eu * ev / max_lines as f64).sqrt();
+ let count = |e: f64| if ds > 0.0 && ds.is_finite() { (e / ds).ceil().clamp(1.0, max_lines as f64) as usize } else { 1 };
+ let (nu, nv) = (count(eu), count(ev));
+ let (du, dv) = (eu / nu as f64, ev / nv as f64);
+ let (u0, v0, t0, t1) = (comp(bx.min, ku), comp(bx.min, kv), comp(bx.min, k), comp(bx.max, k));
+ let line_u = |i: usize| u0 + (i as f64 + LINE_OFFSET[0]) * du;
+ let line_v = |j: usize| v0 + (j as f64 + LINE_OFFSET[1]) * dv;
+ // The lines whose positions fall in [lo, hi].
+ let span = |lo: f64, hi: f64, origin: f64, step: f64, offset: f64, n: usize| -> Option<(usize, usize)> {
+ if !(step > 0.0) {
+ return Some((0, 0));
+ }
+ let a = ((lo - origin) / step - offset).ceil().max(0.0);
+ let b = ((hi - origin) / step - offset).floor().min(n as f64 - 1.0);
+ (a <= b).then_some((a as usize, b as usize))
+ };
+ // Where each line crosses each mesh: (line, coordinate along the axis, +1 in / -1 out, mesh).
+ let mut hits: Vec<(u32, f64, i8, u8)> = Vec::new();
+ let mut work = 0usize;
+ for (m, tree) in trees.iter().enumerate() {
+ for ti in tree.column(bx, k) {
+ let Some(t) = tree.tris.get(ti) else { continue };
+ let nk = comp((t[1] - t[0]).cross(t[2] - t[0]), k);
+ if nk == 0.0 || !nk.is_finite() {
+ continue;
+ }
+ // Lines run towards +axis: they enter where the outward normal points against them.
+ let sign: i8 = if nk < 0.0 { 1 } else { -1 };
+ let tb = box_of(t);
+ let (Some((i0, i1)), Some((j0, j1))) = (
+ span(comp(tb.min, ku), comp(tb.max, ku), u0, du, LINE_OFFSET[0], nu),
+ span(comp(tb.min, kv), comp(tb.max, kv), v0, dv, LINE_OFFSET[1], nv),
+ ) else {
+ continue;
+ };
+ work = work.saturating_add((i1 - i0 + 1).saturating_mul(j1 - j0 + 1));
+ if work > MAX_LINE_WORK {
+ return None;
+ }
+ for i in i0..=i1 {
+ let pu = line_u(i);
+ for j in j0..=j1 {
+ let pv = line_v(j);
+ // Watertight edge tests (Woop, Benthin & Wald, JCGT 2013) in the plane across
+ // the axis: two triangles get exactly opposite values on the edge they share.
+ let at = |p: Vec3| (comp(p, ku) - pu, comp(p, kv) - pv);
+ let ((ax, ay), (bx2, by), (cx, cy)) = (at(t[0]), at(t[1]), at(t[2]));
+ let u = cx * by - cy * bx2;
+ let v = ax * cy - ay * cx;
+ let w = bx2 * ay - by * ax;
+ if (u < 0.0 || v < 0.0 || w < 0.0) && (u > 0.0 || v > 0.0 || w > 0.0) {
+ continue;
+ }
+ let det = u + v + w;
+ if det == 0.0 {
+ continue;
+ }
+ let along = (u * comp(t[0], k) + v * comp(t[1], k) + w * comp(t[2], k)) / det;
+ if let (true, Ok(line)) = (along.is_finite(), u32::try_from(i * nv + j)) {
+ hits.push((line, along, sign, m as u8));
+ }
+ }
+ }
+ }
+ }
+ hits.sort_unstable_by(|a, b| a.0.cmp(&b.0).then(a.1.total_cmp(&b.1)));
+ let wanted = |w: [i32; 2]| match side {
+ Side::OnlyInA => w[0] > 0 && w[1] <= 0,
+ Side::OnlyInB => w[1] > 0 && w[0] <= 0,
+ };
+ let (mut length, mut moment, mut found, mut skipped) = (0.0, Vec3::ZERO, Aabb3::EMPTY, 0);
+ let mut pieces: Vec<(f64, f64)> = Vec::new();
+ let mut rest = hits.as_slice();
+ while let Some(first) = rest.first() {
+ let line = first.0;
+ let (this, after) = rest.split_at(rest.iter().take_while(|h| h.0 == line).count());
+ rest = after;
+ let (pu, pv) = (line_u(line as usize / nv), line_v(line as usize % nv));
+ let (mut w, mut last) = ([0i32; 2], [None::<(f64, i8)>; 2]);
+ let mut prev = f64::NEG_INFINITY;
+ pieces.clear();
+ for &(_, along, sign, m) in this {
+ let m = usize::from(m.min(1));
+ // A line through an edge or corner shared by several triangles crosses there once.
+ let eps = 1e-9 * (1.0 + along.abs());
+ if last.get(m).copied().flatten().is_some_and(|(t, s)| s == sign && (along - t).abs() <= eps) {
+ continue;
+ }
+ if wanted(w) {
+ let (s0, s1) = (prev.max(t0), along.min(t1));
+ // Where the two surfaces meet, rounding leaves pieces of no length between them.
+ if s1 - s0 > 1e-9 * (1.0 + s1.abs()) {
+ pieces.push((s0, s1));
+ }
+ }
+ if let Some(x) = w.get_mut(m) {
+ *x += i32::from(sign);
+ }
+ if let Some(x) = last.get_mut(m) {
+ *x = Some((along, sign));
+ }
+ prev = along;
+ }
+ // A line that leaves a mesh more or less often than it enters passed through a gap.
+ if w != [0, 0] {
+ skipped += 1;
+ continue;
+ }
+ for &(s0, s1) in &pieces {
+ let l = s1 - s0;
+ length += l;
+ moment += from_axes(k, pu, pv, (s0 + s1) * 0.5) * l;
+ found.add(from_axes(k, pu - du * 0.5, pv - dv * 0.5, s0));
+ found.add(from_axes(k, pu + du * 0.5, pv + dv * 0.5, s1));
+ }
+ }
+ let centre = if length > 0.0 { moment / length } else { bx.center() };
+ Some((length * du * dv, centre, found, Lines { axis: k, spacing: [du, dv], count: nu * nv, skipped }))
+}
+
+/// Compare the closed meshes `a` and `b` (in one frame): see the module documentation.
+pub fn compare(a: &Mesh, b: &Mesh, o: &CompareOptions, each: Each) -> Comparison {
+ let tol = if o.tolerance.is_finite() { o.tolerance.max(0.0) } else { 0.01 };
+ let max_points = o.max_points.max(1);
+ let h = spacing_for(a, o.spacing, max_points).max(spacing_for(b, o.spacing, max_points));
+ let cap = a.bounds().union(&b.bounds()).diagonal().max(1.0);
+ let Ok([ta, tb]) = <[TriangleTree; 2]>::try_from(gather(2, each, |i| TriangleTree::new(if i == 0 { a } else { b }))) else {
+ return Comparison::default();
+ };
+ let mut pa = deviate(a, &tb, h, tol, cap, each);
+ let mut pb = deviate(b, &ta, h, tol, cap, each);
+ let (a_to_b, b_to_a) = (deviation(&pa), deviation(&pb));
+ let face_area = [std::mem::take(&mut pa.face_area), std::mem::take(&mut pb.face_area)];
+ let mut pts = sided(pa.off, b, true, each);
+ pts.extend(sided(pb.off, a, false, each));
+ // Samples on one surface are at most `h` apart, and the two surfaces at a region's rim come
+ // within the tolerance of each other: cells of that size keep a region together.
+ let cell = h.max(3.0 * tol).max(1e-6);
+ struct Found {
+ side: Side,
+ area: [f64; 2],
+ bbox: Aabb3,
+ max: f64,
+ at: Vec3,
+ faces: [Vec<(u32, f64)>; 2],
+ weight: f64,
+ }
+ let mut found: Vec<Found> = clusters(&pts, cell)
+ .iter()
+ .filter_map(|g| {
+ let first = pts.get(*g.first()?)?;
+ let mut f = Found {
+ side: first.side,
+ area: [0.0; 2],
+ bbox: Aabb3::EMPTY,
+ max: 0.0,
+ at: first.off.p,
+ faces: [Vec::new(), Vec::new()],
+ weight: 0.0,
+ };
+ let mut faces: [HashMap<u32, f64>; 2] = Default::default();
+ for pt in g.iter().filter_map(|&i| pts.get(i)) {
+ let m = usize::from(!pt.from_a);
+ if let Some(x) = f.area.get_mut(m) {
+ *x += pt.off.w;
+ }
+ if let Some(x) = faces.get_mut(m) {
+ *x.entry(pt.off.face).or_default() += pt.off.w;
+ }
+ f.bbox.add(pt.off.p);
+ f.weight += pt.off.w * pt.off.d;
+ if pt.off.d > f.max {
+ f.max = pt.off.d;
+ f.at = pt.off.p;
+ }
+ }
+ for (to, from) in f.faces.iter_mut().zip(faces) {
+ *to = from.into_iter().collect();
+ to.sort_unstable_by_key(|x| x.0);
+ }
+ Some(f)
+ })
+ .collect();
+ // Which to measure: largest first by the volume the surfaces suggest (area × distance).
+ found.sort_by(|x, y| y.weight.total_cmp(&x.weight).then(y.max.total_cmp(&x.max)));
+ let unlisted = found.len().saturating_sub(o.max_regions);
+ found.truncate(o.max_regions);
+ let grow = Vec3::new(cell, cell, cell);
+ let measured = gather(found.len(), each, |i| {
+ let f = found.get(i)?;
+ region_volume([&ta, &tb], &Aabb3 { min: f.bbox.min - grow, max: f.bbox.max + grow }, f.side, o.max_lines)
+ });
+ let mut regions: Vec<Region> = found
+ .into_iter()
+ .zip(measured)
+ .map(|(f, m)| {
+ let (volume, center, bbox, lines) = match m {
+ Some((v, c, b, l)) if v > 0.0 => (v, c, b, l),
+ Some((v, _, _, l)) => (v, f.bbox.center(), f.bbox, l),
+ None => (f64::NAN, f.bbox.center(), f.bbox, Lines::default()),
+ };
+ let [faces_a, faces_b] = f.faces;
+ Region {
+ side: f.side,
+ volume,
+ center,
+ bbox,
+ area_a: f.area[0],
+ area_b: f.area[1],
+ max_deviation: f.max,
+ at: f.at,
+ faces_a,
+ faces_b,
+ lines,
+ }
+ })
+ .collect();
+ let key = |r: &Region| if r.volume.is_finite() { r.volume } else { -1.0 };
+ regions.sort_by(|x, y| key(y).total_cmp(&key(x)).then(y.max_deviation.total_cmp(&x.max_deviation)));
+ Comparison { a_to_b, b_to_a, regions, unlisted, spacing: h, face_area }
+}
+
+#[cfg(test)]
+#[path = "compare_tests.rs"]
+mod tests;
diff --git a/crates/geom/src/compare_tests.rs b/crates/geom/src/compare_tests.rs
new file mode 100644
index 0000000000..43f65c2738
--- /dev/null
+++ b/crates/geom/src/compare_tests.rs
@@ -0,0 +1,118 @@
+use super::*;
+
+/// An axis-aligned box as a closed mesh (each side two triangles, counter-clockwise from outside).
+fn cuboid(lo: Vec3, hi: Vec3) -> Mesh {
+ let v = |x: bool, y: bool, z: bool| Vec3::new(if x { hi.x } else { lo.x }, if y { hi.y } else { lo.y }, if z { hi.z } else { lo.z });
+ let quads = [
+ [v(false, false, false), v(false, true, false), v(true, true, false), v(true, false, false)],
+ [v(false, false, true), v(true, false, true), v(true, true, true), v(false, true, true)],
+ [v(false, false, false), v(true, false, false), v(true, false, true), v(false, false, true)],
+ [v(false, true, false), v(false, true, true), v(true, true, true), v(true, true, false)],
+ [v(false, false, false), v(false, false, true), v(false, true, true), v(false, true, false)],
+ [v(true, false, false), v(true, true, false), v(true, true, true), v(true, false, true)],
+ ];
+ let mut m = Mesh::default();
+ for (f, q) in quads.iter().enumerate() {
+ let base = m.positions.len() as u32;
+ m.positions.extend_from_slice(q);
+ m.normals.extend_from_slice(&[Vec3::Z; 4]);
+ m.triangles.push([base, base + 1, base + 2]);
+ m.triangles.push([base, base + 2, base + 3]);
+ m.tri_face.extend([f as u32, f as u32]);
+ }
+ m
+}
+
+#[test]
+fn the_tree_finds_the_nearest_point_as_a_search_of_every_triangle_does() {
+ // A crumpled sheet of triangles from a fixed pseudo-random sequence.
+ let mut seed = 12345u64;
+ let mut rnd = || {
+ seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+ (seed >> 11) as f64 / (1u64 << 53) as f64
+ };
+ let mut m = Mesh::default();
+ for _ in 0..500 {
+ let c = Vec3::new(rnd() * 100.0, rnd() * 50.0, rnd() * 20.0);
+ let base = m.positions.len() as u32;
+ for _ in 0..3 {
+ m.positions.push(c + Vec3::new(rnd() * 6.0 - 3.0, rnd() * 6.0 - 3.0, rnd() * 6.0 - 3.0));
+ }
+ m.triangles.push([base, base + 1, base + 2]);
+ }
+ let tree = TriangleTree::new(&m);
+ assert_eq!(tree.len(), 500);
+ for _ in 0..300 {
+ let p = Vec3::new(rnd() * 140.0 - 20.0, rnd() * 90.0 - 20.0, rnd() * 60.0 - 20.0);
+ let brute =
+ m.triangles.iter().filter_map(|t| m.tri(t)).map(|[a, b, c]| closest_on_triangle(p, a, b, c).dist(p)).fold(f64::INFINITY, f64::min);
+ let (d, i) = tree.nearest(p).unwrap();
+ assert!((d - brute).abs() < 1e-12, "{d} vs {brute}");
+ let [a, b, c] = m.tri(&m.triangles[i as usize]).unwrap();
+ assert!((closest_on_triangle(p, a, b, c).dist(p) - d).abs() < 1e-12);
+ }
+ assert!(TriangleTree::new(&Mesh::default()).nearest(Vec3::ZERO).is_none());
+}
+
+#[test]
+fn a_mesh_and_its_copy_are_identical() {
+ let a = cuboid(Vec3::ZERO, Vec3::new(40.0, 30.0, 10.0));
+ let c = compare(&a, &a.clone(), &CompareOptions::default(), &serial);
+ assert!(c.regions.is_empty(), "{:?}", c.regions);
+ // The same triangles: nothing but rounding apart.
+ assert!(c.a_to_b.max < 1e-9 && c.b_to_a.max < 1e-9, "{} {}", c.a_to_b.max, c.b_to_a.max);
+ // Sampled at the requested spacing: the whole surface, and nothing beyond the tolerance.
+ assert!((c.a_to_b.area - 2.0 * (1200.0 + 400.0 + 300.0)).abs() < 1e-6, "{}", c.a_to_b.area);
+ assert_eq!(c.a_to_b.beyond_area, 0.0);
+ assert_eq!(c.spacing, 0.5);
+}
+
+#[test]
+fn a_box_moved_up_has_material_only_it_has_on_top_and_none_below() {
+ // b is a moved 0.3 up: a slab 40 x 30 x 0.3 of each side.
+ let a = cuboid(Vec3::ZERO, Vec3::new(40.0, 30.0, 10.0));
+ let b = cuboid(Vec3::new(0.0, 0.0, 0.3), Vec3::new(40.0, 30.0, 10.3));
+ let c = compare(&a, &b, &CompareOptions::default(), &serial);
+ assert_eq!(c.regions.len(), 2, "{:?}", c.regions);
+ assert!((c.a_to_b.max - 0.3).abs() < 1e-9 && (c.b_to_a.max - 0.3).abs() < 1e-9);
+ for r in &c.regions {
+ // Integrated along lines 0.18 mm apart: the slab's rim falls between them.
+ assert!((r.volume - 360.0).abs() < 360.0 * 0.01, "{r:?}");
+ assert_eq!(r.lines.axis, 2);
+ assert_eq!(r.lines.skipped, 0);
+ let z = if r.side == Side::OnlyInA { 0.15 } else { 10.15 };
+ assert!(r.center.dist(Vec3::new(20.0, 15.0, z)) < 0.1, "{r:?}");
+ assert!((r.bbox.min.z - (z - 0.15)).abs() < 1e-9 && (r.bbox.max.z - (z + 0.15)).abs() < 1e-9, "{r:?}");
+ // Each slab is bounded by the bottom (top) of both meshes, and by the 0.3 mm of the sides
+ // of the one that reaches further, less what lies within the tolerance of the other.
+ let (outer, inner) = if r.side == Side::OnlyInA { (r.area_a, r.area_b) } else { (r.area_b, r.area_a) };
+ assert!((outer - (1200.0 + 140.0 * 0.29)).abs() < 2.0 && (inner - 39.98 * 29.98).abs() < 2.0, "{r:?}");
+ }
+ let sides: Vec<Side> = c.regions.iter().map(|r| r.side).collect();
+ assert!(sides.contains(&Side::OnlyInA) && sides.contains(&Side::OnlyInB));
+}
+
+#[test]
+fn a_box_inside_another_is_material_only_the_outer_one_has() {
+ // No surface of one is near the other's: one region, the shell between them.
+ let a = cuboid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0));
+ let b = cuboid(Vec3::new(5.0, 5.0, 5.0), Vec3::new(15.0, 15.0, 15.0));
+ let c = compare(&a, &b, &CompareOptions::default(), &serial);
+ assert_eq!(c.regions.len(), 1, "{:?}", c.regions);
+ let r = &c.regions[0];
+ assert_eq!(r.side, Side::OnlyInA);
+ assert!((r.volume - 7000.0).abs() < 7000.0 * 0.01, "{}", r.volume);
+ assert!(r.center.dist(Vec3::new(10.0, 10.0, 10.0)) < 1e-2, "{:?}", r.center);
+ assert_eq!(r.faces_a.len(), 6);
+ assert_eq!(r.faces_b.len(), 6);
+}
+
+#[test]
+fn a_tight_budget_coarsens_the_spacing() {
+ let a = cuboid(Vec3::ZERO, Vec3::new(400.0, 300.0, 100.0));
+ let o = CompareOptions { max_points: 20_000, ..CompareOptions::default() };
+ let c = compare(&a, &a, &o, &serial);
+ assert!(c.spacing > 0.5, "{}", c.spacing);
+ assert!((5_000..=24_000).contains(&c.a_to_b.points), "{}", c.a_to_b.points);
+ assert!(c.regions.is_empty());
+}
diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs
index 8a6e3f13f0..21e44948eb 100644
--- a/crates/geom/src/lib.rs
+++ b/crates/geom/src/lib.rs
@@ -11,6 +11,7 @@
mod arcfit;
pub mod brep;
pub mod bspline;
+pub mod compare;
pub mod env;
pub mod fill;
mod mesh;
diff --git a/docs/book/src/guide/features.md b/docs/book/src/guide/features.md
index e6c72b792a..339409f3d1 100644
--- a/docs/book/src/guide/features.md
+++ b/docs/book/src/guide/features.md
@@ -10,7 +10,7 @@ it.
| Create | extrude (one side, two sides, symmetric, taper, start offset, to a distance or through all; new body, join, cut, intersect; thin walls along curves), revolve, sweep, loft, box, cylinder, sphere, torus, coil, pipe, rib, web, emboss, hole (simple, counterbore, countersink, tapped; on faces or at sketch points), thread, rectangular/circular/path patterns, mirror |
| Modify | press pull, fillet, chamfer, shell, draft, scale, combine, split body, offset face, replace face, move/copy, align, remove |
| Construct | offset plane, plane at angle, plane along path |
-| Inspect | measure, section analysis, interference, curvature comb and map, zebra, draft, minimum radius, isocurves, centre of mass |
+| Inspect | measure, section analysis, interference, compare bodies, curvature comb and map, zebra, draft, minimum radius, isocurves, centre of mass |
Extrude automatically selects **Join** for additions when the active component already has a
solid, including sideways elbow connections and screw bosses that meet only part of a face.
@@ -117,6 +117,43 @@ local segment. Preview does not change the design; OK creates one editable timel
The plane follows later path edits. Curved paths use their sampled polyline; absolute distance,
reference-object placement and multi-curve chains are not yet available in this dialog.
+## Comparing two bodies
+
+**Compare Bodies** (`inspect.compare`) lays two versions of one part over each other, such as a
+part and the same part exported by another program, and finds the places where only one of them
+has material. It works from the two surfaces, not from a boolean of the bodies, so it also
+compares bodies that share almost every face, the case a boolean (Combine, Interference) handles
+worst.
+
+```json
+{"command": "inspect.compare", "params": {"a": "Bracket", "b": "Bracket (2)", "tolerance": 0.01, "color": true}}
+```
+
+Without `a` and `b` it compares the two selected bodies, or the design's only two. Both bodies
+are measured (volume, area, centre of mass and box, and `difference`: b − a of each). Each
+surface is sampled at the corners of its triangles and at points at most `spacing` (0.5 mm)
+apart on larger faces, and every sample measures its distance to the other surface: `deviation`
+gives the largest and the mean distance each way. Samples further than `tolerance` (0.01 mm) form
+the **regions**: `only_in_a` where `a` has material and `b` has none, `only_in_b` the other way
+round. Each region gives its volume, the deviating surface area, the largest deviation and where
+it is, its centre and box, and the faces of each body it lies on (`faces_a`, `faces_b`, numbered
+as `model.faces` lists them), largest volume first. The volume is integrated along a grid of
+parallel lines through the region (`resolution` gives their spacing), so a thin sliver is
+measured as well as a block. `identical` is true when no region is found, and `verdict` says it in
+one line. `warnings` lists what makes the result less certain: a body whose surface does not
+enclose the volume it measures (open, or with faces that failed to import), and lines left out of
+a region's volume because they crossed a gap. With `color`, the faces that hold a region turn
+red where only `a` has material and green where only `b` has, on both bodies: the faces mostly
+beyond the tolerance (a small change on a large face leaves the face alone), or, for a region
+with none, the face with the largest share.
+That is one undo step; without `color` the command changes nothing.
+
+The bodies are meshed within a quarter of the tolerance. The kernel meshes no finer than a
+millionth of a body's size, so keep the tolerance at least twice that (0.02 mm for a part 10 m
+across). Large bodies are sampled more coarsely, at about `max_points` (eight million) points
+each; `sampling.spacing_mm` says what was used, and a larger `max_points` (up to 50 million)
+samples them finer, at the cost of time.
+
## Editing a feature from a script
For `solid.pattern.circular`, `axis` accepts `X`, `Y`, `Z`, or `{origin, dir}`.
diff --git a/docs/features.md b/docs/features.md
index 6fbd23099d..3bd8388593 100644
--- a/docs/features.md
+++ b/docs/features.md
@@ -298,7 +298,7 @@ SolidCraft's commands by area, generated by `cargo xtask features` from the comm
| Add Recorded Feature | `timeline.add` | – |
| Export Command Script | `timeline.export_script` | – |
-## Inspect (12, 1 planned)
+## Inspect (13, 1 planned)
| Command | Id | Toolbar |
|---|---|---|
@@ -314,6 +314,7 @@ SolidCraft's commands by area, generated by `cargo xtask features` from the comm
| Continuity Analysis *(planned: [#770](https://github.com/bherbruck/solidcraft/issues/770))* | `inspect.continuity` | SURFACE › INSPECT |
| Interference | `inspect.interference` | SOLID › INSPECT |
| Measure (I) | `inspect.measure` | SOLID › INSPECT |
+| Compare Bodies | `inspect.compare` | – |
| Section Analysis | `inspect.section` | SOLID › INSPECT |
## Files (8)