Cut and Intersect say which component holds the body they missed (#4639) (#4641)

This commit is contained in:
raykholo
2026-10-25 18:42:50 +00:00
committed by GitHub
parent 10124c8ccf
commit 87c9a37663
9 changed files with 188 additions and 33 deletions
@@ -0,0 +1,11 @@
{
"en": {
"diagnostic.empty_boolean_component": "there is no body to cut or intersect in component '{component}'; the tool may overlap '{body}' in component '{other}' — activate that component or pick the body as a target"
},
"ja": {
"diagnostic.empty_boolean_component": "コンポーネント '{component}' に切り取りまたは交差の対象となるボディがありません。ツールはコンポーネント '{other}' の '{body}' と重なる可能性があります。そのコンポーネントをアクティブにするか、ボディを対象として選択してください"
},
"zh": {
"diagnostic.empty_boolean_component": "组件 '{component}' 中没有可供切除或求交的实体;工具可能与组件 '{other}' 中的 '{body}' 重叠 — 请激活该组件或选择该实体作为目标"
}
}
+81 -21
View File
@@ -2601,7 +2601,15 @@ fn intersection_tool_union(tools: Vec<Traced>) -> Result<Vec<Traced>> {
}
/// After a cut handled some sheet bodies as flat machining, apply it to the other targets.
fn apply_beside_sheet_cut(st: &mut ModelState, f: &Feature, tools: Vec<Traced>, op: Operation, targets: &[String], handled: &[String]) -> Result<()> {
fn apply_beside_sheet_cut(
doc: &Document,
st: &mut ModelState,
f: &Feature,
tools: Vec<Traced>,
op: Operation,
targets: &[String],
handled: &[String],
) -> Result<()> {
let effective = if targets.is_empty() { &f.participants } else { targets };
let all = effective.len() == 1 && effective.first().is_some_and(|t| t == "*");
let rest: Vec<String> = st
@@ -2616,7 +2624,7 @@ fn apply_beside_sheet_cut(st: &mut ModelState, f: &Feature, tools: Vec<Traced>,
if rest.is_empty() {
return Ok(());
}
apply_traced(st, f, tools, op, &rest)
apply_traced(doc, st, f, tools, op, &rest)
}
/// Only one target meets every separated tool. A tool with no contact must retain
@@ -2642,8 +2650,8 @@ fn common_join_target(state: &ModelState, indices: &[usize], tools: &[Traced]) -
Ok(common.filter(|index| contacts.iter().all(|contact| *contact == Some(*index))))
}
fn apply_op(state: &mut ModelState, f: &Feature, tools: Vec<Body>, op: Operation, targets: &[String]) -> Result<()> {
apply_traced(state, f, tools.into_iter().map(Traced::unnamed).collect(), op, targets)
fn apply_op(doc: &Document, state: &mut ModelState, f: &Feature, tools: Vec<Body>, op: Operation, targets: &[String]) -> Result<()> {
apply_traced(doc, state, f, tools.into_iter().map(Traced::unnamed).collect(), op, targets)
}
/// Many cut tools clear of each other (a pattern's copies, the circles of a vent field in one
@@ -2688,8 +2696,60 @@ pub(crate) fn boolean_scope(state: &ModelState, f: &Feature, targets: &[String])
(!all && !effective.is_empty(), names)
}
/// Suggest one nearby body without changing the default component scope or running a boolean.
fn empty_boolean_targets(doc: &Document, state: &ModelState, f: &Feature, tools: &[Traced], default_targets: bool) -> DocError {
let plain = "there is no body to cut or intersect";
if !default_targets {
return DocError::Invalid(plain.into());
}
let component_name = |id| {
if id == 0 {
doc.name.clone()
} else {
doc.components.iter().take(10_000).find(|c| c.id == id).map(|c| c.name.clone()).unwrap_or_else(|| format!("Component{id}"))
}
};
let tool_bounds: Vec<_> = tools.iter().take(64).map(|t| t.body.outline_bounds()).collect();
let frame = doc.component_transform(f.component);
let Some(inverse) = crate::mat_inverse(&frame) else { return DocError::Invalid(plain.into()) };
// Named by the component the Browser shows the body in; one shown in the feature's own
// component has no other component to point at.
let others = state
.bodies
.iter()
.take(256)
.map(|b| (b, doc.model_body_component(b)))
.filter(|(b, owner)| b.component != f.component && *owner != f.component);
for (body, owner) in others {
// Compare in the feature's frame, including component placements and body offsets.
let world = body_world(doc, body);
let relative = crate::mat_mul(&inverse, &world);
let bounds = body.outline_bounds();
if bounds.is_empty() || !bounds.min.is_finite() || !bounds.max.is_finite() {
continue;
}
let mut placed = solidcraft_geom::Aabb3::EMPTY;
for x in [bounds.min.x, bounds.max.x] {
for y in [bounds.min.y, bounds.max.y] {
for z in [bounds.min.z, bounds.max.z] {
placed.add(crate::apply_point(&relative, Vec3::new(x, y, z)));
}
}
}
if tool_bounds.iter().any(|b| !b.is_empty() && b.min.is_finite() && b.max.is_finite() && b.meets(&placed)) {
let own = component_name(f.component);
let other = component_name(owner);
let name = &body.name;
return DocError::Invalid(format!(
"{plain} in component '{own}'; the tool may overlap '{name}' in component '{other}' — activate that component or pick the body as a target"
));
}
}
DocError::Invalid(plain.into())
}
/// [`apply_op`] with tools whose lineage is known: the bodies it makes or changes keep theirs.
fn apply_traced(state: &mut ModelState, f: &Feature, tools: Vec<Traced>, op: Operation, targets: &[String]) -> Result<()> {
fn apply_traced(doc: &Document, state: &mut ModelState, f: &Feature, tools: Vec<Traced>, op: Operation, targets: &[String]) -> Result<()> {
let tools = if op == Operation::Intersect { intersection_tool_union(tools)? } else { tools };
// Participants: the feature's own targets, else its explicit participants, else the bodies
// of its component (and what it made itself): other components are left alone.
@@ -2709,7 +2769,7 @@ fn apply_traced(state: &mut ModelState, f: &Feature, tools: Vec<Traced>, op: Ope
};
if op == Operation::NewBody || target_idx.is_empty() {
if op == Operation::Cut || op == Operation::Intersect {
return Err(DocError::Invalid("there is no body to cut or intersect".into()));
return Err(empty_boolean_targets(doc, state, f, &tools, targets.is_empty()));
}
for (k, t) in tools.into_iter().enumerate() {
let name = new_name(state, f, k);
@@ -2755,7 +2815,7 @@ fn apply_traced(state: &mut ModelState, f: &Feature, tools: Vec<Traced>, op: Ope
let mut batched = state.clone();
// Preserve the original participants. For Join, the compound's larger
// size must not expand the contact tolerance and absorb a nearby body.
if apply_traced(&mut batched, f, vec![Traced::step(compound, &tools.iter().collect::<Vec<_>>())], op, &names).is_ok() {
if apply_traced(doc, &mut batched, f, vec![Traced::step(compound, &tools.iter().collect::<Vec<_>>())], op, &names).is_ok() {
*state = batched;
return Ok(());
}
@@ -6301,12 +6361,12 @@ fn replay(
}
// New bodies from a pattern join their source when they touch it (as one feature would).
if f.body_names.is_empty() {
apply_traced(st, f, copies, op, &targets)?;
apply_traced(doc, st, f, copies, op, &targets)?;
} else {
let start = st.bodies.iter().filter(|b| b.feature == f.id).count();
let mut named = f.clone();
named.body_names = f.body_names.iter().skip(start).cloned().collect();
apply_traced(st, &named, copies, op, &targets)?;
apply_traced(doc, st, &named, copies, op, &targets)?;
}
}
if missed > 0 {
@@ -6787,10 +6847,10 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
let bodies: Vec<Body> = tools.iter().map(|t| t.body.clone()).collect();
let handled = more::sheet_cut(f, st, &bodies, &crate::plain(targets), constructor.as_ref(), warning)?;
if !handled.is_empty() {
return apply_beside_sheet_cut(st, f, tools, *operation, &crate::plain(targets), &handled);
return apply_beside_sheet_cut(doc, st, f, tools, *operation, &crate::plain(targets), &handled);
}
}
apply_traced(st, f, tools, *operation, &crate::plain(targets))
apply_traced(doc, st, f, tools, *operation, &crate::plain(targets))
}
FeatureKind::Hole { thread, thread_depth, diameter, .. } => {
let thread_depth = thread_depth.as_ref().map(|d| val(vals, d, Kind::Length)).transpose()?;
@@ -6805,9 +6865,9 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
let handled = sheet_hole_cut(st, f, &tools, warning)?;
let tools: Vec<Traced> = tools.into_iter().map(|(tool, _)| tool).collect();
if handled.is_empty() {
apply_traced(st, f, tools, Operation::Cut, &[])?;
apply_traced(doc, st, f, tools, Operation::Cut, &[])?;
} else {
apply_beside_sheet_cut(st, f, tools, Operation::Cut, &[], &handled)?;
apply_beside_sheet_cut(doc, st, f, tools, Operation::Cut, &[], &handled)?;
}
if let Some(d) = thread {
// Find the bore beyond any entry recess, including shallow and through holes.
@@ -7014,7 +7074,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
if *remove_tools {
st.bodies.retain(|b| !tools.iter().any(|t| *t == b.name));
}
apply_traced(st, f, made, *operation, &[])
apply_traced(doc, st, f, made, *operation, &[])
}
FeatureKind::SplitFace { faces, body, plane, tool, sketch } => {
let i = body_at(st, body, &crate::plain(faces))?;
@@ -7247,9 +7307,9 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
let handled = more::sheet_primitive_cut(f, st, &b, more::PrimitivePrism::Box { lo: corner, hi: corner + s }, *operation, false, warning)?;
let tools = vec![crate::lineage::box_tool(b)];
if !handled.is_empty() {
return apply_beside_sheet_cut(st, f, tools, *operation, &[], &handled);
return apply_beside_sheet_cut(doc, st, f, tools, *operation, &[], &handled);
}
apply_traced(st, f, tools, *operation, &[])
apply_traced(doc, st, f, tools, *operation, &[])
}
FeatureKind::Cylinder { base, axis, radius, height, operation } => {
let (base, radius, height) = (point(vals, base)?, val(vals, radius, Kind::Length)?, val(vals, height, Kind::Length)?);
@@ -7259,17 +7319,17 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
let handled = more::sheet_primitive_cut(f, st, &b, prism, *operation, false, warning)?;
let tools = vec![crate::lineage::cylinder_tool(b)];
if !handled.is_empty() {
return apply_beside_sheet_cut(st, f, tools, *operation, &[], &handled);
return apply_beside_sheet_cut(doc, st, f, tools, *operation, &[], &handled);
}
apply_traced(st, f, tools, *operation, &[])
apply_traced(doc, st, f, tools, *operation, &[])
}
FeatureKind::Sphere { center, radius, operation } => {
let b = kernel::sphere(point(vals, center)?, val(vals, radius, Kind::Length)?)?;
apply_op(st, f, vec![b], *operation, &[])
apply_op(doc, st, f, vec![b], *operation, &[])
}
FeatureKind::Torus { center, major, minor, operation } => {
let b = kernel::torus(point(vals, center)?, val(vals, major, Kind::Length)?, val(vals, minor, Kind::Length)?)?;
apply_op(st, f, vec![b], *operation, &[])
apply_op(doc, st, f, vec![b], *operation, &[])
}
FeatureKind::Combine { target, tools, operation, keep_tools } => {
if tools.iter().any(|t| t == target) {
@@ -7317,7 +7377,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
return Ok(()); // the pieces were all joined back into the body they are part of
}
let op = if *operation == Operation::NewBody { Operation::Join } else { *operation };
apply_traced(st, f, tb, op, std::slice::from_ref(&target.0))?;
apply_traced(doc, st, f, tb, op, std::slice::from_ref(&target.0))?;
if !keep_tools {
st.bodies.retain(|b| !tools.iter().any(|t| *t == b.name));
}
+8 -8
View File
@@ -67,11 +67,11 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
if st.bodies.is_empty() {
return Err(DocError::Invalid("there is no body to emboss".into()));
}
apply_op(st, f, tools, if *deboss { Operation::Cut } else { Operation::Join }, &crate::plain(targets))
apply_op(doc, st, f, tools, if *deboss { Operation::Cut } else { Operation::Join }, &crate::plain(targets))
}
FeatureKind::Rib { .. } => {
let tools = rib_tools(vals, st, f, None)?;
apply_op(st, f, tools, Operation::Join, &[])
apply_op(doc, st, f, tools, Operation::Join, &[])
}
FeatureKind::ReplaceFace { faces, target, body } => {
let tp = doc.resolve_plane_in(vals, target, 0, Some(st))?;
@@ -1889,7 +1889,7 @@ pub(super) fn plastic_eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &F
tools.extend(kernel::extrude(&rp, &[rect], -delta, hr)?.into_iter().map(|b| crate::lineage::part_tool(b, &format!("rib{k}"))));
}
}
apply_traced(st, f, tools, Operation::Join, std::slice::from_ref(&target))?;
apply_traced(doc, st, f, tools, Operation::Join, std::slice::from_ref(&target))?;
// The root fillet: rounds the circle where the post meets the face.
if rf > 1e-9 {
let i = st.bodies.iter().position(|b| b.name == target).ok_or_else(|| DocError::Invalid("boss body".into()))?;
@@ -1913,7 +1913,7 @@ pub(super) fn plastic_eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &F
let hp = Plane::new(position.0, x, z.cross(x)).ok_or_else(|| DocError::Invalid("hole frame".into()))?;
let tool = kernel::extrude(&hp, &[Region2 { outer: Loop2::circle(Vec2::ZERO, rh), holes: Vec::new() }], h - depth, h + delta)?;
let tool = tool.into_iter().map(|b| crate::lineage::part_tool(b, "hole")).collect();
apply_traced(st, f, tool, Operation::Cut, std::slice::from_ref(&target))?;
apply_traced(doc, st, f, tool, Operation::Cut, std::slice::from_ref(&target))?;
}
Ok(())
}
@@ -1999,10 +1999,10 @@ pub(super) fn plastic_eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &F
let delta = (h * 0.05).clamp(1e-3, 0.5);
if *groove {
let tool = kernel::extrude(&plane, &[band], -(h + g), delta)?.into_iter().map(|b| crate::lineage::part_tool(b, "groove")).collect();
apply_traced(st, f, tool, Operation::Cut, std::slice::from_ref(&target))
apply_traced(doc, st, f, tool, Operation::Cut, std::slice::from_ref(&target))
} else {
let tool = kernel::extrude(&plane, &[band], -delta, h)?.into_iter().map(|b| crate::lineage::part_tool(b, "lip")).collect();
apply_traced(st, f, tool, Operation::Join, std::slice::from_ref(&target))
apply_traced(doc, st, f, tool, Operation::Join, std::slice::from_ref(&target))
}
}
FeatureKind::SnapFit { position, direction, hook, length, thickness, width, catch_depth, catch_length, body } => {
@@ -2028,7 +2028,7 @@ pub(super) fn plastic_eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &F
let (lo, hi) = if sgn > 0.0 { (0.0, w) } else { (-w, 0.0) };
let tool = kernel::extrude(&pl, &[Region2 { outer: lp, holes: Vec::new() }], lo, hi)?;
let tool = tool.into_iter().map(|b| crate::lineage::part_tool(b, "arm")).collect();
apply_traced(st, f, tool, Operation::Join, std::slice::from_ref(&target))
apply_traced(doc, st, f, tool, Operation::Join, std::slice::from_ref(&target))
}
FeatureKind::Rest { position, direction, along, width, length, height, draft, thickness, body } => {
let target = body_under(st, body, position.0)?;
@@ -2079,7 +2079,7 @@ pub(super) fn plastic_eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &F
kernel::extrude(&base, &[region], 0.0, h + delta)?
};
let tool = tool.into_iter().map(|b| crate::lineage::part_tool(b, "rest")).collect();
apply_traced(st, f, tool, Operation::Join, std::slice::from_ref(&target))
apply_traced(doc, st, f, tool, Operation::Join, std::slice::from_ref(&target))
}
_ => Err(DocError::Invalid(format!("{} is not a plastic feature", f.name))),
}
+1 -1
View File
@@ -65,7 +65,7 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
if tools.is_empty() {
return Err(DocError::Invalid("pick the surfaces to thicken".into()));
}
apply_op(st, f, tools, *operation, &crate::plain(targets))
apply_op(doc, st, f, tools, *operation, &crate::plain(targets))
}
FeatureKind::SurfaceTrim { body, plane, tool, keep, keep_more, curves, with, keep_with, stitch, extend } => {
let i = st.bodies.iter().position(|b| &b.name == body).ok_or_else(|| DocError::Unknown(format!("body `{body}`")))?;
+50
View File
@@ -492,3 +492,53 @@ fn new_names_take_the_first_free_number() {
let next = sketch(&mut doc);
assert_eq!(name(&doc, next), names[0], "the first freed number is taken again");
}
#[test]
fn empty_boolean_targets_name_overlapping_component() {
for (operation, offset) in [(Operation::Cut, 0.0), (Operation::Intersect, 0.0), (Operation::Cut, 40.0)] {
let (mut doc, sketch) = plate_doc();
let imported = doc.add_component(Some("Imported STEP"), 0).unwrap();
let part = doc.add_component(Some("Part1"), 0).unwrap();
doc.features.last_mut().unwrap().component = imported;
doc.feature_mut(sketch).unwrap().component = imported;
doc.occurrences.iter_mut().find(|o| o.component == imported).unwrap().transform[2][3] = offset;
let mut kind = doc.features.last().unwrap().kind.clone();
if let FeatureKind::Extrude { operation: op, .. } = &mut kind {
*op = operation;
}
let cut = doc.add_feature(kind, None).unwrap();
doc.feature_mut(cut).unwrap().component = part;
let mut model = Model::new();
model.evaluate(&doc);
let error = model.result(cut).unwrap().error.as_deref().unwrap();
assert!(error.contains("component 'Part1'"), "offset {offset}: {error}");
assert!(error.contains("'Body1' in component 'Imported STEP'"), "offset {offset}: {error}");
assert!(error.contains("activate that component or pick the body as a target"), "offset {offset}: {error}");
assert_eq!(model.state().bodies.len(), 1);
assert!(rel(measure(&model.state().bodies[0].body).unwrap().volume, 24000.0) < 1e-9);
}
}
#[test]
fn empty_boolean_targets_without_overlap_keep_plain_message() {
for operation in [Operation::Cut, Operation::Intersect] {
let (mut doc, _) = plate_doc();
let part = doc.add_component(Some("Part1"), 0).unwrap();
let cut = doc
.add_feature(
FeatureKind::Box {
corner: point_expr(Vec3::new(100.0, 100.0, 100.0)),
length: "1".into(),
width: "1".into(),
height: "1".into(),
operation,
},
None,
)
.unwrap();
doc.feature_mut(cut).unwrap().component = part;
let mut model = Model::new();
model.evaluate(&doc);
assert_eq!(model.result(cut).unwrap().error.as_deref(), Some("there is no body to cut or intersect"));
}
}
+1 -1
View File
@@ -2270,7 +2270,7 @@ fn error_rows(app: &mut SolveApp, ctx: &egui::Context, d: &mut Dialog, ui: &mut
/// message is in the catalogs.
fn shown_error(error: &str) -> String {
let msg = error.strip_prefix("invalid parameters for `").and_then(|rest| rest.split_once("`: ")).map_or(error, |(_, msg)| msg);
crate::i18n::tr_label(msg).to_string()
crate::i18n::tr_diagnostic(crate::i18n::tr_label(msg))
}
/// Find the Boundary Fill cells again when the tool bodies changed (keeping the choices of
+34
View File
@@ -166,6 +166,22 @@ impl Locale {
self.default_name(text).unwrap_or_else(|| text.to_string())
}
/// Evaluation errors stay English for scripts; the empty Cut/Intersect hint that names
/// another component is translated where it is shown. Other text is returned unchanged.
pub fn diagnostic(self, text: &str) -> String {
const PREFIX: &str = "there is no body to cut or intersect in component '";
if let Some((before, detail)) = text.split_once(PREFIX)
&& let Some((component, detail)) = detail.split_once("'; the tool may overlap '")
&& let Some((body, detail)) = detail.split_once("' in component '")
&& let Some((other, after)) = detail.split_once("' — activate that component or pick the body as a target")
{
let (component, body, other) = (self.given_name(component), self.given_name(body), self.given_name(other));
let message = self.format("diagnostic.empty_boolean_component", &[("component", &component), ("body", &body), ("other", &other)]);
return format!("{before}{message}{after}");
}
text.to_string()
}
/// Translate generated browser names and labels, preserving custom names otherwise.
pub fn dynamic(self, text: &str) -> String {
if let Some(name) = self.default_name(text) {
@@ -258,6 +274,9 @@ pub fn tr_dyn(text: &str) -> String {
pub fn tr_name(text: &str) -> String {
CURRENT.with(|current| current.get().given_name(text))
}
pub fn tr_diagnostic(text: &str) -> String {
CURRENT.with(|current| current.get().diagnostic(text))
}
#[cfg(test)]
mod tests {
@@ -309,6 +328,21 @@ mod tests {
}
}
#[test]
fn empty_boolean_component_diagnostic_translates_with_literal_names() {
let message = "solid.extrude: there is no body to cut or intersect in component 'Part {1}'; the tool may overlap 'Bracket' in component 'Imported STEP' — activate that component or pick the body as a target";
assert_eq!(Locale::for_language("en").diagnostic(message), message);
for (language, prefix) in [("ja", "solid.extrude: コンポーネント"), ("zh", "solid.extrude: 组件")] {
let translated = Locale::for_language(language).diagnostic(message);
assert!(translated.starts_with(prefix), "{translated}");
for name in ["Part {1}", "Bracket", "Imported STEP"] {
assert!(translated.contains(name), "{translated}");
}
}
let plain = "there is no body to cut or intersect";
assert_eq!(Locale::for_language("ja").diagnostic(plain), plain);
}
/// English first, then by id, so adding a locale edits only its own line.
#[test]
fn locales_are_listed_english_first_then_by_id() {
+1 -1
View File
@@ -1407,7 +1407,7 @@ impl SolveApp {
}
pub fn set_status(&mut self, s: impl Into<String>, error: bool) {
let (text, at) = (s.into(), now_ms());
let (text, at) = (i18n::tr_diagnostic(&s.into()), now_ms());
self.messages.push(&text, error, at);
self.status = Some((text, at, error));
self.status_undo = false;
+1 -1
View File
@@ -296,7 +296,7 @@ pub(crate) fn clipboard_buttons(app: &mut SolveApp, ui: &mut egui::Ui, id: u64)
pub(crate) fn status_text(name: &str, ty: &str, error: Option<&str>, warning: Option<&str>) -> String {
let mut text = format!("{name} ({ty})");
if let Some(error) = error {
text.push_str(&format!("\nError: {error}"));
text.push_str(&format!("\nError: {}", crate::i18n::tr_diagnostic(error)));
}
if let Some(warning) = warning {
text.push_str(&format!("\nWarning: {warning}"));