Join: say so when the joined piece doesn't touch the body (#4434) (#4436)

* claim: #4434

* Join: say so when the joined piece doesn't touch the body (#4434)

A Join (extrude, revolve, sweep, loft, pipe, coil, primitives, thicken,
boundary fill, surface network) whose material meets none of its targets
still joins it to the first target as a separate piece. The result stays
as it was; the feature now warns: "the joined piece doesn't touch `Body1`,
so `Body1` is now in 2 separate pieces (New Body makes it a body of its
own)". History marks it and the command reply carries it.

The check compares pieces (outer shells, not voids) of the bodies the
feature changed or absorbed before and after it, so it holds for the
batched multi-profile path too, stays quiet for a join that bridges
pieces or closes a cavity, and leaves Combine (which joins the bodies it
is given) alone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Frank
2026-10-24 04:13:31 +00:00
committed by GitHub
parent d1a6262861
commit fc3e3b6c8d
3 changed files with 119 additions and 1 deletions
+54
View File
@@ -1965,6 +1965,7 @@ impl Model {
append_warning(&mut warning, note);
}
track_altered_sheets(&state, &mut next, f, &mut warning);
note_join_apart(&state, &next, f, &mut warning);
} else {
boolean_diagnostics = Default::default();
}
@@ -2343,6 +2344,59 @@ fn track_altered_sheets(before: &ModelState, after: &mut ModelState, f: &Feature
}
}
/// A Join whose material meets none of its targets still joins it, to the first target as a
/// separate piece (see `apply_traced`): a valid body in several pieces, but rarely what was meant
/// when Join was left on by mistake. Says so when a feature's Join leaves the bodies it changed
/// in more pieces than they had (#4434). Combine joins the bodies it is given, apart or not.
fn note_join_apart(before: &ModelState, after: &ModelState, f: &Feature, warning: &mut Option<String>) {
let operation = match &f.kind {
FeatureKind::Extrude { operation, .. }
| FeatureKind::Revolve { operation, .. }
| FeatureKind::Box { operation, .. }
| FeatureKind::Cylinder { operation, .. }
| FeatureKind::Sphere { operation, .. }
| FeatureKind::Torus { operation, .. }
| FeatureKind::Loft { operation, .. }
| FeatureKind::Sweep { operation, .. }
| FeatureKind::Pipe { operation, .. }
| FeatureKind::Coil { operation, .. }
| FeatureKind::BoundaryFill { operation, .. }
| FeatureKind::Thicken { operation, .. }
| FeatureKind::SurfaceNetwork { operation, .. } => *operation,
_ => return,
};
if operation != Operation::Join {
return;
}
let pieces = |b: &Body| b.lumps().map_or(1, |l| l.len());
// Pieces of the bodies the join changed or absorbed before it, and of those it kept after.
let (mut had, mut have) = (0usize, 0usize);
let mut grown: Vec<(&str, usize)> = Vec::new();
for was in &before.bodies {
match after.body(&was.name) {
Some(now) if now.body.same_shape(&was.body) => {}
Some(now) => {
let (old, new) = (pieces(&was.body), pieces(&now.body));
had += old;
have += new;
if new > old {
grown.push((now.name.as_str(), new));
}
}
None => had += pieces(&was.body),
}
}
if have <= had {
return;
}
for (name, n) in grown {
append_warning(
warning,
format!("the joined piece doesn't touch `{name}`, so `{name}` is now in {n} separate pieces (New Body makes it a body of its own)"),
);
}
}
/// Add tool bodies to the model according to the operation.
fn sheet_boolean_unchanged(body: &Body, tools: &[Body], op: Operation) -> Result<()> {
if sheet_boolean_changes(body, tools, op)? {
@@ -1346,3 +1346,64 @@ fn spherical_shell_cuts_and_joins_a_block_crossing_its_hollow() {
assert!(state.bodies.iter().all(|b| b.body.validity().is_empty()));
}
}
/// #4434: a Join whose profile stands apart from the body still joins it, as a second piece of
/// `Body1`, and says so; scripts read it from the reply as History shows it. A join that meets
/// the body, one that closes a cavity (a void is not a piece) and a Combine of bodies chosen
/// apart say nothing.
#[test]
fn join_that_meets_no_body_keeps_the_piece_and_says_so() {
let apart = "`Body1` is now in 2 separate pieces";
let two_squares = || {
let mut s = Session::default();
s.execute("sketch.create", &json!({"plane": "XY", "name": "Sketch1"})).unwrap();
s.execute("sketch.rectangle.two_point", &json!({"p0": [0, 0], "p1": [20, 20]})).unwrap();
s.execute("sketch.rectangle.two_point", &json!({"p0": [40, 0], "p1": [60, 20]})).unwrap();
s.execute(
"solid.extrude",
&json!({"sketch": "Sketch1", "profiles": [{"point": [10, 10]}], "distance": 10, "operation": "new", "name": "Extrude1"}),
)
.unwrap();
s
};
let mut s = two_squares();
let join = s
.execute(
"solid.extrude",
&json!({"sketch": "Sketch1", "profiles": [{"point": [50, 10]}], "distance": 10, "operation": "join", "name": "Extrude2"}),
)
.unwrap();
assert!(join["warning"].as_str().is_some_and(|w| w.contains(apart)), "{join}");
assert_eq!(s.model.results.last().and_then(|r| r.warning.as_deref()), join["warning"].as_str());
assert_eq!(s.model.state().bodies.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(), ["Body1"]);
assert!((volume(&s, "Body1") - 8000.0).abs() < 1e-6, "{}", volume(&s, "Body1"));
// Both profiles at once, one on the body and one apart: joined as one tool, still told.
let mut s = two_squares();
let both = s
.execute("solid.extrude", &json!({"sketch": "Sketch1", "profiles": [{"point": [10, 10]}, {"point": [50, 10]}], "distance": 5, "start_offset": 10, "operation": "join"}))
.unwrap();
assert!(both["warning"].as_str().is_some_and(|w| w.contains(apart)), "{both}");
// A box joined apart from the body, then one bridging both pieces: only the first is told.
let mut s = two_squares();
let box_apart = s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10, "center": [10, 40, 5], "operation": "join"})).unwrap();
assert!(box_apart["warning"].as_str().is_some_and(|w| w.contains(apart)), "{box_apart}");
let bridge = s.execute("solid.box", &json!({"length": 10, "width": 30, "height": 10, "center": [10, 25, 5], "operation": "join"})).unwrap();
assert!(bridge["warning"].is_null(), "{bridge}");
// A lid joined on a cup closes a cavity: one piece with a void, nothing to say.
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 20, "width": 20, "height": 10, "center": [0, 0, 5], "operation": "new"})).unwrap();
s.execute("solid.box", &json!({"length": 16, "width": 16, "height": 10, "center": [0, 0, 6], "operation": "cut"})).unwrap();
let lid = s.execute("solid.box", &json!({"length": 20, "width": 20, "height": 2, "center": [0, 0, 11], "operation": "join"})).unwrap();
assert_eq!(s.model.state().body("Body1").map(|b| b.body.shell_count()), Some(2));
assert!(lid["warning"].is_null(), "{lid}");
// Combine joins the bodies it is given, apart or not.
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10, "center": [0, 0, 5], "operation": "new", "body_name": "A"})).unwrap();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10, "center": [30, 0, 5], "operation": "new", "body_name": "B"})).unwrap();
let combine = s.execute("solid.combine", &json!({"target": "A", "tools": ["B"], "operation": "join"})).unwrap();
assert!(combine["warning"].is_null(), "{combine}");
}
+4 -1
View File
@@ -16,7 +16,10 @@ Extrude automatically selects **Join** for additions when the active component a
solid, including sideways elbow connections and screw bosses that meet only part of a face.
Extruding into existing material selects **Cut**. In an empty component it selects **New Body**;
choose **New Body** explicitly to keep an addition separate. Changing the default does not alter
operations already saved in a design.
operations already saved in a design. A Join (of an extrude, revolve, sweep, loft, primitive…)
whose material touches none of its target bodies still joins it, to the first one as a separate
piece, and the feature's warning says so: "`Body1` is now in 2 separate pieces". Combine joins
the bodies it is given without that warning.
**Extrude to a picked target** (Preferences › Design, off by default) lets a pick choose the
extent. With it on and a profile selected in the solid Extrude dialog, picking a face away from