SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 239/509: engine: a shell that opens no face makes a closed hollow body (and 3 more)
jyviko7c481d281fc9
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex b602b55c06..479a32b3a5 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -6785,7 +6785,12 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:}FeatureKind::Shell { faces, thickness, body, direction, tangent_chain } => {let t = val(vals, thickness, Kind::Length)?;- let i = body_at(st, body, &crate::plain(faces))?;+ // No face opened (a closed hollow body) picks no body: the one there is, or the named one.+ let i = match (faces.is_empty(), body, st.bodies.len()) {+ (true, None, 1) => 0,+ (true, None, _) => return Err(DocError::Invalid("a shell that opens no face needs the body named".into())),+ _ => body_at(st, body, &crate::plain(faces))?,+ };let Some(mb) = st.bodies.get(i).cloned() else { return Err(DocError::Invalid("body".into())) };let picks = crate::plain(faces);let open = if *tangent_chain {@@ -6823,7 +6828,9 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:// The cavity's faces are the shell's inner walls, named after the faces they offset.let inner = mb.before_as(crate::lineage::Operand::Inner(mb.name.clone()));let cavity = if inn > 0.0 { Traced::step(kernel::offset_faces(&mb.body, &walls, -inn)?, &[&inner]) } else { inner };- let cavity = Traced::step(kernel::offset_faces(&cavity.body, &open, 2.0 * t + 1.0)?, &[&cavity]);+ // The open faces pushed out of the way (none: the cavity stays sealed inside).+ let cavity =+ if open.is_empty() { cavity } else { Traced::step(kernel::offset_faces(&cavity.body, &open, 2.0 * t + 1.0)?, &[&cavity]) };let cut = kernel::boolean(&outer.body, &cavity.body, BoolOp::Cut)?.ok_or_else(|| DocError::Invalid("the shell removed everything".into()))?;(cut, vec![outer, cavity])diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rsindex f4a3b1e8ce..587599bc5e 100644--- a/crates/engine/src/cmd/features.rs+++ b/crates/engine/src/cmd/features.rs@@ -97,7 +97,7 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("solid.shell", "Shell", shell).at("SOLID", "MODIFY").icon("shell")- .params("faces: [[x,y,z] points on the faces to remove, or face names from model.faces]; thickness: expr; direction?: inside|outside|both; tangent_chain?: bool (also open faces joined smoothly to the picked ones); body?"),+ .params("faces: [[x,y,z] points on the faces to remove, or face names from model.faces; none: a closed hollow body]; thickness: expr; direction?: inside|outside|both; tangent_chain?: bool (also open faces joined smoothly to the picked ones); body? (needed with no faces when there are several bodies)"),CommandSpec::new("solid.draft", "Draft", draft).at("SOLID", "MODIFY").icon("draft")@@ -2649,7 +2649,11 @@ fn face_points(s: &Session, p: &Value, cmd: &str) -> Result<Vec<Vec3>> {fn shell(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "solid.shell";- let faces = face_points(s, p, cmd)?;+ // No face opened: a closed hollow body, its void sealed inside.+ let faces = match p.get("faces").and_then(Value::as_array) {+ Some(a) if a.is_empty() => Vec::new(),+ _ => face_points(s, p, cmd)?,+ };let thickness = req_expr(cmd, p, "thickness")?;check_expr(s, &thickness, Kind::Length, cmd, "thickness")?;let direction = str_(p, "direction").map(str::to_ascii_lowercase).unwrap_or_default();diff --git a/crates/engine/tests/shell_regressions.rs b/crates/engine/tests/shell_regressions.rsindex 5243877ff1..b1f3f1e4b1 100644--- a/crates/engine/tests/shell_regressions.rs+++ b/crates/engine/tests/shell_regressions.rs@@ -86,3 +86,22 @@ fn sound(s: &Session) {assert!(b.body.validity().is_empty(), "{:?}", b.body.validity());}}++/// A shell that opens no face (rig shell/4009): a closed hollow body, the void sealed inside. A+/// 40 × 30 × 12.5 box with a 2.5 wall inside leaves a 35 × 25 × 7.5 void; grown 2.5 outside, the+/// walls are a 45 × 35 × 17.5 box less the original.+#[test]+fn a_shell_that_opens_no_face_seals_its_void() {+ for (direction, want, shells) in [("inside", 15000.0 - 35.0 * 25.0 * 7.5, 2), ("outside", 45.0 * 35.0 * 17.5 - 15000.0, 2)] {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 40.0, "width": 30.0, "height": 12.5}));+ run(&mut s, "solid.shell", json!({"faces": [], "thickness": 2.5, "direction": direction}));+ let errors: Vec<_> = s.model.results.iter().filter_map(|r| r.error.clone()).collect();+ assert!(errors.is_empty(), "{direction}: {errors:?}");+ let st = s.model.state();+ assert_eq!(st.bodies.len(), 1, "{direction}: one body");+ assert_eq!(st.bodies[0].body.shell_count(), shells, "{direction}: an outer and an inner shell");+ let got = volume(&s);+ assert!((got - want).abs() < 1e-6 * want, "{direction}: volume {got}, want {want}");+ }+}diff --git a/crates/kernel/src/tess/mod.rs b/crates/kernel/src/tess/mod.rsindex db16a59221..07933b789e 100644--- a/crates/kernel/src/tess/mod.rs+++ b/crates/kernel/src/tess/mod.rs@@ -205,9 +205,14 @@ pub(crate) fn plan(b: &brep::Brep, tol: f64, turn: Option<size::Turn>) -> Result/// its loop would wind round the surface). Each loop then starts at a node off every pole whose/// predecessor is off them too, so the step from its last node to its first, which/// [`seam::drift`] takes as the nearest copy, never crosses a pole. A vertex loop (a pole)-/// bounds no area and has no nodes of its own. A pcurve that does not cover its edge's interval, or puts a-/// node farther off the edge than the tolerances allow, is an error naming the face and edge:-/// the record is wrong there.+/// bounds no area and has no nodes of its own. Where the face's loops pass a vertex more than once+/// (two holes touching at a point, a loop through another's corner), the pcurves of the edges from+/// it give its parameters apart by their rounding, and two nodes 1e-14 apart put crossing+/// constraints into the triangulation: a pass whose parameters agree with the first pass's to+/// that rounding (1e-9 relative) takes the first's. Farther apart they are two places of the+/// surface (a seam's two sides, a closed spline's ends). A pcurve that does not cover its edge's+/// interval, or puts a node farther off the edge than the tolerances allow, is an error naming+/// the face and edge: the record is wrong there.fn boundary(b: &brep::Brep,fi: usize,@@ -220,6 +225,8 @@ fn boundary(let dom = uv::domain(s);let fail = |e: u32, why: String| unsupported(format!("face {fi} ({}): edge {e}: {why}", kind(&face.surface)));let mut out = Boundary { loops: Vec::with_capacity(face.loops.len()), segments: Vec::with_capacity(face.loops.len()) };+ // Each vertex's parameters, from the first edge use of the face to start there.+ let mut at_vertex: std::collections::HashMap<u32, [f64; 2]> = std::collections::HashMap::new();for l in &face.loops {let Loop::Edges { edges } = l else { continue };let (mut pts, mut uvs): (Vec<Vec3>, Vec<[f64; 2]>) = (Vec::new(), Vec::new());@@ -265,6 +272,18 @@ fn boundary(q[0] += shift[0];q[1] += shift[1];}+ if let (Some(&v), Some(q)) = (edge.vertices.get(usize::from(!oe.forward)), eq.first_mut()) {+ match at_vertex.get(&v) {+ Some(first) => {+ if (0..2).all(|d| (first[d] - q[d]).abs() <= 1e-9 * first[d].abs().max(q[d].abs()).max(1.0)) {+ *q = *first;+ }+ }+ None => {+ at_vertex.insert(v, *q);+ }+ }+ }end = eq.last().copied();ep.pop();eq.pop();diff --git a/crates/kernel/src/tess/tests.rs b/crates/kernel/src/tess/tests.rsindex 00af3b78d9..64d48602da 100644--- a/crates/kernel/src/tess/tests.rs+++ b/crates/kernel/src/tess/tests.rs@@ -128,6 +128,19 @@ fn holes_and_trimmed_faces_are_watertight() {assert!((a - b).abs() < 0.01 * b, "cross hole volume {a} vs {b}");}+/// Through holes in pairs whose circles touch at one point (rig booleans/307): the plate's faces+/// have one loop round each pair, through their common vertex twice. Both passes are one point of+/// the face's (u, v), not two nodes the pcurves put 1e-14 apart, whose constraints crossed+/// ("boundary crosses itself").+#[test]+fn holes_touching_at_a_point_are_watertight() {+ let mut body = ok(crate::box_solid(Vec3::new(-50.0, -50.0, 0.0), Vec3::new(50.0, 50.0, 5.0)));+ for (x, y) in [(25.0, 0.0), (-25.0, 0.0), (0.0, 25.0), (0.0, -25.0), (15.0, 0.0), (-15.0, 0.0), (0.0, 15.0), (0.0, -15.0)] {+ body = cut(&body, &ok(crate::cylinder(Vec3::new(x, y, -1.0), Vec3::Z, 5.0, 7.0)));+ }+ check("holes touching at a point", &body, 0.01, 10000.0 * 5.0 - 8.0 * PI * 25.0 * 5.0);+}+#[test]fn faces_and_edges_keep_the_body_order() {let body = ok(crate::cylinder(Vec3::ZERO, Vec3::Z, 2.0, 5.0));diff --git a/crates/smlib/src/export.rs b/crates/smlib/src/export.rsindex 8f02a6806f..62fa38fb54 100644--- a/crates/smlib/src/export.rs+++ b/crates/smlib/src/export.rs@@ -404,6 +404,13 @@ fn surfaces(flat: View, n_faces: usize) -> Res<Vec<(b::Surface, Option<b::Surfac};// A NURBS face's own block came first; a form follows the analytic face's canonical entry.let form = if kind != SURFACE_NURBS && forms.get(f) == Some(&1) { Some(next_nurbs(&mut nurbs_at)?) } else { None };+ // The record's torus is a ring torus. SMLib keeps horn and spindle tori too (a half disc+ // revolved about a line through its rim's end, its tube touching the axis, the major+ // radius a rounding below the minor): such a face is its NURBS form, unlabelled.+ let (surface, form) = match (surface, form) {+ (b::Surface::Torus { major_radius, minor_radius, .. }, Some(n)) if !(major_radius > minor_radius) => (n, None),+ other => other,+ };out.push((surface, form));}Ok(out)diff --git a/crates/smlib/src/sweeps_tests.rs b/crates/smlib/src/sweeps_tests.rsindex abf1fda680..5508d80884 100644--- a/crates/smlib/src/sweeps_tests.rs+++ b/crates/smlib/src/sweeps_tests.rs@@ -49,6 +49,24 @@ fn revolutions_whole_and_partial() {assert_close(solid_volume(&b, "quarter ring"), PI / 2.0 * 7.0 * 4.0, 1e-6, "quarter ring");}+/// A half disc of radius 14 centred 14 off the axis, its rim outward, three quarters of a turn+/// (rig sweeps/4007): a horn torus, which SMLib gives a major radius a rounding below its minor.+/// The record's torus is a ring torus, so the face comes out as its NURBS form, unlabelled, and+/// the record validates. Pappus: 3/4 turn · 2π (14 + 4·14 / 3π) · π 14² / 2.+#[test]+fn a_horn_torus_comes_out_as_its_nurbs() {+ let half = vec![+ Curve::Arc { center: [14.0, 0.0, 0.0], axis: [0.0, -1.0, 0.0], reference: [1.0, 0.0, 0.0], radius: 14.0, start: -PI / 2.0, end: PI / 2.0 },+ Curve::Line { start: [14.0, 0.0, 14.0], end: [14.0, 0.0, -14.0] },+ ];+ let b = Brep::revolve(&half, [0.0; 3], [0.0, 0.0, 1.0], 1.5 * PI, true).unwrap();+ let want = 1.5 * PI * (14.0 + 56.0 / (3.0 * PI)) * PI * 98.0;+ assert_close(solid_volume(&b, "horn torus"), want, 1e-6, "horn torus");+ let record = b.to_native().unwrap();+ record.validate().unwrap();+ assert!(record.faces.iter().all(|f| !matches!(f.surface, solidcraft_geom::brep::Surface::Torus { .. })), "a torus label on a horn torus");+}+#[test]fn sweeps_lofts_and_screws() {let disc = [circle([5.0, 0.0, 0.0], 2.0)];diff --git a/tests/kernel-cases/booleans/2928-join-cap-touching-lips-with-offset-walls/recipe.json b/tests/kernel-cases/booleans/2928-join-cap-touching-lips-with-offset-walls/recipe.jsonindex dff6c0d750..defab27cd8 100644--- a/tests/kernel-cases/booleans/2928-join-cap-touching-lips-with-offset-walls/recipe.json+++ b/tests/kernel-cases/booleans/2928-join-cap-touching-lips-with-offset-walls/recipe.json@@ -131,6 +131,14 @@"command": "solid.extrude","params": {"sketch": "Base",+ "profiles": [+ {+ "point": [+ 4,+ 0+ ]+ }+ ],"distance": 2,"operation": "new","body_name": "Base"diff --git a/tests/kernel-cases/shell/4009-closed-shell-internal-void/expected.json b/tests/kernel-cases/shell/4009-closed-shell-internal-void/expected.jsonindex 33c5e659fd..7c5ac82d3b 100644--- a/tests/kernel-cases/shell/4009-closed-shell-internal-void/expected.json+++ b/tests/kernel-cases/shell/4009-closed-shell-internal-void/expected.json@@ -6,6 +6,7 @@"source": "analytic","method": "outer box 40x30x12.5, void = inward offset box 35x25x7.5 (2.5 wall every side). V=15000-6562.5=8437.5; area=outer 2(1200+500+375)=4150 + void 2(875+187.5+262.5)... computed in python; faces 6+6=12; one body with an outer and an inner shell; centroid (20,15,6.25) by symmetry","body_count": 1,+ "shells": 2,"volume_mm3": 8437.5,"area_mm2": 6800.0,"faces": 12,