diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs index ca797a11c..69878323f 100644 --- a/crates/doc/src/document.rs +++ b/crates/doc/src/document.rs @@ -196,15 +196,16 @@ impl Operation { } } -/// What a join makes of solids that only touch, along an edge or at a point, or don't touch at -/// all: they share no volume and no area, so nothing fuses them. +/// What a join makes of pieces that share no face: they share no volume and no area, so nothing +/// fuses them. #[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum Touching { - /// Each becomes a body of its own. + /// A piece that touches another only along an edge or at a point cannot be one solid with it + /// and becomes a body of its own; pieces that touch nothing stay one body of several pieces. #[default] Separate, - /// They stay one body of several pieces. + /// Every piece stays in one body, also those that touch along an edge or at a point. OneBody, } @@ -2585,8 +2586,9 @@ pub struct Feature { /// its faces are named after them and references follow them through Update Links (#3330). #[serde(default, skip_serializing_if = "Vec::is_empty")] pub link_faces: Vec>, - /// What a join of this feature makes of solids that only touch or don't touch: separate - /// bodies (the default) or one body of several pieces. + /// What a join of this feature makes of pieces that share no face: those that touch along an + /// edge or at a point become separate bodies and those that touch nothing stay one body (the + /// default), or every piece stays one body. #[serde(default, skip_serializing_if = "Touching::is_separate")] pub touching: Touching, #[serde(flatten)] diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index d6eb4d390..d161d401f 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -777,7 +777,8 @@ impl ModelState { self.fitted.get(&feature)?.iter().fold(None, |acc, r| Some(acc.map_or((*r, *r), |(lo, hi): (f64, f64)| (lo.min(*r), hi.max(*r))))) } - /// How the solids join `feature` kept as separate bodies met, when it kept any apart. + /// How the pieces join `feature` split off into bodies of their own touched the others, when + /// it split any off. pub fn kept_separate(&self, feature: u64) -> Option { self.kept_separate.get(&feature).copied() } @@ -830,28 +831,30 @@ pub struct ModelState { /// The radius spline of each edge a fillet tapered (a point on the edge with it, by feature /// id, see `FilletFit::Taper`). tapered: BTreeMap>, - /// How the solids a join kept as separate bodies met (by feature id), for its notice. + /// How the pieces a join split off into bodies of their own touched the others (by feature + /// id), for its notice. kept_separate: BTreeMap, } -/// How the solids a join kept as separate bodies (`Touching::Separate`) met: the most any two -/// of them shared, least first. +/// How a piece a join split off into a body of its own (`Touching::Separate`) touched the +/// pieces it was joined with: the most any such piece shared with another, least first. #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum KeptSeparate { - /// Nothing: they don't touch. - Apart, /// A point. AtPoint, + /// A line or a point their boundaries don't hold (a face tangent to another): found on the + /// exact geometry, which doesn't say which. + Touching, /// A curve: an edge of both. AlongEdge, } impl KeptSeparate { - /// Its id in a feature's result: `apart`, `at_point` or `along_edge`. + /// Its id in a feature's result: `at_point`, `touching` or `along_edge`. pub fn id(self) -> &'static str { match self { - KeptSeparate::Apart => "apart", KeptSeparate::AtPoint => "at_point", + KeptSeparate::Touching => "touching", KeptSeparate::AlongEdge => "along_edge", } } @@ -859,8 +862,8 @@ impl KeptSeparate { /// What a feature's result says about it. pub fn notice(self) -> &'static str { match self { - KeptSeparate::Apart => "These bodies don't touch, so they were kept as separate bodies.", KeptSeparate::AtPoint => "These bodies only touch at a point, so they were kept as separate bodies.", + KeptSeparate::Touching => "These bodies only touch along a line or at a point, so they were kept as separate bodies.", KeptSeparate::AlongEdge => "These bodies only touch along an edge, so they were kept as separate bodies.", } } @@ -3143,10 +3146,14 @@ fn join(state: &mut ModelState, tools: Vec, target_idx: &[usize]) -> Res Ok(joined) } -/// With `Touching::Separate`: the pieces of the joined body `name` that share no area with each -/// other become bodies of their own, named as a cut's pieces are; pieces that share a face stay -/// one body. How the pieces kept apart met, when it has any (a sheet metal or mesh body keeps -/// its pieces). +/// With `Touching::Separate`: the joined body `name` never keeps two pieces that touch only +/// along an edge or at a point, since they cannot be one solid. Its pieces that share a face are +/// one group. The groups that hold the material of the body before the feature (the first group +/// where that is not known) stay in it, each unless it touches one already kept; every other +/// group that touches another along an edge or at a point (as the record says, or on the exact +/// geometry where SMLib left the contact out) becomes a body of its own, named as a cut's pieces +/// are; groups that touch nothing stay in the joined body, which keeps its name. How +/// the pieces split off touched, when any were (a sheet metal or mesh body keeps its pieces). fn separate_touching(state: &mut ModelState, name: &str) -> Result> { let Some(i) = state.bodies.iter().position(|b| b.name == name) else { return Ok(None) }; let Some(mb) = state.bodies.get(i).filter(|b| !b.body.is_mesh() && !state.sheets.iter().any(|s| s.body == name)) else { return Ok(None) }; @@ -3170,31 +3177,116 @@ fn separate_touching(state: &mut ModelState, name: &str) -> Result> = Vec::new(); - let mut group_of: BTreeMap = BTreeMap::new(); + let mut group_of: Vec = Vec::with_capacity(n); + let mut by_root: BTreeMap = BTreeMap::new(); for k in 0..n { - let g = *group_of.entry(find(&root, k)).or_insert_with(|| { + let g = *by_root.entry(find(&root, k)).or_insert_with(|| { groups.push(Vec::new()); groups.len() - 1 }); if let Some(list) = groups.get_mut(g) { list.push(k); } + group_of.push(g); } - if groups.len() < 2 { - return Ok(None); + // The groups each group touches along an edge or at a point (groups never share a face), and + // the most any two of them share. + let mut touches: Vec> = vec![Vec::new(); groups.len()]; + let mut most: Option = None; + for c in &contacts { + let (Some(&a), Some(&b)) = (group_of.get(c.regions[0]), group_of.get(c.regions[1])) else { continue }; + if a == b { + continue; + } + for (g, h) in [(a, b), (b, a)] { + if let Some(list) = touches.get_mut(g).filter(|l| !l.contains(&h)) { + list.push(h); + } + } + most = most.max(Some(if c.contact == Contact::Vertex { KeptSeparate::AtPoint } else { KeptSeparate::AlongEdge })); } - // The most any two of the separate pieces share (never a face). - let kept = contacts - .iter() - .filter(|c| find(&root, c.regions[0]) != find(&root, c.regions[1])) - .map(|c| if c.contact == Contact::Vertex { KeptSeparate::AtPoint } else { KeptSeparate::AlongEdge }) - .max() - .unwrap_or(KeptSeparate::Apart); - let pieces = mb.body.parts(&groups)?; + // Groups the record has apart may still touch where SMLib left the contact out of the + // topology (a face tangent to another along a line). + if groups.len() > 1 { + for [a, b] in unrecorded_touches(&mb.body.parts(&groups)?, &touches)? { + for (g, h) in [(a, b), (b, a)] { + if let Some(list) = touches.get_mut(g) { + list.push(h); + } + } + most = most.max(Some(KeptSeparate::Touching)); + } + } + let Some(most) = most else { return Ok(None) }; + // What stays in the joined body: the groups that touch nothing, and those of the body before + // the feature, each unless it touches one already kept. + let mut anchor = groups_from_body(mb, &groups).filter(|a| a.contains(&true)).unwrap_or_default(); + if anchor.is_empty() { + anchor = (0..groups.len()).map(|g| g == 0).collect(); + } + let mut stays: Vec = touches.iter().map(Vec::is_empty).collect(); + for g in 0..groups.len() { + let free = touches.get(g).is_some_and(|t| !t.iter().any(|h| stays.get(*h) == Some(&true))); + if free + && anchor.get(g) == Some(&true) + && let Some(slot) = stays.get_mut(g) + { + *slot = true; + } + } + let mut kept: Vec = groups.iter().zip(&stays).filter(|(_, s)| **s).flat_map(|(g, _)| g.iter().copied()).collect(); + kept.sort_unstable(); + let parts: Vec> = std::iter::once(kept).chain(groups.into_iter().zip(&stays).filter(|(_, s)| !**s).map(|(g, _)| g)).collect(); + let pieces = mb.body.parts(&parts)?; let mut taken: std::collections::BTreeSet = state.bodies.iter().map(|b| b.name.clone()).collect(); let named = named_pieces(mb, pieces, &mut taken); state.bodies.splice(i..=i, named); - Ok(Some(kept)) + Ok(Some(most)) +} + +/// The pairs of `pieces` (positions) that touch though `touches` (the pieces each touches, as +/// the record says) doesn't list them: their least distance on the exact faces and edges is +/// within the larger of their record tolerances. A distance only the meshes give is not trusted +/// to say they touch. +fn unrecorded_touches(pieces: &[Body], touches: &[Vec]) -> Result> { + let meshes = pieces + .iter() + .map(|p| { + let chord = (p.size() * 1e-4).max(1e-6); + Ok((p.mesh(&kernel::MeshTolerance::chord(chord))?, chord)) + }) + .collect::>>()?; + let shapes: Vec = pieces.iter().zip(&meshes).map(|(p, (m, chord))| kernel::DistanceShape::new(p, m, *chord)).collect(); + let mut out = Vec::new(); + for (a, (sa, pa)) in shapes.iter().zip(pieces).enumerate() { + for (b, (sb, pb)) in shapes.iter().zip(pieces).enumerate().skip(a + 1) { + if touches.get(a).is_some_and(|t| t.contains(&b)) || !sa.bounds().meets(&sb.bounds()) { + continue; + } + let tol = pa.record().tolerance.max(pb.record().tolerance); + if kernel::body_distance(sa, sb, tol)?.is_some_and(|d| d.exact && d.distance <= tol) { + out.push([a, b]); + } + } + } + Ok(out) +} + +/// Which of `groups` (of positions in `mb`'s material regions) hold material of the body named +/// as `mb` before the feature: a face of theirs came from one of its faces. `None` where the +/// body's lineage is not known. +fn groups_from_body(mb: &ModelBody, groups: &[Vec]) -> Option> { + let from = mb.lineage()?.faces_from_body(&mb.name); + let record = mb.body.record(); + let regions = record.material_regions(); + let holds = |k: usize| { + let shells = regions.get(k).and_then(|&r| record.regions.get(r)).map(|r| r.shells.as_slice()).unwrap_or_default(); + shells.iter().any(|&s| match record.shells.get(s as usize) { + Some(solidcraft_geom::brep::Shell::Faces { faces, .. }) => faces.iter().any(|f| from.get(f.face as usize) == Some(&true)), + _ => false, + }) + }; + Some(groups.iter().map(|g| g.iter().any(|&k| holds(k))).collect()) } /// The bodies the pieces of `mb` become: the first keeps its name, the others are numbered after diff --git a/crates/doc/src/format/pending/join-touching-bodies.rs b/crates/doc/src/format/pending/join-touching-bodies.rs index 6a3c465b8..a61bc4ca5 100644 --- a/crates/doc/src/format/pending/join-touching-bodies.rs +++ b/crates/doc/src/format/pending/join-touching-bodies.rs @@ -1,9 +1,10 @@ -//! A feature that joins saves what it makes of solids that only touch, along an edge or at a -//! point, or don't touch at all: `touching`, `separate` (each becomes a body of its own, the -//! default, not saved) or `one_body` (one body of several pieces). Older builds kept every join's -//! pieces in one body, so this step gives each feature of an older design that can join -//! `one_body`, which keeps its bodies as they were. The last release refuses a design with this -//! change (the newer format number). +//! A feature that joins saves what it makes of pieces that share no face: `touching`, +//! `separate` (the default, not saved: a piece that touches another only along an edge or at a +//! point becomes a body of its own, pieces that touch nothing stay one body) or `one_body` (every +//! piece in one body). Older builds kept every join's pieces in one body, also those touching +//! along an edge or at a point, so this step gives each feature of an older design that can join +//! `one_body`, which keeps its bodies as they were (only a join with such a contact would +//! change). The last release refuses a design with this change (the newer format number). use serde_json::Value; /// Feature types that join without an `operation` saying so: a combine (whose `new` joins too), diff --git a/crates/doc/src/lineage.rs b/crates/doc/src/lineage.rs index 9910578bf..5264e8982 100644 --- a/crates/doc/src/lineage.rs +++ b/crates/doc/src/lineage.rs @@ -96,6 +96,24 @@ impl Lineage { Lineage { history: self.history.clone(), operands } } + /// Whether each face of the body this is the lineage of came, in whole or in part, from a + /// face or edge of `name`, a body of the model before the feature. + pub(crate) fn faces_from_body(&self, name: &str) -> Vec { + let from: Vec = self.operands.iter().map(|op| matches!(op.as_ref(), Operand::Body(n) if n == name)).collect(); + self.history + .faces + .iter() + .map(|face| { + face.origins.iter().any(|origin| match *origin { + FaceOrigin::Face { operand, .. } | FaceOrigin::Edge { operand, .. } | FaceOrigin::Offset { operand, .. } => { + from.get(operand) == Some(&true) + } + FaceOrigin::Profile { .. } | FaceOrigin::Cap { .. } => false, + }) + }) + .collect() + } + /// A tool of `faces` faces and no edges (a mesh's triangles) whose faces have no role. pub(crate) fn unnamed_faces(faces: usize) -> Lineage { let faces = (0..faces).map(|face| FaceProv { origins: vec![FaceOrigin::Face { operand: 0, face }], change: Change::Kept }).collect(); diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rs index 7a5164fdd..9d96ba557 100644 --- a/crates/doc/src/tests.rs +++ b/crates/doc/src/tests.rs @@ -672,3 +672,78 @@ fn empty_boolean_targets_without_overlap_keep_plain_message() { assert_eq!(model.result(cut).unwrap().error.as_deref(), Some("there is no body to cut or intersect")); } } + +/// A box of `size` at `corner`, made with `operation`. +fn cube(doc: &mut Document, corner: Vec3, size: [f64; 3], operation: Operation) -> u64 { + let [length, width, height] = size.map(|x| Expr::new(x.to_string())); + doc.add_feature(FeatureKind::Box { corner: point_expr(corner), length, width, height, operation }, None).unwrap() +} + +/// The bodies of `doc` evaluated, by name with their volumes and pieces, and how feature +/// `feature`'s join touched the pieces it split off. +fn joined(doc: &Document, feature: u64) -> (Vec<(String, f64, usize)>, Option) { + let mut m = Model::new(); + m.evaluate(doc); + assert!(m.results.iter().all(|r| r.error.is_none()), "{:?}", m.results); + let kept = m.results.iter().find(|r| r.id == feature).and_then(|r| r.state.kept_separate(feature)); + let bodies = m.state().bodies.iter().map(|b| (b.name.clone(), measure(&b.body).unwrap().volume, b.body.lumps().unwrap().len())).collect(); + (bodies, kept) +} + +/// Two blocks joined along an edge cannot be one solid: the join splits them into two bodies and +/// says they touch along an edge. +#[test] +fn a_join_splits_blocks_touching_along_an_edge() { + let mut doc = Document::new("edge"); + cube(&mut doc, Vec3::ZERO, [10.0; 3], Operation::NewBody); + let join = cube(&mut doc, Vec3::new(10.0, 10.0, 0.0), [10.0; 3], Operation::Join); + let (bodies, kept) = joined(&doc, join); + assert_eq!(bodies.len(), 2, "{bodies:?}"); + assert!(bodies.iter().all(|(_, v, lumps)| rel(*v, 1000.0) < 1e-6 && *lumps == 1), "{bodies:?}"); + assert_eq!(kept, Some(KeptSeparate::AlongEdge)); + assert!(KeptSeparate::AlongEdge.notice().contains("along an edge")); +} + +/// Two blocks apart joined stay one body of two pieces, and the join says nothing. +#[test] +fn a_join_keeps_blocks_apart_in_one_body() { + let mut doc = Document::new("apart"); + cube(&mut doc, Vec3::ZERO, [10.0; 3], Operation::NewBody); + let join = cube(&mut doc, Vec3::new(20.0, 0.0, 0.0), [10.0; 3], Operation::Join); + let (bodies, kept) = joined(&doc, join); + assert_eq!(bodies.len(), 1, "{bodies:?}"); + assert!(rel(bodies[0].1, 2000.0) < 1e-6 && bodies[0].2 == 2, "{bodies:?}"); + assert_eq!(kept, None); +} + +/// A square ring joined with an arm touching its outer corner along an edge and a hub apart in +/// its hole: the ring and the hub stay one body under the ring's name, the arm is split off, and +/// the join says it touched along an edge. +#[test] +fn a_join_splits_off_only_what_touches_along_an_edge() { + let mut doc = Document::new("ring"); + cube(&mut doc, Vec3::new(-30.0, -30.0, 0.0), [60.0, 60.0, 6.0], Operation::NewBody); + cube(&mut doc, Vec3::new(-24.0, -24.0, -1.0), [48.0, 48.0, 8.0], Operation::Cut); + cube(&mut doc, Vec3::new(-5.0, -5.0, 0.0), [10.0, 10.0, 6.0], Operation::NewBody); + cube(&mut doc, Vec3::new(30.0, 30.0, 0.0), [20.0, 20.0, 6.0], Operation::NewBody); + let combine = doc + .add_feature( + FeatureKind::Combine { + target: "Body1".into(), + tools: vec!["Body3".into(), "Body2".into()], + operation: Operation::Join, + keep_tools: false, + }, + None, + ) + .unwrap(); + let (bodies, kept) = joined(&doc, combine); + let (ring, hub, arm) = (60.0 * 60.0 * 6.0 - 48.0 * 48.0 * 6.0, 600.0, 2400.0); + assert_eq!(bodies.len(), 2, "{bodies:?}"); + let named = |name: &str| bodies.iter().find(|(n, _, _)| n == name).cloned(); + let one = named("Body1").unwrap_or_else(|| panic!("{bodies:?}")); + assert!(rel(one.1, ring + hub) < 1e-6 && one.2 == 2, "the ring and the hub: {bodies:?}"); + let other = bodies.iter().find(|(n, _, _)| n != "Body1").cloned().unwrap_or_else(|| panic!("{bodies:?}")); + assert!(rel(other.1, arm) < 1e-6 && other.2 == 1, "the arm: {bodies:?}"); + assert_eq!(kept, Some(KeptSeparate::AlongEdge)); +} diff --git a/crates/engine/src/boolean_regression_tests.rs b/crates/engine/src/boolean_regression_tests.rs index 3f4e1fe49..961e074cb 100644 --- a/crates/engine/src/boolean_regression_tests.rs +++ b/crates/engine/src/boolean_regression_tests.rs @@ -284,8 +284,7 @@ fn buried_join_end_ignores_bodies_in_other_components() { run(&mut s, "sketch.create", json!({"plane": "XY"})); run(&mut s, "sketch.rectangle.two_point", json!({"p0": [2, 2], "p1": [4, 4]})); run(&mut s, "sketch.finish", json!({})); - // Child's box is apart from the tab: `touching: one_body` keeps them one body to measure. - run(&mut s, "solid.extrude", json!({"distance": 16, "operation": "join", "body_name": "Tab", "touching": "one_body"})); + run(&mut s, "solid.extrude", json!({"distance": 16, "operation": "join", "body_name": "Tab"})); let got = volume(&s, if own_body { "Child" } else { "Tab" }); let expected = 64.0 + if own_body { 800.0 } else { 0.0 }; assert!((got - expected).abs() < 1e-6, "{got}"); @@ -1011,11 +1010,11 @@ fn multi_target_join_keeps_nearby_bodies_and_original_absorption_order() { } } -/// Two posts joined into one body while apart (`touching: one_body`), trimmed by a cut that -/// splits neither, then joined to a case they stand on. The cut split the joined posts into -/// "Posts" and "Posts (1)" without saying so (`created_bodies` was empty), and the join then took -/// only "Posts", leaving the other post behind as a body of its own. A cut that does cut a body in -/// two still makes two bodies, and its reply names the new one. +/// Two posts joined into one body while apart, trimmed by a cut that splits neither, then joined +/// to a case they stand on. The cut split the joined posts into "Posts" and "Posts (1)" without +/// saying so (`created_bodies` was empty), and the join then took only "Posts", leaving the other +/// post behind as a body of its own. A cut that does cut a body in two still makes two bodies, +/// and its reply names the new one. #[test] fn cut_keeps_posts_joined_while_apart_in_one_body() { let mut s = Session::default(); @@ -1023,7 +1022,7 @@ fn cut_keeps_posts_joined_while_apart_in_one_body() { s.execute("solid.box", &json!({"length": 60, "width": 40, "height": 10, "center": [0, 0, 5], "operation": "new", "body_name": "Case"})).unwrap(); s.execute("solid.box", &post("Posts", -20.0)).unwrap(); s.execute("solid.box", &post("Post2", 20.0)).unwrap(); - s.execute("solid.combine", &json!({"target": "Posts", "tools": ["Post2"], "operation": "join", "touching": "one_body"})).unwrap(); + s.execute("solid.combine", &json!({"target": "Posts", "tools": ["Post2"], "operation": "join"})).unwrap(); s.execute("solid.box", &json!({"length": 80, "width": 20, "height": 10, "center": [0, 0, 40], "operation": "new", "body_name": "Trim"})).unwrap(); let cut = s.execute("solid.combine", &json!({"target": "Posts", "tools": ["Trim"], "operation": "cut"})).unwrap(); // Each post loses its top 5 mm: 10 x 10 x 25 left of each. @@ -1064,7 +1063,7 @@ fn combine_of_a_piece_a_cut_used_to_split_off_takes_the_body_it_is_part_of() { .unwrap(); s.execute("solid.box", &post("Posts", -20.0)).unwrap(); s.execute("solid.box", &post("Post2", 20.0)).unwrap(); - s.execute("solid.combine", &json!({"target": "Posts", "tools": ["Post2"], "operation": "join", "touching": "one_body"})).unwrap(); + s.execute("solid.combine", &json!({"target": "Posts", "tools": ["Post2"], "operation": "join"})).unwrap(); s.execute("solid.box", &json!({"length": 80, "width": 20, "height": 10, "center": [0, 0, 40], "operation": "new", "body_name": "Trim"})) .unwrap(); s.execute("solid.combine", &json!({"target": "Posts", "tools": ["Trim"], "operation": "cut"})).unwrap(); diff --git a/crates/engine/src/cmd/config_certificate_tests.rs b/crates/engine/src/cmd/config_certificate_tests.rs index 64fa932d5..ae7b451aa 100644 --- a/crates/engine/src/cmd/config_certificate_tests.rs +++ b/crates/engine/src/cmd/config_certificate_tests.rs @@ -112,8 +112,9 @@ fn legacy_v9_imported_emboss_anchor_and_ordinary_face_paint_replay_without_renam legacy["format"] = json!("solidcraft/9"); let reopened = Session::new(solidcraft_doc::Document::from_json(&legacy.to_string()).unwrap()); // Saved before format 14, it keeps naming the pieces it makes in the kernel's shell order, - // and numbering the pieces of its faces as that build did (#3902); saved before joins kept - // solids that only touch apart, it keeps them one body. + // and numbering the pieces of its faces as that build did (#3902); saved before joins split + // off pieces that touch only along an edge or at a point, it keeps them in + // one body. let anchored = solidcraft_doc::Feature { shell_piece_order: true, kernel_piece_order: true, touching: solidcraft_doc::Touching::OneBody, ..anchored }; assert_eq!(reopened.doc.feature(anchored.id).unwrap(), &anchored); // Names saved before format 14 keep naming the face they named, marked so they are found as diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rs index b50fe881c..f4a3b1e8c 100644 --- a/crates/engine/src/cmd/features.rs +++ b/crates/engine/src/cmd/features.rs @@ -25,7 +25,7 @@ pub static COMMANDS: &[CommandSpec] = &[ .key("E") .contract(&EXTRUDE_CONTRACT) .output(output_schema_for::) - .params("distance: expr (or through_all: true); taper?: angle expr (positive: outward, so the far end is larger along the extrusion direction; negative: inward, so the far end is smaller); corner?: preserve_curvature|tangent|round (how a taper closes a sharp corner its offset opens: each wall continues as itself, a line's plane or an arc's cone, until it meets its neighbour; each continues straight along its end tangent; or an arc about the corner. Without it, each profile preserves curvature where every curve is a line or an arc and takes tangent where another curve has a corner, and the feature's warning says so; a corner rule given is kept, and refused where the kernel cannot build it); sketch?: id|name (default: active or last sketch); profiles?: all | [index] | [{curves: [ids]}] (the profile whose outer loop is made of exactly these curves, or pieces of them; found again on every recompute, so it follows parameter changes; islands inside are its holes; an error when no profile or several match) | [{point:[x,y]}] (index and point picks are stored by their curves when that finds the same profile; a pick on a drawn profile that reference geometry, such as the projected outline of the face the sketch is on, cuts into regions takes the whole drawn profile); exact_regions?: bool (each index or point pick is exactly the region it names, as the dialogs send); default: every drawn profile, except that a loop inside another is its hole and a loop inside that hole is material again; face?: [x,y,z] (extrude a planar body face instead of a sketch profile); faces?: [[x,y,z],…] (coplanar faces of one body); face_body?: name (whose face, where faces of several bodies meet at the point); direction?: positive|negative|symmetric (distance is total thickness, split evenly around the start plane); convention?: total_distance|legacy_per_side (default total_distance; legacy preserves older symmetric extents); distance2?: expr (Two Sides: a second distance the other way from the first side, which may be through_all or to; with direction: negative the first side goes against the normal and distance2 along it); start_offset?: expr (along the sketch normal, also with direction: negative); to?: [x,y,z] (To Object: a face, vertex or point; to_offset?: expr past it); from?: [x,y,z] (From Object: start at that face or point); operation?: new|join|cut|intersect|auto (cut into a body, otherwise join existing solids; new in an empty component); touching?: separate|one_body (a join's solids that only touch, along an edge or at a point, or don't touch: separate bodies, the default, or one body); targets?: [body] (Join from a face, or from a sketch on a body's face, defaults to that face's body; explicit targets or participants override); name?; body_name?; thin?: true (Thin: a wall along sketch curves instead of the profiles) with curves?: [curve ids] (open chains and closed loops, joined where they meet end to end; default: every drawn curve of the sketch), thickness: expr, side?: center|inside|outside|two_sides (a closed loop's inside is the area it encloses, an open chain's the side it bends toward, a straight line's the left of its first curve as drawn; default center), thickness2?: expr (two_sides: the thickness outside); corners are mitred, crossing walls are one"), + .params("distance: expr (or through_all: true); taper?: angle expr (positive: outward, so the far end is larger along the extrusion direction; negative: inward, so the far end is smaller); corner?: preserve_curvature|tangent|round (how a taper closes a sharp corner its offset opens: each wall continues as itself, a line's plane or an arc's cone, until it meets its neighbour; each continues straight along its end tangent; or an arc about the corner. Without it, each profile preserves curvature where every curve is a line or an arc and takes tangent where another curve has a corner, and the feature's warning says so; a corner rule given is kept, and refused where the kernel cannot build it); sketch?: id|name (default: active or last sketch); profiles?: all | [index] | [{curves: [ids]}] (the profile whose outer loop is made of exactly these curves, or pieces of them; found again on every recompute, so it follows parameter changes; islands inside are its holes; an error when no profile or several match) | [{point:[x,y]}] (index and point picks are stored by their curves when that finds the same profile; a pick on a drawn profile that reference geometry, such as the projected outline of the face the sketch is on, cuts into regions takes the whole drawn profile); exact_regions?: bool (each index or point pick is exactly the region it names, as the dialogs send); default: every drawn profile, except that a loop inside another is its hole and a loop inside that hole is material again; face?: [x,y,z] (extrude a planar body face instead of a sketch profile); faces?: [[x,y,z],…] (coplanar faces of one body); face_body?: name (whose face, where faces of several bodies meet at the point); direction?: positive|negative|symmetric (distance is total thickness, split evenly around the start plane); convention?: total_distance|legacy_per_side (default total_distance; legacy preserves older symmetric extents); distance2?: expr (Two Sides: a second distance the other way from the first side, which may be through_all or to; with direction: negative the first side goes against the normal and distance2 along it); start_offset?: expr (along the sketch normal, also with direction: negative); to?: [x,y,z] (To Object: a face, vertex or point; to_offset?: expr past it); from?: [x,y,z] (From Object: start at that face or point); operation?: new|join|cut|intersect|auto (cut into a body, otherwise join existing solids; new in an empty component); touching?: separate|one_body (what a join makes of pieces that share no face: separate, the default, makes each piece that touches another only along an edge or at a point a body of its own and keeps pieces that touch nothing in one body; one_body keeps every piece in one body); targets?: [body] (Join from a face, or from a sketch on a body's face, defaults to that face's body; explicit targets or participants override); name?; body_name?; thin?: true (Thin: a wall along sketch curves instead of the profiles) with curves?: [curve ids] (open chains and closed loops, joined where they meet end to end; default: every drawn curve of the sketch), thickness: expr, side?: center|inside|outside|two_sides (a closed loop's inside is the area it encloses, an open chain's the side it bends toward, a straight line's the left of its first curve as drawn; default center), thickness2?: expr (two_sides: the thickness outside); corners are mitred, crossing walls are one"), CommandSpec::new("solid.revolve", "Revolve", revolve) .at("SOLID", "CREATE") .icon("revolve") @@ -51,7 +51,7 @@ pub static COMMANDS: &[CommandSpec] = &[ .key("F") .params("edges: [[x,y,z] point on edge | {body, index}] ; radius: expr; tangent_chain?: bool (default true: each picked edge's tangent chain is rounded with it; false: exactly the picked edges); body?; type?: constant|curvature (alias g2: curvature-continuous quintic between planar faces along straight edges, one planar end face at each end (including sloped ends); radius sets the equivalent circular setback, not constant curvature; exact fit only)|chord (radius is the width across)|variable (radius at the end nearest start, radius2 at the other; one end may be 0, where the round closes to the corner)|spline (the radius along the edge is a clamped B-spline from the end nearest start: radius is its first control radius, radii the rest, knots its knot vector from 0 to 1; one end may be 0); radius2?; start?: [x,y,z]; radii?: [expr, …]; knots?: [number, …]; mid?: [[position 0…1 from start, radius expr], …] (variable radii between the ends); smooth?: bool (smooth instead of straight between the radii); corner?: rolling|g2 (rolling, the default: the corners where three blended edges meet are pieces of the rolling ball's sphere, tangent to each blend; g2: a patch repeating each blend's surface up to the second order, constant-radius exact fillets only, refused where it cannot be built); fit?: exact|reduce|taper (exact, the default: a radius too large for the geometry around the edges is refused; reduce: where it doesn't fit it is reduced to the largest that does, one radius for edges sharing a face; the smallest used is returned as `radius_applied`, each edge's as `radii_applied: [{edge: [x,y,z], radius}]`, and noted in the feature's warning; taper: along each straight edge between planar faces where it doesn't fit, the radius follows the room there as a smooth spline, down to 0 where a face closes to a point, noted in the feature's warning)"), CommandSpec::new("solid.chamfer", "Chamfer", chamfer).at("SOLID", "MODIFY").icon("chamfer").params("edges: [[x,y,z] | {body, index}] ; distance: expr; tangent_chain?: bool (default true: each picked edge's tangent chain is cut with it; false: exactly the picked edges); distance2?: expr (along the second face) | angle?: expr (from the first face); flip?: bool (which face is first: by default the one facing up most); body?"), - CommandSpec::new("solid.combine", "Combine", combine).at("SOLID", "MODIFY").icon("combine").params("target: body; tools: [body]; operation?: join|cut|intersect; touching?: separate|one_body (a join's solids that only touch, along an edge or at a point, or don't touch: separate bodies, the default, or one body); keep_tools?: bool; new_component?: bool (the result goes into a new component; component_name?)"), + CommandSpec::new("solid.combine", "Combine", combine).at("SOLID", "MODIFY").icon("combine").params("target: body; tools: [body]; operation?: join|cut|intersect; touching?: separate|one_body (what a join makes of pieces that share no face: separate, the default, makes each piece that touches another only along an edge or at a point a body of its own and keeps pieces that touch nothing in one body; one_body keeps every piece in one body); keep_tools?: bool; new_component?: bool (the result goes into a new component; component_name?)"), CommandSpec::new("solid.pattern.rectangular", "Rectangular Pattern", pattern_rect) .at("SOLID", "CREATE") .icon("pattern_rect") @@ -611,7 +611,7 @@ pub(super) fn add_feature(s: &mut Session, p: &Value, kind: FeatureKind) -> Resu /// `add_feature`; `world` is false when `kind` is already in the active component's frame. fn add_feature_in(s: &mut Session, p: &Value, kind: FeatureKind, world: bool) -> Result { let name = str_(p, "name"); - // What a join makes of solids that only touch or don't touch: separate bodies unless asked. + // What a join makes of pieces that share no face (`Touching`): separate unless asked. let touching = match p.get("touching") { None | Some(Value::Null) => Touching::Separate, Some(v) => v.as_str().and_then(Touching::parse).ok_or_else(|| EngineError::Other("`touching` must be separate or one_body".into()))?, @@ -780,7 +780,8 @@ fn add_feature_in(s: &mut Session, p: &Value, kind: FeatureKind, world: bool) -> // A warning (a reference found again elsewhere, a reduced radius) 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()); - // A join that kept solids apart says so, with the edit that makes them one body instead. + // A join that split pieces touching along an edge or at a point into bodies of their own says + // so, with the edit that makes them one body instead. let notice = r.as_ref().and_then(|r| r.state.kept_separate(id)).map(|kept| FeatureNotice { message: kept.notice().to_string(), contact: kept.id().to_string(), diff --git a/crates/engine/src/cmd/interference_tests.rs b/crates/engine/src/cmd/interference_tests.rs index 3a29a0fc5..09feb1c93 100644 --- a/crates/engine/src/cmd/interference_tests.rs +++ b/crates/engine/src/cmd/interference_tests.rs @@ -69,11 +69,7 @@ fn a_piece_of_a_body_inside_another_is_still_found() { let mut s = Session::default(); run(&mut s, "solid.box", json!({"length": 20, "width": 20, "height": 20, "corner": [0, 0, 0], "body_name": "Block"})); run(&mut s, "solid.box", json!({"length": 2, "width": 2, "height": 2, "corner": [5, 5, 5], "operation": "new", "body_name": "Pieces"})); - run( - &mut s, - "solid.box", - json!({"length": 2, "width": 2, "height": 2, "corner": [30, 5, 5], "operation": "join", "targets": ["Pieces"], "touching": "one_body"}), - ); + run(&mut s, "solid.box", json!({"length": 2, "width": 2, "height": 2, "corner": [30, 5, 5], "operation": "join", "targets": ["Pieces"]})); let st = s.world_state().unwrap(); let pieces = st.bodies.iter().find(|b| b.name == "Pieces").map(|b| b.body.shell_count()); assert_eq!(pieces, Some(2), "the two cubes are one body in two pieces"); diff --git a/crates/engine/src/exact_tool_tests.rs b/crates/engine/src/exact_tool_tests.rs index ee34231cc..dc29b3c4c 100644 --- a/crates/engine/src/exact_tool_tests.rs +++ b/crates/engine/src/exact_tool_tests.rs @@ -103,9 +103,8 @@ fn a_cut_leaves_what_stands_beside_it() { } /// A join adds only its sketch: a block against a wall narrower than the block adds nothing -/// beside the wall, a block 0.1 mm from a wall leaves the gap (and, meeting nothing, stays a body -/// of its own), and a pad flush with a block's side does not reach a neighbour 0.8 mm from that -/// side. +/// beside the wall, a block 0.1 mm from a wall leaves the gap, and a pad flush with a block's +/// side does not reach a neighbour 0.8 mm from that side. #[test] fn a_join_adds_only_its_sketch() { let wall = || { @@ -120,11 +119,8 @@ fn a_join_adds_only_its_sketch() { let mut s = wall(); rectangle(&mut s, at_height(0.0), [2.1, 10.0], [20.0, 50.0], 30.0, "join", Value::Null); - let names = bodies(&s); - assert_eq!(names.len(), 2, "{names:?}"); - let total: f64 = names.iter().map(|b| volume(&s, b)).sum(); - assert!(same(total, 2.0 * 40.0 * 30.0 + 17.9 * 40.0 * 30.0), "{total}"); - assert!(names.iter().all(|b| !has(&s, b, [2.05, 30.0, 15.0])), "the 0.1 mm gap is filled"); + assert!(same(volume(&s, "Wall"), 2.0 * 40.0 * 30.0 + 17.9 * 40.0 * 30.0), "{}", volume(&s, "Wall")); + assert!(!has(&s, "Wall", [2.05, 30.0, 15.0]), "the 0.1 mm gap is filled"); let mut s = Session::default(); run(&mut s, "solid.box", json!({"length": 300, "width": 200, "height": 100, "body_name": "A"})); diff --git a/crates/engine/src/schema/features.rs b/crates/engine/src/schema/features.rs index 25fe04a38..53e1a9c56 100644 --- a/crates/engine/src/schema/features.rs +++ b/crates/engine/src/schema/features.rs @@ -38,7 +38,7 @@ pub struct BoxParams { /// The bodies a join, cut or intersect works on. Default: the bodies the box meets. #[serde(default)] pub targets: Option, - /// What a join makes of solids that only touch or don't touch. Default: separate. + /// What a join makes of pieces that share no face. Default: separate. #[serde(default)] pub touching: Option, /// The bodies taking part (the same as `targets` for a primitive). @@ -138,7 +138,7 @@ pub struct ExtrudeParams { /// that body. #[serde(default)] pub targets: Option, - /// What a join makes of solids that only touch or don't touch. Default: separate. + /// What a join makes of pieces that share no face. Default: separate. #[serde(default)] pub touching: Option, /// The bodies taking part; overrides the default scope. @@ -177,7 +177,8 @@ pub struct ExtrudeParams { pub struct FeatureNotice { /// The text to show. pub message: String, - /// How the solids kept apart met: `along_edge`, `at_point` or `apart`. + /// How the bodies split off touched the others: `along_edge`, `at_point` or `touching` (along + /// a line or at a point their boundaries don't hold). pub contact: String, /// The command that changes the feature as the notice offers. pub action: NoticeAction, @@ -212,9 +213,10 @@ pub struct FeatureResult { /// A warning from the evaluation (a Boolean that needed a retry, a reference found again /// elsewhere), or `null`. pub warning: Option, - /// A join that kept solids as separate bodies because they only touch along an edge or at a - /// point, or don't touch (its `touching: separate`): what to tell the user, and the edit that - /// makes them one body instead. Left out otherwise. + /// A join that split pieces into bodies of their own because they touch the others only along + /// an edge or at a point (its `touching: separate`): what to tell the user, and the edit that + /// makes them one body instead. Left out otherwise, also when the join kept pieces that touch + /// nothing in one body. #[serde(default, skip_serializing_if = "Option::is_none")] pub notice: Option, /// How long the feature took to evaluate, in milliseconds. diff --git a/crates/engine/src/schema/types.rs b/crates/engine/src/schema/types.rs index 5b1a47a9c..2ef39ac6f 100644 --- a/crates/engine/src/schema/types.rs +++ b/crates/engine/src/schema/types.rs @@ -379,7 +379,7 @@ impl JsonSchema for OperationParam { } } -/// What a join makes of solids that only touch or don't touch, as `Touching::parse` reads it. +/// What a join makes of pieces that share no face, as `Touching::parse` reads it. #[derive(Clone, Debug, PartialEq)] pub struct TouchingParam(pub Touching); @@ -402,7 +402,7 @@ impl JsonSchema for TouchingParam { fn json_schema(_: &mut SchemaGenerator) -> Schema { enum_schema( &["separate", "one_body"], - "What a join makes of solids that only touch, along an edge or at a point, or don't touch: separate bodies (separate, the default) or one body of several pieces (one_body).", + "What a join makes of pieces that share no face: separate (the default) makes each piece that touches another only along an edge or at a point a body of its own and keeps pieces that touch nothing in one body; one_body keeps every piece in one body.", ) } } diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 5ebb8decf..b2c75b6dd 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -203,21 +203,13 @@ fn join_merges_into_the_body_it_meets() { assert!(rel(volume(&mut s), 2064.0) < 1e-6); } -/// A join that meets no body keeps what it made as a body of its own beside the first body -/// (`touching: separate`, the default), and says so with the edit that makes them one; with -/// `touching: one_body` it joins the first body as a separate lump. +/// A join that meets no body still joins the first body, as a separate lump, and says nothing: +/// pieces that touch nothing stay one body. #[test] fn join_meeting_nothing_keeps_the_first_body() { let mut s = Session::default(); run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10})); let r = run(&mut s, "solid.box", json!({"length": 4, "width": 4, "height": 4, "corner": [40, 0, 0], "operation": "join"})); - assert_eq!(r["notice"]["contact"], "apart", "{r}"); - assert_eq!(r["notice"]["action"]["params"]["set"], json!({"touching": "one_body"}), "{r}"); - assert_eq!(s.model.state().bodies.len(), 2); - assert!(rel(volume(&mut s), 1064.0) < 1e-6); - run(&mut s, "edit.undo", json!({})); - let r = - run(&mut s, "solid.box", json!({"length": 4, "width": 4, "height": 4, "corner": [40, 0, 0], "operation": "join", "touching": "one_body"})); assert!(r.get("notice").is_none(), "{r}"); let st = s.model.state(); assert_eq!(st.bodies.len(), 1); @@ -225,6 +217,19 @@ fn join_meeting_nothing_keeps_the_first_body() { assert!(rel(volume(&mut s), 1064.0) < 1e-6); } +/// A join of a box touching the first only along an edge keeps it a body of its own and says +/// so, with the edit that makes them one body. +#[test] +fn join_touching_along_an_edge_keeps_a_separate_body() { + let mut s = Session::default(); + run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10})); + let r = run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [10, 10, 0], "operation": "join"})); + assert_eq!(r["notice"]["contact"], "along_edge", "{r}"); + assert_eq!(r["notice"]["message"], "These bodies only touch along an edge, so they were kept as separate bodies.", "{r}"); + assert_eq!(r["notice"]["action"]["params"]["set"], json!({"touching": "one_body"}), "{r}"); + assert_eq!(s.model.state().bodies.len(), 2); +} + /// A 1 mm floor extruded into a through hole, from the sketch the plate was extruded from: the /// disc's wall lies on the hole's and its foot in the plate's bottom face. A wedge extruded /// sideways on top keeps the plate from being a prism along Z (the 2D route would take it diff --git a/crates/engine/src/tests/robustness.rs b/crates/engine/src/tests/robustness.rs index 355edd6b7..df49cb5a2 100644 --- a/crates/engine/src/tests/robustness.rs +++ b/crates/engine/src/tests/robustness.rs @@ -141,8 +141,7 @@ fn fillet_that_would_open_the_surface_is_refused() { } } -/// Shell of a body in two pieces (a cylinder joined clear of a ring, kept one body with -/// `touching: one_body`): each piece is shelled. +/// Shell of a body in two pieces (a cylinder joined clear of a ring): each piece is shelled. #[test] fn shell_of_a_body_in_two_pieces() { script(json!([ @@ -150,7 +149,7 @@ fn shell_of_a_body_in_two_pieces() { {"command": "sketch.rectangle.two_point", "params": {"p0": [2.5, 0], "p1": [22.5, 17.5]}}, {"command": "sketch.finish", "params": {}}, {"command": "solid.revolve", "params": {"angle": "360 deg", "axis": "Z"}}, - {"command": "solid.cylinder", "params": {"axis": [0.0, 1.0, 0.0], "base": [-22.5, 22.5, 0.0], "height": 30.0, "operation": "join", "radius": 10.0, "touching": "one_body"}}, + {"command": "solid.cylinder", "params": {"axis": [0.0, 1.0, 0.0], "base": [-22.5, 22.5, 0.0], "height": 30.0, "operation": "join", "radius": 10.0}}, {"command": "solid.shell", "params": {"faces": [[-22.5, 22.5, 0.0]], "thickness": 2.0}} ])); } diff --git a/crates/geom/src/brep/part.rs b/crates/geom/src/brep/part.rs index 5520b36fe..5c6502c99 100644 --- a/crates/geom/src/brep/part.rs +++ b/crates/geom/src/brep/part.rs @@ -5,7 +5,7 @@ //! of bodies apart from each other join into one by [`Brep::compound`]. use serde::{Deserialize, Serialize}; -use super::{Brep, EdgeUseRef, Invalid, Loop, OrientedFace, Region, Result, Shell, require}; +use super::{Brep, Edge, EdgeUseRef, Invalid, Loop, OrientedFace, Region, Result, Shell, require}; /// A record cut from a larger one, and the source index of each of its items. #[derive(Clone, Debug, PartialEq)] @@ -70,8 +70,10 @@ impl Brep { /// How the material regions meet, read from the record: each pair of regions that shares a /// face, an edge or a vertex, with the most they share. `regions` index /// [`Brep::material_regions`] (so a body's lumps); pairs not listed are apart. Regions share - /// an edge where it is used by faces of both (more than two faces), a vertex where edges or - /// vertex loops of both end at it. Sorted by pair. + /// an edge where it is used by faces of both (more than two faces) or each has a copy of it + /// (an edge of the same curve and interval between vertices at the same points), a vertex + /// where edges or vertex loops of both end at it or at a copy of it (a vertex at the same + /// point). Sorted by pair. pub fn region_contacts(&self) -> Result> { let material = self.material_regions(); // The material regions (positions in `material`) each face, edge and vertex belongs to. @@ -126,8 +128,45 @@ impl Brep { } } } + // A producer that keeps each solid's boundary closed on its own gives solids that touch a + // copy each of the edge or vertex they share (SMLib's export splits them so): the same + // curve over the same interval between vertices at the same points, a vertex at the same + // point. Copies are one edge or vertex here; their owners are listed together. + let point = |v: u32| self.vertices.get(v as usize).map(|x| x.point.map(f64::to_bits)).ok_or(Invalid("vertex reference")); + let mut at_point = std::collections::BTreeMap::<[u64; 3], Vec>::new(); + for (v, owners) in on_vertex.iter().enumerate().filter(|(_, o)| !o.is_empty()) { + at_point.entry(point(u32::try_from(v).map_err(|_| Invalid("vertex index"))?)?).or_default().extend(owners); + } + let mut edge_copies = std::collections::BTreeMap::<([[u64; 3]; 2], [u64; 2]), Vec<(&Edge, Vec)>>::new(); + for (e, owners) in on_edge.iter().enumerate().filter(|(_, o)| !o.is_empty()) { + let edge = self.edges.get(e).ok_or(Invalid("edge reference"))?; + let key = ([point(edge.vertices[0])?, point(edge.vertices[1])?], edge.interval.map(f64::to_bits)); + let same = edge_copies.entry(key).or_default(); + match same.iter_mut().find(|(other, _)| other.curve == edge.curve && other.nurbs == edge.nurbs) { + Some((_, all)) => all.extend(owners), + None => same.push((edge, owners.clone())), + } + } + let copied = |lists: Vec>| -> Vec> { + lists + .into_iter() + .map(|mut l| { + l.sort_unstable(); + l.dedup(); + l + }) + .collect() + }; + let edge_copies = copied(edge_copies.into_values().flatten().map(|(_, owners)| owners).collect()); + let vertex_copies = copied(at_point.into_values().collect()); let mut pairs = std::collections::BTreeMap::<[usize; 2], Contact>::new(); - for (owners, contact) in [(&on_face, Contact::Face), (&on_edge, Contact::Edge), (&on_vertex, Contact::Vertex)] { + for (owners, contact) in [ + (&on_face, Contact::Face), + (&on_edge, Contact::Edge), + (&edge_copies, Contact::Edge), + (&on_vertex, Contact::Vertex), + (&vertex_copies, Contact::Vertex), + ] { for list in owners.iter().filter(|l| l.len() > 1) { for (i, &a) in list.iter().enumerate() { for &b in list.iter().skip(i + 1) { diff --git a/crates/kernel/src/boolean_history_tests.rs b/crates/kernel/src/boolean_history_tests.rs index 213512342..2e0956236 100644 --- a/crates/kernel/src/boolean_history_tests.rs +++ b/crates/kernel/src/boolean_history_tests.rs @@ -486,13 +486,19 @@ mod smlib { /// Cubes sharing an edge, and cubes sharing a vertex: SMLib's union touches itself there; /// it comes back as two closed shells, the shared edge and vertices split into one copy per - /// cube, each copy with its edge's history (verified against the geometry). + /// cube, each copy with its edge's history (verified against the geometry). The copies say + /// how the two meet. #[test] fn cubes_touching_along_an_edge_or_at_a_vertex_unite_into_two_solids() { + use solidcraft_geom::brep::part::{Contact, RegionContact}; let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0); - for (name, b) in [("edge", boxed(10.0, 10.0, 0.0, 20.0, 20.0, 10.0)), ("vertex", boxed(10.0, 10.0, 10.0, 20.0, 20.0, 20.0))] { + for (name, b, contact) in [ + ("edge", boxed(10.0, 10.0, 0.0, 20.0, 20.0, 10.0), Contact::Edge), + ("vertex", boxed(10.0, 10.0, 10.0, 20.0, 20.0, 20.0), Contact::Vertex), + ] { let r = through_smlib(&a, &b, BoolOp::Union); assert_eq!(r.shell_count(), 2, "{name}"); + assert_eq!(r.region_contacts().unwrap(), vec![RegionContact { regions: [0, 1], contact }], "{name}"); assert_eq!((r.face_count(), r.edge_count()), (12, 24), "{name}"); let v = crate::measure(&r).unwrap().volume; assert!((v - 2000.0).abs() < 1e-6 * 2000.0, "{name}: {v}"); diff --git a/tests/kernel-cases/booleans/2896-join-arm-end-near-ring-wall-gap/expected.json b/tests/kernel-cases/booleans/2896-join-arm-end-near-ring-wall-gap/expected.json index 3d9822f26..f7277377b 100644 --- a/tests/kernel-cases/booleans/2896-join-arm-end-near-ring-wall-gap/expected.json +++ b/tests/kernel-cases/booleans/2896-join-arm-end-near-ring-wall-gap/expected.json @@ -4,7 +4,8 @@ ], "what": "a join of a ring and an arm whose R5 convex tip stops 0.01 mm short of the ring's outer wall: nothing overlaps, so nothing fuses", "source": "analytic", - "method": "ring pi*(30^2-24^2)*6 and arm 6*(350+12.5*pi) are 0.01 mm apart (arm tip at x=30.01): the join has nothing to fuse, so V is the sum of the two. Solids a join leaves apart (or touching only along an edge or at a point) stay separate bodies (owner decision 2026-10-22: a join's `touching` is `separate` by default; crates/doc eval.rs, separate_touching): the arm comes out of the combine as a body of its own beside Ring, the tool body consumed as before: two bodies of one shell each", - "body_count": 2, - "volume_mm3": 8442.875567597792 + "method": "ring pi*(30^2-24^2)*6 and arm 6*(350+12.5*pi) are 0.01 mm apart (arm tip at x=30.01): the join has nothing to fuse, so V is the sum of the two and the arm stays a separate shell. A combine's join of a tool that meets no target keeps it in the target as a separate lump (crates/doc eval.rs, Operation::Join; engine test join_meeting_nothing_keeps_the_first_body), and the tool body is consumed: one body (Ring) of two shells", + "body_count": 1, + "volume_mm3": 8442.875567597792, + "shells": 2 } diff --git a/tests/kernel-cases/booleans/3379-circular-pattern-of-thin-spoke-on-ring/expected.json b/tests/kernel-cases/booleans/3379-circular-pattern-of-thin-spoke-on-ring/expected.json index d4aa56df0..f8ca6d564 100644 --- a/tests/kernel-cases/booleans/3379-circular-pattern-of-thin-spoke-on-ring/expected.json +++ b/tests/kernel-cases/booleans/3379-circular-pattern-of-thin-spoke-on-ring/expected.json @@ -4,7 +4,7 @@ ], "what": "a circular pattern (count 5) of a spoke thinner than the ring it joins (faces 0.5 mm inside the rim and hub faces)", "source": "analytic", - "method": "ring pi*(66^2-63^2)*3 + hub pi*12^2*3 + 5 spokes. A spoke is the box 53x2x2.5 (x 11..64, z +-1.25, y 0.5..2.5; the issue starts it at x=12, tangent to the hub, which joins the hub by a line only, so it starts at 11 here to overlap it). It overlaps the ring by 5.021 and the hub by 4.891 (width * Int over z in -1.25..1.25 of 64 - sqrt(63^2-z^2) and of sqrt(12^2-z^2) - 11). V = ring + hub + 5*(265 - overlaps), one body. The hub, apart from the ring when it is joined, is joined with touching: one_body, so the ring and hub stay one body for the spokes to join (a join keeps solids that share no volume as separate bodies by default, owner decision 2026-10-22).", + "method": "ring pi*(66^2-63^2)*3 + hub pi*12^2*3 + 5 spokes. A spoke is the box 53x2x2.5 (x 11..64, z +-1.25, y 0.5..2.5; the issue starts it at x=12, tangent to the hub, which joins the hub by a line only, so it starts at 11 here to overlap it). It overlaps the ring by 5.021 and the hub by 4.891 (width * Int over z in -1.25..1.25 of 64 - sqrt(63^2-z^2) and of sqrt(12^2-z^2) - 11). V = ring + hub + 5*(265 - overlaps), one body", "body_count": 1, "volume_mm3": 6279.997172312351 } diff --git a/tests/kernel-cases/booleans/3379-circular-pattern-of-thin-spoke-on-ring/recipe.json b/tests/kernel-cases/booleans/3379-circular-pattern-of-thin-spoke-on-ring/recipe.json index b4a1542a8..6e61872f9 100644 --- a/tests/kernel-cases/booleans/3379-circular-pattern-of-thin-spoke-on-ring/recipe.json +++ b/tests/kernel-cases/booleans/3379-circular-pattern-of-thin-spoke-on-ring/recipe.json @@ -45,8 +45,7 @@ "operation": "join", "targets": [ "rim" - ], - "touching": "one_body" + ] } }, { diff --git a/tests/kernel-cases/booleans/3455-join-of-64-separate-pegs/expected.json b/tests/kernel-cases/booleans/3455-join-of-64-separate-pegs/expected.json index 22d70b04b..aec452bd9 100644 --- a/tests/kernel-cases/booleans/3455-join-of-64-separate-pegs/expected.json +++ b/tests/kernel-cases/booleans/3455-join-of-64-separate-pegs/expected.json @@ -4,7 +4,7 @@ ], "what": "one combine of 64 separate pegs that do not touch: 36 s on truck, growing 4-9x per doubling; must finish in seconds", "source": "analytic", - "method": "64 non-touching 48-gon pegs of circumradius 2, 1 mm tall, 6 mm apart: each area 0.5*48*2^2*sin(2pi/48) = 12.5305, V = 64 * 12.5305 * 1. The join keeps them in one body (several lumps). A hang is a failure: time should grow with the number of bodies. One body with 64 shells. The combine joins with touching: one_body, which keeps the pegs one body (by default a join keeps solids that share no volume as separate bodies, owner decision 2026-10-22).", + "method": "64 non-touching 48-gon pegs of circumradius 2, 1 mm tall, 6 mm apart: each area 0.5*48*2^2*sin(2pi/48) = 12.5305, V = 64 * 12.5305 * 1. The join keeps them in one body (several lumps). A hang is a failure: time should grow with the number of bodies. One body with 64 shells", "body_count": 1, "shells": 64, "volume_mm3": 801.9529 diff --git a/tests/kernel-cases/booleans/3455-join-of-64-separate-pegs/recipe.json b/tests/kernel-cases/booleans/3455-join-of-64-separate-pegs/recipe.json index d78d69760..530e72815 100644 --- a/tests/kernel-cases/booleans/3455-join-of-64-separate-pegs/recipe.json +++ b/tests/kernel-cases/booleans/3455-join-of-64-separate-pegs/recipe.json @@ -12889,8 +12889,7 @@ "Peg (63)", "Peg (64)" ], - "operation": "join", - "touching": "one_body" + "operation": "join" } } ] diff --git a/tests/kernel-cases/booleans/3526-intersect-keeps-every-lump/expected.json b/tests/kernel-cases/booleans/3526-intersect-keeps-every-lump/expected.json index b2c6aa39e..2db4443d1 100644 --- a/tests/kernel-cases/booleans/3526-intersect-keeps-every-lump/expected.json +++ b/tests/kernel-cases/booleans/3526-intersect-keeps-every-lump/expected.json @@ -5,7 +5,7 @@ ], "what": "intersect of a two-lump target (two spheres joined while apart) with a box holding the bottom half of each", "source": "analytic", - "method": "box x -10..40, y -10..10, z -10..0 holds the z<=0 half of each r=4 sphere (centres (0,0,0), (30,0,0)): V = 2 * (2/3) pi 4^3 = 268.083. The body must not be removed. One body with two shells. The second sphere is joined with touching: one_body, which makes the two-lump target (a join keeps solids that share no volume as separate bodies by default, owner decision 2026-10-22).", + "method": "box x -10..40, y -10..10, z -10..0 holds the z<=0 half of each r=4 sphere (centres (0,0,0), (30,0,0)): V = 2 * (2/3) pi 4^3 = 268.083. The body must not be removed. One body with two shells", "body_count": 1, "shells": 2, "volume_mm3": 268.0826 diff --git a/tests/kernel-cases/booleans/3526-intersect-keeps-every-lump/recipe.json b/tests/kernel-cases/booleans/3526-intersect-keeps-every-lump/recipe.json index bbc7a5242..cd071542d 100644 --- a/tests/kernel-cases/booleans/3526-intersect-keeps-every-lump/recipe.json +++ b/tests/kernel-cases/booleans/3526-intersect-keeps-every-lump/recipe.json @@ -25,8 +25,7 @@ "operation": "join", "targets": [ "Balls" - ], - "touching": "one_body" + ] } }, {