Sheet metal: refuse a flat pattern that no longer matches the body (#3324) (#3325)

* claim: #3324

* Sheet metal: refuse a flat pattern that no longer matches the body

A feature that is not sheet metal can change a sheet body's material
without its sheet model knowing: a mirror combined into it, an extrude
joined onto it, a fillet or chamfer on a corner. The flat pattern, the
DXF and the bend table then wrote the sheet as it was before, a part
other than the one in the design, with no warning.

The evaluator now notes, per sheet, the first such feature: one that
changes the body's shape while its sheet model stays the same. That
feature warns, and sheet.flat_pattern, sheet.export_dxf (also with
per_body) and sheet.export_bend_table refuse with "not supported yet",
naming it. A sheet metal feature, or machining the sheet keeps as
cut-outs, rebuilds the body from the model: it clears the note and
warns that the change is not kept. Moving the body, splitting its faces
and cosmetic threads leave the flat pattern as it is.

* Sheet metal: a modelled thread is refused in the flat pattern too

Only a cosmetic thread leaves a sheet body's material as it is. A
modelled thread cuts the thread profile into the hole, which the flat
pattern does not have, and a later sheet metal feature dropped it
without a word. It now marks the sheet like a fillet does: it warns,
the flat pattern, DXF and bend table refuse naming it, and the feature
that rebuilds the body says the thread is not kept.
This commit is contained in:
raykholo authored and GitHub committed 2026-10-20 12:07:24 +00:00
1 parent e44dd4ff9e
commit ca9ebb44db
6 files changed
+202 -6

No files matched your search

+47
View File
@@ -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) -> St
unique_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)? {
+23
View File
@@ -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, region
relief_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, pt
relief_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.
+10 -1
View File
@@ -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()))?
+104
View File
@@ -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));
}
+10 -5
View File
@@ -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> {
+8
View File
@@ -314,6 +314,14 @@ but a pocket crossing a bend zone cannot yet be refolded. Machining folded bend
tapered sheet cuts and other unsupported 3D sheet Cut/Intersect operations report an error before changing
the 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. Pick
the face (or give `sketch.create` the point `plane: {face: [x, y, z]}`) and the sketch attaches
to that panel instead of to a certified source face. It keeps the face's name,