SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
feat: free-form cut-outs stay exact in sheet-metal flat patterns (#692)
NOWN-DEV4ff8f3e14d9c
diff --git a/crates/doc/src/eval_more.rs b/crates/doc/src/eval_more.rsindex afeecab62f..ee82cbef06 100644--- a/crates/doc/src/eval_more.rs+++ b/crates/doc/src/eval_more.rs@@ -340,20 +340,17 @@ fn on_sheet_material(st: &ModelState, i: usize, p: Vec3) -> bool {offsets.iter().any(|&dx| offsets.iter().any(|&dy| offsets.iter().any(|&dz| mesh.contains(p + Vec3::new(dx, dy, dz)))))}-/// A region mirrored in the sketch x axis (y → −y); curves other than lines and arcs as polylines.+/// A region mirrored in the sketch x axis (y → −y), exactly: free-form curves through their+/// control points.fn mirror_y(r: &Region2) -> Region2 {let f = |p: Vec2| Vec2::new(p.x, -p.y);let m = |l: &Loop2| {let segs: Vec<Seg2> = l.segs.iter()- .flat_map(|s| match *s {- Seg2::Line { a, b } => vec![Seg2::Line { a: f(a), b: f(b) }],- Seg2::Arc { center, radius, start, sweep } => vec![Seg2::Arc { center: f(center), radius, start: -start, sweep: -sweep }],- other => {- let pts: Vec<Vec2> = (0..=16).map(|k| f(other.point_at(k as f64 / 16.0))).collect();- pts.windows(2).map(|w| Seg2::Line { a: w[0], b: w[1] }).collect()- }+ .map(|s| match *s {+ Seg2::Arc { center, radius, start, sweep } => Seg2::Arc { center: f(center), radius, start: -start, sweep: -sweep },+ other => sheet::map_controls(&other, f),}).collect();Loop2 { segs }.ccw()diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rsindex dfb118a54e..769bd23fb9 100644--- a/crates/doc/src/sheet.rs+++ b/crates/doc/src/sheet.rs@@ -18,8 +18,8 @@ use crate::{DocError, Document, IDENTITY, Mat, Result, apply_point, apply_vector// Bound the aggregate geometry, including sampled curves and intermediate clipping pieces.// These are work limits, never geometry truncation: a larger input returns a useful error.-// Exact lines and arcs count once each (the planar booleans work on them whole); sampled-// curves count their 0.001 mm chords.+// Exact lines and arcs count once each (the planar booleans work on them whole); free-form+// curves (conics, splines, text) count the arcs the planar booleans follow them with.const MAX_FLAT_POINTS: usize = 16_384;// The 0.001 mm chords of everything, arcs included: what the planar booleans sample (their// own limit is the same).@@ -71,23 +71,57 @@ fn flat_points(polys: &[Vec<Vec2>]) -> Result<usize> {Ok(n)}+/// A loop as the planar booleans arrange it: free-form segments (conics, splines, text)+/// followed by tangent arcs within the kernel's fit tolerance.+fn fitted_loop(lp: &Loop2) -> Result<Loop2> {+ if lp.is_line_arc() {+ return Ok(lp.clone());+ }+ if lp.segs.len() > MAX_FLAT_POINTS {+ return Err(flat_budget_error());+ }+ lp.fit_arcs(kernel::PLANAR_FIT_TOL).ok_or_else(flat_budget_error)+}++/// A region of lines and arcs only (see [`fitted_loop`]): what the folded solid is sewn from.+fn fitted_region(region: &Region2) -> Result<Region2> {+ Ok(Region2 { outer: fitted_loop(®ion.outer)?, holes: region.holes.iter().map(fitted_loop).collect::<Result<_>>()? })+}++/// A region with every free-form loop as its 0.001 mm chords: the outline a pocket is+/// machined along. The body booleans take a tool of many small cylinders several times+/// slower than one of planes.+fn chorded_region(region: &Region2) -> Result<Region2> {+ let chorded = |lp: &Loop2| -> Result<Loop2> { if lp.is_line_arc() { Ok(lp.clone()) } else { Ok(Loop2::polygon(&flat_polyline(lp)?)) } };+ Ok(Region2 {+ outer: chorded(®ion.outer)?.ccw(),+ holes: region.holes.iter().map(|h| chorded(h).map(|l| l.ccw().reversed())).collect::<Result<_>>()?,+ })+}++/// A line or free-form segment with its points mapped by `f`: exact under any affine map (a+/// conic keeps its weight). An arc is given by angles, not points, and stays as it is.+pub(crate) fn map_controls(seg: &Seg2, f: impl Fn(Vec2) -> Vec2) -> Seg2 {+ match *seg {+ Seg2::Line { a, b } => Seg2::Line { a: f(a), b: f(b) },+ Seg2::Cubic { p0, p1, p2, p3 } => Seg2::Cubic { p0: f(p0), p1: f(p1), p2: f(p2), p3: f(p3) },+ Seg2::Conic { a, apex, b, w } => Seg2::Conic { a: f(a), apex: f(apex), b: f(b), w },+ Seg2::Bezier { n, mut p } => {+ p.iter_mut().take(usize::from(n) + 1).for_each(|q| *q = f(*q));+ Seg2::Bezier { n, p }+ }+ arc @ Seg2::Arc { .. } => arc,+ }+}+fn planar_region(region: &Region2) -> Result<Region2> {if region.holes.len() > MAX_FLAT_PIECES {return Err(flat_budget_error());}region_complexity(std::slice::from_ref(region))?;- let convert = |lp: &Loop2| -> Result<Loop2> {- if lp.segs.iter().all(|s| matches!(s, Seg2::Line { .. } | Seg2::Arc { .. })) {- Ok(lp.clone())- } else {- // Keep free-form profiles through controlled 0.001 mm chord sampling.- Ok(Loop2::polygon(&flat_polyline(lp)?))- }- };- Ok(Region2 {- outer: convert(®ion.outer)?.ccw(),- holes: region.holes.iter().map(|h| convert(h).map(|l| l.ccw().reversed())).collect::<Result<_>>()?,- })+ // Free-form loops stay exact: the planar booleans follow them with arcs and hand a loop+ // they leave whole its exact segments back.+ Ok(Region2 { outer: region.outer.ccw(), holes: region.holes.iter().map(|h| h.ccw().reversed()).collect() })}fn region_complexity(regions: &[Region2]) -> Result<(usize, usize)> {@@ -103,13 +137,21 @@ fn regions_complexity<'a>(regions: impl Iterator<Item = &'a Region2>) -> Result<return Err(flat_budget_error());}for lp in std::iter::once(®ion.outer).chain(®ion.holes) {+ // A free-form loop costs what the planar booleans work on: its fitted arcs.+ let fitted;+ let lp = if lp.is_line_arc() {+ lp+ } else {+ fitted = fitted_loop(lp)?;+ &fitted+ };edges = edges.saturating_add(lp.segs.len());if edges > MAX_FLAT_POINTS {return Err(flat_budget_error());}for seg in &lp.segs {let chords = seg.polyline(1e-3).len().saturating_sub(1);- points = points.saturating_add(if matches!(seg, Seg2::Line { .. } | Seg2::Arc { .. }) { 1 } else { chords });+ points = points.saturating_add(1);samples = samples.saturating_add(chords);if points > MAX_FLAT_POINTS || samples > MAX_FLAT_SAMPLES {return Err(flat_budget_error());@@ -843,22 +885,26 @@ impl SheetBody {for (i, f) in self.flanges.iter().enumerate() {pieces.push((Piece::Zone(i), self.zone(f)));}+ // The folded solid is sewn from lines and arcs: free-form outlines and cut-outs follow+ // their fitted arcs there (the flat pattern keeps them exact).let mut cuts = Vec::new();let mut cut_points = 0usize;for hole in &self.holes {- let region = planar_region(hole)?;+ let region = fitted_region(&planar_region(hole)?)?;cut_points = cut_points.saturating_add(region_complexity(std::slice::from_ref(®ion))?.1);if cut_points > MAX_FLAT_POINTS {return Err(flat_budget_error());}cuts.push(region);}- cuts.extend(self.through_pocket_regions(work)?);+ for pocket in self.through_pocket_regions(work)? {+ cuts.push(fitted_region(&pocket)?);+ }let cuts = material_union(cuts, work)?;let mut out = Vec::new();let mut points = 0usize;for (piece, region) in pieces {- let panel = planar_region(®ion)?;+ let panel = fitted_region(&planar_region(®ion)?)?;let material = if cuts.is_empty() { vec![panel] } else { material_boolean(&[panel], &cuts, kernel::BoolOp::Cut, work)? };for region in material {points = points.saturating_add(region_complexity(std::slice::from_ref(®ion))?.1);@@ -1050,7 +1096,12 @@ impl SheetBody {/// The flat pattern as one extrusion (outline with its cut-outs).pub fn flat_solid(&self) -> Result<Body> {- let regions = self.flat_regions()?;+ let mut regions = self.flat_regions()?;+ if !self.pockets.is_empty() {+ // Pockets are machined by the prism booleans, which read walls of planes and+ // cylinders: the blank they cut follows its fitted arcs then.+ regions = regions.iter().map(fitted_region).collect::<Result<_>>()?;+ }let mut local = self.clone();local.frame = Plane::XY;local.flat = true;@@ -1128,13 +1179,14 @@ impl SheetBody {if self.pockets.len() > 1000 {return Err(flat_budget_error());}- regions_complexity(self.pockets.iter().map(|p| &p.region))?;+ let outlines = self.pockets.iter().map(|p| chorded_region(&p.region)).collect::<Result<Vec<_>>>()?;+ regions_complexity(outlines.iter())?;let panels = if self.flat {vec![(None, self.flat_regions()?)]} else {self.material_panels(None, work)?.into_iter().map(|(pi, r)| (pi, vec![r])).collect()};- for pocket in &self.pockets {+ for (pocket, outline) in self.pockets.iter().zip(&outlines) {if !pocket.z0.is_finite() || !pocket.z1.is_finite() || pocket.z0 < 0.0 || pocket.z1 > self.t || pocket.z0 >= pocket.z1 {return Err(DocError::Invalid("invalid sheet pocket depth".into()));}@@ -1148,10 +1200,13 @@ impl SheetBody {}}for (pi, panel) in &panels {- let clipped = material_boolean(panel, std::slice::from_ref(&pocket.region), kernel::BoolOp::Intersect, work)?;+ let clipped = material_boolean(panel, std::slice::from_ref(outline), kernel::BoolOp::Intersect, work)?;if clipped.is_empty() {continue;}+ // What the tool takes over from a free-form cut-out of the panel follows its+ // fitted arcs: walls of planes and cylinders, which the prism booleans take.+ let clipped = clipped.iter().map(fitted_region).collect::<Result<Vec<_>>>()?;let w = if self.flat { self.frame_mat() } else { self.world(*pi) };let plane = plane_of(&w, Vec3::ZERO, Vec3::X, Vec3::Y)?;// BRep replay is costlier than planar clipping; share the command budget.@@ -1243,7 +1298,9 @@ impl SheetBody {/// Actual flat material boundaries after cut-outs. The same panel and cut regions build/// the folded solid; planar unions remove panel/bend seams and turn edge-crossing cuts- /// into notches. Lines and circular arcs remain exact through clipping and merging.+ /// into notches. Lines and circular arcs remain exact through clipping and merging; a+ /// free-form loop that comes out whole is the curve it was drawn as, one that is clipped+ /// follows it with tangent arcs.pub fn flat_regions(&self) -> Result<Vec<Region2>> {let regions = self.flat_material()?;if regions.is_empty() {@@ -2995,21 +3052,12 @@ impl SheetBody {Seg2::Arc { center: map(center), radius, start: rot + start, sweep }}}- other => Seg2::Line { a: map(other.start()), b: map(other.end()) },+ // Free-form segments map exactly, through their control points.+ other => map_controls(&other, map),}};- let map_loop = |lp: &Loop2| -> Result<Loop2> {- let curved_other = lp.segs.iter().any(|x| !matches!(x, Seg2::Line { .. } | Seg2::Arc { .. }));- if curved_other {- Ok(Loop2::polygon(&flat_polyline(lp)?.into_iter().map(map).collect::<Vec<_>>()))- } else {- Ok(Loop2 { segs: lp.segs.iter().map(seg).collect() })- }- };- Ok(Region2 {- outer: map_loop(&r.outer)?.ccw(),- holes: r.holes.iter().map(|h| map_loop(h).map(|l| l.ccw().reversed())).collect::<Result<_>>()?,- })+ let map_loop = |lp: &Loop2| Loop2 { segs: lp.segs.iter().map(seg).collect() };+ Ok(Region2 { outer: map_loop(&r.outer).ccw(), holes: r.holes.iter().map(|h| map_loop(h).ccw().reversed()).collect() })}/// Panels whose plane is parallel to `plane` (world): (panel, region).@@ -3730,24 +3778,113 @@ mod tests {}#[test]- fn freeform_profile_uses_bounded_sampling_with_exact_round_holes() {+ fn freeform_profile_stays_exact_with_exact_round_holes() {let mut s = plate(100.0, 60.0);+ let cubic =+ Seg2::Cubic { p0: Vec2::new(100.0, 60.0), p1: Vec2::new(200.0 / 3.0, 80.0), p2: Vec2::new(100.0 / 3.0, 80.0), p3: Vec2::new(0.0, 60.0) };s.base.outer.segs = vec![Seg2::Line { a: Vec2::ZERO, b: Vec2::new(100.0, 0.0) },Seg2::Line { a: Vec2::new(100.0, 0.0), b: Vec2::new(100.0, 60.0) },- Seg2::Cubic { p0: Vec2::new(100.0, 60.0), p1: Vec2::new(200.0 / 3.0, 80.0), p2: Vec2::new(100.0 / 3.0, 80.0), p3: Vec2::new(0.0, 60.0) },+ cubic,Seg2::Line { a: Vec2::new(0.0, 60.0), b: Vec2::ZERO },];s.holes.push(Region2 { outer: Loop2::circle(Vec2::new(50.0, 30.0), 3.0), holes: vec![] });let regions = s.flat_regions().unwrap();- assert!(regions[0].outer.segs.iter().all(|s| matches!(s, Seg2::Line { .. })));+ // The outline the cut leaves whole keeps its exact cubic, the hole its exact arcs.+ assert_eq!(regions[0].outer.segs.iter().filter(|s| matches!(s, Seg2::Line { .. })).count(), 3);+ assert!(regions[0].outer.segs.contains(&cubic), "{:?}", regions[0].outer);assert!(regions[0].holes[0].segs.iter().all(|s| matches!(s, Seg2::Arc { .. })));// The cubic has x=100(1-t), y=60+60t(1-t), hence an exact blank area of 7000.+ assert!((regions[0].area() - (7000.0 - std::f64::consts::PI * 9.0)).abs() < 1e-9, "{}", regions[0].area());let expected = (7000.0 - std::f64::consts::PI * 9.0) * 2.5;assert!((vol(&s.solid().unwrap()) - expected).abs() < 0.5);assert!((vol(&s.flat_solid().unwrap()) - expected).abs() < 0.5);}+ /// An ellipse about `c` with semi-axes `a` (along x) and `b`, as four exact conics.+ fn ellipse(c: Vec2, a: f64, b: f64) -> Region2 {+ let corners = [c + Vec2::new(a, 0.0), c + Vec2::new(0.0, b), c - Vec2::new(a, 0.0), c - Vec2::new(0.0, b)];+ let w = std::f64::consts::FRAC_1_SQRT_2;+ let segs = (0..4).map(|i| Seg2::Conic { a: corners[i], apex: corners[i] + corners[(i + 1) % 4] - c, b: corners[(i + 1) % 4], w }).collect();+ Region2 { outer: Loop2 { segs }, holes: vec![] }+ }++ #[test]+ fn free_form_cut_outs_stay_exact_in_the_flat_pattern_and_follow_arcs_in_the_folded_solid() {+ let mut s = plate(100.0, 60.0);+ s.add_flange(Vec3::new(50.0, 0.0, 2.5), 20.0, std::f64::consts::FRAC_PI_2, 2.5, "inside", false).unwrap();+ let (blank, folded) = (s.flat_regions().unwrap()[0].area(), vol(&s.solid().unwrap()));+ let hole = ellipse(Vec2::new(40.0, 30.0), 15.0, 8.0);+ let cut = std::f64::consts::PI * 15.0 * 8.0;+ s.holes.push(hole.clone());+ // The flat pattern's cut-out is the ellipse itself (four conics, running as a hole) and+ // its area is the blank less π·15·8.+ let regions = s.flat_regions().unwrap();+ assert_eq!(regions.len(), 1);+ let h = ®ions[0].holes[0];+ assert!(h.segs.len() == 4 && h.segs.iter().all(|x| hole.outer.segs.contains(&x.reversed())), "{h:?}");+ assert!((regions[0].area() - (blank - cut)).abs() < 1e-9, "{} vs {}", regions[0].area(), blank - cut);+ // The folded solid is sewn from lines and arcs within the fit tolerance (times the+ // perimeter, 74 mm): fewer than half the 264 chords of 0.001 mm.+ let cells = s.cells_with_work(&mut FlatWork::new()).unwrap();+ let base = cells.iter().find(|c| c.piece == Piece::Panel(None)).unwrap();+ assert!(base.holes.len() == 1 && base.holes[0].len() < 132 && base.holes[0].iter().all(Seg2::is_line_or_arc), "{}", base.holes[0].len());+ assert!((Loop2 { segs: base.holes[0].clone() }.signed_area().abs() - cut).abs() < kernel::PLANAR_FIT_TOL * 74.0);+ assert!((folded - vol(&s.solid().unwrap()) - cut * 2.5).abs() < 0.5);+ // The flat solid has the ellipse's wall as four faces.+ let flat = s.flat_solid().unwrap();+ assert!((vol(&flat) - (blank - cut) * 2.5).abs() < 0.5);+ assert_eq!(flat.face_count(), regions[0].outer.segs.len() + 4 + 2);+ }++ #[test]+ fn regions_map_into_the_flat_frame_with_their_exact_curves() {+ let s = plate(100.0, 60.0);+ let hole = ellipse(Vec2::new(40.0, 30.0), 15.0, 8.0);+ // Drawn on the sheet's own plane: the region as it is.+ assert_eq!(s.region_to_flat(None, &Plane::XY, &hole).unwrap(), hole);+ // Drawn from below (y mirrored) at (40, −30), with a cubic and a quartic lobe on its+ // right: the same ellipse on the sheet, every curve through its mirrored controls.+ let below = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Y * -1.0 };+ let mirror = |p: Vec2| Vec2::new(p.x, -p.y);+ let seen = Region2 { outer: Loop2 { segs: hole.outer.segs.iter().map(|x| map_controls(x, mirror)).collect() }, holes: vec![] };+ let mapped = s.region_to_flat(None, &below, &seen).unwrap();+ assert!(mapped.outer.is_ccw() && mapped.outer.segs.len() == 4 && mapped.outer.segs.iter().all(|x| hole.outer.segs.contains(x)), "{mapped:?}");+ // A cubic and a quartic closed by a line, clockwise in that plane: counter-clockwise on+ // the sheet, every control point mirrored.+ let (a, b, c) = (Vec2::new(60.0, -20.0), Vec2::new(60.0, -40.0), Vec2::new(80.0, -30.0));+ let (cubic, quartic) = (+ [a, a + Vec2::new(10.0, 4.0), c + Vec2::new(0.0, 8.0), c],+ [c, c + Vec2::new(0.0, -6.0), c + Vec2::new(-6.0, -12.0), b + Vec2::new(8.0, -2.0), b],+ );+ let lobe = |f: fn(Vec2) -> Vec2| Loop2 {+ segs: vec![+ solidcraft_geom::bezier(&cubic.map(f)).unwrap(),+ solidcraft_geom::bezier(&quartic.map(f)).unwrap(),+ Seg2::Line { a: f(b), b: f(a) },+ ],+ };+ let drawn = lobe(|p| p);+ let mapped = s.region_to_flat(None, &below, &Region2 { outer: drawn.clone(), holes: vec![] }).unwrap();+ assert_eq!(mapped.outer, lobe(mirror));+ assert!(mapped.holes.is_empty() && (mapped.area() + drawn.signed_area()).abs() < 1e-9 && mapped.area() > 100.0, "{}", mapped.area());+ }++ #[test]+ fn pockets_with_free_form_outlines_are_machined_beside_free_form_cut_outs() {+ let mut s = plate(100.0, 60.0);+ s.holes.push(ellipse(Vec2::new(30.0, 30.0), 15.0, 8.0));+ let pocket = ellipse(Vec2::new(70.0, 30.0), 10.0, 6.0);+ s.record_pocket(pocket.clone(), 0.0, 1.0, &mut FlatWork::new()).unwrap();+ // The plate less the through ellipse (π·15·8 of 2.5 mm) and the pocket (π·10·6 of 1 mm).+ let expected = (6000.0 - std::f64::consts::PI * 120.0) * 2.5 - std::f64::consts::PI * 60.0;+ assert!((vol(&s.solid().unwrap()) - expected).abs() < 0.5, "{}", vol(&s.solid().unwrap()));+ assert!((vol(&s.flat_solid().unwrap()) - expected).abs() < 0.5, "{}", vol(&s.flat_solid().unwrap()));+ // The machining record keeps the pocket's exact outline.+ let machined = s.machining().unwrap();+ assert!(machined.len() == 1 && machined[0].region.outer == pocket.outer, "{} records", machined.len());+ }+#[test]fn flat_geometry_budgets_reject_aggregate_and_intermediate_work() {let mut s = plate(100.0, 60.0);diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rsindex 30783b3493..7793d371ed 100644--- a/crates/engine/src/cmd/sheet_tests.rs+++ b/crates/engine/src/cmd/sheet_tests.rs@@ -1333,6 +1333,75 @@ fn inherited_round_hole_survives_flange_and_unfold_in_flipped_frames() {}}+fn faces(s: &mut Session) -> (u64, u64) {+ let body = run(s, "inspect.measure", json!({}))["bodies"][0].clone();+ (body["faces"].as_u64().unwrap(), body["face_types"]["cylinder"].as_u64().unwrap_or(0))+}++#[test]+fn elliptic_cut_out_stays_exact_in_the_flat_pattern_and_follows_arcs_when_folded() {+ use solidcraft_geom::Seg2;+ 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 (uncut, blank) = (volume(&mut s), s.model.state().sheets[0].flat_regions().unwrap()[0].area());+ let (plain_faces, plain_cylinders) = faces(&mut s);+ run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Cut"}));+ run(&mut s, "sketch.ellipse", json!({"center": [40, 30], "major": [55, 30], "minor_radius": 8}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch": "Cut", "through_all": true, "operation": "cut", "direction": "symmetric"}));+ // The ellipse takes π·15·8 of the 2.5 mm sheet (a body's volume is measured on its mesh).+ let cut = PI * 15.0 * 8.0;+ let folded = volume(&mut s);+ assert!((uncut - folded - cut * 2.5).abs() < 0.5, "{}", uncut - folded);+ // The flat pattern holds the ellipse itself, so its area is the blank less π·15·8.+ let regions = s.model.state().sheets[0].flat_regions().unwrap();+ let hole = ®ions[0].holes[0];+ assert!(hole.segs.len() == 4 && hole.segs.iter().all(|x| matches!(x, Seg2::Conic { .. })), "{} segments", hole.segs.len());+ assert!((regions[0].area() - (blank - cut)).abs() < 1e-9, "{}", regions[0].area());+ // The flat pattern JSON lists it as those four curves, one `polyline` each, with every+ // point on the ellipse ((x − 40)/15)² + ((y − 30)/8)² = 1.+ let shapes = flat(&mut s)["cutout_shapes"].as_array().cloned().unwrap_or_default();+ let curves: Vec<Vec<Value>> = shapes[0]["segments"].as_array().into_iter().flatten().filter_map(|x| x["polyline"].as_array().cloned()).collect();+ assert!(shapes.len() == 1 && curves.len() == 4 && shapes[0]["segments"].as_array().is_some_and(|a| a.len() == 4), "{} curves", curves.len());+ let off = |p: &Value| ((p[0].as_f64().unwrap_or(0.0) - 40.0) / 15.0).powi(2) + ((p[1].as_f64().unwrap_or(0.0) - 30.0) / 8.0).powi(2) - 1.0;+ assert!(curves.iter().all(|c| c.len() > 2 && c.iter().all(|p| off(p).abs() < 1e-9)));+ // Folded, the cut-out's wall is cylinders over tangent arcs: fewer than half the 264+ // chords of 0.001 mm (four quarters of √(2·17/0.008) = 66 each).+ let (cut_faces, cut_cylinders) = faces(&mut s);+ let wall = cut_faces - plain_faces;+ assert!(wall < 132 && cut_cylinders - plain_cylinders + 4 >= wall, "{wall} wall faces, {} cylinders", cut_cylinders - plain_cylinders);+ // Unfolded, it is the four conic faces of the ellipse.+ run(&mut s, "sheet.unfold", json!({}));+ assert!((volume(&mut s) - (blank - cut) * 2.5).abs() < 0.5);+ assert_eq!(faces(&mut s).0, regions[0].outer.segs.len() as u64 + 4 + 2);+ run(&mut s, "sheet.refold", json!({}));+ assert!((volume(&mut s) - folded).abs() < 0.1);+}++#[test]+fn flipped_base_flange_keeps_its_elliptic_outline() {+ for flip in [false, true] {+ let mut s = Session::default();+ run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Oval"}));+ run(&mut s, "sketch.ellipse", json!({"center": [0, 0], "major": [25, 0], "minor_radius": 12}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "sheet.flange", json!({"sketch": "Oval", "flip": flip}));+ let regions = s.model.state().sheets[0].flat_regions().unwrap();+ let outline = ®ions[0].outer.segs;+ assert!(+ outline.len() == 4 && outline.iter().all(|x| matches!(x, solidcraft_geom::Seg2::Conic { .. })),+ "flip {flip}: {} segments",+ outline.len()+ );+ // π·25·12 of the 2.5 mm sheet: exactly in the flat pattern; within 0.5 mm³ in the body,+ // which follows the outline by arcs and is measured on its mesh (a 64-sided outline+ // would be 3.8 mm³ short).+ assert!((regions[0].area() - PI * 300.0).abs() < 1e-9, "flip {flip}: {}", regions[0].area());+ assert!((volume(&mut s) - PI * 300.0 * 2.5).abs() < 0.5, "flip {flip}: {}", volume(&mut s));+ }+}+#[test]fn crossing_only_disconnecting_cut_preserves_all_material_states() {let mut s = Session::default();diff --git a/crates/geom/src/arcfit.rs b/crates/geom/src/arcfit.rsnew file mode 100644index 0000000000..332cee3338--- /dev/null+++ b/crates/geom/src/arcfit.rs@@ -0,0 +1,391 @@+//! Arc fitting: free-form segments (conics, cubic and higher Béziers) as chains of circular+//! arcs and lines within a tolerance, tangent-continuous inside each segment (biarcs).+//!+//! Code that works on lines and arcs alone (planar booleans, the folded sheet-metal solid)+//! keeps smooth curves this way with far fewer pieces than a chord polyline of the same+//! tolerance: a biarc's error falls with the cube of its length, a chord's with the square.++use std::f64::consts::{PI, TAU};++use crate::{Loop2, Region2, Seg2, Vec2};++/// Most pieces one segment is fitted with.+pub const MAX_FIT_PIECES: usize = 2048;+/// Deepest subdivision of one segment.+const MAX_DEPTH: u32 = 30;+/// Samples inside each candidate span that must lie within the tolerance.+const SAMPLES: usize = 12;++impl Seg2 {+ /// A straight line or a circular arc (what [`Seg2::fit_arcs`] produces).+ pub fn is_line_or_arc(&self) -> bool {+ matches!(self, Seg2::Line { .. } | Seg2::Arc { .. })+ }++ /// Lines and circular arcs that follow the segment within `tol` (mm), in order, the first+ /// starting at the segment's start and the last ending at its end; consecutive pieces share+ /// their end points and tangents. Lines and arcs come back unchanged. `None` when the+ /// segment is not finite or would need more than [`MAX_FIT_PIECES`] pieces.+ pub fn fit_arcs(&self, tol: f64) -> Option<Vec<Seg2>> {+ if self.is_line_or_arc() {+ return Some(vec![*self]);+ }+ if !(tol.is_finite() && tol > 0.0) {+ return None;+ }+ let tol = tol.max(1e-9);+ let mut out: Vec<Seg2> = Vec::new();+ // Spans still to fit; the last pushed is fitted first, so pushing the right half before+ // the left one keeps the output in parameter order.+ let mut todo = vec![(0.0f64, 1.0f64, 0u32)];+ let mut steps = 0usize;+ while let Some((t0, t1, depth)) = todo.pop() {+ steps += 1;+ if steps > 4 * MAX_FIT_PIECES {+ return None;+ }+ let (p0, p1) = (self.point_at(t0), self.point_at(t1));+ if !(p0.is_finite() && p1.is_finite()) {+ return None;+ }+ if p0.dist(p1) < 1e-12 && self.span_extent(t0, t1) < tol {+ continue;+ }+ let fit = match (self.tangent_out(t0, t1), self.tangent_in(t0, t1)) {+ (Some(d0), Some(d1)) => biarc(p0, d0, p1, d1).filter(|arcs| self.within(arcs, t0, t1, tol)),+ _ => None,+ };+ match fit {+ Some(arcs) => {+ out.extend(arcs);+ if out.len() > MAX_FIT_PIECES {+ return None;+ }+ }+ None if depth < MAX_DEPTH => {+ let tm = 0.5 * (t0 + t1);+ todo.push((tm, t1, depth + 1));+ todo.push((t0, tm, depth + 1));+ }+ None => {+ // Too fine to split further (a cusp): the chord is within the tolerance+ // here or nothing is.+ let chord = [Seg2::Line { a: p0, b: p1 }];+ if !self.within(&chord, t0, t1, tol) {+ return None;+ }+ out.push(chord[0]);+ }+ }+ }+ // The pieces join where their spans meet; pin the outer ends to the segment's own.+ if let Some(first) = out.first_mut() {+ *first = with_start(*first, self.start());+ }+ if let Some(last) = out.last_mut() {+ *last = with_end(*last, self.end());+ }+ Some(out)+ }++ /// Unit direction of travel leaving `t` towards `t1`.+ fn tangent_out(&self, t: f64, t1: f64) -> Option<Vec2> {+ self.derivative(t).normalized().or_else(|| (self.point_at(t + (t1 - t) * 1e-4) - self.point_at(t)).normalized())+ }++ /// Unit direction of travel arriving at `t1` from `t0`.+ fn tangent_in(&self, t0: f64, t1: f64) -> Option<Vec2> {+ self.derivative(t1).normalized().or_else(|| (self.point_at(t1) - self.point_at(t1 - (t1 - t0) * 1e-4)).normalized())+ }++ /// Largest distance of the span's sample points from its start (a loop's size).+ fn span_extent(&self, t0: f64, t1: f64) -> f64 {+ let p0 = self.point_at(t0);+ (1..=SAMPLES).map(|i| self.point_at(t0 + (t1 - t0) * i as f64 / (SAMPLES + 1) as f64).dist(p0)).fold(0.0, f64::max)+ }++ /// Do `pieces` follow the span `t0..t1` within `tol` both ways?+ fn within(&self, pieces: &[Seg2], t0: f64, t1: f64, tol: f64) -> bool {+ if pieces.iter().any(|p| matches!(p, Seg2::Arc { sweep, .. } if sweep.abs() > PI)) {+ return false;+ }+ let samples: Vec<Vec2> = (0..=SAMPLES + 1).map(|i| self.point_at(t0 + (t1 - t0) * i as f64 / (SAMPLES + 1) as f64)).collect();+ // The curve near the pieces...+ if samples.iter().any(|p| pieces.iter().map(|s| dist_to(s, *p)).fold(f64::INFINITY, f64::min) > tol) {+ return false;+ }+ // ...and the pieces near the curve (their quarter points against the curve's closest+ // point on the span).+ pieces.iter().all(|s| {+ [0.25, 0.5, 0.75].iter().all(|f| {+ let q = s.point_at(*f);+ self.dist_on_span(q, t0, t1, &samples) <= tol+ })+ })+ }++ /// Distance from `q` to the span `t0..t1` (closest sample, then Newton steps).+ fn dist_on_span(&self, q: Vec2, t0: f64, t1: f64, samples: &[Vec2]) -> f64 {+ let n = samples.len().saturating_sub(1).max(1);+ let (k, mut best) = samples.iter().enumerate().map(|(i, p)| (i, p.dist(q))).fold((0, f64::INFINITY), |a, b| if b.1 < a.1 { b } else { a });+ let mut t = t0 + (t1 - t0) * k as f64 / n as f64;+ for _ in 0..12 {+ let (p, d) = (self.point_at(t), self.derivative(t));+ let dd = d.dot(d);+ if !(dd > 1e-300) {+ break;+ }+ let nt = (t - (p - q).dot(d) / dd).clamp(t0, t1);+ best = best.min(self.point_at(nt).dist(q));+ if (nt - t).abs() < 1e-15 {+ break;+ }+ t = nt;+ }+ best+ }+}++impl Loop2 {+ /// The loop with every free-form segment fitted by lines and arcs (see+ /// [`Seg2::fit_arcs`]). `None` when a segment cannot be fitted.+ pub fn fit_arcs(&self, tol: f64) -> Option<Loop2> {+ let mut segs = Vec::with_capacity(self.segs.len());+ for s in &self.segs {+ segs.extend(s.fit_arcs(tol)?);+ if segs.len() > MAX_FIT_PIECES * 8 {+ return None;+ }+ }+ Some(Loop2 { segs })+ }++ /// Only lines and arcs?+ pub fn is_line_arc(&self) -> bool {+ self.segs.iter().all(Seg2::is_line_or_arc)+ }+}++impl Region2 {+ /// Only lines and arcs?+ pub fn is_line_arc(&self) -> bool {+ self.outer.is_line_arc() && self.holes.iter().all(Loop2::is_line_arc)+ }+}++/// Distance from `p` to a line or arc segment (other segments: to their closest point).+fn dist_to(s: &Seg2, p: Vec2) -> f64 {+ match *s {+ Seg2::Line { a, b } => {+ let d = b - a;+ let l2 = d.len2();+ let t = if l2 > 1e-300 { ((p - a).dot(d) / l2).clamp(0.0, 1.0) } else { 0.0 };+ (a + d * t).dist(p)+ }+ Seg2::Arc { center, radius, start, sweep } => {+ let ang = (p - center).angle();+ let delta = if sweep >= 0.0 { (ang - start).rem_euclid(TAU) } else { (start - ang).rem_euclid(TAU) };+ if delta <= sweep.abs() { (p.dist(center) - radius).abs() } else { p.dist(s.start()).min(p.dist(s.end())) }+ }+ _ => s.point_at(s.closest_param(p)).dist(p),+ }+}++/// The two arcs (or lines) from `p0` leaving along unit `d0` to `p1` arriving along unit `d1`,+/// meeting tangentially: the tangent lines from both ends are cut at one length `d`, and the+/// arcs join at the middle of the line between the two cut points (which is `2 d` long).+fn biarc(p0: Vec2, d0: Vec2, p1: Vec2, d1: Vec2) -> Option<Vec<Seg2>> {+ let v = p1 - p0;+ let vv = v.dot(v);+ if vv < 1e-24 {+ return None;+ }+ let len = vv.sqrt();+ let chord = v / len;+ if d0.cross(chord).abs() < 1e-12 && d1.cross(chord).abs() < 1e-12 && d0.dot(chord) > 0.0 && d1.dot(chord) > 0.0 {+ return Some(vec![Seg2::Line { a: p0, b: p1 }]);+ }+ // |v − d (d0 + d1)| = 2 d, the positive root.+ let t = d0 + d1;+ let vt = v.dot(t);+ let a = 2.0 * (1.0 - d0.dot(d1));+ let d = if a < 1e-12 {+ if vt <= 1e-12 * len {+ return None;+ }+ vv / (2.0 * vt)+ } else {+ (-vt + (vt * vt + a * vv).max(0.0).sqrt()) / a+ };+ if !(d.is_finite() && d > 0.0) {+ return None;+ }+ let j = ((p0 + d0 * d) + (p1 - d1 * d)) * 0.5;+ let mut out = Vec::with_capacity(2);+ if j.dist(p0) > 1e-12 {+ out.push(arc_from(p0, d0, j)?);+ }+ if j.dist(p1) > 1e-12 {+ out.push(arc_from(p1, -d1, j)?.reversed());+ }+ (!out.is_empty()).then_some(out)+}++/// The arc leaving `p` along unit `d` that ends at `q` (a line when `q` lies straight ahead).+fn arc_from(p: Vec2, d: Vec2, q: Vec2) -> Option<Seg2> {+ let c = q - p;+ let cc = c.dot(c);+ let n = d.perp();+ let h = n.dot(c);+ // Sagitta of the arc over the chord: a line when the bulge is negligible.+ if h.abs() * cc.sqrt() < 1e-12 * cc || (cc / (2.0 * h)).abs() > 1e7 {+ return (d.dot(c) > 0.0).then_some(Seg2::Line { a: p, b: q });+ }+ let r = cc / (2.0 * h);+ let center = p + n * r;+ let start = (p - center).angle();+ let mut sweep = (q - center).angle() - start;+ if r > 0.0 {+ while sweep <= 0.0 {+ sweep += TAU;+ }+ } else {+ while sweep >= 0.0 {+ sweep -= TAU;+ }+ }+ (sweep.is_finite() && sweep.abs() <= TAU).then_some(Seg2::Arc { center, radius: r.abs(), start, sweep })+}++/// `s` moved to start exactly at `p` (an arc keeps its centre; `p` is within a rounding error).+fn with_start(s: Seg2, p: Vec2) -> Seg2 {+ match s {+ Seg2::Line { b, .. } => Seg2::Line { a: p, b },+ other => other,+ }+}++/// `s` moved to end exactly at `p`.+fn with_end(s: Seg2, p: Vec2) -> Seg2 {+ match s {+ Seg2::Line { a, .. } => Seg2::Line { a, b: p },+ other => other,+ }+}++#[cfg(test)]+mod tests {+ use std::f64::consts::{FRAC_1_SQRT_2, FRAC_PI_2};++ use super::*;++ /// Largest distance of 401 points of `seg` from `pieces`: 30 times as many as the fit+ /// itself looks at in a span.+ fn max_dev(seg: &Seg2, pieces: &[Seg2]) -> f64 {+ (0..=400)+ .map(|i| seg.point_at(i as f64 / 400.0))+ .map(|p| pieces.iter().map(|s| dist_to(s, p)).fold(f64::INFINITY, f64::min))+ .fold(0.0, f64::max)+ }++ fn chained(seg: &Seg2, pieces: &[Seg2]) {+ assert!(pieces.first().unwrap().start().dist(seg.start()) < 1e-9);+ assert!(pieces.last().unwrap().end().dist(seg.end()) < 1e-9);+ for w in pieces.windows(2) {+ assert!(w[0].end().dist(w[1].start()) < 1e-9, "{w:?}");+ // Tangent-continuous inside the segment (biarc joints and span joints).+ assert!(w[0].end_tangent().dot(w[1].start_tangent()) > 1.0 - 1e-6, "{w:?}");+ }+ assert!(pieces.iter().all(Seg2::is_line_or_arc));+ }++ fn ellipse(c: Vec2, a: f64, b: f64) -> Loop2 {+ let corners = [c + Vec2::new(a, 0.0), c + Vec2::new(0.0, b), c - Vec2::new(a, 0.0), c - Vec2::new(0.0, b)];+ Loop2 {+ segs: (0..4)+ .map(|i| Seg2::Conic { a: corners[i], apex: corners[i] + corners[(i + 1) % 4] - c, b: corners[(i + 1) % 4], w: FRAC_1_SQRT_2 })+ .collect(),+ }+ }++ #[test]+ fn a_circular_arc_given_as_a_conic_comes_back_as_arcs_of_its_circle() {+ // A quarter circle of radius 10 about (5, −3): the biarc through its ends and end+ // tangents lies on the circle itself.+ let c = Vec2::new(5.0, -3.0);+ let q = Seg2::Conic { a: c + Vec2::new(10.0, 0.0), apex: c + Vec2::new(10.0, 10.0), b: c + Vec2::new(0.0, 10.0), w: FRAC_1_SQRT_2 };+ let arcs = q.fit_arcs(1e-6).unwrap();+ assert_eq!(arcs.len(), 2, "{arcs:?}");+ let mut total = 0.0;+ for s in &arcs {+ let Seg2::Arc { center, radius, sweep, .. } = *s else { panic!("{s:?}") };+ assert!(center.dist(c) < 1e-9 && (radius - 10.0).abs() < 1e-9, "{s:?}");+ total += sweep;+ }+ assert!((total - FRAC_PI_2).abs() < 1e-9, "{total}");+ chained(&q, &arcs);+ }++ #[test]+ fn quarter_ellipse_fits_within_the_tolerance_with_few_arcs() {+ let q = ellipse(Vec2::new(200.0, 150.0), 30.0, 12.0).segs[0];+ for tol in [1e-2, 1e-3, 1e-4] {+ let arcs = q.fit_arcs(tol).unwrap();+ chained(&q, &arcs);+ assert!(max_dev(&q, &arcs) <= tol * 1.01, "tol {tol}: {}", max_dev(&q, &arcs));+ // Far fewer pieces than a chord polyline of the same tolerance.+ let chords = q.polyline(tol).len() - 1;+ assert!(arcs.len() * 2 < chords, "tol {tol}: {} arcs vs {chords} chords", arcs.len());+ }+ // The chords of 0.001 mm: √(2·√(30² + 12²) / 0.008) = 89.9, so 90.+ assert_eq!(q.polyline(1e-3).len() - 1, 90);+ assert!(q.fit_arcs(1e-3).unwrap().len() <= 32);+ }++ #[test]+ fn glyph_like_quadratics_cubics_and_s_curves_fit() {+ let segs = [+ Seg2::Conic { a: Vec2::new(0.0, 0.0), apex: Vec2::new(1.0, 2.0), b: Vec2::new(3.0, 0.5), w: 1.0 },+ Seg2::Cubic { p0: Vec2::new(0.0, 0.0), p1: Vec2::new(1.0, 3.0), p2: Vec2::new(2.0, -3.0), p3: Vec2::new(3.0, 0.0) },+ // A cusp-like cubic and one with a coincident control point.+ Seg2::Cubic { p0: Vec2::new(0.0, 0.0), p1: Vec2::new(4.0, 2.0), p2: Vec2::new(-1.0, 2.0), p3: Vec2::new(3.0, 0.0) },+ Seg2::Cubic { p0: Vec2::new(0.0, 0.0), p1: Vec2::new(0.0, 0.0), p2: Vec2::new(2.0, 1.0), p3: Vec2::new(3.0, 0.0) },+ Seg2::Conic { a: Vec2::new(0.0, 0.0), apex: Vec2::new(5.0, 5.0), b: Vec2::new(10.0, 0.0), w: 3.0 },+ crate::bezier(&[Vec2::new(0.0, 0.0), Vec2::new(1.0, 2.0), Vec2::new(2.0, -1.0), Vec2::new(3.0, 2.0), Vec2::new(4.0, 0.0)]).unwrap(),+ ];+ for s in segs {+ let arcs = s.fit_arcs(1e-3).unwrap();+ assert!(max_dev(&s, &arcs) <= 1.01e-3, "{s:?}: {}", max_dev(&s, &arcs));+ assert!(arcs.first().unwrap().start().dist(s.start()) < 1e-9 && arcs.last().unwrap().end().dist(s.end()) < 1e-9);+ for w in arcs.windows(2) {+ assert!(w[0].end().dist(w[1].start()) < 1e-9);+ }+ }+ // A straight "curve" is one line; lines and arcs come back as they are.+ let flat = Seg2::Cubic { p0: Vec2::ZERO, p1: Vec2::new(1.0, 0.0), p2: Vec2::new(2.0, 0.0), p3: Vec2::new(3.0, 0.0) };+ assert_eq!(flat.fit_arcs(1e-3).unwrap(), vec![Seg2::Line { a: Vec2::ZERO, b: Vec2::new(3.0, 0.0) }]);+ let arc = Seg2::Arc { center: Vec2::ZERO, radius: 2.0, start: 0.0, sweep: 1.0 };+ assert_eq!(arc.fit_arcs(1e-3).unwrap(), vec![arc]);+ // Hostile input.+ let bad = Seg2::Conic { a: Vec2::new(f64::NAN, 0.0), apex: Vec2::ZERO, b: Vec2::new(1.0, 0.0), w: 1.0 };+ assert!(bad.fit_arcs(1e-3).is_none());+ assert!(segs[0].fit_arcs(0.0).is_none() && segs[0].fit_arcs(f64::NAN).is_none());+ }++ #[test]+ fn fitted_ellipse_loop_keeps_its_area() {+ let lp = ellipse(Vec2::ZERO, 15.0, 8.0);+ let fitted = lp.fit_arcs(1e-3).unwrap();+ assert!(fitted.is_closed(1e-9) && fitted.is_line_arc() && !lp.is_line_arc());+ // π·a·b, within the tolerance times the perimeter (74 mm).+ let exact = PI * 15.0 * 8.0;+ assert!((lp.signed_area() - exact).abs() < 1e-9, "{}", lp.signed_area());+ assert!((fitted.signed_area() - exact).abs() < 1e-3 * 74.0, "{} vs {exact}", fitted.signed_area());+ assert!(fitted.segs.len() * 2 < lp.polyline(1e-3).len(), "{} pieces", fitted.segs.len());+ // As a hole of a 40 × 20 plate.+ let plate = Loop2::polygon(&[Vec2::new(-20.0, -10.0), Vec2::new(20.0, -10.0), Vec2::new(20.0, 10.0), Vec2::new(-20.0, 10.0)]);+ let (free, arcs) = (Region2 { outer: plate.clone(), holes: vec![lp.reversed()] }, Region2 { outer: plate, holes: vec![fitted.reversed()] });+ assert!(arcs.is_line_arc() && !free.is_line_arc());+ assert!((free.area() - (800.0 - exact)).abs() < 1e-9 && (arcs.area() - (800.0 - exact)).abs() < 1e-3 * 74.0, "{}", arcs.area());+ }+}diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rsindex 8ca68e3c22..f15ce9ecf4 100644--- a/crates/geom/src/lib.rs+++ b/crates/geom/src/lib.rs@@ -8,6 +8,7 @@#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]#![forbid(unsafe_code)]+mod arcfit;pub mod brep;pub mod bspline;pub mod env;@@ -18,6 +19,7 @@ mod profile;pub mod tspline;mod vec;+pub use arcfit::MAX_FIT_PIECES;pub use mesh::{Aabb3, InsideIndex, Mesh, MeshMeasure};pub use plane::Plane;pub use profile::{Loop2, MAX_BEZIER_DEGREE, Region2, Seg2, bezier};diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex d8844de0cc..30b7e1984b 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -97,7 +97,7 @@ pub use offset::with_same_surface;pub use ops::{BoolOp, boolean, can_join_touching_faces, split_by_plane, transform, transform_matrix, union_apart};pub use polybool::{faceted_boolean, planar_boolean};pub use polyhedron::{HalfSpace, convex_polyhedron, draft, offset_faces, shell};-pub use prism::{extrude_planar_regions, planar_regions_boolean};+pub use prism::{PLANAR_FIT_TOL, extrude_planar_regions, planar_regions_boolean};pub use prism_measure::certified_prism_equivalent;pub use sew::{EdgeSpec, FaceSpec, SurfSpec, sew};pub use splitface::{SplitTool, split_body, split_faces, split_faces_with_map};diff --git a/crates/kernel/src/prism.rs b/crates/kernel/src/prism.rsindex 7d428aa419..84dbab50da 100644--- a/crates/kernel/src/prism.rs+++ b/crates/kernel/src/prism.rs@@ -6,6 +6,8 @@//! Stepped extrusions (case floors and walls) use sections between every cap level, so a//! circular boss can meet the rim without shifting either operand off its exact plane.+use std::borrow::Cow;+use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};use truck_modeling as mt;@@ -19,13 +21,23 @@ const MAX_PLANAR_SEGMENTS: usize = 8192;const MAX_PLANAR_EVENTS: usize = 131_072;const MAX_PLANAR_PAIRS: usize = 16_000_000;-/// Boolean of planar regions bounded by straight lines and circular arcs. Boundaries stay-/// analytic; disjoint results and retained islands are returned as separate regions.+/// Free-form boundary segments (conics, Béziers) take part in planar booleans as lines and+/// arcs within this distance (mm); loops that come out whole get their exact segments back.+pub const PLANAR_FIT_TOL: f64 = 1e-3;++/// Boolean of planar regions bounded by straight lines, circular arcs and free-form segments.+/// Lines and arcs stay analytic. Free-form loops are arranged as tangent arcs within+/// [`PLANAR_FIT_TOL`]: a loop the operation leaves whole comes back exact, one it cuts keeps+/// the arcs. Disjoint results and retained islands are returned as separate regions.pub fn planar_regions_boolean(a: &[Region2], b: &[Region2], op: BoolOp, tolerance: f64) -> Result<Vec<Region2>> {crate::guard("planar region boolean", || {if !tolerance.is_finite() || !(1e-9..=1.0).contains(&tolerance) {return Err(KernelError::Invalid("planar boolean tolerance must be finite and between 1e-9 and 1 mm".into()));}+ let mut exact: Vec<(Loop2, Loop2)> = Vec::new();+ let mut pieces = 0usize;+ let (a, b) = (fit_free_form(a, &mut exact, &mut pieces)?, fit_free_form(b, &mut exact, &mut pieces)?);+ let (a, b): (&[Region2], &[Region2]) = (&a, &b);let loops = || a.iter().chain(b).flat_map(|r| std::iter::once(&r.outer).chain(&r.holes));let mut edges = 0usize;let mut samples = 0usize;@@ -59,11 +71,72 @@ pub fn planar_regions_boolean(a: &[Region2], b: &[Region2], op: BoolOp, toleranc}}}- boolean2d(a, b, op, tolerance)- .ok_or_else(|| KernelError::Failed("planar region arrangement failed or exceeded its bounded processing budget".into()))+ let out = boolean2d(a, b, op, tolerance)+ .ok_or_else(|| KernelError::Failed("planar region arrangement failed or exceeded its bounded processing budget".into()))?;+ Ok(restore_exact_loops(out, &exact, tolerance))})}+/// Regions with their free-form loops fitted by lines and arcs; `exact` records each fitted+/// loop with the loop it stands for, `pieces` counts the fitted segments. Regions of lines and+/// arcs alone are passed on as they are.+fn fit_free_form<'a>(regions: &'a [Region2], exact: &mut Vec<(Loop2, Loop2)>, pieces: &mut usize) -> Result<Cow<'a, [Region2]>> {+ if regions.iter().all(Region2::is_line_arc) {+ return Ok(Cow::Borrowed(regions));+ }+ let mut fit = |lp: &Loop2| -> Result<Loop2> {+ if lp.is_line_arc() {+ return Ok(lp.clone());+ }+ let fitted = lp.fit_arcs(PLANAR_FIT_TOL).filter(|f| {+ *pieces = pieces.saturating_add(f.segs.len());+ *pieces <= MAX_PLANAR_SEGMENTS+ });+ let fitted = fitted.ok_or_else(|| {+ KernelError::Invalid("planar boolean: a free-form boundary is not finite or takes more arcs than the geometry budget".into())+ })?;+ exact.push((fitted.clone(), lp.clone()));+ Ok(fitted)+ };+ let fitted: Result<Vec<Region2>> =+ regions.iter().map(|r| Ok(Region2 { outer: fit(&r.outer)?, holes: r.holes.iter().map(&mut fit).collect::<Result<_>>()? })).collect();+ fitted.map(Cow::Owned)+}++/// Output loops that are a fitted free-form loop, whole (from any start, either way round), get+/// the exact loop back, running the same way.+fn restore_exact_loops(regions: Vec<Region2>, exact: &[(Loop2, Loop2)], tol: f64) -> Vec<Region2> {+ if exact.is_empty() {+ return regions;+ }+ let near = |p: Vec2, q: Vec2| p.dist(q) <= tol * 10.0;+ let same_run = |l: &Loop2, f: &Loop2| -> bool {+ let n = f.segs.len();+ let Some(first) = l.segs.first() else { return false };+ (0..n).any(|k| {+ f.segs.get(k).is_some_and(|s| near(s.start(), first.start()))+ && l.segs.iter().enumerate().all(|(i, s)| {+ f.segs.get((k + i) % n).is_some_and(|g| near(g.start(), s.start()) && near(g.end(), s.end()) && near(g.mid(), s.mid()))+ })+ })+ };+ let restore = |l: Loop2| -> Loop2 {+ for (fitted, original) in exact {+ if fitted.segs.len() != l.segs.len() {+ continue;+ }+ if same_run(&l, fitted) {+ return original.clone();+ }+ if same_run(&l, &fitted.reversed()) {+ return original.reversed();+ }+ }+ l+ };+ regions.into_iter().map(|r| Region2 { outer: restore(r.outer), holes: r.holes.into_iter().map(&restore).collect() }).collect()+}+/// Extrude normalized planar material as one logical compound, retaining every disjoint/// region and its holes. Planar arrangement certifies separation before shells are joined.pub fn extrude_planar_regions(plane: &Plane, regions: &[Region2], start: f64, end: f64) -> Result<Body> {@@ -95,8 +168,10 @@ pub fn extrude_planar_regions(plane: &Plane, regions: &[Region2], start: f64, enif normalized.is_empty() {return Err(KernelError::Invalid("empty planar material extrusion".into()));}- for (i, a) in normalized.iter().enumerate() {- for b in normalized.iter().skip(i + 1) {+ // The separation test knows lines and arcs: free-form loops take part as their arcs.+ let fitted = fit_free_form(&normalized, &mut Vec::new(), &mut 0)?;+ for (i, a) in fitted.iter().enumerate() {+ for b in fitted.iter().skip(i + 1) {for s in std::iter::once(&a.outer).chain(&a.holes).flat_map(|l| &l.segs) {for t in std::iter::once(&b.outer).chain(&b.holes).flat_map(|l| &l.segs) {remaining_pairs = remaining_pairs@@ -887,19 +962,61 @@ fn dist_to(regions: &[Region2], p: Vec2) -> f64 {.fold(f64::INFINITY, f64::min)}-/// Direction of the boundary of `regions` through `p` (on it), as the boundary runs.-fn dir_at(regions: &[Region2], p: Vec2, tol: f64) -> Option<Vec2> {- for r in regions {- for l in std::iter::once(&r.outer).chain(&r.holes) {- for s in &l.segs {- let t = s.closest_param(p);- if s.point_at(t).dist(p) < tol {- return s.derivative(t).normalized();+/// The bounding box of a line or an arc, grown by twice the tolerance (and by the rounding of+/// its own corners): (min, max). Whatever lies within the tolerance of the segment lies in the+/// box. `None` for other segments and for values that are not finite: no box, and nothing is+/// skipped for it.+type SegBox = (Vec2, Vec2);++fn seg_box(s: &Seg2, tol: f64) -> Option<SegBox> {+ let mut pts = vec![s.start(), s.end()];+ match *s {+ Seg2::Line { .. } => {}+ Seg2::Arc { center, radius, start, sweep } => {+ // The axis extremes the arc passes.+ for k in 0..4 {+ let ang = k as f64 * std::f64::consts::FRAC_PI_2;+ let delta =+ if sweep >= 0.0 { (ang - start).rem_euclid(std::f64::consts::TAU) } else { (start - ang).rem_euclid(std::f64::consts::TAU) };+ if delta <= sweep.abs() {+ pts.push(center + Vec2::from_angle(ang) * radius);}}}+ _ => return None,+ }+ let lo = pts.iter().fold(Vec2::new(f64::INFINITY, f64::INFINITY), |m, p| Vec2::new(m.x.min(p.x), m.y.min(p.y)));+ let hi = pts.iter().fold(Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY), |m, p| Vec2::new(m.x.max(p.x), m.y.max(p.y)));+ let g = tol * 2.0 + 1e-12 * pts.iter().fold(0.0, |m: f64, p| m.max(p.x.abs()).max(p.y.abs()));+ (pts.iter().all(|p| p.is_finite()) && g.is_finite()).then_some((Vec2::new(lo.x - g, lo.y - g), Vec2::new(hi.x + g, hi.y + g)))+}++fn boxes_meet(a: Option<SegBox>, b: Option<SegBox>) -> bool {+ match (a, b) {+ (Some((a0, a1)), Some((b0, b1))) => a0.x <= b1.x && b0.x <= a1.x && a0.y <= b1.y && b0.y <= a1.y,+ _ => true,}- None+}++fn box_holds(b: Option<SegBox>, p: Vec2) -> bool {+ b.is_none_or(|(lo, hi)| p.x >= lo.x && p.x <= hi.x && p.y >= lo.y && p.y <= hi.y)+}++/// Distance from `p` to the nearest of `segs` whose box holds it: infinite when none does (no+/// segment is within the tolerance of `p` then).+fn near_dist(segs: &[Seg2], boxes: &[Option<SegBox>], p: Vec2) -> f64 {+ segs.iter().zip(boxes).filter(|(_, b)| box_holds(**b, p)).map(|(s, _)| s.point_at(s.closest_param(p)).dist(p)).fold(f64::INFINITY, f64::min)+}++/// Direction of the first of `segs` through `p` (within `tol`), as it runs.+fn near_dir(segs: &[Seg2], boxes: &[Option<SegBox>], p: Vec2, tol: f64) -> Option<Vec2> {+ let (s, t) = segs+ .iter()+ .zip(boxes)+ .filter(|(_, b)| box_holds(**b, p))+ .map(|(s, _)| (s, s.closest_param(p)))+ .find(|(s, t)| s.point_at(*t).dist(p) < tol)?;+ s.derivative(t).normalized()}/// 2D boolean of regions bounded by lines and arcs.@@ -922,12 +1039,19 @@ fn boolean2d_tagged(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option<Seif sa.iter().chain(&sb).any(|s| !matches!(s, Seg2::Line { .. } | Seg2::Arc { .. })) {return None;}+ // Only segments whose bounding boxes meet can cross, touch or lie on each other: the other+ // pairs skip the exact tests (a closest-point search each).+ let (box_a, box_b): (Vec<_>, Vec<_>) = (sa.iter().map(|s| seg_box(s, tol)).collect(), sb.iter().map(|s| seg_box(s, tol)).collect());+ let apart = |i: usize, j: usize| !boxes_meet(box_a.get(i).copied().flatten(), box_b.get(j).copied().flatten());// Split every segment where it crosses the other side's boundary.let mut cut_a: Vec<Vec<f64>> = vec![Vec::new(); sa.len()];let mut cut_b: Vec<Vec<f64>> = vec![Vec::new(); sb.len()];let mut events = 0usize;for (i, s) in sa.iter().enumerate() {for (j, t) in sb.iter().enumerate() {+ if apart(i, j) {+ continue;+ }for (u, v) in crossings(s, t, tol) {events += 2;if events > MAX_PLANAR_EVENTS {@@ -940,7 +1064,10 @@ fn boolean2d_tagged(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option<Se}// Ends of the other side's segments lying on a segment split it too (touching corners).for (i, s) in sa.iter().enumerate() {- for t in &sb {+ for (j, t) in sb.iter().enumerate() {+ if apart(i, j) {+ continue;+ }for p in [t.start(), t.end()] {let u = s.closest_param(p);if s.point_at(u).dist(p) < tol {@@ -954,7 +1081,10 @@ fn boolean2d_tagged(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option<Se}}for (j, t) in sb.iter().enumerate() {- for s in &sa {+ for (i, s) in sa.iter().enumerate() {+ if apart(i, j) {+ continue;+ }for p in [s.start(), s.end()] {let v = t.closest_param(p);if t.point_at(v).dist(p) < tol {@@ -997,9 +1127,9 @@ fn boolean2d_tagged(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option<Selet (n, tag) = (split.len(), ta.get(i).copied().unwrap_or(BLANK));for (k, p) in split.into_iter().enumerate() {let m = p.point_at(0.5);- let on = dist_to(&b, m) < tol;+ let on = near_dist(&sb, &box_b, m) < tol;let keep = if on {- let same = dir_at(&b, m, tol).is_some_and(|d| d.dot(p.derivative(0.5)) > 0.0);+ let same = near_dir(&sb, &box_b, m, tol).is_some_and(|d| d.dot(p.derivative(0.5)) > 0.0);match op {BoolOp::Union | BoolOp::Intersect => same,BoolOp::Cut => !same,@@ -1028,7 +1158,7 @@ fn boolean2d_tagged(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option<Selet (n, tag) = (split.len(), tb.get(j).copied().unwrap_or(BLANK));for (k, p) in split.into_iter().enumerate() {let m = p.point_at(0.5);- if dist_to(&a, m) < tol {+ if near_dist(&sa, &box_a, m) < tol {continue;}let ins = inside(&a, m);@@ -2205,6 +2335,101 @@ mod planar_tests {assert!(extrude_planar_regions(&plane, &circles, 0.0, 2.0).is_err());}+ /// An ellipse about `c` with semi-axes `a` (along x) and `b`, as four exact conics.+ fn ellipse(c: Vec2, a: f64, b: f64) -> Loop2 {+ let corners = [c + Vec2::new(a, 0.0), c + Vec2::new(0.0, b), c - Vec2::new(a, 0.0), c - Vec2::new(0.0, b)];+ let w = std::f64::consts::FRAC_1_SQRT_2;+ Loop2 {+ segs: (0..4).map(|i| Seg2::Conic { a: corners[i], apex: corners[i] + corners[(i + 1) % 4] - c, b: corners[(i + 1) % 4], w }).collect(),+ }+ }++ #[test]+ fn free_form_cut_outs_stay_exact_when_whole_and_follow_arcs_when_cut() {+ let plate = rectangle(Vec2::ZERO, Vec2::new(100.0, 60.0));+ let hole = Region2 { outer: ellipse(Vec2::new(40.0, 30.0), 15.0, 8.0), holes: vec![] };+ let out = planar_regions_boolean(std::slice::from_ref(&plate), std::slice::from_ref(&hole), BoolOp::Cut, 1e-7).unwrap();+ assert_eq!(out.len(), 1);+ assert_eq!(out[0].holes.len(), 1);+ // The whole ellipse comes back as its four exact conics, running as a hole (clockwise):+ // the plate less π·15·8.+ let h = &out[0].holes[0];+ assert_eq!(h.segs.len(), 4);+ assert!(h.segs.iter().all(|s| hole.outer.segs.contains(&s.reversed())), "{h:?}");+ assert!(h.signed_area() < 0.0);+ let exact = 6000.0 - std::f64::consts::PI * 15.0 * 8.0;+ assert!((out[0].area() - exact).abs() < 1e-9, "{} vs {exact}", out[0].area());+ // What the cut takes is the ellipse, whole and exact, counter-clockwise.+ let taken = planar_regions_boolean(std::slice::from_ref(&plate), std::slice::from_ref(&hole), BoolOp::Intersect, 1e-7).unwrap();+ assert!(taken.len() == 1 && taken[0].outer.segs.iter().all(|s| hole.outer.segs.contains(s)), "{taken:?}");+ // An ellipse centred on the plate's edge makes a notch of half the ellipse: its part+ // inside follows arcs within the fit tolerance (times half the perimeter, 37 mm).+ let over = Region2 { outer: ellipse(Vec2::new(100.0, 30.0), 15.0, 8.0), holes: vec![] };+ let out = planar_regions_boolean(std::slice::from_ref(&plate), std::slice::from_ref(&over), BoolOp::Cut, 1e-7).unwrap();+ assert_eq!(out.len(), 1);+ assert!(out[0].holes.is_empty() && out[0].outer.is_line_arc());+ let notched = 6000.0 - std::f64::consts::PI * 15.0 * 8.0 / 2.0;+ assert!((out[0].area() - notched).abs() < PLANAR_FIT_TOL * 37.0, "{} vs {notched}", out[0].area());+ // Two ellipses that overlap join into one outline of arcs; apart, both stay exact.+ let beside = |dx: f64| Region2 { outer: ellipse(Vec2::new(40.0 + dx, 30.0), 15.0, 8.0), holes: vec![] };+ let joined = planar_regions_boolean(std::slice::from_ref(&hole), &[beside(20.0)], BoolOp::Union, 1e-7).unwrap();+ assert!(joined.len() == 1 && joined[0].outer.is_line_arc(), "{joined:?}");+ let apart = planar_regions_boolean(std::slice::from_ref(&hole), &[beside(40.0)], BoolOp::Union, 1e-7).unwrap();+ assert!(apart.len() == 2 && apart.iter().all(|r| r.outer.segs.len() == 4 && !r.outer.is_line_arc()), "{apart:?}");+ // The flat material extrudes with the exact elliptic wall: four conic faces, two caps.+ let body = extrude_planar_regions(&Plane::XY, &planar_regions_boolean(&[plate], &[hole], BoolOp::Cut, 1e-7).unwrap(), 0.0, 2.0).unwrap();+ assert_eq!(body.face_count(), 4 + 4 + 2);+ let v = crate::measure(&body).unwrap().volume;+ assert!((v - exact * 2.0).abs() < 1e-3 * exact, "{v}");+ }++ #[test]+ fn free_form_loops_that_cannot_be_followed_are_refused() {+ let plate = rectangle(Vec2::ZERO, Vec2::new(100.0, 60.0));+ let mut bad = ellipse(Vec2::new(40.0, 30.0), 15.0, 8.0);+ bad.segs[1] = Seg2::Conic { a: bad.segs[1].start(), apex: Vec2::new(f64::NAN, 0.0), b: bad.segs[1].end(), w: 1.0 };+ let e = planar_regions_boolean(std::slice::from_ref(&plate), &[Region2 { outer: bad, holes: vec![] }], BoolOp::Cut, 1e-7).unwrap_err();+ assert!(e.to_string().contains("free-form"), "{e}");+ // More fitted arcs than the arrangement's segment budget.+ let many: Vec<Region2> = (0..400).map(|i| Region2 { outer: ellipse(Vec2::new(40.0 * i as f64, 0.0), 15.0, 8.0), holes: vec![] }).collect();+ assert!(planar_regions_boolean(&[plate], &many, BoolOp::Cut, 1e-7).is_err());+ }++ #[test]+ fn segment_boxes_hold_what_lies_within_the_tolerance() {+ // An arc of radius 10 about the origin from 45° to 135° passes the top of its circle:+ // x within ±10/√2, y from 10/√2 to 10, grown by twice the tolerance.+ let r = 10.0 * std::f64::consts::FRAC_1_SQRT_2;+ let arc = Seg2::Arc { center: Vec2::ZERO, radius: 10.0, start: std::f64::consts::FRAC_PI_4, sweep: std::f64::consts::FRAC_PI_2 };+ for s in [arc, arc.reversed()] {+ let (lo, hi) = seg_box(&s, 1e-3).unwrap();+ assert!(lo.dist(Vec2::new(-r - 2e-3, r - 2e-3)) < 1e-9 && hi.dist(Vec2::new(r + 2e-3, 10.0 + 2e-3)) < 1e-9, "{lo:?} {hi:?}");+ }+ let (lo, hi) = seg_box(&Seg2::Line { a: Vec2::new(3.0, -1.0), b: Vec2::new(-2.0, 4.0) }, 0.5).unwrap();+ assert!(lo.dist(Vec2::new(-3.0, -2.0)) < 1e-9 && hi.dist(Vec2::new(4.0, 5.0)) < 1e-9, "{lo:?} {hi:?}");+ // A line 3 tolerances above the arc's top meets its box (each is grown by two); one+ // 5 tolerances above does not. No box (a free-form segment, a value that is not+ // finite) hides nothing.+ let level = |y: f64| seg_box(&Seg2::Line { a: Vec2::new(-1.0, y), b: Vec2::new(1.0, y) }, 1e-3);+ assert!(boxes_meet(seg_box(&arc, 1e-3), level(10.003)) && !boxes_meet(seg_box(&arc, 1e-3), level(10.005)));+ let free = ellipse(Vec2::ZERO, 2.0, 1.0).segs[0];+ assert!(seg_box(&free, 1e-3).is_none() && seg_box(&Seg2::Line { a: Vec2::new(f64::NAN, 0.0), b: Vec2::X }, 1e-3).is_none());+ assert!(boxes_meet(None, level(500.0)) && box_holds(None, Vec2::new(500.0, 500.0)));+ }++ #[test]+ fn many_small_cut_outs_far_apart_cut_as_before() {+ // 400 round holes in a strip: almost every pair of segments is far apart.+ let plate = rectangle(Vec2::ZERO, Vec2::new(2000.0, 20.0));+ let holes: Vec<Region2> =+ (0..400).map(|i| Region2 { outer: Loop2::circle(Vec2::new(2.5 + 5.0 * i as f64, 10.0), 1.8), holes: vec![] }).collect();+ let out = planar_regions_boolean(&[plate], &holes, BoolOp::Cut, 1e-7).unwrap();+ assert_eq!(out.len(), 1);+ assert_eq!(out[0].holes.len(), 400);+ let exact = 40_000.0 - 400.0 * std::f64::consts::PI * 1.8 * 1.8;+ assert!((out[0].area() - exact).abs() < 1e-6, "{}", out[0].area());+ }+#[test]fn analytic_circle_classification_respects_signed_sweeps_and_seams() {for seam in [0.0, 0.13, std::f64::consts::FRAC_PI_2, -std::f64::consts::FRAC_PI_2] {diff --git a/docs/book/src/guide/sheet-metal.md b/docs/book/src/guide/sheet-metal.mdindex 904ab1049c..b4adbf75e6 100644--- a/docs/book/src/guide/sheet-metal.md+++ b/docs/book/src/guide/sheet-metal.md@@ -125,10 +125,13 @@ adaptively. The `OUTLINE`, `BEND_UP` and `BEND_DOWN` layers separate cuts from bBase-flange profiles keep their interior holes. Through cuts that cross a sheet edge becomenotches in the flat outline; overlapping and repeated cuts remove their combined area once.The flat preview, DXF and unfolded solid use the same material boundaries. Lines and circular-arcs remain exact; other profile curves use a 0.001 mm chord tolerance.+arcs remain exact. An ellipse, a spline or text stays the curve it was drawn as in the flat+pattern and the unfolded solid; the folded solid follows it with tangent arcs within 0.001 mm,+and the DXF and the point lists write it as chords within 0.001 mm.Flat-pattern JSON lists each cut-out twice, in the same order: as points (`cutouts`), andexactly (`cutout_shapes`): a round hole as `{"circle": {"center", "radius"}}`, any other as its-`line`, `arc` (centre, radius, start and sweep in degrees) and `polyline` segments.+`line`, `arc` (centre, radius, start and sweep in degrees) and `polyline` segments (one+`polyline` for each ellipse quarter, spline or glyph curve).Cuts can leave separate material pieces, including the centre of a ring cut. These piecesremain one logical sheet group through Unfold / Refold and export as separate flat outlines.