SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sheet metal: bend angles as the included (press-brake) angle, set per rule (#4968) (#6040)
Ahmad Khan919f54a23e36
diff --git a/assets/locales/en.json b/assets/locales/en.jsonindex 1602d0488e..d8d58e629a 100644--- a/assets/locales/en.json+++ b/assets/locales/en.json@@ -36,6 +36,7 @@"Also deletes": "Also deletes","Anchor": "Anchor","Angle 2": "Angle 2",+ "Angle Display": "Angle Display","Animate": "Animate","App/system information and command settings are included. Review private details before sharing.": "App/system information and command settings are included. Review private details before sharing.","Appearance name": "Appearance name",@@ -53,6 +54,7 @@"BOUNDARY SURFACE": "BOUNDARY SURFACE","BROWSER": "BROWSER","Bar": "Bar",+ "Bend": "Bend","Bend Edges": "Bend Edges","Bend Line Position": "Bend Line Position","Bend Position": "Bend Position",@@ -249,6 +251,7 @@"In This Design": "In This Design","In place (surfaces)": "In place (surfaces)","In plane": "In plane",+ "Included": "Included","Inside": "Inside","Instant": "Instant","Interface font": "Interface font",diff --git a/assets/locales/ja.json b/assets/locales/ja.jsonindex 82b1ca132d..fcd6770d34 100644--- a/assets/locales/ja.json+++ b/assets/locales/ja.json@@ -36,6 +36,7 @@"Also deletes": "同時に削除される要素:","Anchor": "基準点","Angle 2": "角度 2",+ "Angle Display": "角度の表示","Animate": "アニメーション","App/system information and command settings are included. Review private details before sharing.": "アプリ・システム情報とコマンド設定が含まれます。共有前に非公開の情報を確認してください。","Appearance name": "外観名",@@ -53,6 +54,7 @@"BOUNDARY SURFACE": "境界サーフェス","BROWSER": "ブラウザ","Bar": "平鋼",+ "Bend": "曲げ角度","Bend Edges": "曲げエッジ","Bend Line Position": "曲げ線位置","Bend Position": "曲げ位置",@@ -249,6 +251,7 @@"In This Design": "このデザイン内","In place (surfaces)": "その場で(サーフェス)","In plane": "平面内",+ "Included": "挟角","Inside": "内側","Instant": "即時","Interface font": "インターフェースフォント",diff --git a/assets/locales/zh.json b/assets/locales/zh.jsonindex 63a5bcda5b..27f76b63b1 100644--- a/assets/locales/zh.json+++ b/assets/locales/zh.json@@ -36,6 +36,7 @@"Also deletes": "同时删除","Anchor": "基准点","Angle 2": "角度 2",+ "Angle Display": "角度显示","Animate": "动画","App/system information and command settings are included. Review private details before sharing.": "报告包含应用和系统信息以及命令设置。共享前请检查私人信息。","Appearance name": "外观名称",@@ -53,6 +54,7 @@"BOUNDARY SURFACE": "边界曲面","BROWSER": "浏览器","Bar": "扁钢",+ "Bend": "折弯角度","Bend Edges": "折弯边","Bend Line Position": "弯折线位置","Bend Position": "折弯位置",@@ -249,6 +251,7 @@"In This Design": "在此设计中","In place (surfaces)": "原位(曲面)","In plane": "在平面内",+ "Included": "夹角","Inside": "内侧","Instant": "即时","Interface font": "界面字体",diff --git a/crates/doc/src/format/pending/sheet-rule-angle-display.rs b/crates/doc/src/format/pending/sheet-rule-angle-display.rsnew file mode 100644index 0000000000..4d35f3c30a--- /dev/null+++ b/crates/doc/src/format/pending/sheet-rule-angle-display.rs@@ -0,0 +1,6 @@+//! A sheet metal rule can say how the bend angles of its parts read in the DXF bend notes+//! (`angle_display`: `bend`, the default, or `included`, the angle left between a bend's two+//! sides, 180° less the bend angle, as a press brake is set; #4968). It is saved only when it is+//! `included`, in the rule and in the sheet bodies of the design's saved model. Older designs+//! need no step: a rule or body without it reads its bends as bend angles, as before. The last+//! release refuses a design saved with this (the newer format number).diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rsindex 9a6e001812..0c78b26492 100644--- a/crates/doc/src/sheet.rs+++ b/crates/doc/src/sheet.rs@@ -259,6 +259,11 @@ pub struct SheetRule {/// Gap between flanges that meet at a corner.#[serde(default = "rule_gap")]pub gap: String,+ /// How the bend angles of its parts read in the DXF bend notes: `bend` (how far the sheet+ /// turns from flat) or `included` (the angle left between the bend's two sides, as a press+ /// brake is set). A choice, not an expression; saved only when it isn't `bend`.+ #[serde(default = "rule_angle_display", skip_serializing_if = "is_bend_display")]+ pub angle_display: String,}impl SheetRule {@@ -311,6 +316,14 @@ fn rule_corner_relief_shape() -> String {fn rule_hem_gap() -> String {"0.01 mm".into()}+fn rule_angle_display() -> String {+ AngleDisplay::Bend.name().into()+}+/// A rule that reads bend angles as bend angles leaves the setting out of the design, which+/// then saves as it did before the setting existed.+fn is_bend_display(s: &str) -> bool {+ AngleDisplay::parse(s) == Some(AngleDisplay::Bend)+}impl SheetRule {/// Default: Steel (mm), 2.5 mm, K 0.44, bend radius = Thickness.@@ -326,6 +339,7 @@ impl SheetRule {corner_relief_shape: rule_corner_relief_shape(),hem_gap: rule_hem_gap(),gap: rule_gap(),+ angle_display: rule_angle_display(),}}}@@ -384,6 +398,48 @@ impl ReliefShape {}}+/// How a rule's bend angles read in the DXF bend notes (a rule's `angle_display`). The bend+/// table gives both angles, and a flange's `angle` is always the bend angle.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "lowercase")]+pub enum AngleDisplay {+ /// How far the sheet turns from flat: a flange at 58° reads 58°.+ #[default]+ Bend,+ /// The angle left between the bend's two sides, 180° less the bend angle: a 58° bend reads+ /// 122°, a 90° bend 90°.+ Included,+}++impl AngleDisplay {+ pub fn parse(s: &str) -> Option<AngleDisplay> {+ match s.trim().to_ascii_lowercase().as_str() {+ "bend" => Some(AngleDisplay::Bend),+ "included" => Some(AngleDisplay::Included),+ _ => None,+ }+ }++ pub fn name(self) -> &'static str {+ match self {+ AngleDisplay::Bend => "bend",+ AngleDisplay::Included => "included",+ }+ }++ pub fn is_bend(&self) -> bool {+ *self == AngleDisplay::Bend+ }++ /// A bend of `bend_deg` degrees as this display reads it.+ pub fn of(self, bend_deg: f64) -> f64 {+ match self {+ AngleDisplay::Bend => bend_deg,+ AngleDisplay::Included => 180.0 - bend_deg,+ }+ }+}+/// The corner relief an edge flange feature asks for in place of the rule's. A value left out/// follows the rule.#[derive(Clone, Copy, Debug, Default, PartialEq)]@@ -405,6 +461,7 @@ pub struct RuleValues {pub corner_relief_shape: ReliefShape,pub hem_gap: f64,pub gap: f64,+ pub angle_display: AngleDisplay,}impl Document {@@ -440,6 +497,8 @@ impl Document {})?,hem_gap: with_t(&r.hem_gap, Kind::Length)?,gap: with_t(&r.gap, Kind::Length)?,+ angle_display: AngleDisplay::parse(&r.angle_display)+ .ok_or_else(|| DocError::Invalid(format!("unknown bend angle display `{}` (bend or included)", r.angle_display)))?,};if !(0.0..=1.0).contains(&v.k_factor) || v.bend_radius < 0.0 {return Err(DocError::Invalid("the K-factor must be 0…1 and the bend radius positive".into()));@@ -541,6 +600,9 @@ pub struct SheetBody {/// The rule's bend relief (`relief_width`, `relief_depth`), cut into the base where a/// flange's bend ends beside more of the base.pub bend_relief: (f64, f64),+ /// How the DXF bend notes read its bend angles (the rule's `angle_display`).+ #[serde(default, skip_serializing_if = "AngleDisplay::is_bend")]+ pub angle_display: AngleDisplay,/// 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)>,@@ -685,6 +747,13 @@ pub struct BendInfo {pub end: Vec2,}+impl BendInfo {+ /// The angle left between the bend's two sides (degrees): 180° less `angle_deg`.+ pub fn included_angle_deg(&self) -> f64 {+ AngleDisplay::Included.of(self.angle_deg)+ }+}+fn rot_about(o: Vec3, k: Vec3, a: f64) -> Mat {crate::rigid(Vec3::ZERO, o, k, a)}@@ -4515,6 +4584,7 @@ pub fn base_flange(body: &str, rule: &str, rv: &RuleValues, plane: Plane, regionrelief: rv.corner_relief_shape,relief_size: rv.corner_relief,bend_relief: (rv.relief_width, rv.relief_depth),+ angle_display: rv.angle_display,base_curves: Vec::new(),altered_by: None,}@@ -4574,6 +4644,7 @@ pub fn contour_flange(body: &str, rule: &str, rv: &RuleValues, plane: &Plane, ptrelief: rv.corner_relief_shape,relief_size: rv.corner_relief,bend_relief: (rv.relief_width, rv.relief_depth),+ angle_display: rv.angle_display,base_curves: Vec::new(),altered_by: None,};@@ -4699,6 +4770,7 @@ mod tests {corner_relief_shape: ReliefShape::Notch,hem_gap: 0.01,gap: 2.5,+ angle_display: AngleDisplay::Bend,}}@@ -5251,6 +5323,7 @@ mod tests {corner_relief_shape: ReliefShape::Notch,hem_gap: 0.01,gap: 2.0,+ angle_display: AngleDisplay::Bend,};let r = rect(Vec2::new(0.0, 0.0), Vec2::new(100.0, 0.0), Vec2::new(100.0, 80.0), Vec2::new(0.0, 80.0));let mut s = base_flange("Body1", "AL2", &rule, Plane::XY, r);@@ -5346,6 +5419,7 @@ mod tests {corner_relief_shape: ReliefShape::Notch,hem_gap: 0.01,gap: 0.5,+ angle_display: AngleDisplay::Bend,}}@@ -5593,6 +5667,49 @@ mod tests {}}+ #[test]+ fn the_rule_names_how_its_bend_angles_read() {+ // A rule saved before the setting existed reads bend angles, and saves as it did.+ let old: SheetRule = serde_json::from_str(r#"{"name":"Old","thickness":"2 mm","k_factor":"0.5","bend_radius":"1 mm"}"#).unwrap();+ assert_eq!(old.angle_display, "bend");+ assert_eq!(SheetRule::steel().angle_display, "bend");+ assert!(serde_json::to_value(&old).unwrap().get("angle_display").is_none());+ let (doc, vals) = (Document::default(), std::collections::BTreeMap::new());+ assert_eq!(doc.rule_values(&vals, &old).unwrap().angle_display, AngleDisplay::Bend);+ for (text, display) in [("included", AngleDisplay::Included), (" Included ", AngleDisplay::Included), ("BEND", AngleDisplay::Bend)] {+ let rule = SheetRule { angle_display: text.into(), ..old.clone() };+ assert_eq!(doc.rule_values(&vals, &rule).unwrap().angle_display, display);+ assert_eq!(AngleDisplay::parse(display.name()), Some(display));+ }+ // An included rule is saved with the setting and read back the same.+ let included = SheetRule { angle_display: "included".into(), ..old.clone() };+ let saved = serde_json::to_value(&included).unwrap();+ assert_eq!(saved["angle_display"], "included");+ assert_eq!(serde_json::from_value::<SheetRule>(saved).unwrap(), included);+ // No other word is a display.+ for text in ["deflection", "inside", ""] {+ let err = doc.rule_values(&vals, &SheetRule { angle_display: text.into(), ..old.clone() }).unwrap_err().to_string();+ assert!(err.contains(&format!("unknown bend angle display `{text}` (bend or included)")), "{err}");+ }+ }++ /// The included angle is what a bend leaves between its sides: 180° less the bend angle, so a+ /// 90° bend reads the same both ways. A body keeps its rule's display.+ #[test]+ fn the_included_angle_is_180_less_the_bend_angle() {+ for (deg, included) in [(58.0, 122.0), (90.0, 90.0), (120.0, 60.0)] {+ let bends = flanged(f64::to_radians(deg)).bends();+ assert_eq!(bends.len(), 1);+ assert!((bends[0].angle_deg - deg).abs() < 1e-9 && (bends[0].included_angle_deg() - included).abs() < 1e-9, "{bends:?}");+ assert!((AngleDisplay::Bend.of(bends[0].angle_deg) - deg).abs() < 1e-9);+ assert!((AngleDisplay::Included.of(bends[0].angle_deg) - included).abs() < 1e-9);+ }+ let r = rect(Vec2::new(0.0, 0.0), Vec2::new(100.0, 0.0), Vec2::new(100.0, 80.0), Vec2::new(0.0, 80.0));+ assert_eq!(base_flange("Body1", "Steel", &steel(), Plane::XY, r.clone()).angle_display, AngleDisplay::Bend);+ let shop = RuleValues { angle_display: AngleDisplay::Included, ..steel() };+ assert_eq!(base_flange("Body1", "Shop", &shop, Plane::XY, r).angle_display, AngleDisplay::Included);+ }+#[test]fn corner_reliefs_cut_the_base_corner_and_stop_the_bends() {use std::f64::consts::{FRAC_PI_2, FRAC_PI_4};diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rsindex 1388eddee1..59e81a554e 100644--- a/crates/engine/src/cmd/sheet.rs+++ b/crates/engine/src/cmd/sheet.rs@@ -57,6 +57,8 @@ pub static COMMANDS: &[CommandSpec] = &[gap: between flanges that meet at a corner, whose ends are closed toward each other at any angle); \corner_relief_shape?: notch|round|rectangular|tear (what is cut where two bends meet at a corner of the base: round and rectangular a relief \`corner_relief` across; tear none, each bend's end is cut straight from the corner to its flange's end; default notch); \+ angle_display?: bend|included (how the DXF bend notes read the bend angles: the bend angle, default, or the included angle \+ left between the bend's sides, 180° less it; the bend table gives both, and a flange's `angle` is always the bend angle); \active?: bool; delete?: bool",),CommandSpec::new("sheet.rules", "List Sheet Metal Rules", list_rules).icon("sheet_rules").noundo().doc_only().params("→ rules with their expressions and values, and the active one"),@@ -72,7 +74,8 @@ pub static COMMANDS: &[CommandSpec] = &[.params("body?, path?, curves?: exact|arcs (default exact: an ellipse as ELLIPSE, splines, text outlines and other Béziers as SPLINE; arcs: tangent arcs and lines within 0.001 mm, for machines that read only those), \text?: cut|etch (default cut: letters that text cut through the sheet are cut contours on layer TEXT; etch: single contours on layer ETCH and the sheet keeps its material there; text machined to a depth is always on ETCH), \- bend_notes?: bool (default false: a note beside each bend line on layer BEND_NOTES, `B1 UP 90%%d R1`), note_height?: mm (default 3), \+ bend_notes?: bool (default false: a note beside each bend line on layer BEND_NOTES, `B1 UP 90%%d R1`, its angle the included angle \+ when the body's rule has angle_display: included), note_height?: mm (default 3), \bend_lines?: bool (default true; false leaves BEND_UP and BEND_DOWN out, for a cutter that would cut them), \layers?: roles|single (default roles, the layers below; single: every entity on layer 0), \per_body?: bool (a file for every sheet body, `<path>-<body>.dxf`, or their DXF texts without a path → files: [{body, path | dxf, bends}]; not with `body`) \@@ -81,7 +84,7 @@ pub static COMMANDS: &[CommandSpec] = &[),CommandSpec::new("sheet.export_bend_table", "Export Bend Table", export_bend_table).icon("bendtable").noundo()- .params("body?, format?: csv|json (default csv), path? → bend table in mm and degrees, including rule and flat centre-line coordinates; a bend that cut-outs split has a row for each piece"),+ .params("body?, format?: csv|json (default csv), path? → bend table in mm and degrees, including rule and flat centre-line coordinates; angle_deg is the bend angle and included_angle_deg the angle left between the bend's sides (180° less it); a bend that cut-outs split has a row for each piece"),];fn points(p: &Value, k: &str, cmd: &str) -> Result<Vec<Vec3>> {@@ -416,6 +419,10 @@ fn rules(s: &mut Session, p: &Value) -> Result<Value> {let shape = shape.as_str().and_then(solidcraft_doc::sheet::ReliefShape::parse);rule.corner_relief_shape = shape.ok_or_else(|| bad(cmd, "`corner_relief_shape` must be notch, round, rectangular or tear"))?.name().into();}+ if let Some(display) = p.get("angle_display").filter(|v| !v.is_null()) {+ let display = display.as_str().and_then(sheet::AngleDisplay::parse);+ rule.angle_display = display.ok_or_else(|| bad(cmd, "`angle_display` must be bend or included"))?.name().into();+ }let (vals, _) = s.doc.param_values();let values = s.doc.rule_values(&vals, &rule).map_err(|e| bad(cmd, e.to_string()))?;let doc = s.doc_mut();@@ -433,7 +440,17 @@ fn rules(s: &mut Session, p: &Value) -> Result<Value> {}s.refresh();let errors: Vec<Value> = s.model.results.iter().filter_map(|r| r.error.as_ref().map(|e| json!({"feature": r.name, "error": e}))).collect();- Ok(json!({"rule": rule, "values": values, "errors": errors}))+ Ok(json!({"rule": rule_json(&rule), "values": values, "errors": errors}))+}++/// A rule as the rule commands list it: as saved, and with its `angle_display` also while it is+/// the `bend` a design leaves out.+fn rule_json(r: &SheetRule) -> Value {+ let mut v = json!(r);+ if let Value::Object(m) = &mut v {+ m.insert("angle_display".into(), json!(r.angle_display));+ }+ v}fn list_rules(s: &mut Session, _p: &Value) -> Result<Value> {@@ -442,7 +459,7 @@ fn list_rules(s: &mut Session, _p: &Value) -> Result<Value> {if all.is_empty() {all.push(SheetRule::steel());}- let rules: Vec<Value> = all.iter().map(|r| json!({"rule": r, "values": s.doc.rule_values(&vals, r).ok()})).collect();+ let rules: Vec<Value> = all.iter().map(|r| json!({"rule": rule_json(r), "values": s.doc.rule_values(&vals, r).ok()})).collect();let active = s.doc.sheet_rule(None).name;Ok(json!({"rules": rules, "active": active}))}@@ -508,7 +525,7 @@ fn flat_json(sh: &SheetBody) -> Result<Value> {.bends().iter().map(|b| {- json!({"bend": b.index, "angle_deg": b.angle_deg, "radius": b.radius, "direction": if b.up { "up" } else { "down" },+ json!({"bend": b.index, "angle_deg": b.angle_deg, "included_angle_deg": b.included_angle_deg(), "radius": b.radius, "direction": if b.up { "up" } else { "down" },"allowance": b.allowance, "length": b.length, "start": pt(&b.start), "end": pt(&b.end)})}).collect();@@ -622,10 +639,10 @@ fn compact(v: f64) -> String {if t.is_empty() || t == "-0" { "0".into() } else { t.into() }}-/// The note beside a bend line, `B1 UP 90%%d R2.5` (number, direction, angle, inner radius): as-/// high as `height`, centred half a height beside the middle of the line, parallel to it and-/// readable from below or from the right. (`%%d` is AutoCAD's degree sign.)-fn bend_note(b: &solidcraft_doc::sheet::BendInfo, height: f64) -> solidcraft_io::DxfShape {+/// The note beside a bend line, `B1 UP 90%%d R2.5` (number, direction, angle as `display` reads+/// it, inner radius): as high as `height`, centred half a height beside the middle of the line,+/// parallel to it and readable from below or from the right. (`%%d` is AutoCAD's degree sign.)+fn bend_note(b: &solidcraft_doc::sheet::BendInfo, height: f64, display: sheet::AngleDisplay) -> solidcraft_io::DxfShape {let along = (b.end - b.start).normalized().unwrap_or(Vec2::X);let mut angle = along.angle().to_degrees();if angle > 90.0 + 1e-9 {@@ -638,7 +655,7 @@ fn bend_note(b: &solidcraft_doc::sheet::BendInfo, height: f64) -> solidcraft_io:at: (b.start + b.end) * 0.5 + beside * (height * 0.5),height,angle_deg: angle,- text: format!("B{} {} {}%%d R{}", b.index, if b.up { "UP" } else { "DOWN" }, compact(b.angle_deg), compact(b.radius)),+ text: format!("B{} {} {}%%d R{}", b.index, if b.up { "UP" } else { "DOWN" }, compact(display.of(b.angle_deg)), compact(b.radius)),}}@@ -742,7 +759,7 @@ pub fn flat_dxf(sh: &SheetBody, o: &DxfOptions) -> Result<String> {entities.push(DxfEntity { layer: if b.up { "BEND_UP" } else { "BEND_DOWN" }.into(), shape: DxfShape::Line(b.start, b.end) });}if let Some(height) = o.bend_notes {- entities.push(DxfEntity { layer: "BEND_NOTES".into(), shape: bend_note(&b, height) });+ entities.push(DxfEntity { layer: "BEND_NOTES".into(), shape: bend_note(&b, height, sh.angle_display) });}}for (c, r) in perforation {@@ -893,11 +910,11 @@ fn export_bend_table(s: &mut Session, p: &Value) -> Result<Value> {// Always quote text fields: body/rule names may include commas, quotes or newlines.let quote = |s: &str| format!("\"{}\"", s.replace('"', "\"\""));let mut csv =- "body,rule,thickness_mm,k_factor,bend,angle_deg,direction,radius_mm,allowance_mm,length_mm,start_x_mm,start_y_mm,end_x_mm,end_y_mm\r\n"+ "body,rule,thickness_mm,k_factor,bend,angle_deg,direction,radius_mm,allowance_mm,length_mm,start_x_mm,start_y_mm,end_x_mm,end_y_mm,included_angle_deg\r\n".to_string();for b in sh.bends() {csv.push_str(&format!(- "{},{},{:.9},{:.9},{},{:.9},{},{:.9},{:.9},{:.9},{:.9},{:.9},{:.9},{:.9}\r\n",+ "{},{},{:.9},{:.9},{},{:.9},{},{:.9},{:.9},{:.9},{:.9},{:.9},{:.9},{:.9},{:.9}\r\n",quote(&sh.body),quote(&sh.rule),sh.t,@@ -911,7 +928,8 @@ fn export_bend_table(s: &mut Session, p: &Value) -> Result<Value> {b.start.x,b.start.y,b.end.x,- b.end.y+ b.end.y,+ b.included_angle_deg()));}csvdiff --git a/crates/engine/src/cmd/sheet_dxf_tests.rs b/crates/engine/src/cmd/sheet_dxf_tests.rsindex 3fa2455fbd..8a99ce6eb1 100644--- a/crates/engine/src/cmd/sheet_dxf_tests.rs+++ b/crates/engine/src/cmd/sheet_dxf_tests.rs@@ -471,6 +471,46 @@ fn a_bend_note_sits_beside_each_bend_line_when_asked_for() {assert!(note.is_some_and(|e| values(e, 40) == [5.0]));}+#[test]+fn a_bend_note_gives_the_included_angle_when_the_rule_reads_it_so() {+ // The included angle is 180° less the bend angle: 122° for a 58° bend, 90° for a 90° one.+ for (deg, included) in [(58.0, 122.0), (90.0, 90.0)] {+ let mut plain = Vec::new();+ for display in ["bend", "included"] {+ let mut s = sheet_of_2mm();+ run(&mut s, "sheet.manage_rules", json!({"name": "Sheet2", "angle_display": display}));+ let mut s = plate_in(s, &[]);+ run(&mut s, "sheet.flange", json!({"edges": [[50, 0, 2]], "height": 20, "angle": format!("{deg} deg")}));+ let dxf = export(&mut s, json!({"bend_notes": true}));+ let notes: Vec<String> = entities(&dxf).iter().filter(|e| e.0 == "TEXT").map(|e| string(e, 1)).collect();+ let shown = if display == "included" { included } else { deg };+ assert_eq!(notes, [format!("B1 UP {shown}%%d R1")], "{deg}° under {display}");+ plain.push(export(&mut s, json!({})));+ }+ // Without notes the setting changes nothing in the file.+ assert_eq!(plain.first(), plain.get(1), "{deg}°");+ }+}++/// A body whose base flange names its rule keeps that rule's notes whichever rule is active when+/// the DXF is written, and a bend down reads its included angle the same way.+#[test]+fn a_bend_note_follows_the_bodys_own_rule_and_bends_down_too() {+ let mut s = sheet_of_2mm();+ run(&mut s, "sheet.manage_rules", json!({"name": "Sheet2", "angle_display": "included"}));+ run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Base"}));+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [100, 60]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "sheet.flange", json!({"sketch": "Base", "rule": "Sheet2"}));+ run(&mut s, "sheet.flange", json!({"edges": [[50, 0, 2]], "height": 20, "angle": "58 deg", "flip": true}));+ let notes = |s: &mut Session| -> Vec<String> {+ entities(&export(s, json!({"bend_notes": true}))).iter().filter(|e| e.0 == "TEXT").map(|e| string(e, 1)).collect()+ };+ assert_eq!(notes(&mut s), ["B1 DOWN 122%%d R1"]);+ run(&mut s, "sheet.manage_rules", json!({"name": "Other", "thickness": "2 mm", "angle_display": "bend", "active": true}));+ assert_eq!(notes(&mut s), ["B1 DOWN 122%%d R1"], "another active rule does not change this body's notes");+}+/// Two sheet bodies: a lid and, 200 mm away, a side wall with one bend.fn lid_and_wall() -> Session {let mut s = Session::default();diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rsindex 8e862439fe..a4af61367e 100644--- a/crates/engine/src/cmd/sheet_tests.rs+++ b/crates/engine/src/cmd/sheet_tests.rs@@ -1296,7 +1296,12 @@ fn the_bend_table_and_the_dxf_follow_what_flat_cuts_leave_of_a_bend() {let csv = run(&mut s, "sheet.export_bend_table", json!({}));let text = csv["text"].as_str().unwrap_or_default();assert_eq!((text.lines().count(), csv["bends"].as_u64()), (2, Some(1)), "{text}");- assert!(text.lines().nth(1).is_some_and(|l| l.contains(",1,90.000000000,up,1.000000000,3.141592654,100.000000000,100.000000000,")), "{text}");+ assert!(+ text.lines()+ .nth(1)+ .is_some_and(|l| l.contains(",1,90.000000000,up,1.000000000,3.141592654,100.000000000,100.000000000,") && l.ends_with(",90.000000000")),+ "{text}"+ );// A slot across what is left splits the bend: a row and a line for each piece, both bend 1.run(&mut s, "sheet.unfold", json!({}));rectangle_tool(&mut s, "Slot", [140.0, -20.0], [160.0, 10.0]);@@ -1598,6 +1603,8 @@ fn bend_table_exports_shop_dimensions_and_tracks_parameter_changes() {let csv = run(&mut s, "sheet.export_bend_table", json!({}));let text = csv["text"].as_str().unwrap();assert!(text.starts_with("body,rule,thickness_mm,k_factor,bend,angle_deg,direction,"));+ // The included angle comes last, so a reader that takes the columns by position is unaffected.+ assert!(text.lines().next().is_some_and(|h| h.ends_with(",end_y_mm,included_angle_deg")), "{text}");assert!(text.contains("\"Shop, \"\"steel\"\"\""), "{text}");assert_eq!(text.lines().count(), 2);assert_eq!(csv["bends"], 1);@@ -1617,6 +1624,103 @@ fn bend_table_exports_shop_dimensions_and_tracks_parameter_changes() {assert!(empty.execute("sheet.export_bend_table", &json!({})).is_err());}+/// A 100 x 60 base of the 2 mm rule `Shop` (R 1, K 0.5, its `angle_display` as given; none leaves+/// it out) with a 20 mm edge flange at `deg` on its y = 0 edge.+fn shop_bend(deg: f64, display: Option<&str>) -> Session {+ let mut s = Session::default();+ let mut rule = json!({"name": "Shop", "thickness": "2 mm", "k_factor": 0.5, "bend_radius": "1 mm", "active": true});+ if let Some(d) = display {+ rule["angle_display"] = json!(d);+ }+ run(&mut s, "sheet.manage_rules", rule);+ base(&mut s, 100.0, 60.0);+ run(&mut s, "sheet.flange", json!({"edges": [[50, 0, 2]], "height": 20, "angle": format!("{deg} deg")}));+ s+}++/// The DXF bend notes of the last sheet body.+fn bend_notes(s: &mut Session) -> Vec<String> {+ let dxf = run(s, "sheet.export_dxf", json!({"bend_notes": true}))["dxf"].as_str().unwrap_or_default().to_string();+ dxf.lines().map(str::trim).filter(|l| l.starts_with('B') && l.contains("%%d")).map(str::to_string).collect()+}++#[test]+fn the_bend_table_gives_the_included_angle_beside_the_bend_angle() {+ // 180° less the bend angle whatever the rule shows: a 58° bend leaves 122°, a 90° one 90°.+ for (deg, included) in [(58.0, 122.0), (90.0, 90.0)] {+ for display in [None, Some("bend"), Some("included")] {+ let mut s = shop_bend(deg, display);+ let csv = run(&mut s, "sheet.export_bend_table", json!({}));+ let text = csv["text"].as_str().unwrap_or_default();+ let mut lines = text.lines();+ let header: Vec<&str> = lines.next().unwrap_or_default().split(',').collect();+ let row: Vec<&str> = lines.next().unwrap_or_default().split(',').collect();+ let column = |name: &str| header.iter().position(|h| *h == name);+ assert_eq!((column("angle_deg"), column("included_angle_deg")), (Some(5), Some(14)), "{text}");+ let (angle, inside) = (format!("{deg:.9}"), format!("{included:.9}"));+ assert_eq!((row.get(5).copied(), row.get(14).copied()), (Some(angle.as_str()), Some(inside.as_str())), "{display:?}: {text}");+ for format in ["json", "flat"] {+ let table = if format == "json" {+ let text = run(&mut s, "sheet.export_bend_table", json!({"format": "json"}))["text"].as_str().unwrap_or_default().to_string();+ serde_json::from_str(&text).unwrap_or_default()+ } else {+ flat(&mut s)+ };+ let b = &table["bends"][0];+ let near = |k: &str, want: f64| (b[k].as_f64().unwrap_or(f64::NAN) - want).abs() < 1e-9;+ assert!(near("angle_deg", deg) && near("included_angle_deg", included), "{format} {display:?}: {b}");+ }+ }+ }+}++#[test]+fn the_angle_display_is_a_rule_setting_checked_saved_and_undone() {+ let mut s = shop_bend(58.0, None);+ let display = |s: &mut Session| {+ let r = run(s, "sheet.rules", json!({}));+ (r["rules"][0]["rule"]["angle_display"].clone(), r["rules"][0]["values"]["angle_display"].clone())+ };+ assert_eq!(display(&mut s), (json!("bend"), json!("bend")));+ assert_eq!(bend_notes(&mut s), ["B1 UP 58%%d R1"]);+ // A design whose rules read bend angles saves as it did before the setting.+ let before = s.doc.to_json();+ assert!(!before.contains("angle_display"), "{before}");+ // Only the two words are displays; a refused one changes nothing and makes no rule.+ for wrong in [json!("deflection"), json!("press brake"), json!(""), json!(122), json!(true)] {+ for name in ["Shop", "Other"] {+ let e = s.execute("sheet.manage_rules", &json!({"name": name, "angle_display": wrong})).map(|_| ()).unwrap_err().to_string();+ assert!(e.contains("`angle_display` must be bend or included"), "{e}");+ assert_eq!(s.doc.to_json(), before, "{name}: {wrong}");+ }+ }+ let undo = s.undo.len();+ let r = run(&mut s, "sheet.manage_rules", json!({"name": "Shop", "angle_display": " Included "}));+ assert_eq!((&r["rule"]["angle_display"], &r["values"]["angle_display"]), (&json!("included"), &json!("included")));+ assert_eq!(bend_notes(&mut s), ["B1 UP 122%%d R1"]);+ // Other settings leave it alone, and so does null.+ run(&mut s, "sheet.manage_rules", json!({"name": "Shop", "hem_gap": "0.02 mm", "angle_display": null}));+ assert_eq!(display(&mut s), (json!("included"), json!("included")));+ // Saved with the design and read back; a design saved without it reads bend angles.+ let mut saved: Value = serde_json::from_str(&s.doc.to_json()).unwrap();+ assert_eq!(saved["sheet"]["rules"][0]["angle_display"], "included");+ let mut reopened = Session::new(solidcraft_doc::Document::from_json(&saved.to_string()).unwrap());+ assert_eq!(display(&mut reopened).0, "included");+ assert_eq!(bend_notes(&mut reopened), ["B1 UP 122%%d R1"]);+ if let Some(rule) = saved["sheet"]["rules"][0].as_object_mut() {+ rule.remove("angle_display");+ }+ let mut older = Session::new(solidcraft_doc::Document::from_json(&saved.to_string()).unwrap());+ assert_eq!(display(&mut older), (json!("bend"), json!("bend")));+ assert_eq!(bend_notes(&mut older), ["B1 UP 58%%d R1"]);+ // Undone like the rule's other changes.+ assert_eq!(s.undo.len(), undo + 2);+ run(&mut s, "edit.undo", json!({}));+ run(&mut s, "edit.undo", json!({}));+ assert_eq!(display(&mut s).0, "bend");+ assert_eq!(bend_notes(&mut s), ["B1 UP 58%%d R1"]);+}+#[test]fn malformed_fold_points_are_rejected_atomically() {let mut s = Session::default();diff --git a/crates/ui-egui/src/dialogs_sheet.rs b/crates/ui-egui/src/dialogs_sheet.rsindex 560b10ca6c..dfe47d6cf7 100644--- a/crates/ui-egui/src/dialogs_sheet.rs+++ b/crates/ui-egui/src/dialogs_sheet.rs@@ -37,6 +37,10 @@ const RULE_FIELDS: [(&str, &str); 8] = [/// The corner relief shapes the manager offers (the rule's `corner_relief_shape`) and their labels.const RELIEF_SHAPES: [&str; 4] = ["notch", "round", "rectangular", "tear"];const RELIEF_SHAPE_LABELS: [&str; 4] = ["Notch", "Round", "Rectangular", "Tear"];+/// How the manager's rule reads bend angles in the DXF bend notes (the rule's `angle_display`)+/// and their labels.+const ANGLE_DISPLAYS: [&str; 2] = ["bend", "included"];+const ANGLE_DISPLAY_LABELS: [&str; 2] = ["Bend", "Included"];/// The corner relief shapes an edge flange offers: the rule's (index 0, nothing of its own), then/// the shapes of `RELIEF_SHAPES` in order.const FLANGE_RELIEF_LABELS: [&str; 5] = ["Rule", "Notch", "Round", "Rectangular", "Tear"];@@ -90,6 +94,8 @@ crate::dialog_descriptor::dialog_descriptors! {values: Vec<String>,/// The corner relief shape (index into `RELIEF_SHAPES`).relief: usize,+ /// How bend angles read (index into `ANGLE_DISPLAYS`).+ angles: usize,active: bool,loaded: Option<usize>,},@@ -165,7 +171,7 @@ pub fn start(app: &SolveApp, id: &str) -> Option<(Kind, Vec<SelInput>)> {let active = app.session.doc.sheet.active.clone();let rules = rule_list(app);let pick = active.and_then(|a| rules.iter().position(|r| r.name == a)).unwrap_or(0);- (Sm::Rules { pick, name: String::new(), values: Vec::new(), relief: 0, active: true, loaded: None }, vec![])+ (Sm::Rules { pick, name: String::new(), values: Vec::new(), relief: 0, angles: 0, active: true, loaded: None }, vec![])}"sheet.flat_pattern" => (Sm::FlatPattern { data: None, key: None, status: None }, vec![SelInput::new("Body (last if none)", BODIES, false)]),_ => Sm::simple_start(id)?,@@ -286,7 +292,7 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Sm, inputs: &mut [Sel}Sm::Unfold { .. } => {}Sm::Convert { rule } => rule_combo(app, ui, "sm_conv_rule", rule),- Sm::Rules { pick, name, values, relief, active, loaded } => {+ Sm::Rules { pick, name, values, relief, angles, active, loaded } => {let rules = rule_list(app);crate::rule_editor::rule_editor! {ui, "sm_rules", rules, pick, name, active, loaded;@@ -305,6 +311,7 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Sm, inputs: &mut [Selbase.gap.clone(),];*relief = RELIEF_SHAPES.iter().position(|s| s.eq_ignore_ascii_case(base.corner_relief_shape.trim())).unwrap_or(0);+ *angles = ANGLE_DISPLAYS.iter().position(|d| d.eq_ignore_ascii_case(base.angle_display.trim())).unwrap_or(0);*active = app.session.doc.sheet_rule(None).name == base.name || *pick >= rules.len();},fields: {@@ -315,6 +322,7 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Sm, inputs: &mut [Sel}enter |= expr_row(ui, label, v);}+ choice_row(ui, "Angle Display", "sm_angle_display", angles, &ANGLE_DISPLAY_LABELS);}}if *pick < rules.len()@@ -569,11 +577,12 @@ pub fn commands(app: &SolveApp, k: &Sm, inputs: &[SelInput], extra: &Map<String,}("sheet.convert", p)}- Sm::Rules { pick, name, values, relief, active, .. } => {+ Sm::Rules { pick, name, values, relief, angles, active, .. } => {let rules = rule_list(app);let fields = RULE_FIELDS.iter().map(|(key, _)| *key).zip(values);let mut p = crate::rule_editor::params(rules.get(*pick).map(|r| r.name.as_str()), name, *active, fields)?;p["corner_relief_shape"] = json!(RELIEF_SHAPES.get(*relief).copied().unwrap_or("notch"));+ p["angle_display"] = json!(ANGLE_DISPLAYS.get(*angles).copied().unwrap_or("bend"));("sheet.manage_rules", p)}Sm::FlatPattern { .. } => return Ok(Vec::new()),diff --git a/crates/ui-egui/src/dialogs_sheet_tests.rs b/crates/ui-egui/src/dialogs_sheet_tests.rsindex eef1501561..3371d278b9 100644--- a/crates/ui-egui/src/dialogs_sheet_tests.rs+++ b/crates/ui-egui/src/dialogs_sheet_tests.rs@@ -391,6 +391,51 @@ fn rules_dialog_picks_the_corner_relief_shape() {}}+/// The rule manager's angle display: picked in the dialog, it reaches the rule and the bend notes+/// of the part made with it, and the dialog shows it the next time.+#[test]+fn rules_dialog_sets_how_bend_angles_read() {+ for mode in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked] {+ let mut h = crate::scenario::Harness::new();+ h.call("ui.set", json!({"layout":mode}));+ h.app.run("sheet.manage_rules", json!({"name": "AL2", "thickness": "2 mm", "bend_radius": "1 mm", "active": true})).unwrap();+ h.app.run("sketch.create", json!({"plane": "XY", "name": "Base"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [100, 60]})).unwrap();+ h.app.run("sketch.finish", json!({})).unwrap();+ h.app.run("sheet.flange", json!({"sketch": "Base"})).unwrap();+ h.app.run("sheet.flange", json!({"edges": [[50, 0, 2]], "height": 20, "angle": "58 deg"})).unwrap();+ let shown = |app: &SolveApp| match app.dialog.as_ref().map(|d| &d.kind) {+ Some(Kind::Sheet(Sm::Rules { angles, .. })) => Some(*angles),+ _ => None,+ };+ let note = |app: &mut SolveApp| {+ let dxf = app.session.execute("sheet.export_dxf", &json!({"bend_notes": true})).unwrap();+ dxf["dxf"].as_str().unwrap_or_default().lines().map(str::trim).find(|l| l.starts_with("B1 ")).map(str::to_string)+ };+ assert_eq!(note(&mut h.app).as_deref(), Some("B1 UP 58%%d R1"));+ h.step(&json!({"start": "sheet.manage_rules"})).unwrap();+ h.frames(3);+ assert_eq!(shown(&h.app), Some(0), "a rule starts with bend angles");+ h.step(&json!({"click": {"handle": "dialog:Angle Display"}})).unwrap();+ h.step(&json!({"click": {"handle": "dialog:Angle Display:Included"}})).unwrap();+ assert_eq!(shown(&h.app), Some(1));+ h.step(&json!({"widget": "OK"})).unwrap();+ assert!(h.app.dialog.is_none(), "{:?}", h.app.dialog);+ assert_eq!(h.app.session.doc.sheet_rule(None).angle_display, "included");+ assert_eq!(note(&mut h.app).as_deref(), Some("B1 UP 122%%d R1"));+ h.step(&json!({"start": "sheet.manage_rules"})).unwrap();+ h.frames(3);+ assert_eq!(shown(&h.app), Some(1), "the dialog shows the rule's display");+ // Back to bend angles; the rule's other values are as they were.+ h.step(&json!({"click": {"handle": "dialog:Angle Display"}})).unwrap();+ h.step(&json!({"click": {"handle": "dialog:Angle Display:Bend"}})).unwrap();+ h.step(&json!({"widget": "OK"})).unwrap();+ let rule = h.app.session.doc.sheet_rule(None);+ assert_eq!((rule.angle_display.as_str(), rule.thickness.as_str()), ("bend", "2 mm"));+ assert_eq!(note(&mut h.app).as_deref(), Some("B1 UP 58%%d R1"));+ }+}+/// The rule manager's rectangular relief, on a base whose corners are not square: the shape and/// the size the dialog shows reach the part, the bends and the flat pattern.#[test]diff --git a/crates/ui-egui/src/rule_editor_tests.rs b/crates/ui-egui/src/rule_editor_tests.rsindex 712dc5e7ab..b7aaf15ad9 100644--- a/crates/ui-egui/src/rule_editor_tests.rs+++ b/crates/ui-egui/src/rule_editor_tests.rs@@ -13,6 +13,7 @@ const SHEET_ROWS: &[&str] = &["Corner Relief","Hem Gap","Flange Gap",+ "Angle Display","Active rule",];const PLASTIC_ROWS: &[&str] = &[@@ -65,7 +66,7 @@ fn sheet_rule_editor_contract() {let (mut kind, _) = crate::dialogs_sheet::start(&app, "sheet.manage_rules").unwrap();frame(&mut app, &ctx, &mut kind, SHEET_ROWS);let mut expected = json!({"name":"Steel (mm)","active":true,"corner_relief_shape":"notch","thickness":"2.5 mm","k_factor":"0.44",- "bend_radius":"Thickness","relief_width":"Thickness","relief_depth":"Thickness * 0.5","corner_relief":"Thickness * 4.0","hem_gap":"0.01 mm","gap":"Thickness"});+ "bend_radius":"Thickness","relief_width":"Thickness","relief_depth":"Thickness * 0.5","corner_relief":"Thickness * 4.0","hem_gap":"0.01 mm","gap":"Thickness","angle_display":"bend"});assert_eq!(commands(&app, &kind), vec![("sheet.manage_rules".into(), expected.clone())]);let Kind::Sheet(Sm::Rules { pick, values, relief, .. }) = &mut kind else { panic!() };*pick = 1;diff --git a/docs/book/src/guide/sheet-metal.md b/docs/book/src/guide/sheet-metal.mdindex 5f7ede6ee9..da9bdce920 100644--- a/docs/book/src/guide/sheet-metal.md+++ b/docs/book/src/guide/sheet-metal.md@@ -210,8 +210,10 @@ computing a point on a face with holes or a curved outline: `model.faces` givesFor a shop drawing or spreadsheet, `sheet.export_bend_table` returns CSV by default; choose`format: "json"` for structured data. It includes the sheet rule, thickness, bend angles,-radii, allowances and flat centre-line coordinates. Lengths use millimetres and angles use-degrees. A bend is listed where its centre line has material: one that a cut-out has shortened+radii, allowances and flat centre-line coordinates. Each bend has its bend angle (`angle_deg`)+and its included angle (`included_angle_deg`, below; the CSV's last column, so the columns before+it keep their places). Lengths use millimetres and+angles use degrees. A bend is listed where its centre line has material: one that a cut-out has shortenedgives the length and ends it has left, and one that cut-outs split gives a row for every piece,all with the bend's number (the flat pattern and the DXF draw the same pieces as bend lines).Supply `path` to save it, or omit `path` to receive the content through the command@@ -268,6 +270,23 @@ For a program that cuts every line it is given, `"bend_lines": false` leaves the(`BEND_UP` and `BEND_DOWN` are then empty), and `"layers": "single"` writes every entity on layer`0` instead of a layer for each role.+A bend's angle is how far the sheet turns from flat. Many press brakes are set by the+**included angle** instead: the angle left between the bend's two sides, 180° less the bend+angle. A 90° bend is 90° either way, but a 58° bend is set as 122°. The rule's `angle_display`+(Angle Display in Sheet Metal Rules) says which one the DXF's bend notes give: `bend` (Bend,+the default) or `included` (Included). Under an `included` rule the note of a 58°+bend reads `B1 UP 122° R1`. The bend table gives both angles whatever the rule says, in columns+of their own (`angle_deg` and `included_angle_deg`), so neither is taken for the other. The+setting does not change the flange angle yet: `angle` in `sheet.flange` and in the Flange dialog+is always the bend angle, so a 122° included angle is a flange at `180 deg - 122 deg`. A design+keeps the setting in its rule, so templates made from it read their bends the same way.++```json+{"command":"sheet.manage_rules","params":{"name":"Sheet 2 mm","angle_display":"included"}}+{"command":"sheet.flange","params":{"edges":[[50,0,2]],"height":20,"angle":"180 deg - 122 deg"}}+{"command":"sheet.export_dxf","params":{"path":"bracket-flat.dxf","bend_notes":true}}+```+A design with several sheet bodies exports one file for each with `"per_body": true`: the filesare `<path>-<body>.dxf` (characters a file name cannot hold become `_`; two bodies that wouldshare a name get `_2`, `_3`…), and the reply lists them in `files`. Without a `path` it lists