Skip to content

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

fix: refuse Boolean retries that change the part away from the tool (#616) (#644)

bherbruck29258767ce9d
diff --git a/apps/solidcraft-cli/tests/corpus/README.md b/apps/solidcraft-cli/tests/corpus/README.md
index 5216c111aa..d9266d8b93 100644
--- a/apps/solidcraft-cli/tests/corpus/README.md
+++ b/apps/solidcraft-cli/tests/corpus/README.md
@@ -19,9 +19,10 @@ hostile variants of it never panic.
| `move-bodies` | 00baf1d | `solid.move` before it could copy: two bodies, one translated in place, one translated and turned 90 deg about Z (no `copy` key anywhere in the file) |
| `split-body-pieces` | v0.3.2 (07e263d) | a slot along X cuts a block into two bodies; a fillet, a chamfer and an appearance refer to the pieces by body name (`Body1`, `Body1 (1)`) |
| `issue-489-stacked-join` | v0.6.0 (809ecf7), desktop | a 70 × 84 extrude, then a 70 × 62 strip joined on its top face, sketched partly over the face's projected edges (issue #489; expected values from main at 2880525) |
+| `issue-616-lid-ribs` | v0.7.0 (a9879fa), CLI | a rounded lid with a skirt ring, a window and a slot cut through, then four ribs joined on the plate over the skirt, flush with the window's sides; v0.7.0 displaced the ribs and left a slit through the skirt and plate (issue #616; script `examples/regressions/lid_ribs_flush_with_window.json`, expected values from the fix) |
The scripts that made them are in `scripts/` (`issue-489-stacked-join` was drawn in the desktop
-app and has none). Every flat face of every final body must also take an attached sketch and an
+app and has none; `issue-616-lid-ribs` is made by its regression script). Every flat face of every final body must also take an attached sketch and an
offset plane; the faces that can't yet are listed with their issues in `design_corpus.rs`.
Never regenerate a file with a newer build: the point is that it was written by the old one. Add new files for new eras instead.
diff --git a/apps/solidcraft-cli/tests/corpus/issue-616-lid-ribs.expected.json b/apps/solidcraft-cli/tests/corpus/issue-616-lid-ribs.expected.json
new file mode 100644
index 0000000000..b605b13cd5
--- /dev/null
+++ b/apps/solidcraft-cli/tests/corpus/issue-616-lid-ribs.expected.json
@@ -0,0 +1,227 @@
+{
+ "bodies": [
+ {
+ "area_mm2": 8430.29544246263,
+ "bbox": {
+ "max": [
+ 176.8000000000002,
+ 89.30000000000001,
+ 14.100000000000001
+ ],
+ "min": [
+ 99.99999999999991,
+ -1.820765760385257e-14,
+ 0.0
+ ]
+ },
+ "center_of_mass": [
+ 138.3999999716193,
+ 51.04392591016203,
+ 2.0990634391586322
+ ],
+ "density_g_cm3": 1.29,
+ "edges": 156,
+ "face_types": {
+ "cylinder": 4,
+ "plane": 50
+ },
+ "faces": 54,
+ "kernel": {
+ "edges": 156,
+ "faces": 54,
+ "shells": 1,
+ "vertices": 104
+ },
+ "mass_g": 9.101726874183207,
+ "material": "Default",
+ "name": "Lid",
+ "vertices": 104,
+ "volume_mm3": 7055.602228048997
+ }
+ ],
+ "body_count": 1,
+ "params": [],
+ "sketches": [
+ {
+ "curves": 8,
+ "dof": 8,
+ "id": 3,
+ "name": "Skirt",
+ "profiles": 2,
+ "status": "solved",
+ "visible": false
+ }
+ ],
+ "timeline": [
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 1,
+ "ms": 1.178957,
+ "name": "Box1",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "BoxFeature",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 2,
+ "ms": 83.24342399999999,
+ "name": "Fillet1",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "FilletFeature",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 3,
+ "ms": 0.150889,
+ "name": "Skirt",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "Sketch",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 4,
+ "ms": 94.465481,
+ "name": "Extrude1",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "ExtrudeFeature",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 5,
+ "ms": 50.426736,
+ "name": "Box2",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "BoxFeature",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 6,
+ "ms": 40.383005,
+ "name": "Box3",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "BoxFeature",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 7,
+ "ms": 59.041461000000005,
+ "name": "Box4",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "BoxFeature",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [
+ {
+ "face_shift_mm": 0.0,
+ "rotation_rad": 0.0,
+ "strategy": "planar_fallback",
+ "tolerance_mm": 0.0,
+ "translation_mm": 0.0
+ }
+ ],
+ "truncated": false
+ },
+ "error": null,
+ "id": 8,
+ "ms": 562.5477970000001,
+ "name": "Rib1",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "BoxFeature",
+ "warning": "Boolean retry: exact planar fallback (no displacement)"
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 9,
+ "ms": 89.56076,
+ "name": "Rib2",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "BoxFeature",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 10,
+ "ms": 65.330634,
+ "name": "Rib3",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "BoxFeature",
+ "warning": null
+ },
+ {
+ "boolean_diagnostics": {
+ "events": [],
+ "truncated": false
+ },
+ "error": null,
+ "id": 11,
+ "ms": 97.229403,
+ "name": "Rib4",
+ "rolled_back": false,
+ "suppressed": false,
+ "type": "BoxFeature",
+ "warning": null
+ }
+ ],
+ "total": {
+ "area_mm2": 8430.29544246263,
+ "edges": 156,
+ "faces": 54,
+ "mass_g": 9.101726874183207,
+ "vertices": 104,
+ "volume_mm3": 7055.602228048997
+ }
+}
diff --git a/apps/solidcraft-cli/tests/corpus/issue-616-lid-ribs.solidcraft b/apps/solidcraft-cli/tests/corpus/issue-616-lid-ribs.solidcraft
new file mode 100644
index 0000000000..e2315262e0
--- /dev/null
+++ b/apps/solidcraft-cli/tests/corpus/issue-616-lid-ribs.solidcraft
@@ -0,0 +1,507 @@
+{
+ "features": [
+ {
+ "body_names": [
+ "Lid"
+ ],
+ "corner": [
+ 100.0,
+ 0.0,
+ 0.0
+ ],
+ "height": "2.4",
+ "id": 1,
+ "length": "76.8",
+ "name": "Box1",
+ "operation": "new_body",
+ "param_names": [
+ "d1",
+ "d2",
+ "d3"
+ ],
+ "suppressed": false,
+ "type": "box",
+ "width": "89.3"
+ },
+ {
+ "edge_names": [
+ "F1:-x|F1:-y",
+ "F1:+x|F1:-y",
+ "F1:+y|F1:-x",
+ "F1:+x|F1:+y"
+ ],
+ "edge_refs": [
+ {
+ "dir": [
+ 0.0,
+ 0.0,
+ -1.0
+ ],
+ "max": [
+ 176.8,
+ 89.3,
+ 2.4
+ ],
+ "min": [
+ 100.0,
+ 0.0,
+ 0.0
+ ]
+ },
+ {
+ "dir": [
+ 0.0,
+ 0.0,
+ 1.0
+ ],
+ "max": [
+ 176.8,
+ 89.3,
+ 2.4
+ ],
+ "min": [
+ 100.0,
+ 0.0,
+ 0.0
+ ]
+ },
+ {
+ "dir": [
+ 0.0,
+ 0.0,
+ 1.0
+ ],
+ "max": [
+ 176.8,
+ 89.3,
+ 2.4
+ ],
+ "min": [
+ 100.0,
+ 0.0,
+ 0.0
+ ]
+ },
+ {
+ "dir": [
+ 0.0,
+ 0.0,
+ 1.0
+ ],
+ "max": [
+ 176.8,
+ 89.3,
+ 2.4
+ ],
+ "min": [
+ 100.0,
+ 0.0,
+ 0.0
+ ]
+ }
+ ],
+ "edges": [
+ [
+ 100.0,
+ 0.0,
+ 1.2
+ ],
+ [
+ 176.8,
+ 0.0,
+ 1.2
+ ],
+ [
+ 100.0,
+ 89.3,
+ 1.2
+ ],
+ [
+ 176.8,
+ 89.3,
+ 1.2
+ ]
+ ],
+ "id": 2,
+ "name": "Fillet1",
+ "param_names": [
+ "d4"
+ ],
+ "radius": "3",
+ "suppressed": false,
+ "type": "fillet"
+ },
+ {
+ "id": 3,
+ "name": "Skirt",
+ "param_names": [
+ "d5"
+ ],
+ "plane": {
+ "base": {
+ "name": "XY",
+ "type": "origin"
+ },
+ "distance": "2.4",
+ "type": "offset"
+ },
+ "sketch": {
+ "constraints": [
+ {
+ "id": "k1",
+ "l": 0,
+ "type": "horizontal"
+ },
+ {
+ "id": "k2",
+ "l": 2,
+ "type": "horizontal"
+ },
+ {
+ "id": "k3",
+ "l": 1,
+ "type": "vertical"
+ },
+ {
+ "id": "k4",
+ "l": 3,
+ "type": "vertical"
+ },
+ {
+ "id": "k5",
+ "l": 4,
+ "type": "horizontal"
+ },
+ {
+ "id": "k6",
+ "l": 6,
+ "type": "horizontal"
+ },
+ {
+ "id": "k7",
+ "l": 5,
+ "type": "vertical"
+ },
+ {
+ "id": "k8",
+ "l": 7,
+ "type": "vertical"
+ }
+ ],
+ "counters": {
+ "k": 8,
+ "l": 8,
+ "p": 8
+ },
+ "curves": [
+ {
+ "a": 1,
+ "b": 2,
+ "construction": false,
+ "id": "l1",
+ "type": "line"
+ },
+ {
+ "a": 2,
+ "b": 3,
+ "construction": false,
+ "id": "l2",
+ "type": "line"
+ },
+ {
+ "a": 3,
+ "b": 4,
+ "construction": false,
+ "id": "l3",
+ "type": "line"
+ },
+ {
+ "a": 4,
+ "b": 1,
+ "construction": false,
+ "id": "l4",
+ "type": "line"
+ },
+ {
+ "a": 5,
+ "b": 6,
+ "construction": false,
+ "id": "l5",
+ "type": "line"
+ },
+ {
+ "a": 6,
+ "b": 7,
+ "construction": false,
+ "id": "l6",
+ "type": "line"
+ },
+ {
+ "a": 7,
+ "b": 8,
+ "construction": false,
+ "id": "l7",
+ "type": "line"
+ },
+ {
+ "a": 8,
+ "b": 5,
+ "construction": false,
+ "id": "l8",
+ "type": "line"
+ }
+ ],
+ "points": [
+ {
+ "fixed": true,
+ "id": "origin",
+ "pos": [
+ 0.0,
+ 0.0
+ ]
+ },
+ {
+ "fixed": false,
+ "id": "p1",
+ "pos": [
+ 102.65,
+ 2.65
+ ]
+ },
+ {
+ "fixed": false,
+ "id": "p2",
+ "pos": [
+ 174.15,
+ 2.65
+ ]
+ },
+ {
+ "fixed": false,
+ "id": "p3",
+ "pos": [
+ 174.15,
+ 86.65
+ ]
+ },
+ {
+ "fixed": false,
+ "id": "p4",
+ "pos": [
+ 102.65,
+ 86.65
+ ]
+ },
+ {
+ "fixed": false,
+ "id": "p5",
+ "pos": [
+ 104.15,
+ 4.15
+ ]
+ },
+ {
+ "fixed": false,
+ "id": "p6",
+ "pos": [
+ 172.65,
+ 4.15
+ ]
+ },
+ {
+ "fixed": false,
+ "id": "p7",
+ "pos": [
+ 172.65,
+ 85.15
+ ]
+ },
+ {
+ "fixed": false,
+ "id": "p8",
+ "pos": [
+ 104.15,
+ 85.15
+ ]
+ }
+ ]
+ },
+ "suppressed": false,
+ "type": "sketch"
+ },
+ {
+ "extent": {
+ "direction": "positive",
+ "distance": "3"
+ },
+ "id": 4,
+ "name": "Extrude1",
+ "operation": "join",
+ "param_names": [
+ "d6"
+ ],
+ "profiles": {
+ "loops": [
+ [
+ "l1",
+ "l2",
+ "l3",
+ "l4"
+ ]
+ ],
+ "type": "curves"
+ },
+ "sketch": 3,
+ "suppressed": false,
+ "targets": [
+ "Lid"
+ ],
+ "type": "extrude"
+ },
+ {
+ "corner": [
+ 104.4,
+ 5.4,
+ -1.0
+ ],
+ "height": "8",
+ "id": 5,
+ "length": "68",
+ "name": "Box2",
+ "operation": "cut",
+ "param_names": [
+ "d7",
+ "d8",
+ "d9"
+ ],
+ "suppressed": false,
+ "type": "box",
+ "width": "61"
+ },
+ {
+ "corner": [
+ 116.4,
+ 72.0,
+ -1.0
+ ],
+ "height": "8",
+ "id": 6,
+ "length": "44",
+ "name": "Box3",
+ "operation": "cut",
+ "param_names": [
+ "d10",
+ "d11",
+ "d12"
+ ],
+ "suppressed": false,
+ "type": "box",
+ "width": "10"
+ },
+ {
+ "corner": [
+ 127.4,
+ 84.0,
+ 2.4
+ ],
+ "height": "4",
+ "id": 7,
+ "length": "22",
+ "name": "Box4",
+ "operation": "cut",
+ "param_names": [
+ "d13",
+ "d14",
+ "d15"
+ ],
+ "suppressed": false,
+ "type": "box",
+ "width": "6"
+ },
+ {
+ "corner": [
+ 102.8,
+ 14.0,
+ 2.4
+ ],
+ "height": "11.7",
+ "id": 8,
+ "length": "1.6",
+ "name": "Rib1",
+ "operation": "join",
+ "param_names": [
+ "d16",
+ "d17",
+ "d18"
+ ],
+ "suppressed": false,
+ "type": "box",
+ "width": "6"
+ },
+ {
+ "corner": [
+ 102.8,
+ 48.0,
+ 2.4
+ ],
+ "height": "11.7",
+ "id": 9,
+ "length": "1.6",
+ "name": "Rib2",
+ "operation": "join",
+ "param_names": [
+ "d19",
+ "d20",
+ "d21"
+ ],
+ "suppressed": false,
+ "type": "box",
+ "width": "6"
+ },
+ {
+ "corner": [
+ 172.4,
+ 14.0,
+ 2.4
+ ],
+ "height": "11.7",
+ "id": 10,
+ "length": "1.6",
+ "name": "Rib3",
+ "operation": "join",
+ "param_names": [
+ "d22",
+ "d23",
+ "d24"
+ ],
+ "suppressed": false,
+ "type": "box",
+ "width": "6"
+ },
+ {
+ "corner": [
+ 172.4,
+ 48.0,
+ 2.4
+ ],
+ "height": "11.7",
+ "id": 11,
+ "length": "1.6",
+ "name": "Rib4",
+ "operation": "join",
+ "param_names": [
+ "d25",
+ "d26",
+ "d27"
+ ],
+ "suppressed": false,
+ "type": "box",
+ "width": "6"
+ }
+ ],
+ "format": "solidcraft/15",
+ "name": "issue-616-lid-ribs",
+ "next_id": 12,
+ "params": [],
+ "units": "mm"
+}
\ No newline at end of file
diff --git a/apps/solidcraft-cli/tests/design_corpus.rs b/apps/solidcraft-cli/tests/design_corpus.rs
index 9e57b76849..1edaadc54b 100644
--- a/apps/solidcraft-cli/tests/design_corpus.rs
+++ b/apps/solidcraft-cli/tests/design_corpus.rs
@@ -137,11 +137,12 @@ fn body_names_saved_before_exact_history_keep_their_pieces() {
/// ignored test below that checks its faces; a listed plane whose face attaches fails the main
/// check until it is removed from here.
type Planes = &'static [([f64; 3], f64)];
-const NO_ATTACHMENT_YET: [(&str, &str, Option<Planes>, u32); 4] = [
+const NO_ATTACHMENT_YET: [(&str, &str, Option<Planes>, u32); 5] = [
("m0-revolve-primitives", "Body1", None, 494),
("naming-split-pieces", "Body1", None, 494),
("modern-plastic", "Body1", None, 494),
("modern-sheet-metal", "Body1", None, 495),
+ ("issue-616-lid-ribs", "Lid", None, 628),
];
/// The issue a face is listed under, and whether it is listed by its plane (not as every face).
@@ -273,6 +274,12 @@ fn sheet_metal_thickness_faces_take_an_attached_sketch() {
known_faces_attach(495);
}
+#[test]
+#[ignore = "fails until #628 is fixed"]
+fn faces_of_a_lid_with_joined_ribs_take_an_attached_sketch() {
+ known_faces_attach(628);
+}
+
/// A small deterministic generator (xorshift).
struct Rng(u64);
impl Rng {
diff --git a/crates/engine/src/boolean_regression_tests.rs b/crates/engine/src/boolean_regression_tests.rs
index 3526ed89d2..2667b2958d 100644
--- a/crates/engine/src/boolean_regression_tests.rs
+++ b/crates/engine/src/boolean_regression_tests.rs
@@ -118,3 +118,38 @@ fn ring_cut_below_a_recess_keeps_the_part_in_one_body() {
let got = volume(&s, "Frame");
assert!((got - want).abs() < 1e-9 * want, "{got} vs {want}");
}
+
+/// Four ribs joined on a rounded lid, standing on the plate over the skirt and flush with the
+/// window's sides: each adds exactly its own material and nothing changes away from it. The
+/// joins displaced the tool and one left a slit through the far side of the skirt and plate
+/// (#616), which no volume shows: the area does. The reply of each join carries its warning, as
+/// the timeline does (an agent placing parts over MCP saw none).
+#[test]
+fn ribs_flush_with_a_window_change_nothing_away_from_them() {
+ let script: Value = serde_json::from_str(include_str!("../../../examples/regressions/lid_ribs_flush_with_window.json")).unwrap();
+ let steps = script.get("commands").and_then(Value::as_array).unwrap();
+ let (lid, ribs) = steps.split_at(steps.len() - 4);
+ let mut s = Session::default();
+ s.run_script(&Value::Array(lid.to_vec())).unwrap();
+ let measure = |s: &Session| s.model.state().body("Lid").map(|b| solidcraft_kernel::measure(&b.body).unwrap()).unwrap();
+ let (v0, a0) = (measure(&s).volume, measure(&s).area);
+ assert!((v0 - 6703.5222).abs() < 1e-3, "{v0}");
+ for (i, rib) in ribs.iter().enumerate() {
+ let reply = s.execute(rib["command"].as_str().unwrap(), &rib["params"]).unwrap();
+ let id = reply["feature"].as_u64().unwrap();
+ let result = s.model.result(id).unwrap();
+ assert_eq!(reply["warning"], json!(result.warning), "the reply says what the timeline says");
+ assert!(!result.warning.as_deref().unwrap_or_default().contains("tool displacement"), "{:?}", result.warning);
+ let m = measure(&s);
+ let n = (i + 1) as f64;
+ // 1.6 x 6 x 11.7 less the 1.35 x 6 x 3 inside the skirt.
+ assert!((m.volume - (v0 + n * 88.02)).abs() < 1e-6, "rib {}: {}", i + 1, m.volume - v0);
+ // Top 9.6, outer side 6 x 8.7 above the skirt, inner side 6 x 11.7 (flush with the
+ // window's side), ends 2 x (1.6 x 11.7 - 1.35 x 3); the skirt top 8.1, its inner side
+ // 18 and 1.5 of the plate go under the rib.
+ let area = 9.6 + 52.2 + 70.2 + 29.34 - 8.1 - 18.0 - 1.5;
+ assert!((m.area - (a0 + n * area)).abs() < 1e-6, "rib {}: area {} (no slit adds any)", i + 1, m.area - a0);
+ }
+ let bounds = s.model.state().body("Lid").unwrap().body.tessellate(0.01).unwrap().bounds();
+ assert!((bounds.max.z - 14.1).abs() < 1e-9, "{}", bounds.max.z);
+}
diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rs
index 72af07f56b..b19a3b3947 100644
--- a/crates/engine/src/cmd/features.rs
+++ b/crates/engine/src/cmd/features.rs
@@ -483,8 +483,11 @@ fn add_feature_in(s: &mut Session, p: &Value, kind: FeatureKind, world: bool) ->
st.bodies.iter().filter(|b| b.feature != id && old.get(b.name.as_str()).is_some_and(|o| !o.same(&b.body))).map(|b| b.name.as_str()).collect();
let removed: Vec<&str> = before.bodies.iter().map(|b| b.name.as_str()).filter(|n| !now.contains(n)).collect();
let fname = s.doc.feature(id).map(|f| f.name.clone()).unwrap_or_default();
+ // A warning (a Boolean that needed a retry, a reference found again elsewhere) is part of
+ // the reply: a script or an agent sees it without asking the timeline (#616).
+ let warning = r.as_ref().and_then(|r| r.warning.clone());
Ok(json!({"feature": id, "name": fname, "bodies": bodies, "created_bodies": created, "changed_bodies": changed,
- "removed_bodies": removed, "ms": r.map(|r| r.ms)}))
+ "removed_bodies": removed, "warning": warning, "ms": r.map(|r| r.ms)}))
}
fn extrude(s: &mut Session, p: &Value) -> Result<Value> {
diff --git a/crates/kernel/src/boolean_guard.rs b/crates/kernel/src/boolean_guard.rs
new file mode 100644
index 0000000000..ddb0491456
--- /dev/null
+++ b/crates/kernel/src/boolean_guard.rs
@@ -0,0 +1,183 @@
+//! The check every Boolean retry's result must pass before it is returned (issue #616).
+//!
+//! A retry moves things about (the tool nudged, faces pushed apart, pieces cut off and glued
+//! back), so its result is held to what a join or a cut can do at all:
+//! - it is closed;
+//! - a join never loses volume and a cut never gains any;
+//! - outside the tool's box nothing changes: there, the result's surface is the target's and
+//! the target's surface is the result's. A join or a cut can only change the target where the
+//! tool is, so geometry anywhere else (a slit through a wall, a face moved) is wrong.
+//!
+//! A result that fails is refused with an error: a wrong result that looks right is worse.
+
+use solidcraft_geom::{Aabb3, Mesh, Vec3};
+
+use crate::body::Body;
+use crate::{BoolOp, KernelError, Result};
+
+/// Most triangles sampled from each surface (evenly spaced through the mesh).
+const MAX_SAMPLES: usize = 20_000;
+
+/// Distance from `p` to the triangle `abc`.
+fn point_triangle_dist(p: Vec3, a: Vec3, b: Vec3, c: Vec3) -> f64 {
+ let n = (b - a).cross(c - a);
+ let Some(nn) = n.normalized() else {
+ return [(a, b), (b, c), (c, a)].iter().map(|(u, v)| p.dist_to_segment(*u, *v)).fold(f64::INFINITY, f64::min);
+ };
+ let h = (p - a).dot(nn);
+ let q = p - nn * h;
+ let inside = [(a, b), (b, c), (c, a)].iter().all(|(u, v)| (*v - *u).cross(q - *u).dot(n) >= 0.0);
+ if inside { h.abs() } else { [(a, b), (b, c), (c, a)].iter().map(|(u, v)| p.dist_to_segment(*u, *v)).fold(f64::INFINITY, f64::min) }
+}
+
+/// The triangles of a mesh in a uniform grid of cells, each listing the triangles within `reach`
+/// of it, to answer "is this point within `reach` of the surface?".
+struct Near<'a> {
+ mesh: &'a Mesh,
+ min: Vec3,
+ cell: f64,
+ dims: [usize; 3],
+ cells: Vec<Vec<u32>>,
+ reach: f64,
+}
+
+impl<'a> Near<'a> {
+ fn new(mesh: &'a Mesh, reach: f64) -> Option<Self> {
+ let bounds = mesh.bounds();
+ if bounds.is_empty() {
+ return None;
+ }
+ let min = bounds.min - Vec3::new(reach, reach, reach);
+ let size = bounds.size() + Vec3::new(2.0 * reach, 2.0 * reach, 2.0 * reach);
+ // About a few triangles a cell, at most 64^3 cells.
+ let n = (mesh.triangles.len().max(1) as f64).cbrt().clamp(1.0, 64.0);
+ let cell = (size.x.max(size.y).max(size.z) / n).max(reach * 2.0).max(1e-9);
+ let dims = [size.x, size.y, size.z].map(|s| ((s / cell).ceil() as usize).clamp(1, 256));
+ let mut cells = vec![Vec::new(); dims[0] * dims[1] * dims[2]];
+ for (i, t) in mesh.triangles.iter().enumerate() {
+ let Some(tri) = mesh.tri(t) else { continue };
+ let mut bx = Aabb3::EMPTY;
+ for p in tri {
+ bx.add(p);
+ }
+ let lo = Self::index(min, cell, dims, bx.min - Vec3::new(reach, reach, reach));
+ let hi = Self::index(min, cell, dims, bx.max + Vec3::new(reach, reach, reach));
+ for x in lo[0]..=hi[0] {
+ for y in lo[1]..=hi[1] {
+ for z in lo[2]..=hi[2] {
+ if let Some(c) = cells.get_mut((x * dims[1] + y) * dims[2] + z) {
+ c.push(i as u32);
+ }
+ }
+ }
+ }
+ }
+ Some(Near { mesh, min, cell, dims, cells, reach })
+ }
+
+ fn index(min: Vec3, cell: f64, dims: [usize; 3], p: Vec3) -> [usize; 3] {
+ let d = p - min;
+ let f = |v: f64, n: usize| ((v / cell).floor().max(0.0) as usize).min(n - 1);
+ [f(d.x, dims[0]), f(d.y, dims[1]), f(d.z, dims[2])]
+ }
+
+ fn close(&self, p: Vec3) -> bool {
+ let d = p - self.min;
+ let s = [d.x, d.y, d.z];
+ if s.iter().zip(self.dims).any(|(v, n)| *v < 0.0 || *v > self.cell * n as f64) {
+ return false;
+ }
+ let [x, y, z] = Self::index(self.min, self.cell, self.dims, p);
+ let Some(list) = self.cells.get((x * self.dims[1] + y) * self.dims[2] + z) else { return false };
+ list.iter().any(|&t| {
+ self.mesh.triangles.get(t as usize).and_then(|t| self.mesh.tri(t)).is_some_and(|[a, b, c]| point_triangle_dist(p, a, b, c) <= self.reach)
+ })
+ }
+}
+
+/// A point of `from`'s surface outside `region` that is not on `onto`'s surface (within
+/// `reach`), if there is one.
+fn stray_point(from: &Mesh, onto: &Near, region: &Aabb3) -> Option<Vec3> {
+ let step = from.triangles.len().div_ceil(MAX_SAMPLES).max(1);
+ from.triangles.iter().step_by(step).filter_map(|t| from.tri(t)).find_map(|[a, b, c]| {
+ let p = (a + b + c) / 3.0;
+ let outside =
+ p.x < region.min.x || p.y < region.min.y || p.z < region.min.z || p.x > region.max.x || p.y > region.max.y || p.z > region.max.z;
+ (outside && !onto.close(p)).then_some(p)
+ })
+}
+
+fn bad(op: BoolOp, what: String) -> KernelError {
+ let verb = match op {
+ BoolOp::Union => "join",
+ BoolOp::Cut => "cut",
+ BoolOp::Intersect => "intersect",
+ };
+ KernelError::Failed(format!(
+ "the {verb} could not be computed reliably: {what}. The result was refused rather than kept wrong; \
+ where the bodies only touch (faces flush with each other), overlapping them slightly usually helps"
+ ))
+}
+
+/// Check the result of a Boolean that needed a retry (see the module docs). `result` is `None`
+/// for an empty result.
+pub(crate) fn check_retry(a: &Body, b: &Body, op: BoolOp, result: Option<&Body>) -> Result<()> {
+ if op == BoolOp::Intersect || a.is_mesh() || b.is_mesh() {
+ return Ok(());
+ }
+ let Some(r) = result else {
+ // Nothing left: only a cut whose tool covers the whole target (to within the meshes'
+ // chords: a tool touching a round side of the target).
+ let chord = a.size().max(b.size()) * 1e-3;
+ let (Ok(ma), Ok(mb)) = (a.tessellate(chord), b.tessellate(chord)) else { return Ok(()) };
+ let (ba, bb) = (ma.bounds(), mb.bounds());
+ let tol = 2.0 * chord;
+ let within = ba.min.x >= bb.min.x - tol
+ && ba.min.y >= bb.min.y - tol
+ && ba.min.z >= bb.min.z - tol
+ && ba.max.x <= bb.max.x + tol
+ && ba.max.y <= bb.max.y + tol
+ && ba.max.z <= bb.max.z + tol;
+ return if op == BoolOp::Cut && within { Ok(()) } else { Err(bad(op, "it came out empty".into())) };
+ };
+ if r.solid.boundaries().iter().any(|s| s.shell_condition() != truck_modeling::ShellCondition::Closed) {
+ return Err(bad(op, "the result is not closed".into()));
+ }
+ let size = a.size().max(b.size());
+ let t = (size * 2e-4).max(1e-5);
+ let (Ok(ma), Ok(mb), Ok(mr)) = (a.tessellate_with(t, true), b.tessellate_with(t, true), r.tessellate_with(t, true)) else {
+ return Err(bad(op, "the result could not be checked".into()));
+ };
+ let (va, vb, vr) = (ma.measure().volume, mb.measure().volume, mr.measure().volume);
+ let slack = 2e-4 * (va.abs() + vb.abs()) + 1e-9;
+ let volume_ok = vr.is_finite()
+ && match op {
+ BoolOp::Union => vr >= va.max(vb) - slack && vr <= va + vb + slack,
+ BoolOp::Cut => vr <= va + slack && vr >= va - vb - slack,
+ BoolOp::Intersect => true,
+ };
+ if !volume_ok {
+ let what = match op {
+ BoolOp::Union => format!("the joined body's volume would be {vr:.4} mm³ (the target is {va:.4} mm³, the tool {vb:.4} mm³)"),
+ _ => format!("the cut body's volume would be {vr:.4} mm³ (the target is {va:.4} mm³, the tool {vb:.4} mm³)"),
+ };
+ return Err(bad(op, what));
+ }
+ // Outside the tool's box (with room for the meshes' chords and a nudge) the result's
+ // surface and the target's must be the same.
+ let reach = 3.0 * t + size * 1e-5;
+ let mut region = mb.bounds();
+ region.min -= Vec3::new(reach, reach, reach) * 2.0;
+ region.max += Vec3::new(reach, reach, reach) * 2.0;
+ let (Some(near_a), Some(near_r)) = (Near::new(&ma, reach), Near::new(&mr, reach)) else {
+ return Err(bad(op, "the result could not be checked".into()));
+ };
+ let at = |p: Vec3| format!("({:.3}, {:.3}, {:.3})", p.x, p.y, p.z);
+ if let Some(p) = stray_point(&mr, &near_a, &region) {
+ return Err(bad(op, format!("it would change the body away from the tool, at {} (outside the tool's region)", at(p))));
+ }
+ if let Some(p) = stray_point(&ma, &near_r, &region) {
+ return Err(bad(op, format!("it would remove part of the body away from the tool, at {} (outside the tool's region)", at(p))));
+ }
+ Ok(())
+}
diff --git a/crates/kernel/src/coplanar.rs b/crates/kernel/src/coplanar.rs
index 7fb944e4c3..02a76e45cb 100644
--- a/crates/kernel/src/coplanar.rs
+++ b/crates/kernel/src/coplanar.rs
@@ -335,19 +335,16 @@ pub(crate) fn boolean_apart(a: &Body, b: &Body, op: BoolOp) -> Option<Result<Opt
}
for (n, d) in &back {
// a's face points along n; b's face points along −n at the same plane (−d).
- let shift = if op == BoolOp::Union && crate::ops::narrowing_bores() {
+ let shift = if op == BoolOp::Union {
// Pushed into `a`, b's face must have a's material behind it all over and that
// deep: over a hole in a's face (a narrowed bore's rim over the other body's
- // bore) it would fill the hole, through a thin wall it would stick out the far
- // side. Only checked inside `bore_union`, which then tries its other way; a
- // general check turns some joins that come out slightly wrong today (a pad
- // half past an edge) into failures, until such faces can be split first.
+ // bore, a rib standing half over a window) it would fill the hole, through a
+ // thin wall it would stick out the far side (#616). The other retries take
+ // such a join instead.
[d2, d2 * 0.25, d2 * 0.0625]
.into_iter()
.find(|depth| backed(a, b, -*n, -*d, *depth))
.ok_or_else(|| KernelError::Failed("pushing a face: part of it lies over a hole or past the edge of the other body".into()))?
- } else if op == BoolOp::Union {
- d2
} else {
-d2
};
@@ -471,9 +468,10 @@ fn backed(a: &Body, b: &Body, m: Vec3, d: f64, depth: f64) -> bool {
!points.is_empty() && points.iter().all(|p| [0.05, 0.5, 1.0].iter().all(|k| inside.contains(*p + m * (depth * k))))
}
-/// Union of bodies that touch along one identical planar face, back to back (a body joined
-/// with its mirror image): the two faces go and the shells are stitched along their edges.
-/// `None` when no such pair of faces exists.
+/// Union of bodies that touch along identical planar faces, back to back (a body joined with
+/// its mirror image, or the pieces of a body cut apart by a plane, which may meet in several
+/// faces): every such pair of faces goes and the shells are stitched along their edges. `None`
+/// when no such pair of faces exists.
pub(crate) fn glue(a: &Body, b: &Body) -> Option<Result<Body>> {
use mt::{BoundedCurve, ParametricCurve};
let size = a.size().max(b.size());
@@ -484,13 +482,18 @@ pub(crate) fn glue(a: &Body, b: &Body) -> Option<Result<Body>> {
let (t0, t1) = c.range_tuple();
from_p3(c.subs((t0 + t1) * 0.5))
};
- // Matching faces: same plane, opposite normals, the same edges.
+ // Matching faces: same plane, opposite normals, the same edges. Every pair is glued: a
+ // pair left behind would stay inside the result as a zero-thickness slit (issue #616).
let (pa, pb) = (planes(a), planes(b));
let fa_list: Vec<&mt::Face> = a.solid.face_iter().collect();
let fb_list: Vec<&mt::Face> = b.solid.face_iter().collect();
+ // B edge → the matching A edge; B vertex → the matching A vertex.
+ let mut map: HashMap<mt::EdgeID, mt::Edge> = HashMap::new();
+ let mut vmap: HashMap<mt::VertexID, mt::Vertex> = HashMap::new();
+ let (mut glued_a, mut glued_b): (Vec<usize>, Vec<usize>) = (Vec::new(), Vec::new());
for (ia, x) in &pa {
for (ib, y) in &pb {
- if x.n.dot(y.n) > -1.0 + 1e-9 || (x.d + y.d).abs() > tol {
+ if glued_a.contains(ia) || glued_b.contains(ib) || x.n.dot(y.n) > -1.0 + 1e-9 || (x.d + y.d).abs() > tol {
continue;
}
let (Some(fa), Some(fb)) = (fa_list.get(*ia), fb_list.get(*ib)) else { continue };
@@ -499,9 +502,7 @@ pub(crate) fn glue(a: &Body, b: &Body) -> Option<Result<Body>> {
if ea.len() != eb.len() {
continue;
}
- // B edge → the matching A edge.
- let mut map: HashMap<mt::EdgeID, mt::Edge> = HashMap::new();
- let mut vmap: HashMap<mt::VertexID, mt::Vertex> = HashMap::new();
+ let (mut pair_map, mut pair_vmap) = (Vec::new(), Vec::new());
let mut ok = true;
for e in &eb {
let ends = (key(from_p3(e.absolute_front().point())), key(from_p3(e.absolute_back().point())));
@@ -515,75 +516,81 @@ pub(crate) fn glue(a: &Body, b: &Body) -> Option<Result<Body>> {
break;
};
let same = key(from_p3(f.absolute_front().point())) == ends.0;
- map.insert(e.id(), if same { f.absolute_clone() } else { f.absolute_clone().inverse() });
+ pair_map.push((e.id(), if same { f.absolute_clone() } else { f.absolute_clone().inverse() }));
let (fa_v, fb_v) = if same {
(f.absolute_front().clone(), f.absolute_back().clone())
} else {
(f.absolute_back().clone(), f.absolute_front().clone())
};
- vmap.insert(e.absolute_front().id(), fa_v);
- vmap.insert(e.absolute_back().id(), fb_v);
+ pair_vmap.push((e.absolute_front().id(), fa_v));
+ pair_vmap.push((e.absolute_back().id(), fb_v));
}
if !ok {
continue;
}
- return Some(guard("glue", || {
- let fail = |m: &str| KernelError::Failed(format!("joining touching faces: {m}"));
- // B's other edges, rebuilt on A's vertices where they meet the seam.
- let mut edges: HashMap<mt::EdgeID, mt::Edge> = map.clone();
- for e in b.solid.edge_iter() {
- if edges.contains_key(&e.id()) {
- continue;
- }
- let (f0, f1) = (e.absolute_front(), e.absolute_back());
- if !vmap.contains_key(&f0.id()) && !vmap.contains_key(&f1.id()) {
- edges.insert(e.id(), e.absolute_clone());
- continue;
- }
- let v0 = vmap.get(&f0.id()).cloned().unwrap_or_else(|| f0.clone());
- let v1 = vmap.get(&f1.id()).cloned().unwrap_or_else(|| f1.clone());
- edges.insert(e.id(), mt::Edge::new(&v0, &v1, e.curve()));
- }
- let mut faces: Vec<mt::Face> = fa_list.iter().enumerate().filter(|(i, _)| i != ia).map(|(_, f)| (*f).clone()).collect();
- // Every face but the two glued is kept; an edge along the seam is an edge of both.
- let kept = |operand: usize, n: usize, skip: usize| {
- (0..n).filter(move |i| *i != skip).map(move |i| record::from_face(operand, i, Change::Kept))
- };
- let from: Vec<FaceProv> = kept(0, fa_list.len(), *ia).chain(kept(1, fb_list.len(), *ib)).collect();
- let mut origins = record::edge_origins(&a.solid, 0);
- for (old, o) in record::edge_origins(&b.solid, 1) {
- if let Some(new) = edges.get(&old) {
- origins.entry(new.id()).or_default().extend(o);
- }
- }
- for (i, f) in fb_list.iter().enumerate() {
- if i == *ib {
- continue;
- }
- let wires: Vec<mt::Wire> = f
- .absolute_boundaries()
- .iter()
- .map(|w| {
- w.edge_iter()
- .filter_map(|e| edges.get(&e.id()).map(|ne| if e.front() == e.absolute_front() { ne.clone() } else { ne.inverse() }))
- .collect::<Vec<_>>()
- .into()
- })
- .collect();
- let mut nf = mt::Face::try_new(wires, f.surface()).map_err(|e| fail(&e.to_string()))?;
- if !f.orientation() {
- nf.invert();
- }
- faces.push(nf);
- }
- let solid = Solid::try_new(vec![faces.into()]).map_err(|e| fail(&e.to_string()))?;
- // Each edge's origins in the solid's edge order.
- let origins = crate::body::edge_order(solid.face_iter()).0.iter().map(|e| origins.get(&e.id()).cloned()).collect();
- crate::boolean_record::heal_build(solid, size, &[], Some(from), origins, &record::counts(&[a, b]))
- }));
+ map.extend(pair_map);
+ vmap.extend(pair_vmap);
+ glued_a.push(*ia);
+ glued_b.push(*ib);
}
}
- None
+ if glued_a.is_empty() {
+ return None;
+ }
+ Some(guard("glue", || {
+ let fail = |m: &str| KernelError::Failed(format!("joining touching faces: {m}"));
+ // B's other edges, rebuilt on A's vertices where they meet a seam.
+ let mut edges: HashMap<mt::EdgeID, mt::Edge> = map.clone();
+ for e in b.solid.edge_iter() {
+ if edges.contains_key(&e.id()) {
+ continue;
+ }
+ let (f0, f1) = (e.absolute_front(), e.absolute_back());
+ if !vmap.contains_key(&f0.id()) && !vmap.contains_key(&f1.id()) {
+ edges.insert(e.id(), e.absolute_clone());
+ continue;
+ }
+ let v0 = vmap.get(&f0.id()).cloned().unwrap_or_else(|| f0.clone());
+ let v1 = vmap.get(&f1.id()).cloned().unwrap_or_else(|| f1.clone());
+ edges.insert(e.id(), mt::Edge::new(&v0, &v1, e.curve()));
+ }
+ let mut faces: Vec<mt::Face> = fa_list.iter().enumerate().filter(|(i, _)| !glued_a.contains(i)).map(|(_, f)| (*f).clone()).collect();
+ // Every face but the glued ones is kept; an edge along a seam is an edge of both.
+ let kept = |operand: usize, n: usize, skip: &[usize]| {
+ (0..n).filter(|i| !skip.contains(i)).map(move |i| record::from_face(operand, i, Change::Kept)).collect::<Vec<_>>()
+ };
+ let from: Vec<FaceProv> = kept(0, fa_list.len(), &glued_a).into_iter().chain(kept(1, fb_list.len(), &glued_b)).collect();
+ let mut origins = record::edge_origins(&a.solid, 0);
+ for (old, o) in record::edge_origins(&b.solid, 1) {
+ if let Some(new) = edges.get(&old) {
+ origins.entry(new.id()).or_default().extend(o);
+ }
+ }
+ for (i, f) in fb_list.iter().enumerate() {
+ if glued_b.contains(&i) {
+ continue;
+ }
+ let wires: Vec<mt::Wire> = f
+ .absolute_boundaries()
+ .iter()
+ .map(|w| {
+ w.edge_iter()
+ .filter_map(|e| edges.get(&e.id()).map(|ne| if e.front() == e.absolute_front() { ne.clone() } else { ne.inverse() }))
+ .collect::<Vec<_>>()
+ .into()
+ })
+ .collect();
+ let mut nf = mt::Face::try_new(wires, f.surface()).map_err(|e| fail(&e.to_string()))?;
+ if !f.orientation() {
+ nf.invert();
+ }
+ faces.push(nf);
+ }
+ let solid = Solid::try_new(vec![faces.into()]).map_err(|e| fail(&e.to_string()))?;
+ // Each edge's origins in the solid's edge order.
+ let origins = crate::body::edge_order(solid.face_iter()).0.iter().map(|e| origins.get(&e.id()).cloned()).collect();
+ crate::boolean_record::heal_build(solid, size, &[], Some(from), origins, &record::counts(&[a, b]))
+ }))
}
/// Union of bodies touching back to back where a planar face of one lies wholly inside a
diff --git a/crates/kernel/src/issue_616_tests.rs b/crates/kernel/src/issue_616_tests.rs
new file mode 100644
index 0000000000..5d6d9e0b88
--- /dev/null
+++ b/crates/kernel/src/issue_616_tests.rs
@@ -0,0 +1,185 @@
+//! Issue #616: small boxes joined flush to the walls and floor of a part never change it away
+//! from the box, and a retry that would is refused.
+
+use solidcraft_geom::{Aabb3, Mesh, Vec3};
+
+use crate::*;
+
+fn bx(c: [f64; 3], s: [f64; 3]) -> Body {
+ box_solid(Vec3::new(c[0], c[1], c[2]), Vec3::new(c[0] + s[0], c[1] + s[1], c[2] + s[2])).unwrap()
+}
+
+fn volume(b: &Body) -> f64 {
+ measure(b).unwrap().volume
+}
+
+/// The lid of the issue (public dimensions): a plate with rounded corners, a skirt ring on
+/// it, a window and a slot cut through, and a notch cut in the skirt.
+fn lid() -> Body {
+ let plate = bx([100., 0., 0.], [76.8, 89.3, 2.4]);
+ let corners: Vec<Vec3> = [[100., 0.], [176.8, 0.], [100., 89.3], [176.8, 89.3]].iter().map(|p| Vec3::new(p[0], p[1], 1.2)).collect();
+ let plate = fillet(&plate, &corners, 3.0).unwrap();
+ let ring = boolean(&bx([102.65, 2.65, 2.4], [71.5, 84., 3.]), &bx([104.15, 4.15, 2.0], [68.5, 81., 4.]), BoolOp::Cut).unwrap().unwrap();
+ let mut b = boolean(&plate, &ring, BoolOp::Union).unwrap().unwrap();
+ for (c, s) in [([104.4, 5.4, -1.], [68., 61., 8.]), ([116.4, 72., -1.], [44., 10., 8.]), ([127.4, 84., 2.4], [22., 6., 4.])] {
+ b = boolean(&b, &bx(c, s), BoolOp::Cut).unwrap().unwrap();
+ }
+ b
+}
+
+/// Distance from `p` to the triangle `abc` (brute force, independent of the guard's grid).
+fn tri_dist(p: Vec3, [a, b, c]: [Vec3; 3]) -> f64 {
+ let n = (b - a).cross(c - a);
+ let Some(u) = n.normalized() else { return f64::INFINITY };
+ let h = (p - a).dot(u);
+ let q = p - u * h;
+ if [(a, b), (b, c), (c, a)].iter().all(|(x, y)| (*y - *x).cross(q - *x).dot(n) >= 0.0) {
+ h.abs()
+ } else {
+ [(a, b), (b, c), (c, a)].iter().map(|(x, y)| p.dist_to_segment(*x, *y)).fold(f64::INFINITY, f64::min)
+ }
+}
+
+/// A point of `from`'s surface outside `region` that is not on `onto`'s surface.
+fn moved_outside(from: &Mesh, onto: &Mesh, region: &Aabb3, tol: f64) -> Option<Vec3> {
+ let tris: Vec<[Vec3; 3]> = onto.triangles.iter().filter_map(|t| onto.tri(t)).collect();
+ from.triangles.iter().filter_map(|t| from.tri(t)).find_map(|[a, b, c]| {
+ let p = (a + b + c) / 3.0;
+ let inside = p.x > region.min.x && p.y > region.min.y && p.z > region.min.z && p.x < region.max.x && p.y < region.max.y && p.z < region.max.z;
+ (!inside && !tris.iter().any(|t| tri_dist(p, *t) < tol)).then_some(p)
+ })
+}
+
+/// The join of `tool` onto `target` left `target` as it was away from the tool: no new surface
+/// (a slit, a moved face) and none lost, outside the tool's box.
+fn assert_local(target: &Body, tool: &Body, joined: &Body, what: &str) {
+ let tol = 1e-3;
+ let (mt, mtool, mj) = (target.tessellate(0.01).unwrap(), tool.tessellate(0.01).unwrap(), joined.tessellate(0.01).unwrap());
+ let mut region = mtool.bounds();
+ region.min -= Vec3::new(0.01, 0.01, 0.01);
+ region.max += Vec3::new(0.01, 0.01, 0.01);
+ assert_eq!(moved_outside(&mj, &mt, &region, tol), None, "{what}: new surface away from the tool");
+ assert_eq!(moved_outside(&mt, &mj, &region, tol), None, "{what}: surface lost away from the tool");
+}
+
+/// The four ribs of the issue, 1.6 × 6 × 11.7, sit on the plate (z = 2.4), over the skirt, flush
+/// with the window's sides. Each join adds exactly what lies outside the skirt, changes nothing
+/// else (it used to leave a slit through the far wall), and needs no displacement of the tool.
+#[test]
+fn ribs_joined_flush_to_the_lid_change_nothing_else() {
+ let mut b = lid();
+ assert!((volume(&b) - 6703.5222).abs() < 1e-3, "{}", volume(&b));
+ for c in [[102.8, 14., 2.4], [102.8, 48., 2.4], [172.4, 14., 2.4], [172.4, 48., 2.4]] {
+ let tool = bx(c, [1.6, 6., 11.7]);
+ let (r, report) = capture_boolean_diagnostics(|| boolean(&b, &tool, BoolOp::Union));
+ let r = r.unwrap().unwrap();
+ // 1.6 × 6 × 11.7 less the 1.35 × 6 × 3 inside the skirt.
+ assert!((volume(&r) - volume(&b) - 88.02).abs() < 1e-6, "{c:?}: {}", volume(&r) - volume(&b));
+ assert!(!report.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{c:?}: {report:?}");
+ assert_eq!(r.solid.boundaries().len(), 1);
+ assert_local(&b, &tool, &r, &format!("{c:?}"));
+ b = r;
+ }
+ let bounds = b.tessellate(0.01).unwrap().bounds();
+ assert!((bounds.max.z - 14.1).abs() < 1e-9, "the ribs keep their height: {}", bounds.max.z);
+}
+
+/// A plane cut through a frame meets it in two faces; gluing the halves back joins both (one
+/// left over was the slit of #616).
+#[test]
+fn glue_joins_every_face_the_pieces_share() {
+ let frame = boolean(&bx([0., 0., 0.], [40., 30., 5.]), &bx([5., 5., -1.], [30., 20., 7.]), BoolOp::Cut).unwrap().unwrap();
+ let low = boolean(&frame, &bx([-1., -1., -1.], [42., 16., 7.]), BoolOp::Intersect).unwrap().unwrap();
+ let high = boolean(&frame, &bx([-1., 15., -1.], [42., 16., 7.]), BoolOp::Intersect).unwrap().unwrap();
+ let glued = crate::coplanar::glue(&low, &high).unwrap().unwrap();
+ assert_eq!(glued.solid.boundaries().len(), 1);
+ assert!((volume(&glued) - volume(&frame)).abs() < 1e-6);
+ assert!((measure(&glued).unwrap().area - measure(&frame).unwrap().area).abs() < 1e-6, "no faces left inside");
+}
+
+/// The guard refuses a result that changed the target away from the tool, or lost volume in a
+/// join, and accepts the right one.
+#[test]
+fn the_retry_guard_refuses_changes_away_from_the_tool() {
+ let target = bx([0., 0., 0.], [40., 30., 5.]);
+ let tool = bx([0., 0., 5.], [4., 4., 4.]);
+ let right = boolean(&target, &tool, BoolOp::Union).unwrap().unwrap();
+ assert!(crate::boolean_guard::check_retry(&target, &tool, BoolOp::Union, Some(&right)).is_ok());
+ // A notch far from the tool (volume still up: the tool adds more than the notch takes).
+ let notched = boolean(&right, &bx([30., 10., 4.], [2., 2., 2.]), BoolOp::Cut).unwrap().unwrap();
+ let e = crate::boolean_guard::check_retry(&target, &tool, BoolOp::Union, Some(&notched)).unwrap_err().to_string();
+ assert!(e.contains("away from the tool") && e.contains("refused"), "{e}");
+ // A join that lost volume.
+ let e = crate::boolean_guard::check_retry(&target, &tool, BoolOp::Union, Some(&bx([0., 0., 0.], [40., 30., 4.]))).unwrap_err().to_string();
+ assert!(e.contains("volume"), "{e}");
+ // A cut that comes out empty while the tool covers only part of the target.
+ assert!(crate::boolean_guard::check_retry(&target, &tool, BoolOp::Cut, None).is_err());
+ assert!(crate::boolean_guard::check_retry(&tool, &target, BoolOp::Cut, None).is_err());
+ assert!(crate::boolean_guard::check_retry(&tool, &bx([-1., -1., 4.], [6., 6., 6.]), BoolOp::Cut, None).is_ok());
+}
+
+/// Random small boxes joined flush to the walls and floor of a shelled box with rounded corners
+/// (sitting on the floor, against a wall, flush with a wall's top or into its corner), and of
+/// the same box with a window through its floor (on the ledge beside the window, flush with its
+/// side, as the ribs of #616), never lose volume and never change the part away from the box. A
+/// join that fails is an error, never a wrong result.
+#[test]
+fn boxes_joined_flush_to_a_shelled_box_stay_local() {
+ let (w, d, h, t) = (60.0, 40.0, 20.0, 2.0);
+ let outer = bx([0., 0., 0.], [w, d, h]);
+ let corners: Vec<Vec3> = [[0., 0.], [w, 0.], [0., d], [w, d]].iter().map(|p| Vec3::new(p[0], p[1], h / 2.0)).collect();
+ let outer = fillet(&outer, &corners, 3.0).unwrap();
+ let shelled = boolean(&outer, &bx([t, t, t], [w - 2. * t, d - 2. * t, h]), BoolOp::Cut).unwrap().unwrap();
+ // The window leaves a 1.5 ledge inside the walls.
+ let (ledge, gap) = (t + 1.5, 6.0);
+ let framed = boolean(&shelled, &bx([ledge, gap, -1.], [w - 2. * ledge, d - 2. * gap, t + 2.]), BoolOp::Cut).unwrap().unwrap();
+ let mut seed = 0x616_u64;
+ let mut next = |lo: f64, hi: f64| {
+ seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+ lo + (hi - lo) * ((seed >> 11) as f64 / (1u64 << 53) as f64)
+ };
+ // Sizes and places on a 0.1 grid, like typed values.
+ let q = |x: f64| (x * 10.0).round() / 10.0;
+ let (mut joined, mut refused) = (0, 0);
+ for (name, target) in [("shelled", &shelled), ("framed", &framed)] {
+ let base = volume(target);
+ for case in 0..20 {
+ let s = [q(next(1.0, 6.0)), q(next(1.0, 6.0)), q(next(1.0, 12.0))];
+ let (x, y) = (q(next(t + 1.0, w - t - 8.0)), q(next(gap, d - gap - 8.0)));
+ let c = match (name, case % 4) {
+ // On the floor.
+ ("shelled", 0) => [x, y, t],
+ // On the floor against the -x wall.
+ ("shelled", 1) => [t, y, t],
+ // Into the +y wall, flush with its top, overlapping it.
+ ("shelled", 2) => [x, d - t - s[1] / 2.0, h - s[2]],
+ // On the floor in the corner of the -x and -y walls, sunk into both.
+ ("shelled", _) => [t - 0.5, t - 0.5, t],
+ // On the ledge over the wall, flush with the window's -x or +x side.
+ (_, 0) => [ledge - 1.6, y, t],
+ (_, 1) => [w - ledge, y, t],
+ // On the ledge against the -x wall, short of the window.
+ (_, 2) => [t, y, t],
+ // Into the +x wall from the ledge, flush with the window's side.
+ _ => [w - ledge, y, t],
+ };
+ let s = if name == "framed" && case % 4 != 2 { [1.6, s[1], s[2]] } else { s };
+ let tool = bx(c, s);
+ let what = format!("{name} case {case}: corner {c:?} size {s:?}");
+ match boolean(target, &tool, BoolOp::Union) {
+ Ok(Some(r)) => {
+ assert!(volume(&r) >= base - 1e-6, "{what}: the join lost volume ({} < {base})", volume(&r));
+ assert!(volume(&r) <= base + volume(&tool) + 1e-6, "{what}");
+ assert_local(target, &tool, &r, &what);
+ joined += 1;
+ }
+ Ok(None) => panic!("{what}: a join came out empty"),
+ Err(e) => {
+ eprintln!("{what}: refused: {e}");
+ refused += 1;
+ }
+ }
+ }
+ }
+ assert_eq!((joined, refused), (40, 0), "every one of these joins works");
+}
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index f88f6ed3b9..1e0bb1157a 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -17,6 +17,7 @@ mod blend_corner;
mod blend_variable;
mod body;
mod boolean_diagnostics;
+mod boolean_guard;
mod boolean_record;
mod bore_guard;
mod build;
@@ -36,6 +37,8 @@ mod iges_in;
mod iges_out;
#[cfg(test)]
mod intersection_curve_tests;
+#[cfg(test)]
+mod issue_616_tests;
mod lip;
mod loopblend;
mod measure;
diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rs
index 2f6fbf9d87..0725e97fa8 100644
--- a/crates/kernel/src/ops.rs
+++ b/crates/kernel/src/ops.rs
@@ -286,11 +286,6 @@ thread_local! {
static BORES: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
-/// Is a union with a narrowed bore running (see [`crate::coplanar::bore_union`])?
-pub(crate) fn narrowing_bores() -> bool {
- BORES.with(|c| c.get())
-}
-
/// Boolean of two bodies. The result may be empty (`Ok(None)`) for a cut that removes
/// everything or an intersection of disjoint bodies. Results are checked against volume bounds
/// and retried with shifted copies and other tolerances when they fail or look wrong.
@@ -340,6 +335,18 @@ pub fn boolean(a: &Body, b: &Body, op: BoolOp) -> Result<Option<Body>> {
BoolOp::Union => r = r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(a, b)).transpose()),
BoolOp::Intersect => {}
}
+ // A retry's result is held to what the operation can do at all; one that fails is refused
+ // rather than returned wrong (issue #616).
+ if (!diagnostics.events.is_empty() || diagnostics.truncated)
+ && let Ok(result) = &r
+ && let Err(e) = crate::boolean_guard::check_retry(a, b, op, result.as_ref())
+ {
+ let tried = diagnostics.warning().unwrap_or_default();
+ r = Err(match e {
+ KernelError::Failed(m) => KernelError::Failed(format!("{m} ({})", tried.trim_start_matches("Boolean retry: "))),
+ other => other,
+ });
+ }
if r.is_ok() {
merge(diagnostics);
}
diff --git a/crates/kernel/src/polybool.rs b/crates/kernel/src/polybool.rs
index 35b9d819d6..32996d353c 100644
--- a/crates/kernel/src/polybool.rs
+++ b/crates/kernel/src/polybool.rs
@@ -504,7 +504,7 @@ fn sliced_planar_boolean(a: &Body, b: &Body, op: BoolOp) -> Option<Result<Option
}
// The rebuild leaves the cut faces' edges split where other polygons were cut; healed,
// they match the pieces outside edge for edge.
- let mut pieces: Vec<Traced> = match r {
+ let pieces: Vec<Traced> = match r {
Some(m) => {
let healed = recorded::heal_body(&m, m.deep_copy(), size, a.split_keep(), &record::counts(&[&middle.0, b]))?;
let h = recorded::of_pair(&healed, &middle.1, &h_b);
@@ -512,18 +512,51 @@ fn sliced_planar_boolean(a: &Body, b: &Body, op: BoolOp) -> Option<Result<Option
}
None => Vec::new(),
};
- // Each piece outside meets the middle along its cut face (glued one shell to another).
- if pieces.iter().chain(&outside).any(|(x, _)| x.solid.boundaries().len() != 1) {
- return Err(fail("a piece in several parts"));
+ // Each piece in its lumps: a cut plane crossing a frame or a ring leaves the middle (or
+ // a piece outside) in several parts, which meet the others along several cut faces.
+ let lumps = |(whole, h): Traced| -> Result<Vec<Traced>> {
+ if whole.solid.boundaries().len() == 1 {
+ return Ok(vec![(whole, h)]);
+ }
+ let parts = whole.lumps()?;
+ let histories = recorded::parts_of(&parts, &whole);
+ Ok(parts
+ .into_iter()
+ .zip(histories)
+ .map(|(p, hp)| {
+ let h = match (hp, h.as_ref()) {
+ (Some(hp), Some(h)) => recorded::composed(hp.substituted(0, h)),
+ _ => None,
+ };
+ (p, h)
+ })
+ .collect())
+ };
+ let mut all: Vec<Traced> = Vec::new();
+ for piece in pieces.into_iter().chain(outside) {
+ all.extend(lumps(piece)?);
}
- for (o, h_o) in outside {
- let joined = pieces.iter().enumerate().find_map(|(i, (m, _))| Some((i, crate::coplanar::glue(m, &o)?.ok()?)));
- let (i, j) = joined.ok_or_else(|| fail("a piece does not join back"))?;
- if let Some(slot) = pieces.get_mut(i) {
- let h = recorded::of_pair(&j, &slot.1, &h_o);
- *slot = (j, h);
+ // Glue pieces that meet along their cut faces until one is left; every cut face pair
+ // goes (a pair left behind would be a slit through the result).
+ let mut joined: Vec<Traced> = Vec::new();
+ while let Some(mut cur) = all.pop() {
+ loop {
+ let found = all.iter().enumerate().find_map(|(i, (o, _))| Some((i, crate::coplanar::glue(&cur.0, o)?.ok()?)));
+ let Some((i, j)) = found else { break };
+ let other = all.swap_remove(i);
+ let h = recorded::of_pair(&j, &cur.1, &other.1);
+ cur = (j, h);
}
+ joined.push(cur);
+ }
+ if joined.iter().any(|(x, _)| x.solid.boundaries().len() != 1) {
+ return Err(fail("a piece in several parts"));
+ }
+ // A join onto one piece is one piece: anything apart is a cut face that did not glue.
+ if op == BoolOp::Union && a.solid.boundaries().len() == 1 && joined.len() != 1 {
+ return Err(fail("a piece does not join back"));
}
+ let pieces = joined;
recorded::join(pieces.into_iter().map(|(p, h)| (p, dropped(h))).collect(), &counts)
};
Some(run())
diff --git a/docs/robustness.md b/docs/robustness.md
index 52e9576b0c..3cb832e3ae 100644
--- a/docs/robustness.md
+++ b/docs/robustness.md
@@ -50,6 +50,18 @@ placement and reports both its translation magnitude and rotation angle.
Exact planar and piecewise fallbacks report zero displacement. The existing
volume and spatial acceptance checks still apply to all results.
+The command that adds a feature carries the same `warning` in its reply, so a
+script or an agent sees a retry without asking the timeline.
+
+A join or a cut that needed any retry is then held to what it can do at all
+(`crates/kernel/src/boolean_guard.rs`, #616): the result is closed, a join
+never loses volume and a cut never gains any, and outside the tool's box the
+result's surface is the target's and the target's is the result's (a join or
+a cut can only change the target where the tool is). A cut may come out empty
+only when the tool covers the target. A result that fails is refused with an
+error naming what was wrong and where, rather than returned: a wrong result
+that looks right is worse than an error.
+
Reports belong to the evaluated feature and survive cached rebuilds and
undo/redo. Cold reopening regenerates them from the embedded design. Failed or
discarded retry branches do not contribute successful-retry events. Reports
diff --git a/examples/regressions/lid_ribs_flush_with_window.json b/examples/regressions/lid_ribs_flush_with_window.json
new file mode 100644
index 0000000000..4b5c6e28b1
--- /dev/null
+++ b/examples/regressions/lid_ribs_flush_with_window.json
@@ -0,0 +1,19 @@
+{
+ "description": "A 76.8 x 89.3 x 2.4 lid plate (corner at x = 100) with its four vertical edges rounded 3 mm, a 1.5 mm skirt ring 3 mm high on it (outside 102.65..174.15 x 2.65..86.65), a 68 x 61 window and a 44 x 10 slot cut through, and a 22 x 6 notch in the skirt. Four 1.6 x 6 x 11.7 ribs are then joined standing on the plate (z = 2.4) over the skirt, each flush with a side of the window (x = 104.4 and x = 172.4). The joins needed retries that displaced the tool, and one left a zero-thickness slit through the skirt and plate at y = 25.5, far from any rib (#616). Each rib adds 1.6*6*11.7 - 1.35*6*3 = 88.02 mm3 and nothing changes away from it: 6703.5222 + 4 * 88.02 mm3.",
+ "commands": [
+ {"command": "solid.box", "params": {"corner": [100, 0, 0], "length": 76.8, "width": 89.3, "height": 2.4, "body_name": "Lid"}},
+ {"command": "solid.fillet", "params": {"edges": [[100, 0, 1.2], [176.8, 0, 1.2], [100, 89.3, 1.2], [176.8, 89.3, 1.2]], "radius": 3}},
+ {"command": "sketch.create", "params": {"plane": "XY", "offset": 2.4, "name": "Skirt"}},
+ {"command": "sketch.rectangle.two_point", "params": {"p0": [102.65, 2.65], "p1": [174.15, 86.65]}},
+ {"command": "sketch.rectangle.two_point", "params": {"p0": [104.15, 4.15], "p1": [172.65, 85.15]}},
+ {"command": "sketch.finish", "params": {}},
+ {"command": "solid.extrude", "params": {"sketch": "Skirt", "profiles": [{"point": [103.4, 40]}], "distance": 3, "operation": "join", "targets": ["Lid"]}},
+ {"command": "solid.box", "params": {"corner": [104.4, 5.4, -1], "length": 68, "width": 61, "height": 8, "operation": "cut"}},
+ {"command": "solid.box", "params": {"corner": [116.4, 72, -1], "length": 44, "width": 10, "height": 8, "operation": "cut"}},
+ {"command": "solid.box", "params": {"corner": [127.4, 84, 2.4], "length": 22, "width": 6, "height": 4, "operation": "cut"}},
+ {"command": "solid.box", "params": {"corner": [102.8, 14, 2.4], "length": 1.6, "width": 6, "height": 11.7, "operation": "join", "name": "Rib1"}},
+ {"command": "solid.box", "params": {"corner": [102.8, 48, 2.4], "length": 1.6, "width": 6, "height": 11.7, "operation": "join", "name": "Rib2"}},
+ {"command": "solid.box", "params": {"corner": [172.4, 14, 2.4], "length": 1.6, "width": 6, "height": 11.7, "operation": "join", "name": "Rib3"}},
+ {"command": "solid.box", "params": {"corner": [172.4, 48, 2.4], "length": 1.6, "width": 6, "height": 11.7, "operation": "join", "name": "Rib4"}}
+ ]
+}
diff --git a/tests/action_matrix/baseline.json b/tests/action_matrix/baseline.json
index 380a20b478..4f6098ed33 100644
--- a/tests/action_matrix/baseline.json
+++ b/tests/action_matrix/baseline.json
@@ -2311,7 +2311,7 @@
"Lid/F14:side:l4|F15:blend:F14:side:l1|F14:side:l4": "edge.axis edge.axis+edit edge.normal_plane edge.project",
"Lid/F14:side:l4|F15:blend:F14:side:l3|F14:side:l4": "edge.axis edge.normal_plane edge.project",
"Lid/F14:side:l4|F2:top": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
- "Lid/F14:start": "face.angle_plane face.angle_plane+edit !face.draft_neutral !face.extrude face.hole face.hole+edit face.midplane face.offset_plane !face.press_pull face.shell face.shell+edit face.sketch",
+ "Lid/F14:start": "face.angle_plane face.angle_plane+edit !face.draft_neutral !face.extrude !face.hole face.hole+edit face.midplane face.offset_plane !face.press_pull face.shell face.shell+edit face.sketch",
"Lid/F14:start|F18:side:a17": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Lid/F14:start|F18:side:a18": "edge.chamfer edge.chamfer+edit edge.fillet edge.normal_plane edge.project",
"Lid/F14:start|F18:side:a19": "edge.chamfer edge.fillet edge.normal_plane edge.project edge.project+edit",
@@ -9219,7 +9219,7 @@
"Tool/F2:side:l3|F2:side:l4": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Tool/F2:side:l3|F2:top": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Tool/F2:side:l3|F4:side:l1": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
- "Tool/F2:side:l4": "face.angle_plane !face.draft_neutral face.extrude face.hole face.offset_plane face.press_pull !face.shell face.sketch",
+ "Tool/F2:side:l4": "face.angle_plane !face.draft_neutral face.extrude !face.hole face.offset_plane face.press_pull !face.shell face.sketch",
"Tool/F2:side:l4|F2:top": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Tool/F2:side:l4|F4:side:l1": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Tool/F2:top": "face.angle_plane !face.draft_neutral face.extrude !face.hole face.offset_plane face.press_pull !face.shell face.sketch",