SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sheet metal: refuse a flat pattern that no longer matches the body (#3324) (#3325)
raykholoca9ebb44db4f
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 82ccad82df..e9832fdb73 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -1416,6 +1416,7 @@ impl Model {if let Some(note) = boolean_diagnostics.warning() {append_warning(&mut warning, note);}+ track_altered_sheets(&state, &mut next, f, &mut warning);} else {boolean_diagnostics = Default::default();}@@ -1622,6 +1623,52 @@ fn copy_body_name(state: &ModelState, f: &Feature, k: usize, source: &str) -> Stunique_body_name(state, base)}+/// Keeps each sheet metal body's flat pattern true to the body (see `SheetBody::altered_by`).+/// A feature that changes a sheet body's material but not its sheet model (a fillet, a join, a+/// mirror combined into it) marks the sheet with its name, and says so. A feature that rebuilds+/// the body from the model (a sheet metal feature, or machining the model keeps as cut-outs,+/// which changes the model) clears the mark, and says that the change it drops is not kept.+/// Features that move whole bodies or only mark their faces (a cosmetic thread, not a modelled+/// one, which cuts material) leave the flat pattern as it was.+fn track_altered_sheets(before: &ModelState, after: &mut ModelState, f: &Feature, warning: &mut Option<String>) {+ if matches!(+ f.kind,+ FeatureKind::Move { .. }+ | FeatureKind::Align { .. }+ | FeatureKind::Rest { .. }+ | FeatureKind::BodyTransfer { .. }+ | FeatureKind::SplitFace { .. }+ | FeatureKind::Thread { modeled: false, .. }+ ) {+ return;+ }+ let ModelState { sheets, bodies, .. } = after;+ for sh in sheets.iter_mut() {+ let Some(old) = before.sheets.iter().find(|s| s.body == sh.body) else { continue };+ let (Some(was), Some(now)) = (before.body(&sh.body), bodies.iter().find(|b| b.name == sh.body)) else { continue };+ if was.body.same_shape(&now.body) {+ continue;+ }+ if f.kind.is_sheet() || sh != old {+ if let Some(lost) = sh.altered_by.take() {+ append_warning(+ warning,+ format!("`{}` is rebuilt from its sheet metal features: what {lost} changed is not kept (not supported yet)", sh.body),+ );+ }+ } else if sh.altered_by.is_none() {+ sh.altered_by = Some(f.name.clone());+ append_warning(+ warning,+ format!(+ "`{}` is sheet metal: its flat pattern, DXF and bend table can't include this change yet and are refused; a later sheet metal feature rebuilds the body without it",+ sh.body+ ),+ );+ }+ }+}+/// 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)? {diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rsindex af1653bf0f..15ba85342c 100644--- a/crates/doc/src/sheet.rs+++ b/crates/doc/src/sheet.rs@@ -513,6 +513,13 @@ pub struct SheetBody {/// The base sketch's lines (id, ends in flat coordinates), naming the base panel's edges.#[serde(default, skip_serializing_if = "Vec::is_empty")]pub base_curves: Vec<(String, Vec2, Vec2)>,+ /// The feature (its name) that changed this body's material without changing its sheet+ /// model: a fillet or chamfer, a join, a mirror combined into it, any feature that is not+ /// sheet metal machining. The flat pattern, its DXF and the bend table no longer describe the+ /// body while it is set, so they are refused. Cleared when a sheet metal feature rebuilds the+ /// body from the model. Derived from feature history, like `pockets`.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub altered_by: Option<String>,}/// A straight round bore of one panel (None = the base), in flat coordinates: a cylinder from@@ -849,6 +856,20 @@ struct ReturnCorner {}impl SheetBody {+ /// Whether the flat pattern still describes the body: refused, naming the feature, once a+ /// feature that is not sheet metal changed the body's material (see `altered_by`). The flat+ /// pattern, its DXF and the bend table all check it, so none of them makes a part other than+ /// the one in the design.+ pub fn flat_matches_body(&self) -> Result<()> {+ match &self.altered_by {+ None => Ok(()),+ Some(feature) => Err(DocError::Invalid(format!(+ "not supported yet: the flat pattern of `{}` can't include {feature}, which changed the body after its sheet metal features, so the flat pattern, DXF and bend table would not match the part; remove or suppress {feature}, or make that shape with sheet metal features",+ self.body+ ))),+ }+ }+/// Bend allowance of a flange.pub fn allowance(&self, f: &SheetFlange) -> f64 {f.angle.abs() * (f.radius + self.k * self.t)@@ -4343,6 +4364,7 @@ pub fn base_flange(body: &str, rule: &str, rv: &RuleValues, plane: Plane, regionrelief_size: rv.corner_relief,bend_relief: (rv.relief_width, rv.relief_depth),base_curves: Vec::new(),+ altered_by: None,}}@@ -4401,6 +4423,7 @@ pub fn contour_flange(body: &str, rule: &str, rv: &RuleValues, plane: &Plane, ptrelief_size: rv.corner_relief,bend_relief: (rv.relief_width, rv.relief_depth),base_curves: Vec::new(),+ altered_by: None,};let (y0, y1) = if ysign > 0.0 { (0.0, width) } else { (-width, 0.0) };// First segment: the base panel.diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rsindex 58db634abb..9d693d3deb 100644--- a/crates/engine/src/cmd/sheet.rs+++ b/crates/engine/src/cmd/sheet.rs@@ -558,6 +558,7 @@ fn flat_json(sh: &SheetBody) -> Result<Value> {fn flat_pattern(s: &mut Session, p: &Value) -> Result<Value> {let sh = sheet_of(s, p, "sheet.flat_pattern")?;+ sh.flat_matches_body()?;flat_json(&sh)}@@ -818,7 +819,13 @@ fn export_dxf(s: &mut Session, p: &Value) -> Result<Value> {return Err(bad(cmd, "there is no sheet metal body"));}// Every file is made before the first is written.- let texts = sheets.iter().map(|sh| flat_dxf(sh, &options)).collect::<Result<Vec<_>>>()?;+ let texts = sheets+ .iter()+ .map(|sh| {+ sh.flat_matches_body()?;+ flat_dxf(sh, &options)+ })+ .collect::<Result<Vec<_>>>()?;let paths = path.map(|path| body_paths(path, &sheets.iter().map(|sh| sh.body.clone()).collect::<Vec<_>>()));let mut files = Vec::new();for (i, (sh, text)) in sheets.iter().zip(&texts).enumerate() {@@ -833,6 +840,7 @@ fn export_dxf(s: &mut Session, p: &Value) -> Result<Value> {return Ok(json!({"files": files}));}let sh = sheet_of(s, p, cmd)?;+ sh.flat_matches_body()?;let text = flat_dxf(&sh, &options)?;if let Some(path) = path {solidcraft_io::vfs::write(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;@@ -848,6 +856,7 @@ fn export_bend_table(s: &mut Session, p: &Value) -> Result<Value> {return Err(bad(cmd, "`format` must be csv or json"));}let sh = sheet_of(s, p, cmd)?;+ sh.flat_matches_body()?;let table = flat_json(&sh)?;let text = if format == "json" {serde_json::to_string_pretty(&table).map_err(|e| EngineError::Other(e.to_string()))?diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rsindex 0efb477b58..334e3fd2e4 100644--- a/crates/engine/src/cmd/sheet_tests.rs+++ b/crates/engine/src/cmd/sheet_tests.rs@@ -4755,3 +4755,107 @@ fn a_hole_that_parts_a_flange_from_the_base_names_it() {assert_eq!(out["warning"], json!(last_warning(&s)));assert_eq!(flat_pieces(&s).len(), 2);}++/// The three exports of a sheet's flat pattern: its JSON, the DXF (of this body and of every+/// body) and the bend table, each as its error if it is refused.+fn flat_exports(s: &mut Session) -> Vec<std::result::Result<Value, String>> {+ let calls = [+ ("sheet.flat_pattern", json!({})),+ ("sheet.export_dxf", json!({})),+ ("sheet.export_dxf", json!({"per_body": true})),+ ("sheet.export_bend_table", json!({})),+ ];+ calls.iter().map(|(id, p)| s.execute(id, p).map_err(|e| e.to_string())).collect()+}++/// A mirror combined into a sheet, or a tab extruded onto it and joined, makes a part its+/// flat pattern does not have (the mirrored half, the tab): the flat pattern, the DXF and the+/// bend table are refused with the feature's name instead of writing the sheet without it.+#[test]+fn a_mirror_or_a_join_into_a_sheet_refuses_its_flat_pattern_naming_the_feature() {+ let mut s = Session::default();+ base(&mut s, 100.0, 60.0);+ run(&mut s, "sheet.flange", json!({"edges": [[50, 0, 2.5]], "height": 20}));+ let body = s.model.state().sheets[0].body.clone();+ let out = run(&mut s, "solid.mirror", json!({"bodies": [body], "plane": "YZ", "combine": true}));+ assert!(out["warning"].as_str().unwrap_or_default().contains("is sheet metal: its flat pattern, DXF and bend table"), "{out}");+ for result in flat_exports(&mut s) {+ let error = result.expect_err("a mirrored half the flat pattern lacks");+ assert!(error.contains("not supported yet: the flat pattern of") && error.contains("can't include Mirror1"), "{error}");+ }++ let mut s = Session::default();+ base(&mut s, 100.0, 60.0);+ rectangle_tool(&mut s, "Tab", [40.0, 60.0], [60.0, 75.0]);+ run(&mut s, "solid.extrude", json!({"sketch": "Tab", "distance": 2.5, "operation": "join"}));+ for result in flat_exports(&mut s) {+ let error = result.expect_err("a joined tab the flat pattern lacks");+ assert!(error.contains("can't include Extrude1"), "{error}");+ }+}++/// A fillet on a sheet's corner is refused in the flat pattern until a sheet metal feature+/// rebuilds the body from its sheet features; that feature says the round is not kept, and the+/// flat pattern describes the body again.+#[test]+fn a_fillet_on_a_sheet_corner_is_refused_until_a_sheet_feature_rebuilds_the_body() {+ let mut s = Session::default();+ base(&mut s, 100.0, 60.0);+ let out = run(&mut s, "solid.fillet", json!({"edges": [[100, 60, 1.25]], "radius": 10}));+ assert!(out["warning"].as_str().is_some_and(|w| w.contains("is sheet metal")), "{out}");+ let error = s.execute("sheet.export_dxf", &json!({})).unwrap_err().to_string();+ assert!(error.contains("can't include Fillet1"), "{error}");+ let out = run(&mut s, "sheet.flange", json!({"edges": [[50, 0, 2.5]], "height": 20}));+ assert!(out["warning"].as_str().is_some_and(|w| w.contains("what Fillet1 changed is not kept")), "{out}");+ assert!(flat_exports(&mut s).into_iter().all(|r| r.is_ok()));+ assert_eq!(s.model.state().sheets[0].altered_by, None);+}++/// A cosmetic thread in a sheet's hole leaves its flat pattern as it is; a modelled thread cuts+/// material the flat pattern lacks, so it is refused like a fillet until a sheet feature rebuilds+/// the body and says the thread is not kept.+#[test]+fn a_modelled_thread_in_a_sheet_hole_is_refused_but_a_cosmetic_one_is_not() {+ let mut s = Session::default();+ base(&mut s, 100.0, 60.0);+ run(&mut s, "solid.hole", json!({"position": [30, 30, 2.5], "diameter": 4.2}));+ let drilled = volume(&mut s);+ run(&mut s, "solid.thread", json!({"face": [32.1, 30, 1.25], "designation": "M5"}));+ assert_eq!(last_warning(&s), "");+ assert!(flat_exports(&mut s).into_iter().all(|r| r.is_ok()));+ run(&mut s, "solid.thread", json!({"face": [32.1, 30, 1.25], "designation": "M5", "modeled": true}));+ assert!(volume(&mut s) < drilled - 0.05, "the modelled thread cuts material");+ assert!(last_warning(&s).contains("is sheet metal"), "{}", last_warning(&s));+ for result in flat_exports(&mut s) {+ let error = result.expect_err("a modelled thread the flat pattern lacks");+ assert!(error.contains("can't include Thread2"), "{error}");+ }+ let out = run(&mut s, "sheet.flange", json!({"edges": [[50, 0, 2.5]], "height": 20}));+ assert!(out["warning"].as_str().is_some_and(|w| w.contains("what Thread2 changed is not kept")), "{out}");+ assert!(flat_exports(&mut s).into_iter().all(|r| r.is_ok()));+}++/// A sheet built and machined with sheet features (flanges, a hem, a hole and a cut across a+/// bend while unfolded, refolded, then moved) keeps its flat pattern and exports.+#[test]+fn a_sheet_made_of_sheet_features_and_flat_cuts_still_exports_its_flat_pattern() {+ let mut s = Session::default();+ base(&mut s, 100.0, 60.0);+ run(&mut s, "sheet.flange", json!({"edges": [[50, 0, 2.5], [100, 30, 2.5]], "height": 20}));+ run(&mut s, "sheet.hem", json!({"edges": [[0, 30, 2.5]], "length": 8}));+ run(&mut s, "solid.hole", json!({"position": [30, 30, 2.5], "diameter": 6}));+ run(&mut s, "sheet.unfold", json!({}));+ rectangle_tool(&mut s, "Slot", [45.0, -10.0], [55.0, 10.0]);+ run(&mut s, "solid.extrude", json!({"sketch": "Slot", "through_all": true, "direction": "symmetric", "operation": "cut"}));+ run(&mut s, "sheet.refold", json!({}));+ let body = s.model.state().sheets[0].body.clone();+ run(&mut s, "solid.move", json!({"bodies": [body], "translate": [10, 0, 0]}));+ let flagged = |w: &str| w.contains("flat pattern, DXF and bend table") || w.contains("is not kept");+ assert!(s.model.results.iter().all(|r| r.error.is_none() && !r.warning.as_deref().is_some_and(flagged)), "{:?}", s.model.results);+ assert_eq!(s.model.state().sheets[0].altered_by, None);+ for result in flat_exports(&mut s) {+ let value = result.expect("a sheet the flat pattern describes");+ assert!(value.is_object(), "{value}");+ }+ assert_eq!(flat(&mut s)["cutouts"].as_array().map(Vec::len), Some(2));+}diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex be11a11993..33db86eebe 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -568,17 +568,22 @@ impl Body {/// operation made it) is not part of it: an operation that leaves a body as it is (a cut by/// a tool clear of it) gives the same body, with that operation's history.pub fn same(&self, other: &Body) -> bool {+ self.same_shape(other)+ && self.color == other.color+ && same_shared(&self.paint, &other.paint)+ && same_shared(&self.splits, &other.splits)+ && same_shared(&self.face_sources, &other.face_sources)+ && self.regularization_protected == other.regularization_protected+ }++ /// The very same shape (shared solid or mesh), whatever its colour, paint or face splits.+ pub fn same_shape(&self, other: &Body) -> bool {std::sync::Arc::ptr_eq(&self.solid, &other.solid)&& match (&self.mesh, &other.mesh) {(Some(a), Some(b)) => std::sync::Arc::ptr_eq(a, b),(None, None) => true,_ => false,}- && self.color == other.color- && same_shared(&self.paint, &other.paint)- && same_shared(&self.splits, &other.splits)- && same_shared(&self.face_sources, &other.face_sources)- && self.regularization_protected == other.regularization_protected}pub(crate) fn new(solid: Solid) -> Result<Body> {diff --git a/docs/book/src/guide/sheet-metal.md b/docs/book/src/guide/sheet-metal.mdindex 813927f0b2..8e8f3a4b33 100644--- a/docs/book/src/guide/sheet-metal.md+++ b/docs/book/src/guide/sheet-metal.md@@ -314,6 +314,14 @@ but a pocket crossing a bend zone cannot yet be refolded. Machining folded bendtapered sheet cuts and other unsupported 3D sheet Cut/Intersect operations report an error before changingthe design; they cannot silently restore removed material during a later sheet rebuild.+Other features that change a sheet body's material without the sheet knowing it (a fillet or+chamfer on a corner, an extrude joined onto it, a Mirror or Combine joined into it) are not in+the flat pattern yet. Such a feature warns, and while the body carries its change the flat+pattern, the DXF and the bend table are refused with an error that names it, rather than writing+a part that does not match the body. A later sheet metal feature rebuilds the body from its sheet+features and says that the change is not kept. Moving the body, splitting its faces and cosmetic+threads leave the flat pattern as it is.+A sketch can be drawn on a flat face of the sheet: the base or a flange, on either side. Pickthe face (or give `sketch.create` the point `plane: {face: [x, y, z]}`) and the sketch attachesto that panel instead of to a certified source face. It keeps the face's name,