Skip to content

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

Extrudes from a nested STEP part's face join and cut it with the imported root active (#3223, #2872) (#3852)

raykholo9b8016342163
diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rs
index 8f9d762c66..51c5ad8fc6 100644
--- a/crates/engine/src/cmd/features.rs
+++ b/crates/engine/src/cmd/features.rs
@@ -205,13 +205,16 @@ fn auto_operation_in(s: &Session, p: &Value, world_faces: bool) -> Option<&'stat
// Match the evaluator's implicit participants: a grouped cut from an empty
// assembly component considers every body; otherwise keep the active scope.
// Explicit participants override either default.
+ // A component with no body of its own works on those of the components inside it (#3223).
let parts = string_list(p, "participants");
let implicit_all = grouped.is_some() && !st.bodies.iter().any(|body| s.doc.model_body_component(body) == s.active_component);
- let bodies: Vec<_> = st
- .bodies
- .iter()
- .filter(|b| if parts.is_empty() { implicit_all || s.doc.model_body_component(b) == s.active_component } else { parts.contains(&b.name) })
- .collect();
+ let bodies: Vec<_> = if !parts.is_empty() {
+ st.bodies.iter().filter(|b| parts.contains(&b.name)).collect()
+ } else if implicit_all {
+ st.bodies.iter().collect()
+ } else {
+ active_scope(s, &st)
+ };
if bodies.is_empty() {
return Some("new");
}
@@ -494,11 +497,12 @@ fn add_feature_in(s: &mut Session, p: &Value, kind: FeatureKind, world: bool) ->
}
// A cut or intersect made where the active component has no body of its own (a sketch in
// the assembly's root, cutting through the parts, #1234) would have nothing to work on: it
- // takes part in every body instead, which it changes only where it meets them.
+ // takes part in every body instead, which it changes only where it meets them. An extrude's
+ // own operation counts too: an automatic one that came out as a cut (#3223).
let participants = if participants.is_empty()
&& !primitive
&& (matches!(str_(p, "operation").and_then(Operation::parse), Some(Operation::Cut | Operation::Intersect))
- || p.get("faces").is_some() && matches!(&kind, FeatureKind::Extrude { operation: Operation::Cut | Operation::Intersect, .. }))
+ || matches!(&kind, FeatureKind::Extrude { operation: Operation::Cut | Operation::Intersect, .. }))
&& {
let st = s.model.state();
!st.bodies.is_empty() && !st.bodies.iter().any(|b| s.doc.model_body_component(b) == s.active_component)
@@ -652,14 +656,40 @@ fn extrude(s: &mut Session, p: &Value) -> Result<Value> {
}
/// The body whose face `sketch` is attached to (on the face itself, not offset from it), when
-/// it is a body of the active component.
+/// it is one the active component works on ([`active_scope`]).
fn sketch_face_body(s: &Session, sketch: u64) -> Option<String> {
let FeatureKind::Sketch { plane: solidcraft_doc::PlaneRef::Face { anchor: Some(anchor), .. }, .. } = &s.doc.feature(sketch)?.kind else {
return None;
};
let st = s.model.state();
- let body = st.body(&anchor.target.body)?;
- (s.doc.model_body_component(body) == s.active_component).then(|| body.name.clone())
+ active_scope(s, &st).into_iter().find(|b| b.name == anchor.target.body).map(|b| b.name.clone())
+}
+
+/// The bodies a feature of the active component works on when it names none: the component's
+/// own. A component with no body of its own (the root of an opened STEP assembly, whose parts
+/// are components inside it) works on the bodies of the components inside it whose geometry is
+/// in its own frame, as an import places it: a profile sketched on such a part's face meets the
+/// part where it is shown (#3223).
+fn active_scope<'a>(s: &Session, st: &'a solidcraft_doc::ModelState) -> Vec<&'a solidcraft_doc::ModelBody> {
+ let active = s.active_component;
+ let own: Vec<_> = st.bodies.iter().filter(|b| s.doc.model_body_component(b) == active).collect();
+ if !own.is_empty() {
+ return own;
+ }
+ let Some(into_active) = solidcraft_doc::mat_inverse(&s.doc.component_transform(active)) else { return own };
+ st.bodies
+ .iter()
+ .filter(|b| {
+ let comp = s.doc.model_body_component(b);
+ if !s.doc.component_within(comp, active) {
+ return false;
+ }
+ let frame = s.doc.component_transform(comp);
+ let world = s.doc.model_body_offset(b).map_or(frame, |offset| solidcraft_doc::mat_mul(&frame, offset));
+ let rel = solidcraft_doc::mat_mul(&into_active, &world);
+ rel.iter().flatten().zip(solidcraft_doc::IDENTITY.iter().flatten()).all(|(a, b)| (a - b).abs() < 1e-9)
+ })
+ .collect()
}
/// A thin extrude's wall from its parameters: the sketch's curves it follows (every drawn
diff --git a/crates/engine/src/cmd/occurrence_tests.rs b/crates/engine/src/cmd/occurrence_tests.rs
index 365710557b..d5bdfd9de6 100644
--- a/crates/engine/src/cmd/occurrence_tests.rs
+++ b/crates/engine/src/cmd/occurrence_tests.rs
@@ -616,6 +616,61 @@ fn matrix_move_turns_a_quarter_and_moves() {
}
}
+/// #3223, #2872: a STEP assembly whose part sits two levels down, each level placed, opened and
+/// stood up. With the imported root active, as Open leaves it, a circle sketched on the part's
+/// top face cuts it through, reads as a Cut dragged in and a Join dragged out, and joins it in
+/// one piece instead of starting a body of the root's own.
+#[test]
+fn a_stood_up_nested_step_part_is_cut_and_joined_from_its_face() {
+ let dir = std::env::temp_dir().join(format!("solidcraft-nested-stood-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let path = dir.join("nested.step");
+ let mut src = Session::default();
+ let (_, carrier) = created(&mut src, "Carrier");
+ let (part, nested) = created(&mut src, "Nested Part");
+ run(&mut src, "solid.box", json!({"length": 40, "width": 24, "height": 10, "body_name": "NestedBlock"}));
+ run(&mut src, "occurrence.move", json!({"occurrence": carrier, "translate": [12, 7, 5], "axis": [0, 0, 1], "angle": "30 deg"}));
+ run(&mut src, "occurrence.move", json!({"occurrence": nested, "translate": [3, 11, 2], "axis": [0, 1, 0], "angle": "20 deg"}));
+ // The middle of the top face, in the file's frame: the imported root's.
+ let top = solidcraft_doc::apply_point(&src.doc.component_transform(part), solidcraft_geom::Vec3::new(20.0, 12.0, 10.0));
+ run(&mut src, "file.export", json!({"path": path, "format": "step"}));
+
+ let mut s = Session::default();
+ run(&mut s, "doc.open", json!({"path": path, "up": "y"}));
+ let _ = std::fs::remove_dir_all(&dir);
+ let at = solidcraft_doc::apply_point(&s.doc.component_transform(s.active_component), top);
+ run(&mut s, "sketch.create", json!({"plane": {"face": [at.x, at.y, at.z]}, "project_edges": false}));
+ let centre = s
+ .doc
+ .features
+ .iter()
+ .rev()
+ .find_map(|f| match &f.kind {
+ solidcraft_doc::FeatureKind::Sketch { plane: solidcraft_doc::PlaneRef::Face { plane, .. }, .. } => Some(plane.to_local(top)),
+ _ => None,
+ })
+ .unwrap();
+ run(&mut s, "sketch.circle.center", json!({"center": [centre.x, centre.y], "radius": 3}));
+ run(&mut s, "sketch.finish", json!({}));
+ assert_eq!(crate::auto_operation(&s, &json!({"distance": -5})), Some("cut"));
+ assert_eq!(crate::auto_operation(&s, &json!({"distance": 5})), Some("join"));
+ let volume = |s: &mut Session| run(s, "inspect.measure", json!({"bodies": ["NestedBlock"]}))["total"]["volume_mm3"].as_f64().unwrap();
+ let block = 40.0 * 24.0 * 10.0;
+ let hole = std::f64::consts::PI * 3.0 * 3.0;
+
+ // The circle is measured as faceted: within a thousandth of what it removes or adds.
+ for operation in ["cut", "auto"] {
+ run(&mut s, "solid.extrude", json!({"distance": -20, "operation": operation}));
+ assert!((block - volume(&mut s) - hole * 10.0).abs() < 1e-3 * hole * 10.0, "{operation}: {}", volume(&mut s));
+ run(&mut s, "edit.undo", json!({}));
+ }
+ run(&mut s, "solid.extrude", json!({"distance": 5, "operation": "join"}));
+ let st = s.model.state();
+ assert_eq!(st.bodies.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(), ["NestedBlock"]);
+ assert_eq!(st.body("NestedBlock").map(|b| b.body.shell_count()), Some(1));
+ assert!((volume(&mut s) - block - hole * 5.0).abs() < 1e-3 * hole * 5.0, "join: {}", volume(&mut s));
+}
+
/// A rotation that is one only up to rounding is orthonormalised; a scale, a shear or a mirror
/// is refused with the reason, and the occurrence stays where it was.
#[test]