Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

STEP: reader

bherbrucked611ed7ba14
diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rs
index d3ea30942b..9cd6e5ea33 100644
--- a/crates/kernel/src/body.rs
+++ b/crates/kernel/src/body.rs
@@ -34,6 +34,23 @@ pub struct FaceInfo {
pub plane_normal: Option<Vec3>,
}
+type MeshedShell = truck_topology::Shell<mt::Point3, PolylineCurve<mt::Point3>, Option<PolygonMesh>>;
+
+/// Triangulate each shell (not the solid: truck's solid constructor panics on the open or
+/// non-manifold shells an import can produce). Faces whose boundary is not exactly on the
+/// surface (imported geometry within the file's tolerance) fail the exact parameter search;
+/// such shells are meshed again projecting onto the surface.
+fn mesh_shells(solid: &Solid, tol: f64) -> Vec<MeshedShell> {
+ solid
+ .boundaries()
+ .iter()
+ .map(|sh| {
+ let m = sh.triangulation(tol);
+ if m.face_iter().any(|f| f.surface().is_none()) { sh.robust_triangulation(tol) } else { m }
+ })
+ .collect()
+}
+
pub(crate) fn p3(v: Vec3) -> mt::Point3 {
mt::Point3::new(v.x, v.y, v.z)
}
@@ -65,7 +82,7 @@ impl Body {
return Err(KernelError::Failed("empty result".into()));
}
// Orient outward: a closed solid must have positive volume.
- let v = guard("orient", || Ok(solid.triangulation(1.0).to_polygon().volume()))?;
+ let v = guard("orient", || Ok(mesh_shells(&solid, 1.0).iter().map(|s| s.to_polygon().volume()).sum::<f64>()))?;
if v < 0.0 {
solid.not();
}
@@ -98,9 +115,9 @@ impl Body {
let tol = if tol.is_finite() && tol > 0.0 { tol } else { 0.05 };
let tol = tol.max(self.size() * 1e-6);
guard("tessellate", || {
- let meshed = self.solid.triangulation(tol);
+ let meshed = mesh_shells(&self.solid, tol);
let mut out = Mesh::default();
- for (fi, face) in meshed.face_iter().enumerate() {
+ for (fi, face) in meshed.iter().flat_map(|s| s.face_iter()).enumerate() {
let Some(pm) = face.surface() else { continue };
let flip = !face.orientation();
let base = u32::try_from(out.positions.len()).unwrap_or(u32::MAX);
@@ -142,7 +159,7 @@ impl Body {
}
}
let mut seen = std::collections::HashMap::new();
- for e in meshed.edge_iter() {
+ for e in meshed.iter().flat_map(|s| s.edge_iter()) {
if seen.contains_key(&e.id()) {
continue;
}
@@ -152,7 +169,7 @@ impl Body {
}
// Which faces each edge bounds.
out.edge_faces = vec![Vec::new(); out.edges.len()];
- for (fi, face) in meshed.face_iter().enumerate() {
+ for (fi, face) in meshed.iter().flat_map(|s| s.face_iter()).enumerate() {
for e in face.edge_iter() {
if let Some(slot) = seen.get(&e.id()).and_then(|i| out.edge_faces.get_mut(*i)) {
let f = u32::try_from(fi).unwrap_or(u32::MAX);
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index ba76df67c4..0ccf300af0 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -2,7 +2,7 @@
//!
//! Everything SolveCraft does with solids goes through this crate: building bodies from planar
//! regions (extrude, revolve) and primitives, booleans, fillets and chamfers, tessellation,
-//! measurement and STEP export. The implementation uses the `truck` crates (Apache-2.0; see
+//! measurement and STEP export and import. The implementation uses the `truck` crates (Apache-2.0; see
//! `plan/adr/0001-geometry-kernel.md`) plus our own local operations (edge fillets and
//! chamfers in `blend.rs`), but no truck type appears in the public API, so the kernel can be
//! replaced without touching the rest of the workspace.
@@ -20,6 +20,7 @@ mod ops;
mod polybool;
mod polyhedron;
mod step;
+mod step_in;
mod topo;
pub use blend::{chamfer, fillet};
@@ -30,6 +31,7 @@ pub use ops::{BoolOp, boolean, split_by_plane, transform, transform_matrix};
pub use polybool::planar_boolean;
pub use polyhedron::{HalfSpace, convex_polyhedron, draft, shell};
pub use step::step_export;
+pub use step_in::{ImportedBody, StepImport, StepNode, step_import};
pub use topo::{TopoCounts, merged_topology, seam_flags};
#[derive(Debug, Clone, PartialEq, thiserror::Error)]
diff --git a/crates/kernel/src/step_in/brep.rs b/crates/kernel/src/step_in/brep.rs
new file mode 100644
index 0000000000..dae0cd791b
--- /dev/null
+++ b/crates/kernel/src/step_in/brep.rs
@@ -0,0 +1,366 @@
+//! STEP topology (ISO 10303-42 topology entities) to kernel solids: breps, shells, faces, loops,
+//! edges and vertices. A face that cannot be built is left out and reported; the rest of the
+//! body is still imported (as an open body when a face is missing).
+
+use std::collections::HashMap;
+
+use mt::{BoundedCurve, EuclideanSpace, InnerSpace, MetricSpace, ParametricCurve};
+use truck_modeling as mt;
+
+use super::Ctx;
+use super::geom::{self, R, entity};
+use super::p21::Param;
+use crate::guard;
+
+/// Most faces in one body.
+const MAX_FACES: usize = 500_000;
+/// Most edges in one loop.
+const MAX_LOOP: usize = 100_000;
+
+/// A body read from a brep entity.
+pub(crate) struct BrepOut {
+ pub solid: mt::Solid,
+ /// Faces left out (with the reason).
+ pub failed: Vec<String>,
+ /// The shells are closed (a solid) rather than open (missing faces, or a surface model).
+ pub closed: bool,
+ /// Faces read from the file (before band faces are split for the kernel).
+ pub file_faces: usize,
+}
+
+#[derive(Default)]
+struct Builder {
+ vertices: HashMap<u64, mt::Vertex>,
+ edges: HashMap<u64, Vec<mt::Edge>>,
+ poly_edges: HashMap<(u64, u64), mt::Edge>,
+ faces: usize,
+}
+
+fn refs(p: Option<&Param>) -> Vec<u64> {
+ p.and_then(Param::as_list).map(|v| v.iter().filter_map(Param::as_ref_id).collect()).unwrap_or_default()
+}
+
+fn rid(p: Option<&Param>, what: &str) -> R<u64> {
+ p.and_then(Param::as_ref_id).ok_or_else(|| format!("{what}: expected a reference"))
+}
+
+impl Builder {
+ fn vertex(&mut self, cx: &Ctx, id: u64) -> R<mt::Vertex> {
+ if let Some(v) = self.vertices.get(&id) {
+ return Ok(v.clone());
+ }
+ let e = entity(cx, id)?;
+ if e.name() != "VERTEX_POINT" {
+ return Err(format!("#{id}: expected VERTEX_POINT, found {}", e.name()));
+ }
+ let p = geom::point(cx, rid(e.params().get(1), "VERTEX_POINT")?)?;
+ let v = mt::Vertex::new(p);
+ self.vertices.insert(id, v.clone());
+ Ok(v)
+ }
+
+ /// Kernel edges (start to end) of an EDGE_CURVE.
+ fn edge_curve(&mut self, cx: &Ctx, id: u64) -> R<Vec<mt::Edge>> {
+ if let Some(e) = self.edges.get(&id) {
+ return Ok(e.clone());
+ }
+ let e = entity(cx, id)?;
+ if e.name() != "EDGE_CURVE" {
+ return Err(format!("#{id}: unsupported edge {}", e.name()));
+ }
+ let p = e.params();
+ let (vs_id, ve_id) = (rid(p.get(1), "edge start")?, rid(p.get(2), "edge end")?);
+ let vs = self.vertex(cx, vs_id)?;
+ let ve = self.vertex(cx, ve_id)?;
+ let sense = p.get(4).and_then(Param::as_bool).unwrap_or(true);
+ let g = geom::curve(cx, rid(p.get(3), "edge geometry")?, 0)?;
+ let closed = vs_id == ve_id;
+ let pieces = guard("step edge", || geom::edge_pieces(&g, vs.point(), ve.point(), sense, closed, cx.tol).map_err(crate::KernelError::Failed))
+ .map_err(|e| e.to_string())?;
+ let n = pieces.len();
+ let mut out = Vec::with_capacity(n);
+ let mut cur = vs.clone();
+ for (i, c) in pieces.into_iter().enumerate() {
+ let next = if i + 1 == n { ve.clone() } else { mt::Vertex::new(c.back()) };
+ out.push(mt::Edge::new_unchecked(&cur, &next, c));
+ cur = next;
+ }
+ self.edges.insert(id, out.clone());
+ Ok(out)
+ }
+
+ /// Edges of an ORIENTED_EDGE (or a bare EDGE_CURVE) in loop order.
+ fn oriented_edge(&mut self, cx: &Ctx, id: u64, depth: usize) -> R<Vec<mt::Edge>> {
+ if depth > 4 {
+ return Err("oriented edges nested too deeply".into());
+ }
+ let e = entity(cx, id)?;
+ match e.name() {
+ "ORIENTED_EDGE" => {
+ let p = e.params();
+ let inner = self.oriented_edge(cx, rid(p.get(3), "ORIENTED_EDGE")?, depth + 1)?;
+ if p.get(4).and_then(Param::as_bool).unwrap_or(true) { Ok(inner) } else { Ok(inner.iter().rev().map(mt::Edge::inverse).collect()) }
+ }
+ _ => self.edge_curve(cx, id),
+ }
+ }
+
+ fn poly_loop(&mut self, cx: &Ctx, pts: &[u64]) -> R<Vec<mt::Edge>> {
+ let n = pts.len();
+ if !(3..=MAX_LOOP).contains(&n) {
+ return Err(format!("polygon loop with {n} points"));
+ }
+ let mut verts = Vec::with_capacity(n);
+ for &id in pts {
+ if let Some(v) = self.vertices.get(&id) {
+ verts.push(v.clone());
+ } else {
+ let v = mt::Vertex::new(geom::point(cx, id)?);
+ self.vertices.insert(id, v.clone());
+ verts.push(v);
+ }
+ }
+ let mut out = Vec::with_capacity(n);
+ for i in 0..n {
+ let (Some(&a), Some(&b)) = (pts.get(i), pts.get((i + 1) % n)) else { continue };
+ if let Some(e) = self.poly_edges.get(&(b, a)) {
+ out.push(e.inverse());
+ continue;
+ }
+ let (Some(va), Some(vb)) = (verts.get(i), verts.get((i + 1) % n)) else { continue };
+ if va.point().distance(vb.point()) < 1e-12 {
+ return Err("polygon loop with repeated points".into());
+ }
+ let e = mt::Edge::try_new(va, vb, mt::Curve::Line(mt::Line(va.point(), vb.point()))).map_err(|e| format!("polygon edge: {e}"))?;
+ self.poly_edges.insert((a, b), e.clone());
+ out.push(e);
+ }
+ Ok(out)
+ }
+
+ /// A face bound as a wire (oriented by the bound's orientation), or `None` for a vertex loop.
+ fn bound(&mut self, cx: &Ctx, id: u64) -> R<Option<mt::Wire>> {
+ let b = entity(cx, id)?;
+ if !matches!(b.name(), "FACE_BOUND" | "FACE_OUTER_BOUND") {
+ return Err(format!("#{id}: unsupported face bound {}", b.name()));
+ }
+ let lp_id = rid(b.params().get(1), "face bound loop")?;
+ let orient = b.params().get(2).and_then(Param::as_bool).unwrap_or(true);
+ let lp = entity(cx, lp_id)?;
+ let edges = match lp.name() {
+ "EDGE_LOOP" => {
+ let ids = refs(lp.params().get(1));
+ if ids.is_empty() || ids.len() > MAX_LOOP {
+ return Err(format!("edge loop with {} edges", ids.len()));
+ }
+ let mut v = Vec::new();
+ for oe in ids {
+ v.extend(self.oriented_edge(cx, oe, 0)?);
+ }
+ v
+ }
+ "POLY_LOOP" => self.poly_loop(cx, &refs(lp.params().get(1)))?,
+ "VERTEX_LOOP" => return Ok(None),
+ n => return Err(format!("unsupported loop {n}")),
+ };
+ let mut w: mt::Wire = edges.into();
+ if !w.is_closed() {
+ return Err("face boundary is not a closed loop".into());
+ }
+ if !orient {
+ w.invert();
+ }
+ Ok(Some(w))
+ }
+
+ /// A face (ADVANCED_FACE, FACE_SURFACE, ORIENTED_FACE or a polygonal FACE).
+ fn face(&mut self, cx: &Ctx, id: u64, depth: usize) -> R<mt::Face> {
+ if depth > 4 {
+ return Err("oriented faces nested too deeply".into());
+ }
+ self.faces += 1;
+ if self.faces > MAX_FACES {
+ return Err(format!("more than {MAX_FACES} faces"));
+ }
+ let e = entity(cx, id)?;
+ let p = e.params();
+ if e.name() == "ORIENTED_FACE" {
+ let mut f = self.face(cx, rid(p.get(2), "ORIENTED_FACE")?, depth + 1)?;
+ if !p.get(3).and_then(Param::as_bool).unwrap_or(true) {
+ f.invert();
+ }
+ return Ok(f);
+ }
+ if !matches!(e.name(), "ADVANCED_FACE" | "FACE_SURFACE" | "FACE") {
+ return Err(format!("unsupported face {}", e.name()));
+ }
+ let mut wires = Vec::new();
+ for b in refs(p.get(1)) {
+ if let Some(w) = self.bound(cx, b)? {
+ wires.push(w);
+ }
+ }
+ if wires.is_empty() {
+ return Err("face without boundary edges".into());
+ }
+ let extent: Vec<mt::Point3> = wires
+ .iter()
+ .flat_map(|w| w.edge_iter())
+ .flat_map(|e| {
+ let c = e.curve();
+ let (t0, t1) = c.range_tuple();
+ (0..8).map(move |i| c.subs(t0 + (t1 - t0) * i as f64 / 8.0)).collect::<Vec<_>>()
+ })
+ .collect();
+ // Seam edges: used twice by the face's loops.
+ let mut uses: HashMap<mt::EdgeID, usize> = HashMap::new();
+ for e in wires.iter().flat_map(|w| w.edge_iter()) {
+ *uses.entry(e.id()).or_default() += 1;
+ }
+ let mut seen = std::collections::HashSet::new();
+ let seam: Vec<mt::Point3> = wires
+ .iter()
+ .flat_map(|w| w.edge_iter())
+ .filter(|e| uses.get(&e.id()).copied().unwrap_or(0) > 1 && seen.insert(e.id()))
+ .flat_map(|e| {
+ let c = e.curve();
+ let (t0, t1) = c.range_tuple();
+ (0..=8).map(move |i| c.subs(t0 + (t1 - t0) * i as f64 / 8.0)).collect::<Vec<_>>()
+ })
+ .collect();
+ let surface = if e.name() == "FACE" {
+ plane_through(&extent).ok_or("polygonal face without a plane")?
+ } else {
+ let sid = rid(p.get(2), "face geometry")?;
+ let sense = p.get(3).and_then(Param::as_bool).unwrap_or(true);
+ guard("step surface", || geom::surface(cx, sid, &extent, &seam, sense, 0).map_err(crate::KernelError::Failed))
+ .map_err(|e| e.to_string())?
+ };
+ match mt::Face::try_new(wires.clone(), surface.clone()) {
+ Ok(f) => Ok(f),
+ // Faces on periodic surfaces run along a seam edge twice: valid in STEP.
+ Err(truck_topology::errors::Error::NotSimpleWire) => Ok(mt::Face::new_unchecked(wires, surface)),
+ Err(e) => Err(format!("face: {e}")),
+ }
+ }
+
+ fn shell(&mut self, cx: &Ctx, id: u64, failed: &mut Vec<String>) -> R<(mt::Shell, bool, usize)> {
+ let e = entity(cx, id)?;
+ let p = e.params();
+ let (faces, flip, closed) = match e.name() {
+ "CLOSED_SHELL" => (refs(p.get(1)), false, true),
+ "OPEN_SHELL" => (refs(p.get(1)), false, false),
+ "ORIENTED_CLOSED_SHELL" | "ORIENTED_OPEN_SHELL" => {
+ let inner = entity(cx, rid(p.get(2), "oriented shell")?)?;
+ (refs(inner.params().get(1)), !p.get(3).and_then(Param::as_bool).unwrap_or(true), e.name() == "ORIENTED_CLOSED_SHELL")
+ }
+ n => return Err(format!("unsupported shell {n}")),
+ };
+ if faces.len() > MAX_FACES {
+ return Err(format!("shell with {} faces", faces.len()));
+ }
+ let mut out = Vec::with_capacity(faces.len());
+ for f in faces {
+ match self.face(cx, f, 0) {
+ Ok(mut face) => {
+ if flip {
+ face.invert();
+ }
+ out.push(face);
+ }
+ Err(err) => {
+ if self.faces > MAX_FACES {
+ return Err(err);
+ }
+ failed.push(format!("face #{f}: {err}"));
+ }
+ }
+ }
+ if out.is_empty() {
+ return Err("no face could be imported".into());
+ }
+ let read = out.len();
+ let out = super::split::split_bands(out, failed);
+ Ok((out.into(), closed, read))
+ }
+}
+
+/// Plane through a polygon (Newell's normal).
+fn plane_through(pts: &[mt::Point3]) -> Option<mt::Surface> {
+ let n = pts.len();
+ let mut nrm = mt::Vector3::new(0.0, 0.0, 0.0);
+ let mut c = mt::Vector3::new(0.0, 0.0, 0.0);
+ for i in 0..n {
+ let (a, b) = (pts.get(i)?, pts.get((i + 1) % n)?);
+ nrm.x += (a.y - b.y) * (a.z + b.z);
+ nrm.y += (a.z - b.z) * (a.x + b.x);
+ nrm.z += (a.x - b.x) * (a.y + b.y);
+ c += a.to_homogeneous().truncate();
+ }
+ let len = nrm.magnitude();
+ if !(len > 1e-12) || n == 0 {
+ return None;
+ }
+ let z = nrm / len;
+ let o = mt::Point3::from_vec(c / n as f64);
+ let a = if z.x.abs() < 0.9 { mt::Vector3::unit_x() } else { mt::Vector3::unit_y() };
+ let x = (a - z * a.dot(z)).normalize();
+ let y = z.cross(x);
+ Some(mt::Surface::Plane(mt::Plane::new(o, o + x, o + y)))
+}
+
+/// Read a solid-like representation item: MANIFOLD_SOLID_BREP, BREP_WITH_VOIDS, FACETED_BREP,
+/// or a SHELL_BASED_SURFACE_MODEL (closed shells give solids, open ones open bodies).
+pub(crate) fn read_item(cx: &Ctx, id: u64) -> R<BrepOut> {
+ let e = entity(cx, id)?;
+ let p = e.params();
+ let mut b = Builder::default();
+ let mut failed = Vec::new();
+ let mut shells = Vec::new();
+ let mut closed = true;
+ let mut file_faces = 0;
+ match e.name() {
+ "MANIFOLD_SOLID_BREP" | "FACETED_BREP" | "BREP_WITH_VOIDS" => {
+ let (s, c, n) = b.shell(cx, rid(p.get(1), "brep outer shell")?, &mut failed)?;
+ closed &= c;
+ file_faces += n;
+ shells.push(s);
+ if e.name() == "BREP_WITH_VOIDS" {
+ for v in refs(p.get(2)) {
+ match b.shell(cx, v, &mut failed) {
+ Ok((s, c, n)) => {
+ closed &= c;
+ file_faces += n;
+ shells.push(s);
+ }
+ Err(err) => failed.push(format!("void shell #{v}: {err}")),
+ }
+ }
+ }
+ }
+ "SHELL_BASED_SURFACE_MODEL" => {
+ for s in refs(p.get(1)) {
+ match b.shell(cx, s, &mut failed) {
+ Ok((s, c, n)) => {
+ closed &= c;
+ file_faces += n;
+ shells.push(s);
+ }
+ Err(err) => failed.push(format!("shell #{s}: {err}")),
+ }
+ }
+ }
+ n => return Err(format!("unsupported item {n}")),
+ }
+ if shells.is_empty() {
+ return Err(failed.first().cloned().unwrap_or_else(|| "no shells".into()));
+ }
+ let solid = match guard("step solid", || mt::Solid::try_new(shells.clone()).map_err(|e| crate::KernelError::Failed(e.to_string()))) {
+ Ok(s) => s,
+ Err(_) => {
+ closed = false;
+ mt::Solid::new_unchecked(shells)
+ }
+ };
+ Ok(BrepOut { solid, failed, closed, file_faces })
+}
diff --git a/crates/kernel/src/step_in/geom.rs b/crates/kernel/src/step_in/geom.rs
new file mode 100644
index 0000000000..c128baf8d6
--- /dev/null
+++ b/crates/kernel/src/step_in/geom.rs
@@ -0,0 +1,835 @@
+//! STEP geometry (ISO 10303-42 entities) to kernel curves and surfaces.
+//!
+//! Points, placements, lines, conics, B-splines (plain and rational), elementary surfaces and
+//! swept surfaces. Edge curves are trimmed to their vertices here, so every kernel edge runs
+//! exactly from its start vertex to its end vertex. Lengths are scaled to millimetres while
+//! reading.
+
+use std::f64::consts::{FRAC_PI_2, PI, TAU};
+
+use mt::{BoundedCurve, Cut, InnerSpace, Invertible, MetricSpace, ParametricCurve, ParametricSurface3D, SearchNearestParameter};
+use truck_modeling as mt;
+
+use super::Ctx;
+use super::p21::{Entity, Param};
+
+/// Geometry nesting we follow (trimmed curve of a surface curve of …).
+const MAX_GEOM_DEPTH: usize = 8;
+/// Most control points in one B-spline (per direction product for surfaces).
+const MAX_CTRL: usize = 1_000_000;
+const MAX_COORD: f64 = 1e9;
+
+pub(crate) type R<T> = std::result::Result<T, String>;
+
+/// An orthonormal frame (AXIS2_PLACEMENT_3D).
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Frame {
+ pub o: mt::Point3,
+ pub x: mt::Vector3,
+ pub y: mt::Vector3,
+ pub z: mt::Vector3,
+}
+
+impl Frame {
+ pub fn matrix(&self) -> mt::Matrix4 {
+ mt::Matrix4::from_cols(self.x.extend(0.0), self.y.extend(0.0), self.z.extend(0.0), self.o.to_homogeneous())
+ }
+ fn at(&self, cx: f64, cy: f64, cz: f64) -> mt::Point3 {
+ self.o + self.x * cx + self.y * cy + self.z * cz
+ }
+}
+
+/// A curve before trimming.
+#[derive(Clone, Debug)]
+pub(crate) enum CurveGeo {
+ Line {
+ p: mt::Point3,
+ d: mt::Vector3,
+ },
+ /// Ellipse (`a == b` for circles) in the frame's XY plane.
+ Conic {
+ f: Frame,
+ a: f64,
+ b: f64,
+ },
+ BSpline(mt::BSplineCurve<mt::Point3>),
+ Nurbs(mt::NurbsCurve<mt::Vector4>),
+}
+
+pub(crate) fn entity<'a>(cx: &Ctx<'a>, id: u64) -> R<&'a Entity> {
+ cx.ex.get(id).ok_or_else(|| format!("missing entity #{id}"))
+}
+
+fn ent_of<'a>(cx: &Ctx<'a>, p: Option<&Param>, what: &str) -> R<(u64, &'a Entity)> {
+ let id = p.and_then(Param::as_ref_id).ok_or_else(|| format!("{what}: expected a reference"))?;
+ Ok((id, entity(cx, id)?))
+}
+
+fn num(p: Option<&Param>, what: &str) -> R<f64> {
+ let x = p.and_then(Param::as_f64).ok_or_else(|| format!("{what}: expected a number"))?;
+ if x.is_finite() && x.abs() < MAX_COORD { Ok(x) } else { Err(format!("{what}: {x} out of range")) }
+}
+
+fn length(cx: &Ctx, p: Option<&Param>, what: &str) -> R<f64> {
+ Ok(num(p, what)? * cx.len)
+}
+
+pub(crate) fn point(cx: &Ctx, id: u64) -> R<mt::Point3> {
+ let e = entity(cx, id)?;
+ if e.name() != "CARTESIAN_POINT" {
+ return Err(format!("#{id}: expected CARTESIAN_POINT, found {}", e.name()));
+ }
+ let c = e.params().get(1).and_then(Param::as_list).ok_or("CARTESIAN_POINT without coordinates")?;
+ let g = |i: usize| -> R<f64> { if i < c.len() { num(c.get(i), "coordinate") } else { Ok(0.0) } };
+ if c.is_empty() || c.len() > 3 {
+ return Err(format!("#{id}: point with {} coordinates", c.len()));
+ }
+ Ok(mt::Point3::new(g(0)?, g(1)?, g(2)?) * cx.len)
+}
+
+fn direction(cx: &Ctx, id: u64) -> R<mt::Vector3> {
+ let e = entity(cx, id)?;
+ if e.name() != "DIRECTION" {
+ return Err(format!("#{id}: expected DIRECTION, found {}", e.name()));
+ }
+ let c = e.params().get(1).and_then(Param::as_list).ok_or("DIRECTION without ratios")?;
+ let g = |i: usize| -> R<f64> { if i < c.len() { num(c.get(i), "direction") } else { Ok(0.0) } };
+ let v = mt::Vector3::new(g(0)?, g(1)?, g(2)?);
+ let m = v.magnitude();
+ if m > 1e-12 && m.is_finite() { Ok(v / m) } else { Err(format!("#{id}: zero direction")) }
+}
+
+fn any_perpendicular(z: mt::Vector3) -> mt::Vector3 {
+ let a = if z.x.abs() < 0.9 { mt::Vector3::unit_x() } else { mt::Vector3::unit_y() };
+ let x = a - z * a.dot(z);
+ x / x.magnitude()
+}
+
+/// AXIS2_PLACEMENT_3D (or 2D, as a frame in the XY plane).
+pub(crate) fn frame(cx: &Ctx, id: u64) -> R<Frame> {
+ let e = entity(cx, id)?;
+ let p = e.params();
+ let o = point(cx, p.get(1).and_then(Param::as_ref_id).ok_or("placement without location")?)?;
+ let (z, rf) = match e.name() {
+ "AXIS2_PLACEMENT_3D" => {
+ let z = match p.get(2).and_then(Param::as_ref_id) {
+ Some(d) => direction(cx, d)?,
+ None => mt::Vector3::unit_z(),
+ };
+ (z, p.get(3).and_then(Param::as_ref_id))
+ }
+ "AXIS2_PLACEMENT_2D" => (mt::Vector3::unit_z(), p.get(2).and_then(Param::as_ref_id)),
+ n => return Err(format!("#{id}: expected AXIS2_PLACEMENT_3D, found {n}")),
+ };
+ let x = match rf {
+ Some(d) => {
+ let r = direction(cx, d)?;
+ let x = r - z * r.dot(z);
+ if x.magnitude() > 1e-9 { x / x.magnitude() } else { any_perpendicular(z) }
+ }
+ None => any_perpendicular(z),
+ };
+ Ok(Frame { o, x, y: z.cross(x), z })
+}
+
+/// AXIS1_PLACEMENT: origin and unit axis.
+fn axis1(cx: &Ctx, id: u64) -> R<(mt::Point3, mt::Vector3)> {
+ let e = entity(cx, id)?;
+ let p = e.params();
+ let o = point(cx, p.get(1).and_then(Param::as_ref_id).ok_or("axis without location")?)?;
+ let d = match p.get(2).and_then(Param::as_ref_id) {
+ Some(d) => direction(cx, d)?,
+ None => mt::Vector3::unit_z(),
+ };
+ Ok((o, d))
+}
+
+fn knot_vec(mults: Option<&Param>, knots: Option<&Param>) -> R<mt::KnotVec> {
+ let m: Vec<usize> = mults
+ .and_then(Param::as_list)
+ .ok_or("B-spline without knot multiplicities")?
+ .iter()
+ .map(|x| x.as_i64().filter(|v| (1..=64).contains(v)).map(|v| v as usize).ok_or_else(|| "bad knot multiplicity".to_string()))
+ .collect::<R<_>>()?;
+ let k: Vec<f64> = knots.and_then(Param::as_list).ok_or("B-spline without knots")?.iter().map(|x| num(Some(x), "knot")).collect::<R<_>>()?;
+ if m.len() != k.len() || k.is_empty() || k.windows(2).any(|w| w.first() > w.get(1)) {
+ return Err("inconsistent knot vector".into());
+ }
+ mt::KnotVec::from_single_multi(k, m).map_err(|e| format!("knot vector: {e}"))
+}
+
+fn generated_knots(kind: &str, n_ctrl: usize, degree: usize) -> R<mt::KnotVec> {
+ if n_ctrl <= degree {
+ return Err("too few control points".into());
+ }
+ let n = n_ctrl + degree + 1;
+ let v: Vec<f64> = match kind {
+ "BEZIER" => {
+ if n_ctrl != degree + 1 {
+ // Piecewise Bézier: segments of `degree` with full interior multiplicity.
+ let segs = (n_ctrl - 1) / degree.max(1);
+ if segs * degree + 1 != n_ctrl {
+ return Err("Bezier control point count".into());
+ }
+ let mut v = vec![0.0; degree + 1];
+ for s in 1..segs {
+ v.extend(std::iter::repeat_n(s as f64, degree));
+ }
+ v.extend(std::iter::repeat_n(segs as f64, degree + 1));
+ v
+ } else {
+ let mut v = vec![0.0; degree + 1];
+ v.extend(std::iter::repeat_n(1.0, degree + 1));
+ v
+ }
+ }
+ "UNIFORM" => (0..n).map(|i| i as f64 - degree as f64).collect(),
+ _ => {
+ // Quasi-uniform: clamped ends, uniform interior.
+ let inner = n_ctrl - degree;
+ let mut v = vec![0.0; degree + 1];
+ v.extend((1..inner).map(|i| i as f64));
+ v.extend(std::iter::repeat_n(inner as f64, degree + 1));
+ v
+ }
+ };
+ Ok(mt::KnotVec::from(v))
+}
+
+fn weights_list(p: Option<&Param>) -> R<Vec<f64>> {
+ p.and_then(Param::as_list)
+ .ok_or("rational B-spline without weights")?
+ .iter()
+ .map(|w| num(Some(w), "weight").and_then(|w| if w > 0.0 { Ok(w) } else { Err("non-positive weight".into()) }))
+ .collect()
+}
+
+fn bspline_curve(cx: &Ctx, e: &Entity) -> R<CurveGeo> {
+ // Common part (B_SPLINE_CURVE): degree, control points, form, closed, self-intersect.
+ let (base, knots, kind): (Vec<Param>, Option<(Option<&Param>, Option<&Param>)>, &str) = if e.is_complex() {
+ let b = e.record("B_SPLINE_CURVE").ok_or("complex curve without B_SPLINE_CURVE")?;
+ let mut base = vec![Param::Str(String::new())];
+ base.extend(b.iter().cloned());
+ let k = e.record("B_SPLINE_CURVE_WITH_KNOTS").map(|k| (k.first(), k.get(1)));
+ let kind = if e.has("BEZIER_CURVE") {
+ "BEZIER"
+ } else if e.has("UNIFORM_CURVE") {
+ "UNIFORM"
+ } else {
+ "QUASI"
+ };
+ (base, k, kind)
+ } else {
+ let p = e.params();
+ let k = (e.name() == "B_SPLINE_CURVE_WITH_KNOTS").then(|| (p.get(6), p.get(7)));
+ let kind = match e.name() {
+ "BEZIER_CURVE" => "BEZIER",
+ "UNIFORM_CURVE" => "UNIFORM",
+ _ => "QUASI",
+ };
+ (p.to_vec(), k, kind)
+ };
+ let degree = base.get(1).and_then(Param::as_i64).filter(|d| (1..=32).contains(d)).ok_or("bad B-spline degree")? as usize;
+ let ctrl_ids = base.get(2).and_then(Param::as_list).ok_or("B-spline without control points")?;
+ if ctrl_ids.len() > MAX_CTRL {
+ return Err("B-spline with too many control points".into());
+ }
+ let ctrl: Vec<mt::Point3> = ctrl_ids.iter().map(|c| point(cx, c.as_ref_id().ok_or("bad control point")?)).collect::<R<_>>()?;
+ let kv = match knots {
+ Some((m, k)) => knot_vec(m, k)?,
+ None => generated_knots(kind, ctrl.len(), degree)?,
+ };
+ if kv.len() != ctrl.len() + degree + 1 {
+ return Err(format!("B-spline knot count {} does not match {} control points of degree {degree}", kv.len(), ctrl.len()));
+ }
+ let bsp = mt::BSplineCurve::try_new(kv, ctrl).map_err(|e| format!("B-spline: {e}"))?;
+ match e.record("RATIONAL_B_SPLINE_CURVE") {
+ Some(r) => {
+ let w = weights_list(r.first())?;
+ let n = mt::NurbsCurve::<mt::Vector4>::try_from_bspline_and_weights(bsp, w).map_err(|e| format!("rational B-spline: {e}"))?;
+ Ok(CurveGeo::Nurbs(n))
+ }
+ None => Ok(CurveGeo::BSpline(bsp)),
+ }
+}
+
+/// A STEP curve entity (unbounded or bounded).
+pub(crate) fn curve(cx: &Ctx, id: u64, depth: usize) -> R<CurveGeo> {
+ if depth > MAX_GEOM_DEPTH {
+ return Err("curve definitions nested too deeply".into());
+ }
+ let e = entity(cx, id)?;
+ let p = e.params();
+ if e.is_complex() {
+ return bspline_curve(cx, e);
+ }
+ match e.name() {
+ "LINE" => {
+ let pt = point(cx, p.get(1).and_then(Param::as_ref_id).ok_or("LINE without point")?)?;
+ let (_, v) = ent_of(cx, p.get(2), "LINE vector")?;
+ let d = direction(cx, v.params().get(1).and_then(Param::as_ref_id).ok_or("VECTOR without direction")?)?;
+ Ok(CurveGeo::Line { p: pt, d })
+ }
+ "CIRCLE" => {
+ let f = frame(cx, p.get(1).and_then(Param::as_ref_id).ok_or("CIRCLE without placement")?)?;
+ let r = length(cx, p.get(2), "radius")?;
+ if r <= 0.0 {
+ return Err("circle radius must be positive".into());
+ }
+ Ok(CurveGeo::Conic { f, a: r, b: r })
+ }
+ "ELLIPSE" => {
+ let f = frame(cx, p.get(1).and_then(Param::as_ref_id).ok_or("ELLIPSE without placement")?)?;
+ let (a, b) = (length(cx, p.get(2), "semi axis")?, length(cx, p.get(3), "semi axis")?);
+ if a <= 0.0 || b <= 0.0 {
+ return Err("ellipse axes must be positive".into());
+ }
+ Ok(CurveGeo::Conic { f, a, b })
+ }
+ "B_SPLINE_CURVE_WITH_KNOTS" | "BEZIER_CURVE" | "UNIFORM_CURVE" | "QUASI_UNIFORM_CURVE" => bspline_curve(cx, e),
+ "POLYLINE" => {
+ let pts: Vec<mt::Point3> = p
+ .get(1)
+ .and_then(Param::as_list)
+ .ok_or("POLYLINE without points")?
+ .iter()
+ .map(|c| point(cx, c.as_ref_id().ok_or("bad polyline point")?))
+ .collect::<R<_>>()?;
+ if pts.len() < 2 || pts.len() > MAX_CTRL {
+ return Err("polyline point count".into());
+ }
+ let mut k = vec![0.0];
+ k.extend((0..pts.len()).map(|i| i as f64));
+ k.push((pts.len() - 1) as f64);
+ Ok(CurveGeo::BSpline(mt::BSplineCurve::try_new(mt::KnotVec::from(k), pts).map_err(|e| format!("polyline: {e}"))?))
+ }
+ "TRIMMED_CURVE" => curve(cx, p.get(1).and_then(Param::as_ref_id).ok_or("TRIMMED_CURVE without basis")?, depth + 1),
+ "SURFACE_CURVE" | "SEAM_CURVE" | "INTERSECTION_CURVE" | "BOUNDED_SURFACE_CURVE" => {
+ curve(cx, p.get(1).and_then(Param::as_ref_id).ok_or("surface curve without 3D curve")?, depth + 1)
+ }
+ n => Err(format!("unsupported curve {n}")),
+ }
+}
+
+/// Rational quadratic NURBS arc of an ellipse from angle `t0` over `sweep > 0`.
+pub(crate) fn conic_arc(f: &Frame, a: f64, b: f64, t0: f64, sweep: f64) -> mt::NurbsCurve<mt::Vector4> {
+ let n = ((sweep / FRAC_PI_2).ceil() as usize).clamp(1, 8);
+ let dt = sweep / n as f64;
+ let w = (dt * 0.5).cos();
+ let at = |c: f64, s: f64| f.at(a * c, b * s, 0.0);
+ let mut ctrl = Vec::with_capacity(2 * n + 1);
+ let p0 = at(t0.cos(), t0.sin());
+ ctrl.push(p0.to_homogeneous());
+ let mut knots = vec![0.0, 0.0, 0.0];
+ for i in 0..n {
+ let ta = t0 + dt * i as f64;
+ let tm = ta + dt * 0.5;
+ let tb = ta + dt;
+ let m = at(tm.cos() / w, tm.sin() / w);
+ ctrl.push(mt::Vector4::new(m.x * w, m.y * w, m.z * w, w));
+ ctrl.push(at(tb.cos(), tb.sin()).to_homogeneous());
+ let k = (i + 1) as f64 / n as f64;
+ knots.push(k);
+ knots.push(k);
+ }
+ // Last knot pair becomes the clamped end (multiplicity 3).
+ knots.push(1.0);
+ mt::NurbsCurve::new(mt::BSplineCurve::new(mt::KnotVec::from(knots), ctrl))
+}
+
+fn conic_angle(f: &Frame, a: f64, b: f64, p: mt::Point3) -> f64 {
+ let d = p - f.o;
+ (d.dot(f.y) / b).atan2(d.dot(f.x) / a)
+}
+
+/// Parameter of the curve point nearest to `p`, and its distance.
+fn nearest_param<C>(c: &C, p: mt::Point3) -> Option<(f64, f64)>
+where
+ C: ParametricCurve<Point = mt::Point3> + BoundedCurve + SearchNearestParameter<mt::D1, Point = mt::Point3>,
+{
+ let (t0, t1) = c.range_tuple();
+ let n = 256;
+ let mut best = (t0, f64::INFINITY);
+ for i in 0..=n {
+ let t = t0 + (t1 - t0) * i as f64 / n as f64;
+ let d = c.subs(t).distance(p);
+ if d < best.1 {
+ best = (t, d);
+ }
+ }
+ if let Some(t) = c.search_nearest_parameter(p, best.0, 64) {
+ let t = t.clamp(t0, t1);
+ let d = c.subs(t).distance(p);
+ if d < best.1 {
+ best = (t, d);
+ }
+ }
+ best.1.is_finite().then_some(best)
+}
+
+/// Sub-curve on `[a, b]` (inside the curve's range).
+fn sub_curve<C: Cut + BoundedCurve + Clone>(c: &C, a: f64, b: f64) -> C {
+ let (t0, t1) = c.range_tuple();
+ let eps = (t1 - t0).abs() * 1e-9;
+ let mut out = c.clone();
+ if a > t0 + eps {
+ out = out.cut(a);
+ }
+ if b < t1 - eps {
+ let _ = out.cut(b);
+ }
+ out
+}
+
+/// Pieces of a spline edge from `ps` to `pe` (two pieces for a closed edge).
+fn spline_pieces<C>(c: &C, ps: mt::Point3, pe: mt::Point3, sense: bool, closed: bool, tol: f64) -> R<Vec<C>>
+where
+ C: ParametricCurve<Point = mt::Point3> + BoundedCurve + SearchNearestParameter<mt::D1, Point = mt::Point3> + Cut + Clone + Invertible,
+{
+ let (t0, t1) = c.range_tuple();
+ let (ts, ds) = nearest_param(c, ps).ok_or("spline evaluation failed")?;
+ let (te, de) = nearest_param(c, pe).ok_or("spline evaluation failed")?;
+ if ds > tol || de > tol {
+ return Err(format!("edge vertices are {:.3e} mm off their curve", ds.max(de)));
+ }
+ let span = t1 - t0;
+ let near = |a: f64, b: f64| (a - b).abs() <= span * 1e-7;
+ let mut pieces = if closed {
+ // Whole closed curve starting at the vertex.
+ if near(ts, t0) || near(ts, t1) {
+ let m = t0 + span * 0.5;
+ vec![sub_curve(c, t0, m), sub_curve(c, m, t1)]
+ } else {
+ vec![sub_curve(c, ts, t1), sub_curve(c, t0, ts)]
+ }
+ } else {
+ let (mut a, mut b) = if sense { (ts, te) } else { (te, ts) };
+ // A closed curve traversed across its seam.
+ if a >= b && c.subs(t0).distance(c.subs(t1)) <= tol {
+ if near(b, t0) {
+ b = t1;
+ } else if near(a, t1) {
+ a = t0;
+ } else {
+ let mut v = vec![sub_curve(c, a, t1), sub_curve(c, t0, b)];
+ if !sense {
+ v.reverse();
+ v.iter_mut().for_each(|x| x.invert());
+ }
+ return Ok(v);
+ }
+ }
+ if b - a <= span * 1e-9 {
+ return Err("degenerate spline edge".into());
+ }
+ vec![sub_curve(c, a, b)]
+ };
+ if !sense {
+ pieces.reverse();
+ pieces.iter_mut().for_each(|x| x.invert());
+ }
+ Ok(pieces)
+}
+
+/// Kernel curves for an edge from `ps` to `pe`: one piece, or two for a closed edge (so no
+/// kernel edge starts and ends at the same vertex).
+pub(crate) fn edge_pieces(g: &CurveGeo, ps: mt::Point3, pe: mt::Point3, sense: bool, closed: bool, tol: f64) -> R<Vec<mt::Curve>> {
+ match g {
+ CurveGeo::Line { .. } => {
+ if closed {
+ return Err("closed straight edge".into());
+ }
+ Ok(vec![mt::Curve::Line(mt::Line(ps, pe))])
+ }
+ CurveGeo::Conic { f, a, b } => {
+ let (a, b) = (*a, *b);
+ let ts = conic_angle(f, a, b, ps);
+ let te = conic_angle(f, a, b, pe);
+ let mut sweep = if sense { te - ts } else { ts - te };
+ sweep = sweep.rem_euclid(TAU);
+ if closed || sweep < 1e-12 {
+ sweep = TAU;
+ }
+ let pieces: Vec<(f64, f64)> = if sweep > PI * 1.5 { vec![(0.0, sweep * 0.5), (sweep * 0.5, sweep)] } else { vec![(0.0, sweep)] };
+ Ok(pieces
+ .into_iter()
+ .map(|(s0, s1)| {
+ if sense {
+ mt::Curve::NurbsCurve(conic_arc(f, a, b, ts + s0, s1 - s0))
+ } else {
+ let mut c = conic_arc(f, a, b, ts - s1, s1 - s0);
+ c.invert();
+ mt::Curve::NurbsCurve(c)
+ }
+ })
+ .collect())
+ }
+ CurveGeo::BSpline(c) => Ok(spline_pieces(c, ps, pe, sense, closed, tol)?.into_iter().map(mt::Curve::BSplineCurve).collect()),
+ CurveGeo::Nurbs(c) => Ok(spline_pieces(c, ps, pe, sense, closed, tol)?.into_iter().map(mt::Curve::NurbsCurve).collect()),
+ }
+}
+
+/// A bounded kernel curve for a swept surface's profile (lines are bounded by `extent`).
+fn bounded_curve(g: &CurveGeo, extent: &[mt::Point3]) -> R<mt::Curve> {
+ Ok(match g {
+ CurveGeo::Line { p, d } => {
+ let (lo, hi) = span_along(extent, *p, *d);
+ mt::Curve::Line(mt::Line(*p + *d * lo, *p + *d * hi))
+ }
+ CurveGeo::Conic { f, a, b } => mt::Curve::NurbsCurve(conic_arc(f, *a, *b, 0.0, TAU)),
+ CurveGeo::BSpline(c) => mt::Curve::BSplineCurve(c.clone()),
+ CurveGeo::Nurbs(c) => mt::Curve::NurbsCurve(c.clone()),
+ })
+}
+
+/// Range of `(q - o)·d` over the points, widened by a margin.
+fn span_along(pts: &[mt::Point3], o: mt::Point3, d: mt::Vector3) -> (f64, f64) {
+ let (mut lo, mut hi) = (f64::INFINITY, f64::NEG_INFINITY);
+ for q in pts {
+ let t = (q - o).dot(d);
+ lo = lo.min(t);
+ hi = hi.max(t);
+ }
+ if !(lo.is_finite() && hi.is_finite()) {
+ return (-1.0, 1.0);
+ }
+ let m = (hi - lo) * 0.25 + 1e-3;
+ (lo - m, hi + m)
+}
+
+/// The angle shared by all the given angles (within 1e-4 rad), if there are any.
+fn common_angle(angles: impl Iterator<Item = f64>) -> Option<f64> {
+ let (mut sx, mut sy, mut n) = (0.0, 0.0, 0usize);
+ let mut all = Vec::new();
+ for a in angles {
+ sx += a.cos();
+ sy += a.sin();
+ n += 1;
+ all.push(a);
+ }
+ if n == 0 {
+ return None;
+ }
+ let m = sy.atan2(sx);
+ let close = all.iter().all(|a| {
+ let d = (a - m).rem_euclid(TAU);
+ d.min(TAU - d) < 1e-4
+ });
+ close.then_some(m)
+}
+
+/// Middle and width of the largest gap between angles (radians, any range).
+fn largest_gap(angles: &[f64]) -> Option<(f64, f64)> {
+ let mut a: Vec<f64> = angles.iter().map(|x| x.rem_euclid(TAU)).filter(|x| x.is_finite()).collect();
+ if a.is_empty() {
+ return None;
+ }
+ a.sort_by(f64::total_cmp);
+ let (mut best, mut mid) = (0.0, 0.0);
+ for i in 0..a.len() {
+ let (Some(&x), Some(&y)) = (a.get(i), a.get((i + 1) % a.len())) else { continue };
+ let gap = if i + 1 == a.len() { y + TAU - x } else { y - x };
+ if gap > best {
+ best = gap;
+ mid = x + gap * 0.5;
+ }
+ }
+ Some((mid, best))
+}
+
+/// The frame turned about its Z axis so that its X axis (the parameter seam of a revolved
+/// surface) lies in the widest angular gap of the face boundary.
+fn seam_frame(f: &Frame, extent: &[mt::Point3], seam: &[mt::Point3]) -> Frame {
+ // A seam edge of the face along the rotation: the parameter seam must be there.
+ if let Some(m) = common_angle(seam.iter().filter_map(|p| {
+ let d = p - f.o;
+ let (x, y) = (d.dot(f.x), d.dot(f.y));
+ (x.hypot(y) > 1e-6 * (1.0 + d.magnitude())).then(|| y.atan2(x))
+ })) {
+ let x = f.x * m.cos() + f.y * m.sin();
+ return Frame { o: f.o, x, y: f.z.cross(x), z: f.z };
+ }
+ let az: Vec<f64> = extent
+ .iter()
+ .filter_map(|p| {
+ let d = p - f.o;
+ let (x, y) = (d.dot(f.x), d.dot(f.y));
+ (x.hypot(y) > 1e-9).then(|| y.atan2(x))
+ })
+ .collect();
+ match largest_gap(&az) {
+ Some((m, gap)) if gap > 1e-3 => {
+ let x = f.x * m.cos() + f.y * m.sin();
+ Frame { o: f.o, x, y: f.z.cross(x), z: f.z }
+ }
+ _ => *f,
+ }
+}
+
+/// Polar axis for a sphere: far from every boundary point, and (for a face concentrated on
+/// one side) with both poles outside the face, so every loop closes in parameter space.
+fn sphere_axis(f: &Frame, extent: &[mt::Point3]) -> mt::Vector3 {
+ let dirs: Vec<mt::Vector3> = extent
+ .iter()
+ .filter_map(|p| {
+ let d = p - f.o;
+ let m = d.magnitude();
+ (m > 1e-12).then(|| d / m)
+ })
+ .collect();
+ if dirs.is_empty() {
+ return f.z;
+ }
+ let mean = dirs.iter().fold(mt::Vector3::new(0.0, 0.0, 0.0), |a, d| a + d) / dirs.len() as f64;
+ let concentrated = mean.magnitude() > 0.3;
+ let mhat = if concentrated { mean / mean.magnitude() } else { mean };
+ let n = 400;
+ let golden = PI * (3.0 - 5f64.sqrt());
+ let mut best = (f64::NEG_INFINITY, f.z);
+ // Half of a Fibonacci sphere (an axis and its opposite are the same poles).
+ for i in 0..n {
+ let z = 1.0 - (i as f64 + 0.5) / n as f64;
+ let r = (1.0 - z * z).max(0.0).sqrt();
+ let t = golden * i as f64;
+ let a = mt::Vector3::new(r * t.cos(), r * t.sin(), z);
+ if concentrated && a.dot(mhat).abs() > 0.35 {
+ continue;
+ }
+ let score = dirs.iter().map(|d| 1.0 - d.dot(a).abs()).fold(f64::INFINITY, f64::min);
+ if score > best.0 {
+ best = (score, a);
+ }
+ }
+ best.1
+}
+
+/// Tube angle of a point on a torus.
+fn tube_angle(f: &Frame, big: f64, p: mt::Point3) -> f64 {
+ let d = p - f.o;
+ let z = d.dot(f.z);
+ let rho = (d - f.z * z).magnitude();
+ z.atan2(rho - big)
+}
+
+fn revolved(curve: mt::Curve, o: mt::Point3, axis: mt::Vector3) -> mt::Surface {
+ mt::Surface::RevolutedCurve(mt::Processor::new(mt::RevolutedCurve::by_revolution(curve, o, axis)))
+}
+
+/// A surface of revolution whose normal at the profile point `(u, 0)` points along `expected`.
+/// The rotation is reversed rather than the surface inverted: truck's inverted `Processor`
+/// swaps the parameters but not the search hints, which breaks meshing.
+fn revolved_oriented(curve: mt::Curve, o: mt::Point3, axis: mt::Vector3, u: f64, expected: mt::Vector3) -> mt::Surface {
+ let s = revolved(curve.clone(), o, axis);
+ if s.normal(u, 0.0).dot(expected) >= 0.0 {
+ return s;
+ }
+ revolved(curve, o, -axis)
+}
+
+fn bspline_surface(cx: &Ctx, e: &Entity) -> R<mt::Surface> {
+ let (base, knots, kind): (Vec<Param>, Option<[Option<&Param>; 4]>, &str) = if e.is_complex() {
+ let b = e.record("B_SPLINE_SURFACE").ok_or("complex surface without B_SPLINE_SURFACE")?;
+ let mut base = vec![Param::Str(String::new())];
+ base.extend(b.iter().cloned());
+ let k = e.record("B_SPLINE_SURFACE_WITH_KNOTS").map(|k| [k.first(), k.get(1), k.get(2), k.get(3)]);
+ let kind = if e.has("BEZIER_SURFACE") {
+ "BEZIER"
+ } else if e.has("UNIFORM_SURFACE") {
+ "UNIFORM"
+ } else {
+ "QUASI"
+ };
+ (base, k, kind)
+ } else {
+ let p = e.params();
+ let k = (e.name() == "B_SPLINE_SURFACE_WITH_KNOTS").then(|| [p.get(8), p.get(9), p.get(10), p.get(11)]);
+ let kind = match e.name() {
+ "BEZIER_SURFACE" => "BEZIER",
+ "UNIFORM_SURFACE" => "UNIFORM",
+ _ => "QUASI",
+ };
+ (p.to_vec(), k, kind)
+ };
+ let deg = |i: usize| base.get(i).and_then(Param::as_i64).filter(|d| (1..=32).contains(d)).map(|d| d as usize).ok_or("bad B-spline degree");
+ let (du, dv) = (deg(1)?, deg(2)?);
+ let rows = base.get(3).and_then(Param::as_list).ok_or("B-spline surface without control points")?;
+ let mut ctrl: Vec<Vec<mt::Point3>> = Vec::with_capacity(rows.len());
+ let mut total = 0usize;
+ for r in rows {
+ let r = r.as_list().ok_or("bad control point row")?;
+ total += r.len();
+ if total > MAX_CTRL {
+ return Err("B-spline surface with too many control points".into());
+ }
+ ctrl.push(r.iter().map(|c| point(cx, c.as_ref_id().ok_or("bad control point")?)).collect::<R<_>>()?);
+ }
+ let nu = ctrl.len();
+ let nv = ctrl.first().map(Vec::len).unwrap_or(0);
+ if nu == 0 || ctrl.iter().any(|r| r.len() != nv) {
+ return Err("ragged B-spline control net".into());
+ }
+ let (ku, kv) = match knots {
+ Some([mu, mv, ku, kv]) => (knot_vec(mu, ku)?, knot_vec(mv, kv)?),
+ None => (generated_knots(kind, nu, du)?, generated_knots(kind, nv, dv)?),
+ };
+ if ku.len() != nu + du + 1 || kv.len() != nv + dv + 1 {
+ return Err("B-spline surface knot counts do not match the control net".into());
+ }
+ let bsp = mt::BSplineSurface::try_new((ku, kv), ctrl).map_err(|e| format!("B-spline surface: {e}"))?;
+ match e.record("RATIONAL_B_SPLINE_SURFACE") {
+ Some(r) => {
+ let w: Vec<Vec<f64>> = r
+ .first()
+ .and_then(Param::as_list)
+ .ok_or("rational surface without weights")?
+ .iter()
+ .map(|row| weights_list(Some(row)))
+ .collect::<R<_>>()?;
+ if w.len() != nu || w.iter().any(|r| r.len() != nv) {
+ return Err("weights do not match the control net".into());
+ }
+ let n = mt::NurbsSurface::<mt::Vector4>::try_from_bspline_and_weights(bsp, w).map_err(|e| format!("rational surface: {e}"))?;
+ Ok(mt::Surface::NurbsSurface(n))
+ }
+ None => Ok(mt::Surface::BSplineSurface(bsp)),
+ }
+}
+
+/// A STEP surface entity as a kernel surface whose normal is the STEP surface normal.
+/// `extent` holds points of the face boundary (bounds the analytic surfaces' parameter ranges).
+/// `sense` false gives the opposite normal (a face with `same_sense = .F.`).
+/// `seam` holds points of the face's seam edges (edges its loops use twice).
+pub(crate) fn surface(cx: &Ctx, id: u64, extent: &[mt::Point3], seam: &[mt::Point3], sense: bool, depth: usize) -> R<mt::Surface> {
+ let sign = if sense { 1.0 } else { -1.0 };
+ let flip = |mut s: mt::Surface| {
+ if !sense {
+ s.invert();
+ }
+ s
+ };
+ if depth > MAX_GEOM_DEPTH {
+ return Err("surface definitions nested too deeply".into());
+ }
+ let e = entity(cx, id)?;
+ if e.is_complex() {
+ return bspline_surface(cx, e).map(flip);
+ }
+ let p = e.params();
+ let placement = || -> R<Frame> { frame(cx, p.get(1).and_then(Param::as_ref_id).ok_or("surface without placement")?) };
+ match e.name() {
+ "PLANE" => {
+ let f = placement()?;
+ Ok(flip(mt::Surface::Plane(mt::Plane::new(f.o, f.o + f.x, f.o + f.y))))
+ }
+ "CYLINDRICAL_SURFACE" => {
+ let f = seam_frame(&placement()?, extent, seam);
+ let r = length(cx, p.get(2), "radius")?;
+ if r <= 0.0 {
+ return Err("cylinder radius must be positive".into());
+ }
+ let (lo, hi) = span_along(extent, f.o, f.z);
+ let line = mt::Curve::Line(mt::Line(f.at(r, 0.0, lo), f.at(r, 0.0, hi)));
+ Ok(revolved_oriented(line, f.o, f.z, 0.5, f.x * sign))
+ }
+ "CONICAL_SURFACE" => {
+ let f = seam_frame(&placement()?, extent, seam);
+ let r = length(cx, p.get(2), "radius")?;
+ let a = num(p.get(3), "semi angle")? * cx.ang;
+ if r < 0.0 || !(a.abs() > 1e-9 && a.abs() < FRAC_PI_2 - 1e-9) {
+ return Err("bad cone".into());
+ }
+ let t = a.tan();
+ let (mut lo, mut hi) = span_along(extent, f.o, f.z);
+ // Stop at the apex.
+ let apex = -r / t;
+ if t > 0.0 {
+ lo = lo.max(apex);
+ } else {
+ hi = hi.min(apex);
+ }
+ if hi - lo <= 1e-9 {
+ return Err("cone face has no extent".into());
+ }
+ let line = mt::Curve::Line(mt::Line(f.at(r + lo * t, 0.0, lo), f.at(r + hi * t, 0.0, hi)));
+ Ok(revolved_oriented(line, f.o, f.z, 0.5, (f.x * a.cos() - f.z * a.sin()) * sign))
+ }
+ "SPHERICAL_SURFACE" => {
+ let f = placement()?;
+ let r = length(cx, p.get(2), "radius")?;
+ if r <= 0.0 {
+ return Err("sphere radius must be positive".into());
+ }
+ // With seam edges the file's own parameterisation fits the loops; else pick poles
+ // away from the boundary.
+ let f = if seam.is_empty() {
+ let z = sphere_axis(&f, extent);
+ let x = any_perpendicular(z);
+ seam_frame(&Frame { o: f.o, x, y: z.cross(x), z }, extent, seam)
+ } else {
+ seam_frame(&f, extent, seam)
+ };
+ let half = Frame { o: f.o, x: f.x, y: f.z, z: -f.y };
+ let arc = conic_arc(&half, r, r, -FRAC_PI_2, PI);
+ let um = (arc.range_tuple().0 + arc.range_tuple().1) * 0.5;
+ Ok(revolved_oriented(mt::Curve::NurbsCurve(arc), f.o, f.z, um, f.x * sign))
+ }
+ "TOROIDAL_SURFACE" => {
+ let f = placement()?;
+ let (big, small) = (length(cx, p.get(2), "major radius")?, length(cx, p.get(3), "minor radius")?);
+ if small <= 0.0 || big < 0.0 {
+ return Err("bad torus radii".into());
+ }
+ // Seam edges either run around the axis (constant tube angle) or around the tube
+ // (constant azimuth); each fixes one parameter seam.
+ let tube_seam: Vec<mt::Point3> =
+ seam.iter().copied().filter(|p| common_angle(std::iter::once(tube_angle(&f, big, *p))).is_some()).collect();
+ let phis_seam = common_angle(tube_seam.iter().map(|p| tube_angle(&f, big, *p)));
+ let az_seam: Vec<mt::Point3> = if phis_seam.is_some() { Vec::new() } else { seam.to_vec() };
+ let f = seam_frame(&f, extent, &az_seam);
+ let phis: Vec<f64> = extent.iter().map(|p| tube_angle(&f, big, *p)).collect();
+ let phi0 = match (phis_seam, largest_gap(&phis)) {
+ (Some(m), _) => m,
+ (None, Some((m, _))) => m,
+ (None, None) => 0.0,
+ };
+ let tube = Frame { o: f.at(big, 0.0, 0.0), x: f.x, y: f.z, z: -f.y };
+ let circle = conic_arc(&tube, small, small, phi0, TAU);
+ let u0 = circle.range_tuple().0;
+ let outward = f.x * phi0.cos() + f.z * phi0.sin();
+ Ok(revolved_oriented(mt::Curve::NurbsCurve(circle), f.o, f.z, u0, outward * sign))
+ }
+ "B_SPLINE_SURFACE_WITH_KNOTS" | "BEZIER_SURFACE" | "UNIFORM_SURFACE" | "QUASI_UNIFORM_SURFACE" => bspline_surface(cx, e).map(flip),
+ "SURFACE_OF_REVOLUTION" => {
+ let g = curve(cx, p.get(1).and_then(Param::as_ref_id).ok_or("revolution without profile")?, depth + 1)?;
+ let (o, axis) = axis1(cx, p.get(2).and_then(Param::as_ref_id).ok_or("revolution without axis")?)?;
+ // Reversed sense: turn the other way round the axis.
+ Ok(revolved(bounded_curve(&g, extent)?, o, axis * sign))
+ }
+ "SURFACE_OF_LINEAR_EXTRUSION" => {
+ let g = curve(cx, p.get(1).and_then(Param::as_ref_id).ok_or("extrusion without profile")?, depth + 1)?;
+ let (_, v) = ent_of(cx, p.get(2), "extrusion vector")?;
+ let d = direction(cx, v.params().get(1).and_then(Param::as_ref_id).ok_or("VECTOR without direction")?)?;
+ let nurbs: mt::NurbsCurve<mt::Vector4> = match bounded_curve(&g, extent)? {
+ mt::Curve::Line(l) => mt::BSplineCurve::new(mt::KnotVec::bezier_knot(1), vec![l.0, l.1]).into(),
+ mt::Curve::BSplineCurve(c) => c.into(),
+ mt::Curve::NurbsCurve(c) => c,
+ mt::Curve::IntersectionCurve(_) => return Err("unsupported extrusion profile".into()),
+ };
+ let (t0, t1) = nurbs.range_tuple();
+ let profile: Vec<mt::Point3> = (0..=32).map(|i| nurbs.subs(t0 + (t1 - t0) * i as f64 / 32.0)).collect();
+ let (plo, phi) = span_along(&profile, mt::Point3::new(0.0, 0.0, 0.0), d);
+ let (elo, ehi) = span_along(extent, mt::Point3::new(0.0, 0.0, 0.0), d);
+ let (lo, hi) = (elo - phi, ehi - plo);
+ let bsp = nurbs.into_non_rationalized();
+ let shift = |w: &mt::Vector4, s: f64| mt::Vector4::new(w.x + d.x * s * w.w, w.y + d.y * s * w.w, w.z + d.z * s * w.w, w.w);
+ let ctrl: Vec<Vec<mt::Vector4>> = bsp.control_points().iter().map(|w| vec![shift(w, lo), shift(w, hi)]).collect();
+ let s =
+ mt::BSplineSurface::try_new((bsp.knot_vec().clone(), mt::KnotVec::bezier_knot(1)), ctrl).map_err(|e| format!("extrusion: {e}"))?;
+ Ok(flip(mt::Surface::NurbsSurface(mt::NurbsSurface::new(s))))
+ }
+ "RECTANGULAR_TRIMMED_SURFACE" | "CURVE_BOUNDED_SURFACE" => {
+ surface(cx, p.get(1).and_then(Param::as_ref_id).ok_or("trimmed surface without basis")?, extent, seam, sense, depth + 1)
+ }
+ n => Err(format!("unsupported surface {n}")),
+ }
+}
diff --git a/crates/kernel/src/step_in/mod.rs b/crates/kernel/src/step_in/mod.rs
new file mode 100644
index 0000000000..06d9314b62
--- /dev/null
+++ b/crates/kernel/src/step_in/mod.rs
@@ -0,0 +1,638 @@
+//! STEP import (ISO 10303-21 files, AP203/AP214/AP242 geometry).
+//!
+//! Our own reader, written from the public standards: [`p21`] parses the exchange structure,
+//! [`geom`] and [`brep`] turn geometry and topology into kernel solids, and this module walks
+//! the product structure (products, shape representations, assemblies with their placements,
+//! units, colours). STEP files are untrusted: every count and nesting depth is capped, every
+//! truck call runs under [`guard`], and what cannot be read becomes a warning rather than a
+//! failure wherever the rest of the file is still usable.
+
+mod brep;
+mod geom;
+pub(crate) mod p21;
+mod split;
+
+use std::collections::{BTreeMap, HashMap, HashSet};
+
+use serde::{Deserialize, Serialize};
+use truck_modeling as mt;
+
+use crate::body::Body;
+use crate::{KernelError, Result, guard};
+use geom::R;
+use p21::{Entity, Exchange, Param};
+
+/// Deepest assembly nesting followed.
+const MAX_ASSEMBLY_DEPTH: usize = 32;
+/// Most body instances in one import.
+const MAX_BODIES: usize = 10_000;
+
+/// A body read from a STEP file.
+#[derive(Clone, Debug)]
+pub struct ImportedBody {
+ /// Solid name (the brep's label), else the product name.
+ pub name: String,
+ pub body: Body,
+ /// Surface colour (linear-ish RGB 0..1) from the file's presentation styles.
+ pub color: Option<[f32; 3]>,
+ /// Product names from the root to the part that holds the body.
+ pub path: Vec<String>,
+ /// The body is a closed solid (false: faces were left out, or the file had a surface model).
+ pub closed: bool,
+ /// Faces read from the file. The body can have more: a face that wraps all the way around
+ /// a closed surface is split in two for the kernel.
+ pub file_faces: usize,
+}
+
+/// One product occurrence in the file's assembly tree.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StepNode {
+ pub name: String,
+ /// Placement in the parent (column-major 4×4, millimetres).
+ pub transform: [[f64; 4]; 4],
+ /// Indices into [`StepImport::bodies`] of this product's own bodies.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub bodies: Vec<usize>,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub children: Vec<StepNode>,
+}
+
+/// Result of [`step_import`].
+#[derive(Clone, Debug)]
+pub struct StepImport {
+ pub bodies: Vec<ImportedBody>,
+ /// Root products (an assembly tree; a plain part is a single root).
+ pub tree: Vec<StepNode>,
+ /// What could not be read (unsupported entities, faces left out…).
+ pub warnings: Vec<String>,
+ /// FILE_SCHEMA (e.g. `AUTOMOTIVE_DESIGN`, `CONFIG_CONTROL_DESIGN`, `AP242_…`).
+ pub schema: String,
+ /// FILE_NAME originating system.
+ pub system: String,
+}
+
+/// Reading context: the file and the units of the representation being read.
+pub(crate) struct Ctx<'a> {
+ pub ex: &'a Exchange,
+ /// Millimetres per file length unit.
+ pub len: f64,
+ /// Radians per file angle unit.
+ pub ang: f64,
+ /// Vertex-on-curve tolerance (mm).
+ pub tol: f64,
+}
+
+#[derive(Clone, Copy)]
+struct Units {
+ len: f64,
+ ang: f64,
+ tol: f64,
+}
+
+const DEFAULT_UNITS: Units = Units { len: 1.0, ang: 1.0, tol: 0.01 };
+
+fn si_prefix(p: Option<&Param>) -> f64 {
+ match p.and_then(Param::as_enum) {
+ Some("EXA") => 1e18,
+ Some("PETA") => 1e15,
+ Some("TERA") => 1e12,
+ Some("GIGA") => 1e9,
+ Some("MEGA") => 1e6,
+ Some("KILO") => 1e3,
+ Some("HECTO") => 1e2,
+ Some("DECA") => 1e1,
+ Some("DECI") => 1e-1,
+ Some("CENTI") => 1e-2,
+ Some("MILLI") => 1e-3,
+ Some("MICRO") => 1e-6,
+ Some("NANO") => 1e-9,
+ Some("PICO") => 1e-12,
+ Some("FEMTO") => 1e-15,
+ Some("ATTO") => 1e-18,
+ _ => 1.0,
+ }
+}
+
+/// A unit's size: millimetres for lengths, radians for plane angles.
+fn unit_factor(ex: &Exchange, id: u64, depth: usize) -> Option<(&'static str, f64)> {
+ if depth > 4 {
+ return None;
+ }
+ let e = ex.get(id)?;
+ let kind = if e.has("LENGTH_UNIT") {
+ "length"
+ } else if e.has("PLANE_ANGLE_UNIT") {
+ "angle"
+ } else {
+ "other"
+ };
+ if let Some(si) = e.record("SI_UNIT") {
+ let base = match si.get(1).and_then(Param::as_enum) {
+ Some("METRE") => 1000.0,
+ Some("RADIAN") => 1.0,
+ _ => return Some((kind, 1.0)),
+ };
+ return Some((kind, si_prefix(si.first()) * base));
+ }
+ if let Some(cb) = e.record("CONVERSION_BASED_UNIT") {
+ let m = ex.get(cb.get(1)?.as_ref_id()?)?;
+ let mp = m.params();
+ let v = mp.first()?.as_f64()?;
+ let (_, f) = unit_factor(ex, mp.get(1)?.as_ref_id()?, depth + 1)?;
+ let x = v * f;
+ return (x.is_finite() && x > 0.0).then_some((kind, x));
+ }
+ Some((kind, 1.0))
+}
+
+/// Units of a representation context (GLOBAL_UNIT_ASSIGNED_CONTEXT, uncertainty).
+fn context_units(ex: &Exchange, ctx: Option<u64>, cache: &mut HashMap<u64, Units>) -> Units {
+ let Some(id) = ctx else { return DEFAULT_UNITS };
+ if let Some(u) = cache.get(&id) {
+ return *u;
+ }
+ let mut u = DEFAULT_UNITS;
+ let mut tol_file = None;
+ if let Some(e) = ex.get(id) {
+ if let Some(units) = e.record("GLOBAL_UNIT_ASSIGNED_CONTEXT").and_then(|r| r.first()).and_then(Param::as_list) {
+ for uid in units.iter().filter_map(Param::as_ref_id) {
+ match unit_factor(ex, uid, 0) {
+ Some(("length", f)) if f.is_finite() && f > 0.0 => u.len = f,
+ Some(("angle", f)) if f.is_finite() && f > 0.0 => u.ang = f,
+ _ => {}
+ }
+ }
+ }
+ if let Some(unc) = e.record("GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT").and_then(|r| r.first()).and_then(Param::as_list) {
+ for uid in unc.iter().filter_map(Param::as_ref_id) {
+ if let Some(m) = ex.get(uid)
+ && let Some(v) = m.params().first().and_then(Param::as_f64)
+ {
+ let f = m.params().get(1).and_then(Param::as_ref_id).and_then(|x| unit_factor(ex, x, 0)).map(|x| x.1);
+ tol_file = Some(v * f.unwrap_or(u.len));
+ }
+ }
+ }
+ }
+ u.tol = tol_file.filter(|t| t.is_finite() && *t > 0.0).map(|t| (t * 10.0).max(1e-3)).unwrap_or(u.len * 1e-2).clamp(1e-4, 1.0);
+ cache.insert(id, u);
+ u
+}
+
+/// Items and context of a representation entity.
+fn representation(e: &Entity) -> Option<(Vec<u64>, Option<u64>)> {
+ let p = if e.is_complex() {
+ e.record("REPRESENTATION")
+ .or_else(|| e.records.iter().find(|r| r.name.ends_with("REPRESENTATION") && r.params.len() >= 3).map(|r| r.params.as_slice()))?
+ } else if e.name().ends_with("REPRESENTATION") {
+ e.params()
+ } else {
+ return None;
+ };
+ let items = p.get(1)?.as_list()?.iter().filter_map(Param::as_ref_id).collect();
+ Some((items, p.get(2).and_then(Param::as_ref_id)))
+}
+
+fn mat_mul(a: &mt::Matrix4, b: &mt::Matrix4) -> mt::Matrix4 {
+ a * b
+}
+
+fn to_array(m: &mt::Matrix4) -> [[f64; 4]; 4] {
+ [[m.x.x, m.x.y, m.x.z, m.x.w], [m.y.x, m.y.y, m.y.z, m.y.w], [m.z.x, m.z.y, m.z.z, m.z.w], [m.w.x, m.w.y, m.w.z, m.w.w]]
+}
+
+/// Inverse of a rigid placement matrix (orthonormal rotation + translation).
+fn rigid_inverse(m: &mt::Matrix4) -> mt::Matrix4 {
+ use mt::SquareMatrix;
+ m.invert().unwrap_or_else(mt::Matrix4::identity)
+}
+
+struct Reader<'a> {
+ ex: &'a Exchange,
+ units: HashMap<u64, Units>,
+ warnings: BTreeMap<String, usize>,
+ /// Representation → its items and context.
+ reps: HashMap<u64, (Vec<u64>, Option<u64>)>,
+ /// Plain representation relationships (same product, no placement).
+ rep_links: HashMap<u64, Vec<u64>>,
+ /// Product definition → its shape representations.
+ pd_reps: HashMap<u64, Vec<u64>>,
+ /// Product definition → child occurrences (NAUO ids).
+ children: HashMap<u64, Vec<u64>>,
+ /// NAUO → placement relationship entity.
+ placements: HashMap<u64, u64>,
+ /// Styled item → colour.
+ colors: HashMap<u64, [f32; 3]>,
+ /// Converted items (brep id → solid, or the error).
+ solids: HashMap<u64, std::result::Result<(mt::Solid, bool, usize), String>>,
+ used_items: HashSet<u64>,
+ /// Items already instanced for the product being read.
+ node_items: HashSet<u64>,
+ bodies: Vec<ImportedBody>,
+}
+
+impl<'a> Reader<'a> {
+ fn warn(&mut self, msg: impl Into<String>) {
+ *self.warnings.entry(msg.into()).or_default() += 1;
+ }
+
+ fn index(&mut self) {
+ let ex = self.ex;
+ let mut pds: HashMap<u64, u64> = HashMap::new(); // PDS → definition
+ let mut sdrs: Vec<(u64, u64)> = Vec::new(); // (PDS, rep)
+ let mut cdsrs: Vec<(u64, u64)> = Vec::new(); // (relationship, PDS)
+ let mut nauos: Vec<(u64, u64, u64)> = Vec::new(); // (id, parent, child)
+ let mut ids: Vec<&u64> = ex.entities.keys().collect();
+ ids.sort();
+ for &id in ids {
+ let Some(e) = ex.get(id) else { continue };
+ if let Some(r) = representation(e) {
+ self.reps.insert(id, r);
+ }
+ let p = e.params();
+ let rf = |i: usize| p.get(i).and_then(Param::as_ref_id);
+ match e.name() {
+ "PRODUCT_DEFINITION_SHAPE" | "PROPERTY_DEFINITION" => {
+ if let Some(d) = rf(2) {
+ pds.insert(id, d);
+ }
+ }
+ "SHAPE_DEFINITION_REPRESENTATION" => {
+ if let (Some(d), Some(r)) = (rf(0), rf(1)) {
+ sdrs.push((d, r));
+ }
+ }
+ "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION" => {
+ if let (Some(r), Some(d)) = (rf(0), rf(1)) {
+ cdsrs.push((r, d));
+ }
+ }
+ "NEXT_ASSEMBLY_USAGE_OCCURRENCE" | "ASSEMBLY_COMPONENT_USAGE" | "SPECIFIED_HIGHER_USAGE_OCCURRENCE" => {
+ if let (Some(a), Some(b)) = (rf(3), rf(4)) {
+ nauos.push((id, a, b));
+ }
+ }
+ "SHAPE_REPRESENTATION_RELATIONSHIP" | "REPRESENTATION_RELATIONSHIP" if !e.is_complex() => {
+ if let (Some(a), Some(b)) = (rf(2), rf(3)) {
+ self.rep_links.entry(a).or_default().push(b);
+ self.rep_links.entry(b).or_default().push(a);
+ }
+ }
+ "STYLED_ITEM" | "OVER_RIDING_STYLED_ITEM" => {
+ if let Some(item) = rf(2)
+ && let Some(c) = self.find_colour(p.get(1))
+ {
+ self.colors.entry(item).or_insert(c);
+ }
+ }
+ _ => {}
+ }
+ }
+ for (d, r) in sdrs {
+ if let Some(&pd) = pds.get(&d) {
+ self.pd_reps.entry(pd).or_default().push(r);
+ }
+ }
+ for (r, d) in cdsrs {
+ if let Some(&nauo) = pds.get(&d) {
+ self.placements.insert(nauo, r);
+ }
+ }
+ for (id, parent, child) in nauos {
+ if parent != child {
+ self.children.entry(parent).or_default().push(id);
+ }
+ }
+ }
+
+ /// First colour reachable from a style list (bounded search).
+ fn find_colour(&self, styles: Option<&Param>) -> Option<[f32; 3]> {
+ let mut queue: Vec<u64> = styles?.as_list()?.iter().filter_map(Param::as_ref_id).collect();
+ let mut seen = HashSet::new();
+ while let Some(id) = queue.pop() {
+ if seen.len() > 64 || !seen.insert(id) {
+ continue;
+ }
+ let e = self.ex.get(id)?;
+ if e.name() == "COLOUR_RGB" {
+ let p = e.params();
+ let c = |i: usize| p.get(i).and_then(Param::as_f64).map(|x| x.clamp(0.0, 1.0) as f32);
+ return Some([c(1)?, c(2)?, c(3)?]);
+ }
+ if e.name() == "DRAUGHTING_PRE_DEFINED_COLOUR" {
+ return Some(match e.params().first().and_then(Param::as_str).unwrap_or("") {
+ "red" => [1.0, 0.0, 0.0],
+ "green" => [0.0, 1.0, 0.0],
+ "blue" => [0.0, 0.0, 1.0],
+ "yellow" => [1.0, 1.0, 0.0],
+ "magenta" => [1.0, 0.0, 1.0],
+ "cyan" => [0.0, 1.0, 1.0],
+ "black" => [0.0, 0.0, 0.0],
+ _ => [1.0, 1.0, 1.0],
+ });
+ }
+ fn walk(p: &Param, out: &mut Vec<u64>, depth: usize) {
+ match p {
+ Param::Ref(r) => out.push(*r),
+ Param::List(v) | Param::Typed(_, v) if depth < 4 => v.iter().for_each(|x| walk(x, out, depth + 1)),
+ _ => {}
+ }
+ }
+ for r in &e.records {
+ for p in &r.params {
+ walk(p, &mut queue, 0);
+ }
+ }
+ }
+ None
+ }
+
+ fn units_of(&mut self, rep: u64) -> Units {
+ let ctx = self.reps.get(&rep).and_then(|r| r.1);
+ context_units(self.ex, ctx, &mut self.units)
+ }
+
+ fn placement_matrix(&mut self, item: u64, u: Units) -> R<mt::Matrix4> {
+ let cx = Ctx { ex: self.ex, len: u.len, ang: u.ang, tol: u.tol };
+ let e = geom::entity(&cx, item)?;
+ if e.name() == "CARTESIAN_TRANSFORMATION_OPERATOR_3D" {
+ let p = e.params();
+ let o = geom::point(&cx, p.get(4).and_then(Param::as_ref_id).ok_or("transformation without origin")?)?;
+ return Ok(mt::Matrix4::from_translation(o.to_homogeneous().truncate()));
+ }
+ Ok(geom::frame(&cx, item)?.matrix())
+ }
+
+ /// Representations of a product (its own shape representations and those linked to them).
+ fn rep_closure(&self, roots: &[u64]) -> Vec<u64> {
+ let mut seen: Vec<u64> = Vec::new();
+ let mut stack: Vec<u64> = roots.to_vec();
+ while let Some(r) = stack.pop() {
+ if seen.contains(&r) || seen.len() > 1024 {
+ continue;
+ }
+ seen.push(r);
+ if let Some(l) = self.rep_links.get(&r) {
+ stack.extend(l.iter().copied());
+ }
+ }
+ seen
+ }
+
+ fn item_solid(&mut self, item: u64, u: Units) -> Option<(mt::Solid, bool, usize)> {
+ if let Some(r) = self.solids.get(&item) {
+ return r.as_ref().ok().cloned();
+ }
+ let cx = Ctx { ex: self.ex, len: u.len, ang: u.ang, tol: u.tol };
+ let r = match guard("step brep", || brep::read_item(&cx, item).map_err(KernelError::Failed)) {
+ Ok(out) => {
+ let label = self.label(item);
+ for f in &out.failed {
+ self.warn(format!("{label}: {f}"));
+ }
+ if !out.closed {
+ self.warn(format!("{label}: imported as an open body (the shell is not closed)"));
+ }
+ Ok((out.solid, out.closed, out.file_faces))
+ }
+ Err(e) => {
+ let label = self.label(item);
+ let msg = e.to_string().trim_start_matches("the operation failed: ").to_string();
+ self.warn(format!("{label}: not imported: {msg}"));
+ Err(msg)
+ }
+ };
+ self.solids.insert(item, r.clone());
+ r.ok()
+ }
+
+ fn label(&self, item: u64) -> String {
+ let name = self.ex.get(item).and_then(|e| e.params().first()).and_then(Param::as_str).unwrap_or("").trim().to_string();
+ if name.is_empty() { format!("solid #{item}") } else { format!("solid '{name}'") }
+ }
+
+ /// Bodies of a representation's items (following mapped items), placed by `m`.
+ fn rep_bodies(&mut self, rep: u64, m: &mt::Matrix4, path: &[String], product: &str, out: &mut Vec<usize>, depth: usize) {
+ if depth > MAX_ASSEMBLY_DEPTH {
+ self.warn("mapped items nested too deeply");
+ return;
+ }
+ let u = self.units_of(rep);
+ let items = self.reps.get(&rep).map(|r| r.0.clone()).unwrap_or_default();
+ for item in items {
+ let Some(e) = self.ex.get(item) else { continue };
+ match e.name() {
+ "MANIFOLD_SOLID_BREP" | "BREP_WITH_VOIDS" | "FACETED_BREP" | "SHELL_BASED_SURFACE_MODEL" => {
+ self.used_items.insert(item);
+ if !self.node_items.insert(item) {
+ continue;
+ }
+ if self.bodies.len() >= MAX_BODIES {
+ self.warn(format!("more than {MAX_BODIES} bodies: the rest are left out"));
+ return;
+ }
+ let Some((solid, closed, file_faces)) = self.item_solid(item, u) else { continue };
+ let identity = *m == mt::Matrix4::from_scale(1.0);
+ let placed = if identity {
+ Ok(solid)
+ } else {
+ let mm = *m;
+ guard("step placement", || Ok(mt::builder::transformed(&solid, mm)))
+ };
+ let body = placed.and_then(Body::new);
+ match body {
+ Ok(body) => {
+ let own = e.params().first().and_then(Param::as_str).unwrap_or("").trim().to_string();
+ let name = if own.is_empty() { product.to_string() } else { own };
+ out.push(self.bodies.len());
+ self.bodies.push(ImportedBody {
+ name,
+ body,
+ color: self.colors.get(&item).copied(),
+ path: path.to_vec(),
+ closed,
+ file_faces,
+ });
+ }
+ Err(err) => {
+ let label = self.label(item);
+ self.warn(format!("{label}: not imported: {err}"));
+ }
+ }
+ }
+ "MAPPED_ITEM" => {
+ let p = e.params();
+ let (Some(map), Some(target)) = (p.get(1).and_then(Param::as_ref_id), p.get(2).and_then(Param::as_ref_id)) else { continue };
+ let Some(me) = self.ex.get(map) else { continue };
+ let (Some(origin), Some(mapped)) =
+ (me.params().first().and_then(Param::as_ref_id), me.params().get(1).and_then(Param::as_ref_id))
+ else {
+ continue;
+ };
+ let mu = self.units_of(mapped);
+ match (self.placement_matrix(target, u), self.placement_matrix(origin, mu)) {
+ (Ok(t), Ok(o)) => {
+ let mm = mat_mul(m, &mat_mul(&t, &rigid_inverse(&o)));
+ for r in self.rep_closure(&[mapped]) {
+ self.rep_bodies(r, &mm, path, product, out, depth + 1);
+ }
+ }
+ (Err(e), _) | (_, Err(e)) => self.warn(format!("mapped item #{item}: {e}")),
+ }
+ }
+ _ => {}
+ }
+ }
+ }
+
+ fn product_name(&self, pd: u64) -> String {
+ let name = (|| {
+ let pdf = self.ex.get(self.ex.get(pd)?.params().get(2)?.as_ref_id()?)?;
+ let prod = self.ex.get(pdf.params().get(2)?.as_ref_id()?)?;
+ let p = prod.params();
+ let n = p.get(1).and_then(Param::as_str).filter(|s| !s.trim().is_empty()).or_else(|| p.first().and_then(Param::as_str))?;
+ Some(n.trim().to_string())
+ })();
+ name.filter(|n| !n.is_empty()).unwrap_or_else(|| "Import".into())
+ }
+
+ /// Placement of a child occurrence in its parent.
+ fn occurrence_matrix(&mut self, nauo: u64, child_reps: &[u64]) -> mt::Matrix4 {
+ let Some(&rel) = self.placements.get(&nauo) else { return mt::Matrix4::from_scale(1.0) };
+ let r = (|| -> R<mt::Matrix4> {
+ let e = self.ex.get(rel).ok_or("missing placement")?;
+ let rr = e.record("REPRESENTATION_RELATIONSHIP").ok_or("placement without representations")?;
+ let (r1, r2) =
+ (rr.get(2).and_then(Param::as_ref_id).ok_or("bad placement")?, rr.get(3).and_then(Param::as_ref_id).ok_or("bad placement")?);
+ let op = e
+ .record("REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION")
+ .and_then(|x| x.first())
+ .and_then(Param::as_ref_id)
+ .ok_or("placement without transformation")?;
+ let ope = self.ex.get(op).ok_or("missing transformation")?;
+ let (u1, u2) = (self.units_of(r1), self.units_of(r2));
+ if ope.name() == "ITEM_DEFINED_TRANSFORMATION" {
+ let p = ope.params();
+ let (i1, i2) = (
+ p.get(2).and_then(Param::as_ref_id).ok_or("bad transformation")?,
+ p.get(3).and_then(Param::as_ref_id).ok_or("bad transformation")?,
+ );
+ let m1 = self.placement_matrix(i1, u1)?;
+ let m2 = self.placement_matrix(i2, u2)?;
+ // rep_1 is normally the component: map its item onto the assembly's item.
+ let child_is_1 = child_reps.contains(&r1) || !child_reps.contains(&r2);
+ Ok(if child_is_1 { mat_mul(&m2, &rigid_inverse(&m1)) } else { mat_mul(&m1, &rigid_inverse(&m2)) })
+ } else {
+ self.placement_matrix(op, u2)
+ }
+ })();
+ match r {
+ Ok(m) => m,
+ Err(e) => {
+ self.warn(format!("component placement #{rel}: {e} (placed at the origin)"));
+ mt::Matrix4::from_scale(1.0)
+ }
+ }
+ }
+
+ fn node(&mut self, pd: u64, local: mt::Matrix4, world: mt::Matrix4, path: &[String], depth: usize, stack: &mut Vec<u64>) -> StepNode {
+ let name = self.product_name(pd);
+ let mut node = StepNode { name: name.clone(), transform: to_array(&local), bodies: Vec::new(), children: Vec::new() };
+ if depth > MAX_ASSEMBLY_DEPTH || stack.contains(&pd) {
+ self.warn("assembly nested too deeply or recursive: some components were left out");
+ return node;
+ }
+ stack.push(pd);
+ let mut path = path.to_vec();
+ path.push(name.clone());
+ let own = self.pd_reps.get(&pd).cloned().unwrap_or_default();
+ let reps = self.rep_closure(&own);
+ let mut bodies = Vec::new();
+ self.node_items.clear();
+ for r in &reps {
+ self.rep_bodies(*r, &world, &path, &name, &mut bodies, 0);
+ }
+ node.bodies = bodies;
+ for nauo in self.children.get(&pd).cloned().unwrap_or_default() {
+ let Some(child) = self.ex.get(nauo).and_then(|e| e.params().get(4)).and_then(Param::as_ref_id) else { continue };
+ let child_own = self.pd_reps.get(&child).cloned().unwrap_or_default();
+ let child_reps = self.rep_closure(&child_own);
+ let m = self.occurrence_matrix(nauo, &child_reps);
+ let w = mat_mul(&world, &m);
+ let c = self.node(child, m, w, &path, depth + 1, stack);
+ node.children.push(c);
+ }
+ stack.pop();
+ node
+ }
+}
+
+/// Read a STEP file: its solids (as bodies, placed by the assembly structure) and the tree.
+pub fn step_import(text: &str) -> Result<StepImport> {
+ let ex = p21::parse(text).map_err(KernelError::Invalid)?;
+ let mut rd = Reader {
+ ex: &ex,
+ units: HashMap::new(),
+ warnings: BTreeMap::new(),
+ reps: HashMap::new(),
+ rep_links: HashMap::new(),
+ pd_reps: HashMap::new(),
+ children: HashMap::new(),
+ placements: HashMap::new(),
+ colors: HashMap::new(),
+ solids: HashMap::new(),
+ used_items: HashSet::new(),
+ node_items: HashSet::new(),
+ bodies: Vec::new(),
+ };
+ rd.index();
+ // Roots: product definitions that are nobody's component.
+ let child_pds: HashSet<u64> =
+ rd.children.values().flatten().filter_map(|n| ex.get(*n).and_then(|e| e.params().get(4)).and_then(Param::as_ref_id)).collect();
+ let mut roots: Vec<u64> =
+ ex.entities.iter().filter(|(id, e)| e.name() == "PRODUCT_DEFINITION" && !child_pds.contains(id)).map(|(id, _)| *id).collect();
+ roots.sort();
+ let identity = mt::Matrix4::from_scale(1.0);
+ let mut tree = Vec::new();
+ for pd in roots {
+ let n = rd.node(pd, identity, identity, &[], 0, &mut Vec::new());
+ if !n.bodies.is_empty() || !n.children.is_empty() {
+ tree.push(n);
+ }
+ }
+ // Solids outside any product structure (bare geometry files).
+ let mut loose: Vec<u64> = rd
+ .reps
+ .iter()
+ .flat_map(|(r, (items, _))| items.iter().map(move |i| (*r, *i)))
+ .filter(|(_, i)| !rd.used_items.contains(i))
+ .filter(|(_, i)| {
+ ex.get(*i).is_some_and(|e| matches!(e.name(), "MANIFOLD_SOLID_BREP" | "BREP_WITH_VOIDS" | "FACETED_BREP" | "SHELL_BASED_SURFACE_MODEL"))
+ })
+ .map(|(r, _)| r)
+ .collect();
+ loose.sort();
+ loose.dedup();
+ if !loose.is_empty() {
+ let mut bodies = Vec::new();
+ rd.node_items = rd.used_items.clone();
+ for r in loose {
+ rd.rep_bodies(r, &identity, &[], "Import", &mut bodies, 0);
+ }
+ if !bodies.is_empty() {
+ tree.push(StepNode { name: "Import".into(), transform: to_array(&identity), bodies, children: Vec::new() });
+ }
+ }
+ if let Some(first) = ex.duplicates.first() {
+ rd.warn(format!("{} entity ids are defined twice (first #{first}); the first definitions were used", ex.duplicates.len()));
+ }
+ let warnings: Vec<String> = rd.warnings.iter().map(|(m, n)| if *n > 1 { format!("{m} (×{n})") } else { m.clone() }).collect();
+ if rd.bodies.is_empty() {
+ let why = warnings.first().cloned().unwrap_or_else(|| "the file has no solids".into());
+ return Err(KernelError::Failed(format!("STEP import: no bodies ({why})")));
+ }
+ Ok(StepImport { bodies: rd.bodies, tree, warnings, schema: ex.schemas.join(", "), system: ex.originating_system.clone() })
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/kernel/src/step_in/p21.rs b/crates/kernel/src/step_in/p21.rs
new file mode 100644
index 0000000000..996583cb49
--- /dev/null
+++ b/crates/kernel/src/step_in/p21.rs
@@ -0,0 +1,551 @@
+//! ISO 10303-21 ("Part 21") exchange structure parser: the HEADER and the DATA section's entity
+//! instances, simple (`#1=NAME(...)`) and complex (`#2=(A(...) B(...))`). Written from the
+//! public standard. Input is hostile: sizes, entity counts and nesting depth are capped and every
+//! error is a message, never a panic.
+
+use std::collections::HashMap;
+
+/// Largest STEP text we parse.
+pub const MAX_BYTES: usize = 512 << 20;
+/// Most entity instances in one file.
+pub const MAX_ENTITIES: usize = 20_000_000;
+/// Deepest parameter list nesting.
+const MAX_DEPTH: usize = 64;
+
+/// A parameter value.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Param {
+ Int(i64),
+ Real(f64),
+ Str(String),
+ /// `.NAME.` (`.T.`/`.F.` included).
+ Enum(String),
+ Ref(u64),
+ List(Vec<Param>),
+ /// `NAME(params)` (a typed value such as `LENGTH_MEASURE(1.)`).
+ Typed(String, Vec<Param>),
+ Binary(String),
+ /// `$`
+ Null,
+ /// `*`
+ Derived,
+}
+
+impl Param {
+ pub fn as_f64(&self) -> Option<f64> {
+ match self {
+ Param::Real(x) => Some(*x).filter(|x| x.is_finite()),
+ Param::Int(i) => Some(*i as f64),
+ Param::Typed(_, v) if v.len() == 1 => v.first().and_then(Param::as_f64),
+ _ => None,
+ }
+ }
+ pub fn as_i64(&self) -> Option<i64> {
+ match self {
+ Param::Int(i) => Some(*i),
+ Param::Real(x) if x.fract() == 0.0 && x.abs() < 9e15 => Some(*x as i64),
+ _ => None,
+ }
+ }
+ pub fn as_ref_id(&self) -> Option<u64> {
+ match self {
+ Param::Ref(r) => Some(*r),
+ _ => None,
+ }
+ }
+ pub fn as_str(&self) -> Option<&str> {
+ match self {
+ Param::Str(s) => Some(s),
+ _ => None,
+ }
+ }
+ pub fn as_enum(&self) -> Option<&str> {
+ match self {
+ Param::Enum(s) => Some(s),
+ _ => None,
+ }
+ }
+ /// `.T.` → true, `.F.` → false (`.U.` and anything else → None).
+ pub fn as_bool(&self) -> Option<bool> {
+ match self.as_enum()? {
+ "T" => Some(true),
+ "F" => Some(false),
+ _ => None,
+ }
+ }
+ pub fn as_list(&self) -> Option<&[Param]> {
+ match self {
+ Param::List(v) => Some(v),
+ _ => None,
+ }
+ }
+}
+
+/// One record of an entity instance: a simple instance has one, a complex one several.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Record {
+ pub name: String,
+ pub params: Vec<Param>,
+}
+
+/// An entity instance.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Entity {
+ pub records: Vec<Record>,
+}
+
+impl Entity {
+ pub fn is_complex(&self) -> bool {
+ self.records.len() > 1
+ }
+ /// Name of a simple instance (the first record of a complex one).
+ pub fn name(&self) -> &str {
+ self.records.first().map(|r| r.name.as_str()).unwrap_or("")
+ }
+ /// Parameters of the record called `name`.
+ pub fn record(&self, name: &str) -> Option<&[Param]> {
+ self.records.iter().find(|r| r.name == name).map(|r| r.params.as_slice())
+ }
+ pub fn has(&self, name: &str) -> bool {
+ self.records.iter().any(|r| r.name == name)
+ }
+ /// Parameters of a simple instance.
+ pub fn params(&self) -> &[Param] {
+ self.records.first().map(|r| r.params.as_slice()).unwrap_or(&[])
+ }
+}
+
+/// A parsed exchange file.
+#[derive(Clone, Debug, Default)]
+pub struct Exchange {
+ /// FILE_SCHEMA names.
+ pub schemas: Vec<String>,
+ /// FILE_NAME originating system.
+ pub originating_system: String,
+ pub entities: HashMap<u64, Entity>,
+ /// Ids defined more than once (the first definition is kept).
+ pub duplicates: Vec<u64>,
+}
+
+impl Exchange {
+ pub fn get(&self, id: u64) -> Option<&Entity> {
+ self.entities.get(&id)
+ }
+}
+
+struct Lexer<'a> {
+ s: &'a [u8],
+ i: usize,
+}
+
+fn err<T>(msg: impl Into<String>) -> Result<T, String> {
+ Err(msg.into())
+}
+
+impl<'a> Lexer<'a> {
+ fn line(&self) -> usize {
+ self.s.get(..self.i).map(|b| b.iter().filter(|c| **c == b'\n').count() + 1).unwrap_or(0)
+ }
+ fn fail<T>(&self, msg: &str) -> Result<T, String> {
+ err(format!("STEP syntax error at line {}: {msg}", self.line()))
+ }
+ fn peek(&self) -> Option<u8> {
+ self.s.get(self.i).copied()
+ }
+ /// Skip whitespace and comments.
+ fn ws(&mut self) -> Result<(), String> {
+ loop {
+ match self.peek() {
+ Some(c) if c.is_ascii_whitespace() => self.i += 1,
+ Some(b'/') if self.s.get(self.i + 1) == Some(&b'*') => {
+ let rest = self.s.get(self.i + 2..).unwrap_or(&[]);
+ match rest.windows(2).position(|w| w == b"*/") {
+ Some(p) => self.i += p + 4,
+ None => return self.fail("unterminated comment"),
+ }
+ }
+ _ => return Ok(()),
+ }
+ }
+ }
+ fn eat(&mut self, c: u8) -> Result<bool, String> {
+ self.ws()?;
+ if self.peek() == Some(c) {
+ self.i += 1;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ }
+ fn expect(&mut self, c: u8) -> Result<(), String> {
+ if self.eat(c)? { Ok(()) } else { self.fail(&format!("expected `{}`", c as char)) }
+ }
+ fn keyword(&mut self) -> Result<String, String> {
+ self.ws()?;
+ let st = self.i;
+ if self.peek() == Some(b'!') {
+ self.i += 1;
+ }
+ while let Some(c) = self.peek() {
+ if c.is_ascii_alphanumeric() || c == b'_' || c == b'-' {
+ self.i += 1;
+ } else {
+ break;
+ }
+ }
+ if self.i == st {
+ return self.fail("expected a keyword");
+ }
+ Ok(String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).to_ascii_uppercase())
+ }
+ fn number(&mut self) -> Result<Param, String> {
+ let st = self.i;
+ while let Some(c) = self.peek() {
+ if c.is_ascii_digit() || matches!(c, b'+' | b'-' | b'.' | b'E' | b'e') {
+ self.i += 1;
+ } else {
+ break;
+ }
+ }
+ let t = std::str::from_utf8(self.s.get(st..self.i).unwrap_or(&[])).unwrap_or("");
+ if !t.contains(['.', 'E', 'e'])
+ && let Ok(i) = t.parse::<i64>()
+ {
+ return Ok(Param::Int(i));
+ }
+ // STEP allows `1.` and `1.E-3`.
+ let fixed = t.replace(".E", ".0E").replace(".e", ".0e");
+ let fixed = if fixed.ends_with('.') { format!("{fixed}0") } else { fixed };
+ match fixed.parse::<f64>() {
+ Ok(x) => Ok(Param::Real(x)),
+ Err(_) => self.fail(&format!("bad number `{t}`")),
+ }
+ }
+ fn string(&mut self) -> Result<String, String> {
+ // Opening quote consumed by the caller.
+ let mut raw = Vec::new();
+ loop {
+ match self.peek() {
+ None => return self.fail("unterminated string"),
+ Some(b'\'') => {
+ if self.s.get(self.i + 1) == Some(&b'\'') {
+ raw.push(b'\'');
+ self.i += 2;
+ } else {
+ self.i += 1;
+ break;
+ }
+ }
+ Some(b'\n') | Some(b'\r') => self.i += 1,
+ Some(c) => {
+ raw.push(c);
+ self.i += 1;
+ }
+ }
+ }
+ Ok(decode_string(&raw))
+ }
+ fn param(&mut self, depth: usize) -> Result<Param, String> {
+ if depth > MAX_DEPTH {
+ return self.fail("parameters nested too deeply");
+ }
+ self.ws()?;
+ let Some(c) = self.peek() else { return self.fail("unexpected end of file") };
+ match c {
+ b'$' => {
+ self.i += 1;
+ Ok(Param::Null)
+ }
+ b'*' => {
+ self.i += 1;
+ Ok(Param::Derived)
+ }
+ b'\'' => {
+ self.i += 1;
+ Ok(Param::Str(self.string()?))
+ }
+ b'"' => {
+ self.i += 1;
+ let st = self.i;
+ while self.peek().is_some_and(|c| c != b'"') {
+ self.i += 1;
+ }
+ let v = String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).to_string();
+ self.expect(b'"')?;
+ Ok(Param::Binary(v))
+ }
+ b'#' => {
+ self.i += 1;
+ let st = self.i;
+ while self.peek().is_some_and(|c| c.is_ascii_digit()) {
+ self.i += 1;
+ }
+ let t = std::str::from_utf8(self.s.get(st..self.i).unwrap_or(&[])).unwrap_or("");
+ t.parse::<u64>().map(Param::Ref).or_else(|_| self.fail("bad entity reference"))
+ }
+ b'.' if self.s.get(self.i + 1).is_some_and(|c| c.is_ascii_alphabetic() || *c == b'_') => {
+ self.i += 1;
+ let st = self.i;
+ while self.peek().is_some_and(|c| c != b'.') {
+ self.i += 1;
+ }
+ let v = String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).trim().to_ascii_uppercase();
+ self.expect(b'.')?;
+ Ok(Param::Enum(v))
+ }
+ b'(' => {
+ self.i += 1;
+ Ok(Param::List(self.list_rest(depth + 1)?))
+ }
+ c if c.is_ascii_digit() || matches!(c, b'+' | b'-' | b'.') => self.number(),
+ c if c.is_ascii_alphabetic() || c == b'!' => {
+ let name = self.keyword()?;
+ self.expect(b'(')?;
+ Ok(Param::Typed(name, self.list_rest(depth + 1)?))
+ }
+ _ => self.fail(&format!("unexpected `{}`", c as char)),
+ }
+ }
+ /// Parameters after an opening `(` up to and including the `)`.
+ fn list_rest(&mut self, depth: usize) -> Result<Vec<Param>, String> {
+ let mut v = Vec::new();
+ if self.eat(b')')? {
+ return Ok(v);
+ }
+ loop {
+ v.push(self.param(depth)?);
+ if self.eat(b',')? {
+ continue;
+ }
+ self.expect(b')')?;
+ return Ok(v);
+ }
+ }
+ fn record(&mut self) -> Result<Record, String> {
+ let name = self.keyword()?;
+ self.expect(b'(')?;
+ Ok(Record { name, params: self.list_rest(1)? })
+ }
+}
+
+/// Decode the Part 21 string escapes (`\X\hh`, `\X2\…\X0\`, `\X4\…\X0\`, `\S\c`, `\\`).
+fn decode_string(raw: &[u8]) -> String {
+ let mut out = String::new();
+ let mut i = 0;
+ let hex = |b: &[u8]| std::str::from_utf8(b).ok().and_then(|t| u32::from_str_radix(t, 16).ok());
+ while let Some(&c) = raw.get(i) {
+ if c == b'\\' {
+ let rest = raw.get(i..).unwrap_or(&[]);
+ if rest.starts_with(b"\\\\") {
+ out.push('\\');
+ i += 2;
+ continue;
+ }
+ if rest.starts_with(b"\\X\\")
+ && let Some(v) = rest.get(3..5).and_then(hex)
+ {
+ out.push(char::from_u32(v).unwrap_or('?'));
+ i += 5;
+ continue;
+ }
+ for (tag, width) in [(&b"\\X2\\"[..], 4usize), (&b"\\X4\\"[..], 8)] {
+ if rest.starts_with(tag)
+ && let Some(end) = rest.windows(4).position(|w| w == b"\\X0\\")
+ {
+ let body = rest.get(4..end).unwrap_or(&[]);
+ let units: Vec<u32> = body.chunks(width).filter_map(hex).collect();
+ if width == 4 {
+ let u16s: Vec<u16> = units.iter().map(|u| *u as u16).collect();
+ out.push_str(&String::from_utf16_lossy(&u16s));
+ } else {
+ out.extend(units.iter().map(|u| char::from_u32(*u).unwrap_or('?')));
+ }
+ i += end + 4;
+ break;
+ }
+ }
+ if i < raw.len() && raw.get(i) == Some(&b'\\') {
+ if rest.starts_with(b"\\S\\")
+ && let Some(&ch) = rest.get(3)
+ {
+ out.push(char::from_u32(ch as u32 + 128).unwrap_or('?'));
+ i += 4;
+ continue;
+ }
+ out.push('\\');
+ i += 1;
+ }
+ continue;
+ }
+ // Plain bytes: keep UTF-8 runs intact.
+ let st = i;
+ while raw.get(i).is_some_and(|c| *c != b'\\') {
+ i += 1;
+ }
+ out.push_str(&String::from_utf8_lossy(raw.get(st..i).unwrap_or(&[])));
+ }
+ out
+}
+
+/// Parse a Part 21 file.
+pub fn parse(text: &str) -> Result<Exchange, String> {
+ if text.len() > MAX_BYTES {
+ return err(format!("STEP file too large ({} MB, limit {} MB)", text.len() >> 20, MAX_BYTES >> 20));
+ }
+ let mut lx = Lexer { s: text.as_bytes(), i: 0 };
+ let magic = lx.keyword()?;
+ if magic != "ISO-10303-21" {
+ return err("not a STEP file (no ISO-10303-21 header)");
+ }
+ lx.expect(b';')?;
+ let mut ex = Exchange::default();
+ loop {
+ lx.ws()?;
+ if lx.peek().is_none() {
+ return err("STEP file ends without END-ISO-10303-21");
+ }
+ let kw = lx.keyword()?;
+ match kw.as_str() {
+ "HEADER" => {
+ lx.expect(b';')?;
+ loop {
+ let k = lx.keyword()?;
+ if k == "ENDSEC" {
+ lx.expect(b';')?;
+ break;
+ }
+ lx.expect(b'(')?;
+ let params = lx.list_rest(1)?;
+ lx.expect(b';')?;
+ match k.as_str() {
+ "FILE_SCHEMA" => {
+ if let Some(Param::List(v)) = params.first() {
+ ex.schemas = v.iter().filter_map(|p| p.as_str().map(str::to_string)).collect();
+ }
+ }
+ "FILE_NAME" => {
+ ex.originating_system = params.get(5).and_then(Param::as_str).unwrap_or("").to_string();
+ }
+ _ => {}
+ }
+ }
+ }
+ "DATA" => {
+ // Optional `DATA('name', ('schema'));`
+ if lx.eat(b'(')? {
+ lx.list_rest(1)?;
+ }
+ lx.expect(b';')?;
+ loop {
+ lx.ws()?;
+ if lx.peek() != Some(b'#') {
+ let k = lx.keyword()?;
+ if k == "ENDSEC" {
+ lx.expect(b';')?;
+ break;
+ }
+ return lx.fail(&format!("unexpected `{k}` in DATA"));
+ }
+ lx.i += 1;
+ let st = lx.i;
+ while lx.peek().is_some_and(|c| c.is_ascii_digit()) {
+ lx.i += 1;
+ }
+ let id: u64 = match std::str::from_utf8(lx.s.get(st..lx.i).unwrap_or(&[])).ok().and_then(|t| t.parse().ok()) {
+ Some(id) => id,
+ None => return lx.fail("bad entity id"),
+ };
+ lx.expect(b'=')?;
+ let records = if lx.eat(b'(')? {
+ let mut rs = Vec::new();
+ while !lx.eat(b')')? {
+ if rs.len() > 64 {
+ return lx.fail("complex entity with too many parts");
+ }
+ rs.push(lx.record()?);
+ }
+ rs
+ } else {
+ vec![lx.record()?]
+ };
+ lx.expect(b';')?;
+ if ex.entities.len() >= MAX_ENTITIES {
+ return err(format!("STEP file has more than {MAX_ENTITIES} entities"));
+ }
+ // A duplicate id is invalid; some writers emit them for geometry nobody
+ // reads. Keep the first definition and report it.
+ match ex.entities.entry(id) {
+ std::collections::hash_map::Entry::Occupied(_) => ex.duplicates.push(id),
+ std::collections::hash_map::Entry::Vacant(v) => {
+ v.insert(Entity { records });
+ }
+ }
+ }
+ }
+ "END-ISO-10303-21" => {
+ lx.expect(b';')?;
+ return Ok(ex);
+ }
+ // ANCHOR / REFERENCE / SIGNATURE sections (Part 21 edition 3): skip to ENDSEC.
+ "ANCHOR" | "REFERENCE" | "SIGNATURE" => {
+ let rest = lx.s.get(lx.i..).unwrap_or(&[]);
+ match rest.windows(7).position(|w| w == b"ENDSEC;") {
+ Some(p) => lx.i += p + 7,
+ None => return lx.fail("unterminated section"),
+ }
+ }
+ _ => return lx.fail(&format!("unexpected `{kw}`")),
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn parses_simple_and_complex() {
+ let t = "ISO-10303-21;\nHEADER;FILE_DESCRIPTION((''),'2;1');\nFILE_NAME('a','',(''),(''),'','sys','');\nFILE_SCHEMA(('AUTOMOTIVE_DESIGN'));ENDSEC;\nDATA;\n#1=CARTESIAN_POINT('p',(0.,1.5E1,-2));\n/* c */ #2=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));\n#3=X('it''s','\\X2\\00E9\\X0\\',$,#1,LENGTH_MEASURE(1.E-3),\"0F\");\nENDSEC;\nEND-ISO-10303-21;\n";
+ let ex = parse(t).unwrap();
+ assert_eq!(ex.schemas, vec!["AUTOMOTIVE_DESIGN"]);
+ assert_eq!(ex.originating_system, "sys");
+ let p = ex.get(1).unwrap();
+ assert_eq!(p.name(), "CARTESIAN_POINT");
+ let xyz: Vec<f64> = p.params()[1].as_list().unwrap().iter().filter_map(Param::as_f64).collect();
+ assert_eq!(xyz, vec![0.0, 15.0, -2.0]);
+ let u = ex.get(2).unwrap();
+ assert!(u.is_complex() && u.has("SI_UNIT"));
+ assert_eq!(u.record("SI_UNIT").unwrap()[0].as_enum(), Some("MILLI"));
+ let x = ex.get(3).unwrap().params();
+ assert_eq!(x[0].as_str(), Some("it's"));
+ assert_eq!(x[1].as_str(), Some("\u{e9}"));
+ assert_eq!(x[2], Param::Null);
+ assert_eq!(x[3].as_ref_id(), Some(1));
+ assert_eq!(x[4].as_f64(), Some(1e-3));
+ }
+
+ #[test]
+ fn hostile_text_is_an_error() {
+ for t in [
+ "",
+ "garbage",
+ "ISO-10303-21;",
+ "ISO-10303-21;DATA;#1=A(",
+ "ISO-10303-21;DATA;#1=A('x",
+ "ISO-10303-21;DATA;#1=A(/*",
+ "ISO-10303-21;DATA;#=A();ENDSEC;END-ISO-10303-21;",
+ "ISO-10303-21;DATA;#99999999999999999999999=A();ENDSEC;END-ISO-10303-21;",
+ "ISO-10303-21;DATA;#1=A(1e999999.);ENDSEC;END-ISO-10303-21;",
+ ] {
+ let _ = parse(t);
+ }
+ let deep = format!("ISO-10303-21;DATA;#1=A({}{});ENDSEC;END-ISO-10303-21;", "(".repeat(10_000), ")".repeat(10_000));
+ assert!(parse(&deep).is_err());
+ let dup = parse("ISO-10303-21;DATA;#1=A(1);#1=B();ENDSEC;END-ISO-10303-21;").unwrap();
+ assert_eq!(dup.duplicates, vec![1]);
+ assert_eq!(dup.get(1).unwrap().name(), "A");
+ assert_eq!(decode_string(b"\\X\\E9"), "\u{e9}");
+ assert_eq!(decode_string(b"a\\X2\\00E900E8\\X0\\b"), "a\u{e9}\u{e8}b");
+ assert_eq!(decode_string(b"\\"), "\\");
+ }
+}
diff --git a/crates/kernel/src/step_in/split.rs b/crates/kernel/src/step_in/split.rs
new file mode 100644
index 0000000000..985746fa6e
--- /dev/null
+++ b/crates/kernel/src/step_in/split.rs
@@ -0,0 +1,409 @@
+//! Splitting band faces that wrap all the way around a closed, non-periodic parameter direction.
+//!
+//! A STEP face may run once around a closed surface and close its loop with a seam edge used
+//! twice (a pipe segment of a torus, a revolved B-spline band). Truck meshes faces in parameter
+//! space and only treats the rotation of a revolved surface as periodic, so such a face is cut
+//! in two along the parameter line opposite its seam; the ring edges it crosses are cut in every
+//! face that uses them.
+
+use std::collections::HashMap;
+
+use mt::{BoundedCurve, BoundedSurface, InnerSpace, Invertible, MetricSpace, ParametricCurve, ParametricSurface, SearchNearestParameter};
+use truck_modeling as mt;
+
+use super::geom::{Frame, R, conic_arc};
+
+/// Samples per edge when looking for the split crossing.
+const SAMPLES: usize = 48;
+
+/// Which surface parameter wraps around.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Dir {
+ U,
+ V,
+}
+
+fn uv_of(s: &mt::Surface, p: mt::Point3) -> Option<(f64, f64)> {
+ s.search_nearest_parameter(p, None, 100).filter(|(u, v)| u.is_finite() && v.is_finite())
+}
+
+fn coord(d: Dir, uv: (f64, f64)) -> f64 {
+ match d {
+ Dir::U => uv.0,
+ Dir::V => uv.1,
+ }
+}
+
+/// The closed, non-periodic direction of a surface with its range.
+fn closed_dirs(s: &mt::Surface) -> Vec<(Dir, f64, f64)> {
+ match s {
+ mt::Surface::RevolutedCurve(p) => {
+ let c = p.entity().entity_curve();
+ let (t0, t1) = c.range_tuple();
+ if c.front().distance(c.back()) < 1e-7 * (1.0 + c.front().to_homogeneous().truncate().magnitude()) {
+ vec![(Dir::U, t0, t1)]
+ } else {
+ vec![]
+ }
+ }
+ mt::Surface::BSplineSurface(_) | mt::Surface::NurbsSurface(_) => {
+ let ((u0, u1), (v0, v1)) = match s {
+ mt::Surface::BSplineSurface(b) => b.range_tuple(),
+ mt::Surface::NurbsSurface(n) => n.range_tuple(),
+ _ => return vec![],
+ };
+ let size = (0..=4)
+ .flat_map(|i| (0..=4).map(move |j| (i, j)))
+ .map(|(i, j)| s.subs(u0 + (u1 - u0) * i as f64 / 4.0, v0 + (v1 - v0) * j as f64 / 4.0).to_homogeneous().truncate().magnitude())
+ .fold(1.0, f64::max);
+ let tol = size * 1e-7;
+ let mut out = Vec::new();
+ if (0..=8).all(|k| {
+ let v = v0 + (v1 - v0) * k as f64 / 8.0;
+ s.subs(u0, v).distance(s.subs(u1, v)) < tol
+ }) {
+ out.push((Dir::U, u0, u1));
+ }
+ if (0..=8).all(|k| {
+ let u = u0 + (u1 - u0) * k as f64 / 8.0;
+ s.subs(u, v0).distance(s.subs(u, v1)) < tol
+ }) {
+ out.push((Dir::V, v0, v1));
+ }
+ out
+ }
+ mt::Surface::Plane(_) => vec![],
+ }
+}
+
+fn samples(c: &mt::Curve, n: usize) -> Vec<(f64, mt::Point3)> {
+ let (t0, t1) = c.range_tuple();
+ (0..=n).map(|i| t0 + (t1 - t0) * i as f64 / n as f64).map(|t| (t, c.subs(t))).collect()
+}
+
+/// Where a ring chain crosses `w = mid`: (edge index in the chain, parameter on the edge's
+/// absolute curve, point).
+fn crossing(s: &mt::Surface, d: Dir, chain: &[mt::Edge], mid: f64, period: f64) -> R<(usize, f64, mt::Point3)> {
+ for (k, e) in chain.iter().enumerate() {
+ let c = e.curve();
+ let pts = samples(&c, SAMPLES);
+ let ws: Vec<Option<f64>> = pts.iter().map(|(_, p)| uv_of(s, *p).map(|uv| coord(d, uv))).collect();
+ for i in 0..SAMPLES {
+ let (Some(Some(wa)), Some(Some(wb)), Some((ta, _)), Some((tb, _))) = (ws.get(i), ws.get(i + 1), pts.get(i), pts.get(i + 1)) else {
+ continue;
+ };
+ if (wb - wa).abs() > period * 0.5 || (wa - mid) * (wb - mid) > 0.0 {
+ continue;
+ }
+ // Bisection on the curve parameter.
+ let (mut lo, mut hi, mut flo) = (*ta, *tb, wa - mid);
+ for _ in 0..60 {
+ let m = 0.5 * (lo + hi);
+ let Some(w) = uv_of(s, c.subs(m)).map(|uv| coord(d, uv)) else { break };
+ let f = w - mid;
+ if (f - flo).abs() > period * 0.5 {
+ break;
+ }
+ if f * flo <= 0.0 {
+ hi = m;
+ } else {
+ lo = m;
+ flo = f;
+ }
+ }
+ let t = 0.5 * (lo + hi);
+ return Ok((k, t, c.subs(t)));
+ }
+ }
+ Err("no crossing with the split line".into())
+}
+
+/// Iso-parameter edge curve `w = mid` from `q1` to `q2`.
+fn iso_curve(s: &mt::Surface, d: Dir, mid: f64, q1: mt::Point3, q2: mt::Point3, seam: &[mt::Point3]) -> R<mt::Curve> {
+ match s {
+ mt::Surface::RevolutedCurve(p) => {
+ // A circle around the axis, turning opposite to the seam (which runs from the q2
+ // side to the q1 side).
+ let (o, a) = (p.entity().origin(), p.entity().axis());
+ let az = |x: mt::Point3, f: &Frame| {
+ let v = x - f.o;
+ v.dot(f.y).atan2(v.dot(f.x))
+ };
+ let c = o + a * (q1 - o).dot(a);
+ let r = (q1 - c).magnitude();
+ if !(r > 1e-9) {
+ return Err("split line on the axis".into());
+ }
+ let x = (q1 - c) / r;
+ let f = Frame { o: c, x, y: a.cross(x), z: a };
+ let mut seam_turn = 0.0;
+ for w in seam.windows(2) {
+ if let (Some(p0), Some(p1)) = (w.first(), w.get(1)) {
+ let d = az(*p1, &f) - az(*p0, &f);
+ seam_turn += (d + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI;
+ }
+ }
+ let sweep = -seam_turn;
+ if sweep.abs() < 1e-9 {
+ return Err("degenerate split line".into());
+ }
+ let f = if sweep > 0.0 { f } else { Frame { o: c, x, y: -a.cross(x), z: -a } };
+ let arc = conic_arc(&f, r, r, 0.0, sweep.abs());
+ if arc.back().distance(q2) > 1e-6 * (1.0 + r) {
+ return Err("split line does not reach the other ring".into());
+ }
+ Ok(mt::Curve::NurbsCurve(arc))
+ }
+ mt::Surface::BSplineSurface(_) | mt::Surface::NurbsSurface(_) => {
+ let hom: mt::BSplineSurface<mt::Vector4> = match s {
+ mt::Surface::BSplineSurface(b) => mt::BSplineSurface::new(
+ b.knot_vecs().clone(),
+ b.control_points().iter().map(|row| row.iter().map(|p| p.to_homogeneous()).collect()).collect(),
+ ),
+ mt::Surface::NurbsSurface(n) => n.non_rationalized().clone(),
+ _ => return Err("unsupported surface".into()),
+ };
+ let iso = mt::Curve::NurbsCurve(iso_bsp(&hom, mid, d == Dir::V)?);
+ let near = |p: mt::Point3| {
+ let (t0, t1) = iso.range_tuple();
+ let mut best = (t0, f64::INFINITY);
+ for i in 0..=256 {
+ let t = t0 + (t1 - t0) * i as f64 / 256.0;
+ let dd = iso.subs(t).distance(p);
+ if dd < best.1 {
+ best = (t, dd);
+ }
+ }
+ if let Some(t) = iso.search_nearest_parameter(p, best.0, 64) {
+ let t = t.clamp(t0, t1);
+ if iso.subs(t).distance(p) <= best.1 {
+ best = (t, iso.subs(t).distance(p));
+ }
+ }
+ best
+ };
+ let ((ta, da), (tb, db)) = (near(q1), near(q2));
+ let scale = 1.0 + q1.to_homogeneous().truncate().magnitude();
+ if da > 1e-5 * scale || db > 1e-5 * scale || (ta - tb).abs() < 1e-12 {
+ return Err("split line does not reach the rings".into());
+ }
+ let (lo, hi) = if ta < tb { (ta, tb) } else { (tb, ta) };
+ let (t0, t1) = iso.range_tuple();
+ let mut c = iso;
+ let eps = (t1 - t0) * 1e-9;
+ if lo > t0 + eps {
+ c = mt::Cut::cut(&mut c, lo);
+ }
+ if hi < t1 - eps {
+ let _ = mt::Cut::cut(&mut c, hi);
+ }
+ if ta > tb {
+ c.invert();
+ }
+ Ok(c)
+ }
+ mt::Surface::Plane(_) => Err("planes do not wrap".into()),
+ }
+}
+
+/// The iso-curve of a homogeneous B-spline surface at `v = w` (`along_u`) or `u = w`.
+fn iso_bsp(b: &mt::BSplineSurface<mt::Vector4>, w: f64, along_u: bool) -> R<mt::NurbsCurve<mt::Vector4>> {
+ let (ku, kv) = b.knot_vecs();
+ let ctrl = b.control_points();
+ let nu = ctrl.len();
+ let nv = ctrl.first().map(Vec::len).unwrap_or(0);
+ let zero = mt::Vector4::new(0.0, 0.0, 0.0, 0.0);
+ let pts: Vec<mt::Vector4> = if along_u {
+ let deg = kv.len().checked_sub(nv + 1).ok_or("bad knot vector")?;
+ let basis = kv.try_bspline_basis_functions(deg, w).map_err(|e| e.to_string())?;
+ ctrl.iter().map(|row| row.iter().zip(&basis).fold(zero, |acc, (p, f)| acc + *p * *f)).collect()
+ } else {
+ let deg = ku.len().checked_sub(nu + 1).ok_or("bad knot vector")?;
+ let basis = ku.try_bspline_basis_functions(deg, w).map_err(|e| e.to_string())?;
+ (0..nv).map(|j| ctrl.iter().zip(&basis).fold(zero, |acc, (row, f)| acc + row.get(j).copied().unwrap_or(zero) * *f)).collect()
+ };
+ let knots = if along_u { ku.clone() } else { kv.clone() };
+ mt::BSplineCurve::try_new(knots, pts).map(mt::NurbsCurve::new).map_err(|e| e.to_string())
+}
+
+type Cut = (mt::Edge, (mt::Edge, mt::Edge));
+
+/// Split a chain at parameter `t` of its edge `k` (absolute curve): the edges before and after
+/// the split point, the edge cut (unless the point is an existing vertex) and the split vertex.
+fn split_chain(chain: &[mt::Edge], k: usize, t: f64, q: mt::Point3) -> R<(Vec<mt::Edge>, Vec<mt::Edge>, Option<Cut>, mt::Vertex)> {
+ let e = chain.get(k).ok_or("bad crossing")?;
+ let (t0, t1) = e.curve().range_tuple();
+ let eps = (t1 - t0).abs() * 1e-7;
+ let at_front = (t - t0).abs() <= eps;
+ let at_back = (t - t1).abs() <= eps;
+ if at_front || at_back {
+ // The split point is a vertex already: split the chain between edges.
+ let v = if at_front { e.absolute_front().clone() } else { e.absolute_back().clone() };
+ let first_end = at_front != e.orientation(); // the point is this edge's end in loop order
+ let cut_at = if first_end { k + 1 } else { k };
+ let before = chain.iter().take(cut_at).cloned().collect();
+ let after = chain.iter().skip(cut_at).cloned().collect();
+ return Ok((before, after, None, v));
+ }
+ let v = mt::Vertex::new(q);
+ let (a, b) = e.cut_with_parameter(&v, t).ok_or("cannot cut a ring edge at the split line")?;
+ let mut before: Vec<mt::Edge> = chain.iter().take(k).cloned().collect();
+ before.push(a.clone());
+ let mut after = vec![b.clone()];
+ after.extend(chain.iter().skip(k + 1).cloned());
+ Ok((before, after, Some((e.clone(), (a, b))), v))
+}
+
+struct Plan {
+ /// Edge cuts: (edge as used in the band's loop, its two pieces in that loop's order).
+ cuts: Vec<Cut>,
+ faces: (mt::Face, mt::Face),
+}
+
+fn plan(face: &mt::Face) -> R<Option<Plan>> {
+ let s = face.surface();
+ let wires = face.absolute_boundaries().clone();
+ let mut uses: HashMap<mt::EdgeID, usize> = HashMap::new();
+ for e in wires.iter().flat_map(|w| w.edge_iter()) {
+ *uses.entry(e.id()).or_default() += 1;
+ }
+ let is_seam = |e: &mt::Edge| uses.get(&e.id()).copied().unwrap_or(0) > 1;
+ if !wires.iter().flat_map(|w| w.edge_iter()).any(is_seam) {
+ return Ok(None);
+ }
+ // The closed direction whose boundary carries the seam.
+ let seam_pts: Vec<mt::Point3> =
+ wires.iter().flat_map(|w| w.edge_iter()).filter(|e| is_seam(e)).flat_map(|e| samples(&e.curve(), 4).into_iter().map(|x| x.1)).collect();
+ let Some((d, w0, w1)) = closed_dirs(&s).into_iter().find(|(d, w0, w1)| {
+ let p = w1 - w0;
+ seam_pts.iter().all(|q| uv_of(&s, *q).map(|uv| coord(*d, uv)).is_some_and(|w| (w - w0).abs().min((w - w1).abs()) < p * 1e-4))
+ }) else {
+ return Ok(None);
+ };
+ let (period, mid) = (w1 - w0, 0.5 * (w0 + w1));
+ let outer_idx = wires.iter().position(|w| w.edge_iter().any(is_seam)).ok_or("no seam loop")?;
+ if wires.iter().enumerate().any(|(i, w)| i != outer_idx && w.edge_iter().any(is_seam)) {
+ return Err("seam edges in several loops".into());
+ }
+ let outer: Vec<mt::Edge> = wires.get(outer_idx).ok_or("no seam loop")?.edge_iter().cloned().collect();
+ let n = outer.len();
+ let start = (0..n)
+ .find(|&i| outer.get(i).is_some_and(is_seam) && outer.get((i + n - 1) % n).is_some_and(|e| !is_seam(e)))
+ .ok_or("loop made only of seam edges")?;
+ let rot: Vec<mt::Edge> = (0..n).filter_map(|i| outer.get((start + i) % n).cloned()).collect();
+ let mut chains: Vec<(bool, Vec<mt::Edge>)> = Vec::new();
+ for e in rot {
+ let seam = is_seam(&e);
+ match chains.last_mut() {
+ Some((s0, c)) if *s0 == seam => c.push(e),
+ _ => chains.push((seam, vec![e])),
+ }
+ }
+ let [(true, s1), (false, r1), (true, s2), (false, r2)] = chains.as_slice() else {
+ return Err(format!("unsupported seam loop layout ({} runs)", chains.len()));
+ };
+ let s2_ids: Vec<mt::EdgeID> = s2.iter().rev().map(mt::Edge::id).collect();
+ if s1.iter().map(mt::Edge::id).collect::<Vec<_>>() != s2_ids {
+ return Err("seam edges are not used back and forth".into());
+ }
+ let (k1, t1, q1) = crossing(&s, d, r1, mid, period)?;
+ let (k2, t2, q2) = crossing(&s, d, r2, mid, period)?;
+ let seam_line: Vec<mt::Point3> = s1.iter().flat_map(|e| samples(&e.oriented_curve(), 16).into_iter().map(|x| x.1)).collect();
+ let iso = iso_curve(&s, d, mid, q1, q2, &seam_line)?;
+ let (r1a, r1b, c1, v1) = split_chain(r1, k1, t1, q1)?;
+ let (r2a, r2b, c2, v2) = split_chain(r2, k2, t2, q2)?;
+ let e_split = mt::Edge::new_unchecked(&v1, &v2, iso);
+ // Face A: split, rest of ring 2, seam, start of ring 1. Face B: the other half.
+ let mut wa: Vec<mt::Edge> = vec![e_split.clone()];
+ wa.extend(r2b);
+ wa.extend(s1.iter().cloned());
+ wa.extend(r1a.iter().cloned());
+ let mut wb: Vec<mt::Edge> = vec![e_split.inverse()];
+ wb.extend(r1b);
+ wb.extend(s2.iter().cloned());
+ wb.extend(r2a);
+ let wire_a: mt::Wire = wa.into();
+ let wire_b: mt::Wire = wb.into();
+ if !wire_a.is_closed() || !wire_b.is_closed() {
+ return Err("split loops do not close".into());
+ }
+ // Holes go to the half that holds them.
+ let side_a = r1a
+ .iter()
+ .flat_map(|e| samples(&e.oriented_curve(), 4))
+ .filter_map(|(_, p)| uv_of(&s, p).map(|uv| coord(d, uv)))
+ .find(|w| (w - mid).abs() > period * 1e-3)
+ .map(|w| w < mid)
+ .ok_or("cannot place the split halves")?;
+ let (mut ha, mut hb) = (vec![wire_a], vec![wire_b]);
+ for (i, w) in wires.iter().enumerate() {
+ if i == outer_idx {
+ continue;
+ }
+ let ws: Vec<f64> = w.edge_iter().flat_map(|e| samples(&e.curve(), 4)).filter_map(|(_, p)| uv_of(&s, p).map(|uv| coord(d, uv))).collect();
+ if ws.iter().all(|x| (*x < mid) == side_a) {
+ ha.push(w.clone());
+ } else if ws.iter().all(|x| (*x < mid) != side_a) {
+ hb.push(w.clone());
+ } else {
+ return Err("a hole crosses the split line".into());
+ }
+ }
+ let mut fa = mt::Face::new_unchecked(ha, s.clone());
+ let mut fb = mt::Face::new_unchecked(hb, s);
+ if !face.orientation() {
+ fa.invert();
+ fb.invert();
+ }
+ Ok(Some(Plan { cuts: c1.into_iter().chain(c2).collect(), faces: (fa, fb) }))
+}
+
+/// Replace cut edges in a face's loops.
+fn recut(face: &mt::Face, cuts: &[(mt::Edge, (mt::Edge, mt::Edge))]) -> mt::Face {
+ let touches = face.absolute_boundaries().iter().flat_map(|w| w.edge_iter()).any(|e| cuts.iter().any(|(c, _)| c.id() == e.id()));
+ if !touches {
+ return face.clone();
+ }
+ let wires: Vec<mt::Wire> = face
+ .absolute_boundaries()
+ .iter()
+ .map(|w| {
+ let mut out: Vec<mt::Edge> = Vec::new();
+ for e in w.edge_iter() {
+ match cuts.iter().find(|(c, _)| c.id() == e.id()) {
+ Some((c, (a, b))) if c.orientation() == e.orientation() => out.extend([a.clone(), b.clone()]),
+ Some((_, (a, b))) => out.extend([b.inverse(), a.inverse()]),
+ None => out.push(e.clone()),
+ }
+ }
+ out.into()
+ })
+ .collect();
+ let mut f = mt::Face::new_unchecked(wires, face.surface());
+ if !face.orientation() {
+ f.invert();
+ }
+ f
+}
+
+/// Split every band face of a shell (see the module docs). Faces that cannot be split stay as
+/// they are and are reported.
+pub(crate) fn split_bands(mut faces: Vec<mt::Face>, warnings: &mut Vec<String>) -> Vec<mt::Face> {
+ let n = faces.len();
+ for i in 0..n {
+ let Some(face) = faces.get(i).cloned() else { continue };
+ match crate::guard("step band split", || plan(&face).map_err(crate::KernelError::Failed)) {
+ Ok(Some(p)) => {
+ faces = faces.iter().map(|f| recut(f, &p.cuts)).collect();
+ if let Some(slot) = faces.get_mut(i) {
+ *slot = p.faces.0;
+ }
+ faces.push(p.faces.1);
+ }
+ Ok(None) => {}
+ Err(e) => warnings
+ .push(format!("face wrapping around a closed surface kept whole: {}", e.to_string().trim_start_matches("the operation failed: "))),
+ }
+ }
+ faces
+}
diff --git a/crates/kernel/src/step_in/tests.rs b/crates/kernel/src/step_in/tests.rs
new file mode 100644
index 0000000000..9387104d16
--- /dev/null
+++ b/crates/kernel/src/step_in/tests.rs
@@ -0,0 +1,285 @@
+use solvecraft_geom::{Loop2, Plane, Region2, Vec2, Vec3};
+
+use super::*;
+use crate::{BoolOp, boolean, box_solid, cylinder, fillet, measure, revolve, sphere, step_export, torus};
+
+fn rel(a: f64, b: f64) -> f64 {
+ (a - b).abs() / b.abs().max(1e-9)
+}
+
+/// Export → import → same volume, area and face count.
+fn round_trip(b: &Body) -> StepImport {
+ let text = step_export(&[b], "test").unwrap();
+ let imp = step_import(&text).unwrap();
+ assert_eq!(imp.bodies.len(), 1, "{:?}", imp.warnings);
+ // truck's writer repeats entity ids for the surfaces of intersection curves (unused here).
+ assert!(imp.warnings.iter().all(|w| w.contains("defined twice")), "{:?}", imp.warnings);
+ let (m0, m1) = (measure(b).unwrap(), measure(&imp.bodies[0].body).unwrap());
+ assert!(rel(m1.volume, m0.volume) < 1e-3, "volume {} vs {}", m1.volume, m0.volume);
+ assert!(rel(m1.area, m0.area) < 1e-3, "area {} vs {}", m1.area, m0.area);
+ assert_eq!(imp.bodies[0].file_faces, b.face_count());
+ assert!(imp.bodies[0].closed);
+ imp
+}
+
+#[test]
+fn round_trip_primitives() {
+ round_trip(&box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap());
+ round_trip(&cylinder(Vec3::new(1.0, 2.0, 3.0), Vec3::new(0.0, 1.0, 1.0), 5.0, 12.0).unwrap());
+ round_trip(&sphere(Vec3::new(1.0, 2.0, 3.0), 10.0).unwrap());
+ round_trip(&torus(Vec3::ZERO, 20.0, 4.0).unwrap());
+}
+
+#[test]
+fn round_trip_features() {
+ let plate = box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 10.0)).unwrap();
+ let pin = cylinder(Vec3::new(20.0, 15.0, -1.0), Vec3::Z, 5.0, 12.0).unwrap();
+ let holed = boolean(&plate, &pin, BoolOp::Cut).unwrap().unwrap();
+ round_trip(&holed);
+ let edge = Vec3::new(20.0, 0.0, 10.0);
+ round_trip(&fillet(&plate, &[edge], 3.0).unwrap());
+ let ring = Region2 { outer: Loop2::circle(Vec2::new(10.0, 0.0), 3.0), holes: vec![] };
+ let donut = revolve(&Plane::XZ, &[ring], Vec2::ZERO, Vec2::Y, 1.5).unwrap();
+ round_trip(&donut[0]);
+}
+
+#[test]
+fn several_bodies_and_names() {
+ let a = box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap();
+ let b = box_solid(Vec3::new(20.0, 0.0, 0.0), Vec3::new(30.0, 10.0, 10.0)).unwrap();
+ let text = step_export(&[&a, &b], "test").unwrap();
+ let imp = step_import(&text).unwrap();
+ assert_eq!(imp.bodies.len(), 2);
+ assert!(imp.bodies.iter().all(|b| !b.name.is_empty()));
+ let vol: f64 = imp.bodies.iter().map(|b| measure(&b.body).unwrap().volume).sum();
+ assert!(rel(vol, 2000.0) < 1e-6);
+}
+
+#[test]
+fn imported_bodies_take_features() {
+ let plate = box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 10.0)).unwrap();
+ let imp = step_import(&step_export(&[&plate], "t").unwrap()).unwrap();
+ let body = &imp.bodies[0].body;
+ // Fillet an edge, cut a hole through it.
+ let rounded = fillet(body, &[Vec3::new(20.0, 0.0, 10.0)], 2.0).unwrap();
+ let v_fillet = 40.0 * (4.0 - std::f64::consts::PI);
+ assert!(rel(measure(&rounded).unwrap().volume, 12000.0 - v_fillet) < 1e-3);
+ let pin = cylinder(Vec3::new(20.0, 15.0, -1.0), Vec3::Z, 5.0, 12.0).unwrap();
+ let holed = boolean(&rounded, &pin, BoolOp::Cut).unwrap().unwrap();
+ let want = 12000.0 - v_fillet - std::f64::consts::PI * 25.0 * 10.0;
+ assert!(rel(measure(&holed).unwrap().volume, want) < 1e-3);
+}
+
+const HEAD: &str = "ISO-10303-21;\nHEADER;\nFILE_DESCRIPTION((''),'2;1');\nFILE_NAME('t','',(''),(''),'','hand','');\nFILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }'));\nENDSEC;\nDATA;\n";
+const TAIL: &str = "ENDSEC;\nEND-ISO-10303-21;\n";
+
+/// A hand-written unit cube brep (`#100`…) in a representation with the given unit and items.
+fn cube_entities() -> String {
+ let mut s = String::new();
+ let pts = [(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0), (0, 0, 1), (1, 0, 1), (1, 1, 1), (0, 1, 1)];
+ for (i, (x, y, z)) in pts.iter().enumerate() {
+ s += &format!("#{}=CARTESIAN_POINT('',({x}.,{y}.,{z}.));\n#{}=VERTEX_POINT('',#{});\n", 200 + i, 210 + i, 200 + i);
+ }
+ // 12 edges as lines (direction vector filler; trimmed by vertices).
+ let edges = [(0, 1), (1, 2), (2, 3), (3, 0), (4, 5), (5, 6), (6, 7), (7, 4), (0, 4), (1, 5), (2, 6), (3, 7)];
+ s += "#290=DIRECTION('',(1.,0.,0.));\n#291=VECTOR('',#290,1.);\n";
+ for (k, (a, b)) in edges.iter().enumerate() {
+ s += &format!("#{}=LINE('',#{},#291);\n#{}=EDGE_CURVE('',#{},#{},#{},.T.);\n", 300 + k, 200 + a, 320 + k, 210 + a, 210 + b, 300 + k);
+ }
+ // Faces: (edge, forward?) loops counter-clockwise seen from outside, and plane frames.
+ let faces: [(&[(usize, bool)], (i32, i32, i32), (i32, i32, i32)); 6] = [
+ (&[(3, false), (2, false), (1, false), (0, false)], (0, 0, 0), (0, 0, -1)),
+ (&[(4, true), (5, true), (6, true), (7, true)], (0, 0, 1), (0, 0, 1)),
+ (&[(0, true), (9, true), (4, false), (8, false)], (0, 0, 0), (0, -1, 0)),
+ (&[(1, true), (10, true), (5, false), (9, false)], (1, 0, 0), (1, 0, 0)),
+ (&[(2, true), (11, true), (6, false), (10, false)], (1, 1, 0), (0, 1, 0)),
+ (&[(3, true), (8, true), (7, false), (11, false)], (0, 1, 0), (-1, 0, 0)),
+ ];
+ let mut face_ids = Vec::new();
+ for (f, (lp, o, n)) in faces.iter().enumerate() {
+ let base = 400 + f * 20;
+ let oes: Vec<String> = lp
+ .iter()
+ .enumerate()
+ .map(|(j, (e, fwd))| {
+ s += &format!("#{}=ORIENTED_EDGE('',*,*,#{},{});\n", base + j, 320 + e, if *fwd { ".T." } else { ".F." });
+ format!("#{}", base + j)
+ })
+ .collect();
+ s += &format!("#{}=EDGE_LOOP('',({}));\n#{}=FACE_OUTER_BOUND('',#{},.T.);\n", base + 5, oes.join(","), base + 6, base + 5);
+ s += &format!("#{}=CARTESIAN_POINT('',({}.,{}.,{}.));\n#{}=DIRECTION('',({}.,{}.,{}.));\n", base + 7, o.0, o.1, o.2, base + 8, n.0, n.1, n.2);
+ s += &format!("#{}=AXIS2_PLACEMENT_3D('',#{},#{},$);\n#{}=PLANE('',#{});\n", base + 9, base + 7, base + 8, base + 10, base + 9);
+ s += &format!("#{}=ADVANCED_FACE('',(#{}),#{},.T.);\n", base + 11, base + 6, base + 10);
+ face_ids.push(format!("#{}", base + 11));
+ }
+ s += &format!("#100=CLOSED_SHELL('',({}));\n#101=MANIFOLD_SOLID_BREP('Cube',#100);\n", face_ids.join(","));
+ s
+}
+
+fn context(id: u64, unit: &str) -> String {
+ format!(
+ "#{id}=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#{}))GLOBAL_UNIT_ASSIGNED_CONTEXT((#{},#{}))REPRESENTATION_CONTEXT('',''));\n#{}=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-6),#{},'','');\n#{}={unit};\n#{}=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));\n",
+ id + 1,
+ id + 2,
+ id + 3,
+ id + 1,
+ id + 2,
+ id + 2,
+ id + 3
+ )
+}
+
+fn product(pd: u64, name: &str) -> String {
+ format!(
+ "#{}=PRODUCT('{name}','{name}','',(#{}));\n#{}=PRODUCT_CONTEXT('',#9,'mechanical');\n#{}=PRODUCT_DEFINITION_FORMATION('','',#{});\n#{pd}=PRODUCT_DEFINITION('design','',#{},#8);\n#{}=PRODUCT_DEFINITION_SHAPE('','',#{pd});\n",
+ pd + 1,
+ pd + 2,
+ pd + 2,
+ pd + 3,
+ pd + 1,
+ pd + 3,
+ pd + 4
+ )
+}
+
+#[test]
+fn hand_written_part_in_inches_with_colour() {
+ let mut t = String::from(HEAD);
+ t += "#8=PRODUCT_DEFINITION_CONTEXT('part definition',#9,'design');\n#9=APPLICATION_CONTEXT('');\n";
+ t += &cube_entities();
+ t += &context(
+ 20,
+ "(CONVERSION_BASED_UNIT('INCH',#30)LENGTH_UNIT()NAMED_UNIT(*));\n#30=LENGTH_MEASURE_WITH_UNIT(LENGTH_MEASURE(25.4),#31);\n#31=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))",
+ );
+ t += &product(50, "Widget");
+ t += "#60=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#101),#20);\n#61=SHAPE_DEFINITION_REPRESENTATION(#54,#62);\n#62=SHAPE_REPRESENTATION('',(),#20);\n#63=SHAPE_REPRESENTATION_RELATIONSHIP('','',#62,#60);\n";
+ t += "#70=STYLED_ITEM('',(#71),#101);\n#71=PRESENTATION_STYLE_ASSIGNMENT((#72));\n#72=SURFACE_STYLE_USAGE(.BOTH.,#73);\n#73=SURFACE_SIDE_STYLE('',(#74));\n#74=SURFACE_STYLE_FILL_AREA(#75);\n#75=FILL_AREA_STYLE('',(#76));\n#76=FILL_AREA_STYLE_COLOUR('',#77);\n#77=COLOUR_RGB('',1.,0.5,0.);\n";
+ t += TAIL;
+ let imp = step_import(&t).unwrap();
+ assert!(imp.warnings.is_empty(), "{:?}", imp.warnings);
+ assert_eq!(imp.bodies.len(), 1);
+ let b = &imp.bodies[0];
+ assert_eq!(b.name, "Cube");
+ assert_eq!(b.path, vec!["Widget".to_string()]);
+ assert_eq!(b.color, Some([1.0, 0.5, 0.0]));
+ let m = measure(&b.body).unwrap();
+ assert!(rel(m.volume, 25.4f64.powi(3)) < 1e-9, "{}", m.volume);
+ assert_eq!(m.faces, 6);
+ assert_eq!(imp.tree.len(), 1);
+ assert_eq!(imp.tree[0].name, "Widget");
+}
+
+#[test]
+fn hand_written_assembly() {
+ let mut t = String::from(HEAD);
+ t += "#8=PRODUCT_DEFINITION_CONTEXT('part definition',#9,'design');\n#9=APPLICATION_CONTEXT('');\n";
+ t += &cube_entities();
+ t += &context(20, "(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.CENTI.,.METRE.))");
+ t += &context(30, "(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))");
+ // Part (cube, in cm) and assembly (mm) with two placed instances of it.
+ t += &product(50, "Block");
+ t += &product(70, "Assembly");
+ t += "#60=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#101,#65),#20);\n#61=SHAPE_DEFINITION_REPRESENTATION(#54,#60);\n";
+ t += "#65=AXIS2_PLACEMENT_3D('',#66,$,$);\n#66=CARTESIAN_POINT('',(0.,0.,0.));\n";
+ t += "#80=SHAPE_REPRESENTATION('',(#81,#84),#30);\n#81=AXIS2_PLACEMENT_3D('',#82,$,$);\n#82=CARTESIAN_POINT('',(0.,0.,0.));\n";
+ t += "#84=AXIS2_PLACEMENT_3D('',#85,#86,#87);\n#85=CARTESIAN_POINT('',(100.,0.,0.));\n#86=DIRECTION('',(0.,0.,1.));\n#87=DIRECTION('',(0.,1.,0.));\n";
+ t += "#88=SHAPE_DEFINITION_REPRESENTATION(#74,#80);\n";
+ for (k, item) in [(0u64, 81u64), (1, 84)] {
+ let n = 600 + k * 10;
+ t += &format!("#{n}=NEXT_ASSEMBLY_USAGE_OCCURRENCE('{k}','Block:{k}','',#70,#50,$);\n");
+ t += &format!("#{}=PRODUCT_DEFINITION_SHAPE('','',#{n});\n", n + 1);
+ t += &format!("#{}=ITEM_DEFINED_TRANSFORMATION('','',#65,#{item});\n", n + 2);
+ t += &format!(
+ "#{}=(REPRESENTATION_RELATIONSHIP('','',#60,#80)REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#{})SHAPE_REPRESENTATION_RELATIONSHIP());\n",
+ n + 3,
+ n + 2
+ );
+ t += &format!("#{}=CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#{},#{});\n", n + 4, n + 3, n + 1);
+ }
+ t += TAIL;
+ let imp = step_import(&t).unwrap();
+ assert!(imp.warnings.is_empty(), "{:?}", imp.warnings);
+ assert_eq!(imp.bodies.len(), 2);
+ let boxes: Vec<_> = imp.bodies.iter().map(|b| measure(&b.body).unwrap()).collect();
+ for m in &boxes {
+ assert!(rel(m.volume, 1000.0) < 1e-9, "{}", m.volume);
+ }
+ // First at the origin, second moved 100 mm along X and turned 90° about Z.
+ assert!(boxes[0].bbox.min.dist(Vec3::ZERO) < 1e-6 && boxes[0].bbox.max.dist(Vec3::new(10.0, 10.0, 10.0)) < 1e-6);
+ assert!(boxes[1].bbox.min.dist(Vec3::new(90.0, 0.0, 0.0)) < 1e-6, "{:?}", boxes[1].bbox);
+ assert!(boxes[1].bbox.max.dist(Vec3::new(100.0, 10.0, 10.0)) < 1e-6, "{:?}", boxes[1].bbox);
+ assert_eq!(imp.tree.len(), 1);
+ let root = &imp.tree[0];
+ assert_eq!(root.name, "Assembly");
+ assert_eq!(root.children.len(), 2);
+ assert!(root.children.iter().all(|c| c.name == "Block" && c.bodies.len() == 1));
+ assert_eq!(imp.bodies[1].path, vec!["Assembly".to_string(), "Block".to_string()]);
+ assert!((root.children[1].transform[3][0] - 100.0).abs() < 1e-9);
+}
+
+#[test]
+fn unsupported_face_is_left_out_and_reported() {
+ let mut t = String::from(HEAD);
+ let cube = cube_entities().replace("#410=PLANE('',#409);", "#410=OFFSET_SURFACE('',#409,1.,.F.);");
+ t += &cube;
+ t += "#60=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#101),#20);\n";
+ t += &context(20, "(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))");
+ t += TAIL;
+ let imp = step_import(&t).unwrap();
+ assert_eq!(imp.bodies.len(), 1);
+ assert!(!imp.bodies[0].closed);
+ assert_eq!(imp.bodies[0].body.face_count(), 5);
+ assert!(imp.warnings.iter().any(|w| w.contains("OFFSET_SURFACE")), "{:?}", imp.warnings);
+ assert!(imp.warnings.iter().any(|w| w.contains("open body")), "{:?}", imp.warnings);
+}
+
+#[test]
+fn hostile_files_never_panic() {
+ let good = step_export(&[&box_solid(Vec3::ZERO, Vec3::new(5.0, 5.0, 5.0)).unwrap()], "t").unwrap();
+ let mut cases: Vec<String> = vec![
+ String::new(),
+ "ISO-10303-21;".into(),
+ format!("{HEAD}{TAIL}"),
+ format!("{HEAD}#1=MANIFOLD_SOLID_BREP('',#1);\n#2=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#1),#3);\n{TAIL}"),
+ format!(
+ "{HEAD}#1=MANIFOLD_SOLID_BREP('',#2);\n#2=CLOSED_SHELL('',(#3));\n#3=ADVANCED_FACE('',(#4),#5,.T.);\n#4=FACE_BOUND('',#6,.T.);\n#6=EDGE_LOOP('',(#7));\n#7=ORIENTED_EDGE('',*,*,#7,.T.);\n#5=PLANE('',#5);\n#9=SHAPE_REPRESENTATION('',(#1),#10);\n{TAIL}"
+ ),
+ format!(
+ "{HEAD}#1=CARTESIAN_POINT('',(1.E308,1.E308,1.E308,1.,2.));\n#2=MANIFOLD_SOLID_BREP('',#1);\n#3=SHAPE_REPRESENTATION('',(#2),$);\n{TAIL}"
+ ),
+ format!(
+ "{HEAD}#1=NEXT_ASSEMBLY_USAGE_OCCURRENCE('','','',#2,#2,$);\n#2=PRODUCT_DEFINITION('','',#3,#3);\n#3=PRODUCT_DEFINITION_FORMATION('','',#3);\n{TAIL}"
+ ),
+ ];
+ // Truncations and byte flips of a real file.
+ for cut in (0..good.len()).step_by(97) {
+ cases.push(good.get(..cut).unwrap_or("").to_string());
+ }
+ for (i, from, to) in [(0, "1.0", "-1.0"), (1, "#1", "#9999"), (2, ".T.", ".F."), (3, "(0.0", "(nan"), (4, "B_SPLINE", "X_SPLINE")] {
+ let _ = i;
+ cases.push(good.replacen(from, to, 3));
+ }
+ cases.push(good.replace("CLOSED_SHELL", "OPEN_SHELL"));
+ for c in &cases {
+ let r = std::panic::catch_unwind(|| step_import(c));
+ assert!(r.is_ok(), "panicked on {:?}", c.get(..c.len().min(200)));
+ }
+}
+
+#[test]
+fn assembly_cycles_are_bounded() {
+ let mut t = String::from(HEAD);
+ t += "#8=PRODUCT_DEFINITION_CONTEXT('part definition',#9,'design');\n#9=APPLICATION_CONTEXT('');\n";
+ t += &cube_entities();
+ t += &context(20, "(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))");
+ t += &product(50, "A");
+ t += &product(70, "B");
+ t += "#60=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#101),#20);\n#61=SHAPE_DEFINITION_REPRESENTATION(#54,#60);\n";
+ // A contains B contains A.
+ t += "#90=NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','','',#50,#70,$);\n#91=NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','','',#70,#50,$);\n";
+ t += TAIL;
+ let r = step_import(&t);
+ // Every product is somebody's component: the solid is still imported (outside the tree).
+ let imp = r.unwrap();
+ assert_eq!(imp.bodies.len(), 1);
+}