SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
fix: the bend table and bend lines follow what cut-outs leave of a bend (#607)
NOWN-DEV9089edfb71c8
diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rsindex ac34315301..47cb2342f7 100644--- a/crates/doc/src/sheet.rs+++ b/crates/doc/src/sheet.rs@@ -1261,27 +1261,38 @@ impl SheetBody {Ok(loops)}- /// The bends: angle, radius, direction, allowance and centre line (flat coordinates).+ /// What is cut out of the flat material: the cut-outs, and the pockets that together go+ /// through the whole thickness.+ fn cut_outs(&self) -> Vec<Region2> {+ let mut cuts = self.holes.clone();+ cuts.extend(self.through_pocket_regions(&mut FlatWork::new()).unwrap_or_default());+ cuts+ }++ /// The bends: angle, radius, direction, allowance and centre line (flat coordinates). A+ /// bend is listed where its centre line has material: one entry for every stretch that the+ /// cut-outs leave of it, all with the bend's `index`, and none for a bend they take whole.pub fn bends(&self) -> Vec<BendInfo> {- self.flanges- .iter()- .enumerate()- .map(|(i, f)| {- let ba = self.allowance(f);- let (u0, u1) = self.zone_span(f);- let a = f.p + f.n * (ba / 2.0) + f.d * u0;- BendInfo {+ let cuts = self.cut_outs();+ let mut out = Vec::new();+ for (i, f) in self.flanges.iter().enumerate() {+ let ba = self.allowance(f);+ let (u0, u1) = self.zone_span(f);+ let a = f.p + f.n * (ba / 2.0) + f.d * u0;+ for (s0, s1) in clear_of(a, f.d, u1 - u0, &cuts) {+ out.push(BendInfo {index: i + 1,angle_deg: f.angle.abs().to_degrees(),radius: f.radius,up: f.angle >= 0.0,allowance: ba,- length: u1 - u0,- start: a,- end: a + f.d * (u1 - u0),- }- })- .collect()+ length: s1 - s0,+ start: if s0 > 0.0 { a + f.d * s0 } else { a },+ end: a + f.d * s1,+ });+ }+ }+ out}/// Topology counted as Fusion does: a round hole is one face bounded by two closed circular@@ -2460,6 +2471,85 @@ fn signed_area(p: &[Vec2]) -> f64 {(0..m).filter_map(|i| Some(p.get(i)?.cross(*p.get((i + 1) % m)?))).sum::<f64>() / 2.0}+/// Where the line from `a` along the unit vector `d` meets a boundary segment, as distances from+/// `a`: lines and arcs exactly, free-form curves on their 0.0001 mm chords.+fn line_hits(a: Vec2, d: Vec2, e: &Seg2, out: &mut Vec<f64>) {+ match *e {+ Seg2::Line { a: p, b: q } => {+ let r = q - p;+ let den = d.cross(r);+ if den.abs() > 1e-12 * r.len() {+ let t = (p - a).cross(d) / den;+ if (-1e-9..=1.0 + 1e-9).contains(&t) {+ out.push((p - a).cross(r) / den);+ }+ }+ }+ Seg2::Arc { center, radius, start, sweep } => {+ let (along, off) = ((center - a).dot(d), (center - a).cross(d));+ if off.abs() <= radius {+ let half = ((radius - off) * (radius + off)).max(0.0).sqrt();+ for s in [along - half, along + half] {+ let angle = (a + d * s - center).angle();+ let turned = if sweep >= 0.0 { angle - start } else { start - angle }.rem_euclid(std::f64::consts::TAU);+ if turned <= sweep.abs() + 1e-9 || turned >= std::f64::consts::TAU - 1e-9 {+ out.push(s);+ }+ }+ }+ }+ _ => {+ for w in e.polyline(1e-4).windows(2) {+ if let [p, q] = *w {+ line_hits(a, d, &Seg2::Line { a: p, b: q }, out);+ }+ }+ }+ }+}++/// The stretches of the line from `a` along the unit vector `d`, `len` long, that lie in none of+/// the `cuts` (flat regions), as distances from `a` in order. A line that no cut reaches comes+/// back whole, as (0, `len`); stretches under a thousandth of a micron are no material.+fn clear_of(a: Vec2, d: Vec2, len: f64, cuts: &[Region2]) -> Vec<(f64, f64)> {+ if !len.is_finite() || len <= 0.0 {+ return Vec::new();+ }+ let b = a + d * len;+ let (lo, hi) = (Vec2::new(a.x.min(b.x) - 1e-6, a.y.min(b.y) - 1e-6), Vec2::new(a.x.max(b.x) + 1e-6, a.y.max(b.y) + 1e-6));+ // Only cut-outs whose box the line enters can hold or cross it.+ let near: Vec<&Region2> = cuts+ .iter()+ .filter(|r| {+ let pts = r.outer.polyline(1e-3);+ let (mut p0, mut p1) = (Vec2::new(f64::MAX, f64::MAX), Vec2::new(f64::MIN, f64::MIN));+ for p in &pts {+ (p0, p1) = (Vec2::new(p0.x.min(p.x), p0.y.min(p.y)), Vec2::new(p1.x.max(p.x), p1.y.max(p.y)));+ }+ p0.x <= hi.x && lo.x <= p1.x && p0.y <= hi.y && lo.y <= p1.y+ })+ .collect();+ let mut at = vec![0.0, len];+ for e in near.iter().flat_map(|r| std::iter::once(&r.outer).chain(&r.holes)).flat_map(|l| &l.segs) {+ line_hits(a, d, e, &mut at);+ }+ at.retain(|s| *s >= 0.0 && *s <= len);+ at.sort_by(f64::total_cmp);+ let mut out: Vec<(f64, f64)> = Vec::new();+ for w in at.windows(2) {+ let [s0, s1] = *w else { continue };+ if s1 - s0 < 1e-9 || near.iter().any(|r| r.contains(a + d * ((s0 + s1) / 2.0))) {+ continue;+ }+ match out.last_mut() {+ Some(last) if s0 - last.1 < 1e-9 => last.1 = s1,+ _ => out.push((s0, s1)),+ }+ }+ out.retain(|(s0, s1)| s1 - s0 > 1e-6);+ out+}+/// Do two polygons' edges cross?fn polys_cross(a: &[Vec2], b: &[Vec2]) -> bool {let seg = |p: &[Vec2], i: usize| -> Option<(Vec2, Vec2)> { Some((*p.get(i)?, *p.get((i + 1) % p.len())?)) };@@ -2711,6 +2801,67 @@ mod tests {assert!((s.flat_size().unwrap().1 - 73.685298).abs() < 1e-5);}+ #[test]+ fn bends_are_listed_where_their_centre_lines_have_material() {+ // A 200 × 100 plate with a 40 mm flange on its y = 0 edge: the bend zone lies below+ // y = 0, BA wide, its centre line along y = −BA / 2 from x = 0 to 200.+ let mut s = plate(200.0, 100.0);+ s.add_flange(Vec3::new(100.0, 0.0, 2.5), 40.0, std::f64::consts::FRAC_PI_2, 2.5, "outside", false).unwrap();+ let ba = s.allowance(&s.flanges[0]);+ assert!((ba - std::f64::consts::FRAC_PI_2 * 3.6).abs() < 1e-12);+ let y = -ba / 2.0;+ let whole = s.bends();+ assert_eq!(whole.len(), 1);+ assert!(whole[0].length == 200.0 && whole[0].start == Vec2::new(0.0, y) && whole[0].end == Vec2::new(200.0, y), "{whole:?}");+ let spans = |s: &SheetBody| -> Vec<(usize, f64, f64)> {+ let b = s.bends();+ assert!(b.iter().all(|b| (b.start.y - y).abs() < 1e-12 && (b.end.y - y).abs() < 1e-12 && (b.length - b.start.dist(b.end)).abs() < 1e-12));+ assert!(b.iter().all(|b| b.up && b.allowance == ba && b.radius == 2.5 && (b.angle_deg - 90.0).abs() < 1e-12));+ b.iter().map(|b| (b.index, b.start.x, b.end.x)).collect()+ };+ let close = |got: &[(usize, f64, f64)], want: &[(usize, f64, f64)]| {+ got.len() == want.len() && got.iter().zip(want).all(|(g, w)| g.0 == w.0 && (g.1 - w.1).abs() < 1e-9 && (g.2 - w.2).abs() < 1e-9)+ };+ let block = |x0: f64, x1: f64, y0: f64, y1: f64| rect(Vec2::new(x0, y0), Vec2::new(x1, y0), Vec2::new(x1, y1), Vec2::new(x0, y1));+ let disc = |x: f64, y: f64, r: f64| Region2 { outer: Loop2::circle(Vec2::new(x, y), r), holes: vec![] };+ let with = |cuts: Vec<Region2>| {+ let mut c = s.clone();+ c.holes.extend(cuts);+ c+ };+ // A cut that takes the flange's left half, bend and all (and a strip of the base).+ let half = with(vec![block(-10.0, 100.0, -60.0, 10.0)]);+ assert!(close(&spans(&half), &[(1, 100.0, 200.0)]), "{:?}", half.bends());+ // A slot across the bend: two stretches, both the same bend.+ let slot = with(vec![block(90.0, 110.0, -20.0, 10.0)]);+ assert!(close(&spans(&slot), &[(1, 0.0, 90.0), (1, 110.0, 200.0)]), "{:?}", slot.bends());+ // A round hole on the centre line takes its diameter; one in the zone beside the line+ // (0.5 across, 2 mm off it) takes nothing.+ let hole = with(vec![disc(50.0, y, 1.0), disc(150.0, y + 2.0, 0.25)]);+ assert!(close(&spans(&hole), &[(1, 0.0, 49.0), (1, 51.0, 200.0)]), "{:?}", hole.bends());+ // A hole crossed off its centre takes its chord there: 2·√(3² − 1²).+ let chord = with(vec![disc(50.0, y + 1.0, 3.0)]);+ let c = 8f64.sqrt();+ assert!(close(&spans(&chord), &[(1, 0.0, 50.0 - c), (1, 50.0 + c, 200.0)]), "{:?}", chord.bends());+ // A ring leaves the island inside it its stretch of the bend.+ let ring = with(vec![Region2 { outer: Loop2::circle(Vec2::new(150.0, y), 10.0), holes: vec![Loop2::circle(Vec2::new(150.0, y), 4.0)] }]);+ assert!(close(&spans(&ring), &[(1, 0.0, 140.0), (1, 146.0, 154.0), (1, 160.0, 200.0)]), "{:?}", ring.bends());+ // A cut over the whole bend zone leaves no bend, and cuts elsewhere leave it whole.+ assert!(with(vec![block(-1.0, 201.0, -ba - 0.5, 0.5)]).bends().is_empty());+ assert_eq!(with(vec![disc(50.0, 50.0, 10.0), block(20.0, 40.0, -30.0, -10.0)]).bends(), whole);+ // Pockets count where together they go through the sheet.+ let mut pocketed = s.clone();+ pocketed.record_pocket(block(90.0, 110.0, -20.0, 10.0), 0.0, 1.0, &mut FlatWork::new()).unwrap();+ assert_eq!(pocketed.bends(), whole);+ pocketed.record_pocket(block(80.0, 105.0, -20.0, 10.0), 1.0, 2.5, &mut FlatWork::new()).unwrap();+ assert!(close(&spans(&pocketed), &[(1, 0.0, 90.0), (1, 105.0, 200.0)]), "{:?}", pocketed.bends());+ // A second flange keeps its own number.+ let mut two = half.clone();+ two.add_flange(Vec3::new(100.0, 100.0, 2.5), 40.0, std::f64::consts::FRAC_PI_2, 2.5, "outside", false).unwrap();+ let b = two.bends();+ assert!(b.len() == 2 && b[0].index == 1 && (b[0].length - 100.0).abs() < 1e-9 && b[1].index == 2 && b[1].length == 200.0, "{b:?}");+ }+#[test]fn flat_faces_of_a_sheet_are_found_and_named_by_panel() {use std::f64::consts::FRAC_PI_2;diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rsindex 1d9e799eea..6425c981b8 100644--- a/crates/engine/src/cmd/sheet.rs+++ b/crates/engine/src/cmd/sheet.rs@@ -54,7 +54,7 @@ pub static COMMANDS: &[CommandSpec] = &[.params("body?, path? → DXF (mm): OUTLINE, BEND_UP and BEND_DOWN (centre lines) layers"),CommandSpec::new("sheet.export_bend_table", "Export Bend Table", export_bend_table).noundo()- .params("body?, format?: csv|json (default csv), path? → bend table in mm and degrees, including rule and flat centre-line coordinates"),+ .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"),];fn points(p: &Value, k: &str, cmd: &str) -> Result<Vec<Vec3>> {diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rsindex 38259ed44c..3369efc5fe 100644--- a/crates/engine/src/cmd/sheet_tests.rs+++ b/crates/engine/src/cmd/sheet_tests.rs@@ -954,6 +954,81 @@ fn tray_shrunk_by_a_parameter_unfolds_like_one_built_at_that_size() {}}+#[test]+fn the_bend_table_and_the_dxf_follow_what_flat_cuts_leave_of_a_bend() {+ // A 200 x 100 plate with a 40 mm flange along y = 0: the bend's centre line runs at y = -pi/2+ // (R 1, T 2, K 0.5: a bend allowance of pi) from x = 0 to 200.+ let mut s = Session::default();+ run(&mut s, "sheet.manage_rules", json!({"name": "R", "thickness": "2 mm", "k_factor": "0.5", "bend_radius": "2 mm", "active": true}));+ base(&mut s, 200.0, 100.0);+ run(&mut s, "sheet.flange", json!({"edges": [[100, 0, 2]], "height": 40, "angle": 90, "radius": 1, "position": "outside"}));+ // (bend number, length, start x, end x) of every row; all on the centre line.+ let rows = |s: &mut Session| -> Vec<(u64, f64, f64, f64)> {+ let f = flat(s);+ let num = |v: &Value| v.as_f64().unwrap_or(f64::NAN);+ f["bends"]+ .as_array()+ .cloned()+ .unwrap_or_default()+ .iter()+ .map(|b| {+ assert!((num(&b["start"][1]) + FRAC_PI_2).abs() < 1e-9 && (num(&b["end"][1]) + FRAC_PI_2).abs() < 1e-9, "{b}");+ (b["bend"].as_u64().unwrap_or(0), num(&b["length"]), num(&b["start"][0]), num(&b["end"][0]))+ })+ .collect()+ };+ let close = |got: &[(u64, f64, f64, f64)], want: &[(u64, f64, f64, f64)]| {+ got.len() == want.len()+ && got.iter().zip(want).all(|(g, w)| g.0 == w.0 && (g.1 - w.1).abs() < 1e-9 && (g.2 - w.2).abs() < 1e-9 && (g.3 - w.3).abs() < 1e-9)+ };+ // The DXF's bend lines: both ends' x of every LINE along the centre line, left to right; the+ // BEND_UP layer holds nothing else.+ let bend_lines = |s: &mut Session| -> Vec<(f64, f64)> {+ let text = run(s, "sheet.export_dxf", json!({}))["dxf"].as_str().unwrap_or_default().to_string();+ let on_layer = text.lines().collect::<Vec<_>>().windows(2).filter(|w| w[0].trim() == "8" && w[1].trim() == "BEND_UP").count();+ let mut found: Vec<(f64, f64)> = solidcraft_io::read_dxf(&text)+ .unwrap()+ .iter()+ .filter_map(|g| match g {+ solidcraft_io::Geom2::Line(a, b) if (a.y + FRAC_PI_2).abs() < 1e-6 && (b.y + FRAC_PI_2).abs() < 1e-6 => {+ Some((a.x.min(b.x), a.x.max(b.x)))+ }+ _ => None,+ })+ .collect();+ found.sort_by(|a, b| a.0.total_cmp(&b.0));+ assert_eq!(found.len(), on_layer, "{text}");+ found+ };+ assert!(close(&rows(&mut s), &[(1, 200.0, 0.0, 200.0)]), "{:?}", rows(&mut s));+ assert_eq!(bend_lines(&mut s).len(), 1);+ // A flat cut takes the flange's left half, its bend and a strip of the base.+ run(&mut s, "sheet.unfold", json!({}));+ rectangle_tool(&mut s, "Half", [-10.0, -60.0], [100.0, 10.0]);+ run(&mut s, "solid.extrude", json!({"sketch": "Half", "through_all": true, "direction": "symmetric", "operation": "cut"}));+ run(&mut s, "sheet.refold", json!({}));+ assert!(close(&rows(&mut s), &[(1, 100.0, 100.0, 200.0)]), "{:?}", rows(&mut s));+ let lines = bend_lines(&mut s);+ assert!(lines.len() == 1 && (lines[0].0 - 100.0).abs() < 1e-6 && (lines[0].1 - 200.0).abs() < 1e-6, "{lines:?}");+ 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}");+ // 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]);+ run(&mut s, "solid.extrude", json!({"sketch": "Slot", "through_all": true, "direction": "symmetric", "operation": "cut"}));+ run(&mut s, "sheet.refold", json!({}));+ assert!(close(&rows(&mut s), &[(1, 40.0, 100.0, 140.0), (1, 40.0, 160.0, 200.0)]), "{:?}", rows(&mut s));+ let lines = bend_lines(&mut s);+ assert!(lines.len() == 2 && (lines[0].1 - 140.0).abs() < 1e-6 && (lines[1].0 - 160.0).abs() < 1e-6, "{lines:?}");+ let csv = run(&mut s, "sheet.export_bend_table", json!({}));+ assert_eq!((csv["text"].as_str().unwrap_or_default().lines().count(), csv["bends"].as_u64()), (3, Some(2)));+ // Unfolded, the flat pattern lists the same pieces.+ run(&mut s, "sheet.unfold", json!({}));+ assert!(close(&rows(&mut s), &[(1, 40.0, 100.0, 140.0), (1, 40.0, 160.0, 200.0)]), "{:?}", rows(&mut s));+}+#[test]fn bend_table_exports_shop_dimensions_and_tracks_parameter_changes() {let mut s = Session::default();diff --git a/docs/book/src/guide/sheet-metal.md b/docs/book/src/guide/sheet-metal.mdindex f6f1f00759..1ca810112e 100644--- a/docs/book/src/guide/sheet-metal.md+++ b/docs/book/src/guide/sheet-metal.md@@ -64,7 +64,10 @@ per edge with an angle and a height box; an empty box takes the value above.For 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. Supply `path` to save it, or omit `path` to receive the content through the command+degrees. A bend is listed where its centre line has material: one that a cut-out has shortened+gives 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 commandresponse. `body` defaults to the last sheet body. Exporting does not add a timeline entry orconsume an undo step.