SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
STEP export: extruded arcs, straight rounds and countersinks as cylinders and cones (#612) (#1139)
Erikas2e6951135ad6
diff --git a/crates/kernel/src/step_in/tests.rs b/crates/kernel/src/step_in/tests.rsindex 6932be2a9e..8b6fdf5a18 100644--- a/crates/kernel/src/step_in/tests.rs+++ b/crates/kernel/src/step_in/tests.rs@@ -863,6 +863,66 @@ fn glued_halves_export_as_whole_faces() {assert_eq!(imp.bodies[0].file_faces, 8);}+/// A slot plate with a round on its top outline (issue #612): the extruded arc ends and the+/// rounds along the straight edges are lone B-spline sheets, written as cylinders bounded by+/// their faces. The rounds' sheets reach far past their edges, and a reader bounding the part by+/// its surfaces saw a 60 mm part as 130 mm long.+#[test]+fn rounded_slot_exports_cylinders() {+ use solidcraft_geom::Seg2;+ use std::f64::consts::{FRAC_PI_2, PI};+ let outer = Loop2 {+ segs: vec![+ Seg2::Line { a: Vec2::new(10.0, -10.0), b: Vec2::new(50.0, -10.0) },+ Seg2::Arc { center: Vec2::new(50.0, 0.0), radius: 10.0, start: -FRAC_PI_2, sweep: PI },+ Seg2::Line { a: Vec2::new(50.0, 10.0), b: Vec2::new(10.0, 10.0) },+ Seg2::Arc { center: Vec2::new(10.0, 0.0), radius: 10.0, start: FRAC_PI_2, sweep: PI },+ ],+ };+ let plate = extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0.0, 4.0).unwrap().pop().unwrap();+ let edges = [Vec3::new(30.0, -10.0, 4.0), Vec3::new(30.0, 10.0, 4.0), Vec3::new(0.0, 0.0, 4.0), Vec3::new(60.0, 0.0, 4.0)];+ let b = fillet(&plate, &edges, 1.0).unwrap();+ let text = step_export(&[&b], "t").unwrap();+ assert!(!text.contains("B_SPLINE_SURFACE"), "{text}");+ assert_eq!(text.matches("CYLINDRICAL_SURFACE(").count(), 4);+ assert_eq!(text.matches("TOROIDAL_SURFACE(").count(), 2);+ // No point of the file (surface placements included) lies outside the part.+ let imp = round_trip(&b);+ for line in text.lines().filter(|l| l.contains("CARTESIAN_POINT")) {+ let Some(xyz) = line.split("((").nth(1).and_then(|r| r.split("))").next()) else { continue };+ let x: f64 = xyz.split(',').next().unwrap().trim().parse().unwrap();+ assert!((-1e-6..=60.0 + 1e-6).contains(&x), "{line}");+ }+ // The volume analytically: the plate less the round's corner section swept along the edges+ // (Pappus: the section's centroid runs 0.2234 r inside the edge round the arcs).+ let section = 1.0 - PI / 4.0;+ let centroid = (10.0 - 3.0 * PI) / (3.0 * (4.0 - PI));+ let want = (800.0 + PI * 100.0) * 4.0 - section * (80.0 + std::f64::consts::TAU * (10.0 - centroid));+ assert!(rel(measure(&imp.bodies[0].body).unwrap().volume, want) < 1e-3);+}++/// A countersink cut into a plate (issue #612): the cone is a tapered extrusion of a disc, a+/// B-spline sheet per half, written as one CONICAL_SURFACE face (the sheets reached below the+/// plate).+#[test]+fn countersink_exports_one_cone() {+ use std::f64::consts::FRAC_PI_4;+ let plate = box_solid(Vec3::new(-10.0, -10.0, 0.0), Vec3::new(10.0, 10.0, 4.0)).unwrap();+ // A 90° countersink, radius 4 at the top face, down from 1 mm above it to radius 1.8, and the+ // 2 mm drill through.+ let disc = Region2 { outer: Loop2::circle(Vec2::ZERO, 5.0), holes: vec![] };+ let cone = crate::extrude_tapered(&Plane::XY.offset(5.0), &disc, 3.2, -1.0, -FRAC_PI_4).unwrap();+ let drill = cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, 2.0, 6.0).unwrap();+ let b = boolean(&boolean(&plate, &cone, BoolOp::Cut).unwrap().unwrap(), &drill, BoolOp::Cut).unwrap().unwrap();+ let text = step_export(&[&b], "t").unwrap();+ assert!(!text.contains("B_SPLINE_SURFACE"), "{text}");+ assert_eq!(text.matches("CONICAL_SURFACE(").count(), 1, "{text}");+ assert_eq!(text.matches("CYLINDRICAL_SURFACE(").count(), 1, "{text}");+ let imp = round_trip(&b);+ // Six box faces, the countersink and the drill.+ assert_eq!(imp.bodies[0].file_faces, 8);+}+/// Knot multiplicities are expanded into one value each before the knot count is compared with/// the control points, so the sum has to be checked first: 1,000,000 knots of multiplicity 64/// against two control points asked for a 500 MB vector (20,000,000 for 10 GB) only to rejectdiff --git a/crates/kernel/src/step_out.rs b/crates/kernel/src/step_out.rsindex b773caa924..357953eaf4 100644--- a/crates/kernel/src/step_out.rs+++ b/crates/kernel/src/step_out.rs@@ -151,8 +151,8 @@ struct Out {shared: HashMap<String, u64>,/// Surfaces written with the opposite normal to the one they replace.flipped: std::collections::HashSet<u64>,- /// B-spline cylinder sheets of the body being copied under merged faces, with the direction- /// of the cylinder's parameter seam.+ /// B-spline cylinder and cone sheets of the body being copied to write as analytic surfaces,+ /// with the direction of their parameter seam.merged: HashMap<u64, V3>,/// Faces of the body being copied: exchange id → written id.faces_out: HashMap<u64, u64>,@@ -270,13 +270,13 @@ impl Out {map.insert(id, new);continue;}- // Flat B-spline sheets are planes; cylindrical ones become cylinders when their- // pieces were merged into one face (a lone piece stays as written).+ // Flat B-spline sheets are planes; ruled ones become cylinders and cones when+ // `analytic_sheets` chose them (their pieces merged, or a lone piece's edges allow).if !done&& let Some(a) = planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| {let seam = self.merged.get(&id)?;- let mut a = cylindrical_bspline(ex, e)?;- if let AnalyticKind::Cylinder { x, .. } = &mut a.kind {+ let mut a = ruled_bspline(ex, e)?;+ if let AnalyticKind::Cylinder { x, .. } | AnalyticKind::Cone { x, .. } = &mut a.kind {*x = *seam;}Some(a)@@ -609,10 +609,11 @@ fn planar_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<AnalyticKind> {Some(AnalyticKind::Plane { o, z, x })}-/// A B-spline surface that is a circular cylinder (a circle or arc swept along a line, as truck-/// makes for extruded round profiles), with its normal direction relative to the cylinder's-/// outward normal.-fn cylindrical_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {+/// A B-spline surface that is a circular cylinder or cone: straight rulings between two coaxial+/// circles or arcs (or an arc and the cone's apex), as truck makes for extruded round profiles,+/// rounds along straight edges and countersinks. With its normal direction relative to the+/// surface's outward normal.+fn ruled_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {use truck_modeling::{ParametricSurface, ParametricSurface3D};if !(e.has("B_SPLINE_SURFACE") || e.name() == "B_SPLINE_SURFACE_WITH_KNOTS") {return None;@@ -624,45 +625,98 @@ fn cylindrical_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic>let p = s.subs(u, v);[p.x, p.y, p.z]};- // Which parameter sweeps along a line: the same translation from one end to the other at- // every point of the profile.+ // Which parameter runs along the rulings: straight from one end to the other at every point+ // of the profile.for along_v in [true, false] {let point = |t: f64, w: f64| if along_v { at(u0 + (u1 - u0) * t, v0 + (v1 - v0) * w) } else { at(u0 + (u1 - u0) * w, v0 + (v1 - v0) * t) };- let prof: Vec<V3> = (0..=8).map(|k| point(k as f64 / 8.0, 0.0)).collect();- let d = sub(point(0.0, 1.0), point(0.0, 0.0));- let len = norm(d);- let scale = prof.iter().map(|p| norm(sub(*p, prof[0]))).fold(len, f64::max);+ let grid: Vec<Vec<V3>> = (0..=4).map(|m| (0..=8).map(|k| point(k as f64 / 8.0, m as f64 / 4.0)).collect()).collect();+ let (Some(p0), Some(p1)) = (grid.first(), grid.last()) else { continue };+ let Some(&first) = p0.first() else { continue };+ let scale = grid.iter().flatten().map(|p| norm(sub(*p, first))).fold(0.0, f64::max);let tol = 1e-7 * (1.0 + scale);- if len < tol- || (0..=8).any(|k| {- let t = k as f64 / 8.0;- (0..=4).any(|m| norm(sub(sub(point(t, m as f64 / 4.0), point(t, 0.0)), mul(d, m as f64 / 4.0))) > tol)- })- {+ let straight = (0..=8).all(|k| {+ let (Some(&a), Some(&b)) = (p0.get(k), p1.get(k)) else { return false };+ let Some(d) = unit(sub(b, a)) else { return false };+ grid.iter().all(|row| row.get(k).is_some_and(|q| norm(cross(sub(*q, a), d)) <= tol))+ });+ if !straight {continue;}- let (Some(&a), Some(&b), Some(&c)) = (prof.first(), prof.get(4), prof.get(8)) else { continue };- let (centre, r, n) = circle3(a, b, c).or_else(|| circle3(a, prof[2], b))?;- let z = unit(d)?;- if norm(cross(n, z)) > 1e-7 || prof.iter().any(|p| (norm(sub(*p, centre)) - r).abs() > tol) {+ // Each end: a circle (centre, radius, axis) or a single point (a cone's apex).+ let ring = |prof: &[V3]| -> Option<(V3, f64, Option<V3>)> {+ let &a = prof.first()?;+ if prof.iter().all(|p| norm(sub(*p, a)) <= tol) {+ return Some((a, 0.0, None));+ }+ let (&b, &c, &h) = (prof.get(4)?, prof.get(8)?, prof.get(2)?);+ let (centre, r, n) = circle3(a, b, c).or_else(|| circle3(a, h, b))?;+ prof.iter().all(|p| (norm(sub(*p, centre)) - r).abs() <= tol).then_some((centre, r, Some(n)))+ };+ let ((c0, r0, n0), (c1, r1, n1)) = (ring(p0)?, ring(p1)?);+ let axis = unit(sub(c1, c0))?;+ if [n0, n1].iter().flatten().any(|n| norm(cross(*n, axis)) > 1e-7) || (n0.is_none() && n1.is_none()) {+ return None;+ }+ let height = norm(sub(c1, c0));+ // The radius grows along z (a cylinder keeps the sweep's direction).+ let (o, z, r, angle) = if (r1 - r0).abs() <= tol {+ (c0, axis, r0, 0.0)+ } else if r1 > r0 {+ (c1, axis, r1, ((r1 - r0) / height).atan())+ } else {+ (c0, mul(axis, -1.0), r0, ((r0 - r1) / height).atan())+ };+ let radius_at = |q: V3| r + dot(sub(q, o), z) * angle.tan();+ let radial = |q: V3| {+ let v = sub(q, o);+ sub(v, mul(z, dot(v, z)))+ };+ if grid.iter().flatten().any(|q| (norm(radial(*q)) - radius_at(*q)).abs() > tol) {return None;}// The surface's own normal against the outward one, mid-face.let (um, vm) = ((u0 + u1) / 2.0, (v0 + v1) / 2.0);let nn = s.normal(um, vm);let q = at(um, vm);- let radial = sub(sub(q, centre), mul(z, dot(sub(q, centre), z)));- let flip = dot([nn.x, nn.y, nn.z], radial) < 0.0;+ let eq = unit(radial(q))?;+ let outward = sub(mul(eq, angle.cos()), mul(z, angle.sin()));+ let flip = dot([nn.x, nn.y, nn.z], outward) < 0.0;// The parameter seam opposite the middle of the sheet, away from its edges.- let x = unit(mul(radial, -1.0)).or_else(|| unit(sub(a, centre)))?;- return Some(Analytic { kind: AnalyticKind::Cylinder { o: centre, z, x, r }, flip });+ let x = mul(eq, -1.0);+ let kind = if angle == 0.0 { AnalyticKind::Cylinder { o, z, x, r } } else { AnalyticKind::Cone { o, z, x, r, angle } };+ return Some(Analytic { kind, flip });}None}-/// A B-spline surface that is really a plane or a cylinder.+/// A B-spline surface that is really a plane, a cylinder or a cone.fn analytic_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {- planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| cylindrical_bspline(ex, e))+ planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| ruled_bspline(ex, e))+}++/// Every edge of a face on a cylinder or cone is a circle square to its axis or one of its+/// rulings (a line along the axis, or through a cone's apex). Faces bounded by other curves (a+/// hole crossing a tube wall) keep their B-spline sheet: readers lay those curves out far more+/// slowly on the analytic surface than on the sheet they came with.+fn square_or_ruled(ex: &p21::Exchange, fe: &p21::Entity, kind: &AnalyticKind) -> bool {+ let (z, apex) = match *kind {+ AnalyticKind::Cylinder { z, .. } => (z, None),+ AnalyticKind::Cone { o, z, r, angle, .. } if angle.tan() > 1e-12 => (z, Some(sub(o, mul(z, r / angle.tan())))),+ _ => return false,+ };+ face_edges(ex, fe).is_some_and(|ls| {+ ls.iter().flatten().all(|(x, _)| {+ edge_samples(ex, *x).is_some_and(|pts| {+ let Some(&q0) = pts.first() else { return false };+ let tol = 1e-7 * (1.0 + norm(q0));+ let ruling = match apex {+ None => pts.iter().all(|q| norm(cross(sub(*q, q0), z)) <= tol),+ Some(a) => pts.iter().all(|q| norm(cross(sub(*q, a), sub(q0, a))) <= tol * (1.0 + norm(sub(q0, a)))),+ };+ ruling || pts.iter().all(|q| dot(sub(*q, q0), z).abs() <= tol)+ })+ })+ })}/// Points along an edge's curve (its ends for a line, None for a conic it cannot sample).@@ -833,8 +887,9 @@ fn face_edges(ex: &p21::Exchange, face: &p21::Entity) -> Option<Vec<Vec<(u64, bo/// Faces that truck splits (a revolution in two or three turns) joined back into one face per/// analytic surface, by dropping the edges between them. Faces whose union would lose all its-/// edges, or whose leftover edges do not close into loops, stay apart.-fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>, keep: &[Vec<Vec3>]) -> HashMap<u64, V3> {+/// edges, or whose leftover edges do not close into loops, stay apart. Returns the surfaces of+/// merged faces.+fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>, keep: &[Vec<Vec3>]) -> std::collections::HashSet<u64> {// An edge on a line the user split along: every sample within a hair of the polyline.let on_split = |ex: &p21::Exchange, e: u64| -> bool {let Some(pts) = edge_samples(ex, e) else { return false };@@ -876,21 +931,10 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,let v = |a: truck_modeling::Vector3| [a.x, a.y, a.z];Some(Analytic { kind: AnalyticKind::Plane { o: [f.o.x, f.o.y, f.o.z], z: v(f.z), x: v(f.x) }, flip: false })}+ // Pieces of a B-spline cylinder or cone merge only when their edges+ // are circles square to the axis and rulings (an extruded hole)._ => analytic_bspline(ex, se).filter(|a| match a.kind {- // Pieces of a B-spline cylinder merge only when their curved edges- // are circles square to the axis (an extruded hole): crossing- // curves (a hole through a tube wall) read far more slowly on a- // cylinder than on the sheet they came with.- AnalyticKind::Cylinder { z, .. } => face_edges(ex, fe).is_some_and(|ls| {- ls.iter().flatten().all(|(x, _)| {- edge_samples(ex, *x).is_some_and(|pts| {- let Some(&q0) = pts.first() else { return false };- let tol = 1e-7 * (1.0 + norm(q0));- pts.iter().all(|q| dot(sub(*q, q0), z).abs() <= tol)- || pts.iter().all(|q| norm(cross(sub(*q, q0), z)) <= tol)- })- })- }),+ AnalyticKind::Cylinder { .. } | AnalyticKind::Cone { .. } => square_or_ruled(ex, fe, &a.kind),_ => true,}),}@@ -1137,10 +1181,16 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,}}}- // B-spline cylinder sheets under merged faces are written as cylinders (the sheet covers only- // its own piece), with the parameter seam on the face's seam edge for a full turn, else- // opposite the face's middle. (Faces replaced by merges stay in the exchange unreferenced:- // only the shells' faces count.)+ merged_surfaces+}++/// B-spline cylinder and cone sheets written as CYLINDRICAL_SURFACE and CONICAL_SURFACE (the+/// sheet covers only its own piece, and a fillet's may reach far past it), with the direction of+/// the parameter seam: on the face's seam edge for a full turn, else opposite the face's middle.+/// Sheets under faces merged from pieces always; a lone piece when its edges are circles square+/// to the axis and rulings. (Faces replaced by merges stay in the exchange unreferenced: only the+/// shells' faces count.)+fn analytic_sheets(ex: &p21::Exchange, merged_surfaces: &std::collections::HashSet<u64>) -> HashMap<u64, V3> {let live: Vec<u64> = ex.entities.values()@@ -1151,12 +1201,16 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,let mut out = HashMap::new();for e in live.iter().filter_map(|f| ex.get(*f)) {let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) else { continue };- if !merged_surfaces.contains(&sid) || out.contains_key(&sid) {+ if out.contains_key(&sid) {continue;}- let Some(Analytic { kind: AnalyticKind::Cylinder { o, z, .. }, .. }) = ex.get(sid).and_then(|se| cylindrical_bspline(ex, se)) else {+ let Some(Analytic { kind, .. }) = ex.get(sid).and_then(|se| ruled_bspline(ex, se)) else {continue;};+ let (AnalyticKind::Cylinder { o, z, .. } | AnalyticKind::Cone { o, z, .. }) = kind else { continue };+ if !merged_surfaces.contains(&sid) && !square_or_ruled(ex, e, &kind) {+ continue;+ }let Some(loops) = face_edges(ex, e) else { continue };let radial = |q: V3| {let v = sub(q, o);@@ -1167,8 +1221,13 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,.flat_map(|l| l.iter().map(move |(x, _)| (l, *x))).find(|(l, x)| l.iter().filter(|(y, _)| y == x).count() > 1).map(|(_, x)| x);- let x = match seam.and_then(|edge| ex.get(edge)?.params().get(1)?.as_ref_id()).and_then(|v| vertex_point(ex, v)) {- Some(q) => unit(radial(q)),+ // (A cone tip's seam has one end at the apex, on the axis.)+ let seam_dir = seam.and_then(|edge| {+ let p = ex.get(edge)?.params();+ [p.get(1), p.get(2)].into_iter().filter_map(|v| vertex_point(ex, v?.as_ref_id()?)).find_map(|q| unit(radial(q)))+ });+ let x = match seam_dir {+ Some(x) => Some(x),None => {let mean = loops.iter()@@ -1187,8 +1246,8 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,out}-/// The B-rep entities of one body as truck writes them, parsed, and the surfaces of faces-/// merged from pieces.+/// The B-rep entities of one body as truck writes them, parsed, and the B-spline sheets to write+/// as cylinders and cones (see `analytic_sheets`). Without `merge` the file is truck's, as is.fn brep_exchange(b: &Body, merge: bool) -> Result<(p21::Exchange, HashMap<u64, V3>, HashMap<u64, FaceLook>)> {let text = crate::step::truck_step(&[b], "SolidCraft")?;let mut ex = p21::parse(&text).map_err(|e| KernelError::Failed(format!("STEP export: {e}")))?;@@ -1209,9 +1268,17 @@ fn brep_exchange(b: &Body, merge: bool) -> Result<(p21::Exchange, HashMap<u64, V}let before = shell_face_count(&ex);let keep = b.split_lines().map(|l| l.as_slice()).unwrap_or(&[]);- let merged = if merge { merge_split_faces(&mut ex, &mut paint, keep) } else { Default::default() };+ let sheets = if merge {+ let merged = merge_split_faces(&mut ex, &mut paint, keep);+ let sheets = analytic_sheets(&ex, &merged);+ // Lone sheets rewritten as analytic surfaces count as changes to check too.+ MERGES.with(|m| m.set(m.get() + sheets.keys().filter(|s| !merged.contains(s)).count()));+ sheets+ } else {+ Default::default()+ };MERGES.with(|m| m.set(m.get() + before.saturating_sub(shell_face_count(&ex))));- Ok((ex, merged, paint))+ Ok((ex, sheets, paint))}/// The separate pieces of a body for export, each keeping its face colours: a body of several@@ -1277,9 +1344,9 @@ fn rigid_frame(m: &[[f64; 4]; 4]) -> Result<([f64; 3], [f64; 3], [f64; 3])> {pub fn step_export_products(products: &[ExportProduct], root: usize, header: &StepHeader) -> Result<String> {MERGES.with(|m| m.set(0));let text = products_text(products, root, header, true)?;- // Faces merged per surface must read back as cleanly as the pieces they came from (a merge- // can leave a loop the reader cannot lay out); otherwise the pieces are written. Without a- // merge there is nothing to check.+ // Faces merged per surface, and sheets rewritten as cylinders and cones, must read back as+ // cleanly as truck's pieces (a merge can leave a loop the reader cannot lay out); otherwise+ // the pieces are written as truck made them. Without a change there is nothing to check.let clean = |t: &str| crate::step_in::step_import(t).is_ok_and(|i| i.warnings.is_empty());if MERGES.with(|m| m.get()) > 0 && !clean(&text) {let plain = products_text(products, root, header, false)?;@@ -1291,7 +1358,7 @@ pub fn step_export_products(products: &[ExportProduct], root: usize, header: &St}thread_local! {- /// Faces merged while writing the current export.+ /// Faces merged and sheets rewritten while writing the current export.static MERGES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };}