SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 187/509: kernel: STEP import and export on the schema 4 record and SMLib
jyviko3696bf259e46
diff --git a/crates/kernel/src/step.rs b/crates/kernel/src/step.rsindex 1f6d343e64..f298e3d11c 100644--- a/crates/kernel/src/step.rs+++ b/crates/kernel/src/step.rs@@ -1,97 +1,5 @@-use truck_modeling as mt;-use truck_stepio::out;-+use crate::Result;use crate::body::Body;-use crate::{KernelError, Result, guard};--/// Intersection-curve edges (from booleans) as cubic B-splines through the exact curve: STEP-/// readers get plain 3D geometry that lies on both faces, and the file does not repeat the two-/// surfaces for every such edge.-fn plain_curves(b: &Body) -> Result<mt::Solid> {- let s = crate::ops::placed_topology(&b.solid, mt::Matrix4::from_scale(1.0))?;- let size = b.size();- let mut seen = std::collections::HashSet::new();- for e in s.edge_iter() {- if !seen.insert(e.id()) {- continue;- }- if let mt::Curve::IntersectionCurve(ic) = e.curve()- && let Some(c) = hermite_through(&ic, size * 1e-4)- {- e.set_curve(mt::Curve::BSplineCurve(c));- }- }- Ok(s)-}--/// A C¹ cubic B-spline through exact points of `c` spaced so that chords deviate at most `tol`-/// (Catmull–Rom tangents over chord length; the cubic is far closer than the chords).-fn hermite_through<C>(c: &C, tol: f64) -> Option<mt::BSplineCurve<mt::Point3>>-where- C: mt::ParametricCurve<Point = mt::Point3, Vector = mt::Vector3> + mt::BoundedCurve + mt::ParameterDivision1D<Point = mt::Point3>,-{- use mt::{InnerSpace, MetricSpace};- let (_, pts) = c.parameter_division(c.range_tuple(), tol);- let pts: Vec<mt::Point3> = pts.into_iter().fold(Vec::new(), |mut v: Vec<mt::Point3>, p| {- if v.last().is_none_or(|q| q.distance(p) > tol * 1e-3) {- v.push(p);- }- v- });- let n = pts.len().checked_sub(1).filter(|n| *n >= 1 && *n < 1_000_000)?;- let mut u = vec![0.0; n + 1];- for i in 1..=n {- u[i] = u[i - 1] + pts[i].distance(pts[i - 1]);- }- let tangent = |i: usize| {- let (a, b) = (i.saturating_sub(1), (i + 1).min(n));- (pts[b] - pts[a]) / (u[b] - u[a])- };- let mut ctrl = vec![pts[0]];- let mut knots = vec![u[0]; 4];- for i in 0..n {- let h = u[i + 1] - u[i];- ctrl.push(pts[i] + tangent(i) * (h / 3.0));- ctrl.push(pts[i + 1] - tangent(i + 1) * (h / 3.0));- ctrl.push(pts[i + 1]);- knots.extend(std::iter::repeat_n(u[i + 1], if i + 1 == n { 4 } else { 3 }));- }- if ctrl.iter().any(|p| !(p.x.is_finite() && p.y.is_finite() && p.z.is_finite())) || tangent(0).magnitude() == 0.0 {- return None;- }- mt::BSplineCurve::try_new(mt::KnotVec::from(knots), ctrl).ok()-}--/// truck's STEP text for the given bodies (geometry and topology; product data is ours).-pub(crate) fn truck_step(bodies: &[&Body], system: &str) -> Result<String> {- if bodies.is_empty() {- return Err(KernelError::Invalid("nothing to export".into()));- }- for b in bodies {- b.require_brep("STEP export")?;- }- guard("step export", || {- let cs: Vec<_> = bodies.iter().map(|b| plain_curves(b).map(|solid| solid.compress())).collect::<Result<_>>()?;- let models: out::StepModels<_, _, _> = cs.iter().collect();- let header = out::StepHeaderDescriptor { organization_system: system.to_owned(), ..Default::default() };- written(&out::CompleteStepDisplay::new(models, header))- })-}--/// The text of truck's STEP writer, or an error. The writer refuses some geometry by returning-/// `fmt::Error` after a line saying why; `to_string` would turn that into a panic (caught by-/// `guard` on the desktop, but the browser build aborts on any panic).-fn written(display: &impl std::fmt::Display) -> Result<String> {- use std::fmt::Write;- let mut text = String::new();- match write!(text, "{display}") {- Ok(()) => Ok(text),- Err(_) => {- let why = text.lines().last().map(str::trim).filter(|l| !l.is_empty() && !l.starts_with('#')).unwrap_or("unsupported geometry");- Err(KernelError::Failed(format!("not supported yet: STEP export of this body ({why})")))- }- }-}/// STEP (ISO 10303-21, AP242) text for the given bodies as one part (`Body1`…, with the/// bodies' colours).diff --git a/crates/kernel/src/step_in/brep.rs b/crates/kernel/src/step_in/brep.rsdeleted file mode 100644index 37591e5acf..0000000000--- a/crates/kernel/src/step_in/brep.rs+++ /dev/null@@ -1,663 +0,0 @@-//! 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, InnerSpace, MetricSpace, ParametricCurve, ParametricSurface};-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;-/// Most boundary loops on one face. Each bound clones its edge handles into a new wire and the-/// face extent then samples nine points per edge, so one face listing the same 100,000-edge-/// loop a million times would hold 1e11 handles.-const MAX_BOUNDS: usize = 10_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,- /// The file face of each kernel face, in face order.- pub face_origin: Vec<u64>,-}--#[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"))-}--/// A contractible outer loop whose winding opposes the surface's parameter normal.-/// Samples follow the wire through periodic seams; a loop that winds around a surface is-/// not a disk in parameter space and must retain the file's sense.-/// The point of a cone (a surface revolved from a line that meets its axis) when `ring`, a-/// face's only loop, goes once round the axis without touching it: the face then reaches the-/// point. `None` for any other surface or loop.-fn enclosed_apex(surface: &mt::Surface, ring: &mt::Wire, tol: f64) -> Option<mt::Point3> {- use mt::Transform as _;- let mt::Surface::RevolutedCurve(proc) = surface else { return None };- let rc = proc.entity();- let mt::Curve::Line(line) = rc.entity_curve() else { return None };- let (o, axis) = (rc.origin(), rc.axis().normalize());- // The rotation applied to the revolved surface, applied to its axis and profile too.- let m = proc.transform();- let (o, axis) = (m.transform_point(o), m.transform_vector(axis).normalize());- let (p0, p1) = (m.transform_point(line.0), m.transform_point(line.1));- let radius = |p: mt::Point3| (p - o).cross(axis).magnitude();- let (r0, r1) = (radius(p0), radius(p1));- if !((r0 - r1).abs() > 1e-9 * (r0 + r1)) {- return None;- }- let apex = p0 + (p1 - p0) * (r0 / (r0 - r1));- if !(radius(apex) <= tol.max(1e-9) * 10.0) {- return None;- }- // Once round the axis, staying clear of it.- let x = (p0 - o) - axis * (p0 - o).dot(axis);- let x = if x.magnitude() > tol { x.normalize() } else { return None };- let y = axis.cross(x);- let mut turned = 0.0;- let mut last: Option<f64> = None;- let mut first: Option<f64> = None;- for edge in ring.edge_iter() {- let c = edge.oriented_curve();- let (t0, t1) = c.range_tuple();- for k in 0..16 {- let q = c.subs(t0 + (t1 - t0) * f64::from(k) / 16.0);- if radius(q) <= tol {- return None;- }- let d = q - o;- let ang = d.dot(y).atan2(d.dot(x));- if let Some(l) = last {- let mut step = ang - l;- step -= (step / std::f64::consts::TAU).round() * std::f64::consts::TAU;- turned += step;- } else {- first = Some(ang);- }- last = Some(ang);- }- }- if let (Some(l), Some(f)) = (last, first) {- let mut step = f - l;- step -= (step / std::f64::consts::TAU).round() * std::f64::consts::TAU;- turned += step;- }- ((turned.abs() - std::f64::consts::TAU).abs() < 0.1).then_some(apex)-}--fn reversed_outer(surface: &mt::Surface, wire: &mt::Wire, tol: f64) -> bool {- if let mt::Surface::RevolutedCurve(proc) = surface {- let rc = proc.entity();- let curve = rc.entity_curve();- let on_axis = |p: mt::Point3| (p - rc.origin()).cross(rc.axis()).magnitude() <= tol;- // A compact support has two legitimate sides of a closed trim (a sphere's- // hemispheres, for example); its winding must choose the side, not repair it.- if (on_axis(curve.front()) && on_axis(curve.back())) || curve.front().distance(curve.back()) <= tol {- return false;- }- }- let periods = truck_meshalgo::tessellation::surface_periods(surface);- let mut first = None::<[f64; 2]>;- let mut previous = None::<[f64; 2]>;- let (mut area, mut magnitude) = (0.0, 0.0);- for edge in wire.edge_iter() {- let curve = edge.oriented_curve();- let (a, b) = curve.range_tuple();- for k in 0..8 {- let point = curve.subs(a + (b - a) * f64::from(k) / 8.0);- let hint = previous.map(|p| (p[0], p[1]));- let valid = |&(u, v): &(f64, f64)| u.is_finite() && v.is_finite() && surface.subs(u, v).distance(point) <= tol;- let Some((u, v)) = truck_meshalgo::tessellation::project_trim_point(surface, point, hint, tol).filter(valid) else {- return false;- };- // A pole has no unique parameter in its collapsed direction. Its arbitrary- // search result cannot determine the winding of an outer loop.- let (du, dv) = (surface.uder(u, v), surface.vder(u, v));- if du.cross(dv).magnitude2() <= 1e-12 * (du.magnitude2() + dv.magnitude2()).powi(2) {- return false;- }- let mut p = [u, v];- let origin = *first.get_or_insert(p);- if let Some(prev) = previous {- for (d, x) in p.iter_mut().enumerate() {- if let Some(period) = periods.get(d).copied().flatten().filter(|p| *p > 0.0) {- *x -= ((*x - prev[d]) / period).round() * period;- }- }- let cross = (prev[0] - origin[0]) * (p[1] - origin[1]) - (p[0] - origin[0]) * (prev[1] - origin[1]);- area += cross;- magnitude += cross.abs();- }- previous = Some(p);- }- }- let (Some(first), Some(last)) = (first, previous) else { return false };- if periods.iter().enumerate().any(|(d, p)| p.is_some_and(|p| (first[d] - last[d]).abs() > p * 0.5)) {- return false;- }- area < -16.0 * f64::EPSILON * magnitude-}--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, cx.snap).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 bounds = refs(p.get(1));- if bounds.len() > MAX_BOUNDS {- return Err(format!("a face with more than {MAX_BOUNDS} boundary loops"));- }- let mut wires = Vec::new();- let mut outer = None;- let mut edges = 0usize;- for b in bounds {- if let Some(w) = self.bound(cx, b)? {- if entity(cx, b)?.name() == "FACE_OUTER_BOUND" {- outer = Some(wires.len());- }- edges = edges.saturating_add(w.len());- if edges > MAX_LOOP {- return Err(format!("a face with more than {MAX_LOOP} boundary edges"));- }- 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 mut surface = if e.name() == "FACE" {- crate::plane_fit::plane_through(&extent).map(mt::Surface::Plane).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())?- };- // An explicit outer bound encloses the face. Some exporters give its surface the- // opposite sense; treating that loop as a hole meshes the rest of the supporting- // cylinder instead. Match the surface to the outer loop without reversing- // shared topological edges. Winding loops (bands and pole seams) are left alone.- if e.name() != "FACE" && seam.is_empty() && outer.and_then(|i| wires.get(i)).is_some_and(|w| reversed_outer(&surface, w, cx.tol)) {- let sid = rid(p.get(2), "face geometry")?;- let sense = p.get(3).and_then(Param::as_bool).unwrap_or(true);- surface = guard("step surface orientation", || geom::surface(cx, sid, &extent, &seam, !sense, 0).map_err(crate::KernelError::Failed))- .map_err(|e| e.to_string())?;- }- // A cone face bounded only by a ring round its axis (no vertex at the point, or a- // VERTEX_LOOP there, which has no edges) covers the cone up to its point. Its surface- // was spanned over the ring alone, a sliver at the base; it is spanned to the apex,- // and the ring is joined to the apex by a seam line out and back, as a cone with a- // seam is written.- let (mut wires, mut surface) = (wires, surface);- if e.name() != "FACE"- && seam.is_empty()- && let [ring] = wires.as_slice()- && let Some(apex) = enclosed_apex(&surface, ring, cx.tol)- && let Some(first) = ring.edge_iter().next()- {- let v = first.front().clone();- let a = mt::Vertex::new(apex);- let line = mt::Edge::new_unchecked(&v, &a, mt::Curve::Line(mt::Line(v.point(), apex)));- let mut to_apex = extent.clone();- to_apex.push(apex);- let seam_line = [v.point(), apex];- let sid = rid(p.get(2), "face geometry")?;- let sense = p.get(3).and_then(Param::as_bool).unwrap_or(true);- let spanned =- guard("step cone to its point", || geom::surface(cx, sid, &to_apex, &seam_line, sense, 0).map_err(crate::KernelError::Failed))- .map_err(|e| e.to_string())?;- let mut edges: Vec<mt::Edge> = ring.edge_iter().cloned().collect();- edges.push(line.clone());- edges.push(line.inverse());- wires = vec![edges.into()];- surface = spanned;- }- // Loops on a surface of revolution start away from the axis: a pole (cone apex, sphere- // pole) has no definite rotation parameter, and the mesher takes the first point's- // parameter as the anchor for the rest of the loop.- let wires: Vec<mt::Wire> = match &surface {- mt::Surface::RevolutedCurve(rc) => {- let (o, a) = (rc.entity().origin(), rc.entity().axis());- let dist = |e: &mt::Edge| {- let v = e.front().point() - o;- (v - a * v.dot(a)).magnitude()- };- wires- .into_iter()- .map(|w| {- let edges: Vec<mt::Edge> = w.edge_iter().cloned().collect();- let start = edges.iter().enumerate().max_by(|x, y| dist(x.1).total_cmp(&dist(y.1))).map(|(i, _)| i).unwrap_or(0);- edges.iter().skip(start).chain(edges.iter().take(start)).cloned().collect::<Vec<_>>().into()- })- .collect()- }- // A loop passing a vertex twice (a figure eight through a pole, as written for a- // torus whose tube touches its axis) starts at a vertex it passes once.- _ => wires- .into_iter()- .map(|w| {- let edges: Vec<mt::Edge> = w.edge_iter().cloned().collect();- // Counted once: a loop may hold 100,000 edges, and asking per edge how- // often its front vertex appears would scan them all again each time.- let mut fronts: HashMap<_, usize> = HashMap::new();- for e in &edges {- *fronts.entry(e.front().id()).or_default() += 1;- }- let passes = |e: &mt::Edge| fronts.get(&e.front().id()).copied().unwrap_or(0);- match edges.first().map(passes) {- Some(n) if n > 1 => {- let start = edges.iter().position(|e| passes(e) == 1).unwrap_or(0);- edges.iter().skip(start).chain(edges.iter().take(start)).cloned().collect::<Vec<_>>().into()- }- _ => w,- }- })- .collect(),- };- 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, Vec<u64>)> {- 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());- let mut origin = 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);- origin.push(f);- }- 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 ball = match (out.as_slice(), origin.as_slice()) {- ([face], [file_face]) => whole_sphere(cx, *file_face, face).map(|patches| (*file_face, patches)),- _ => None,- };- if let Some((file_face, patches)) = ball {- origin = vec![file_face; patches.len()];- out = patches;- }- let out = super::split::split_bands(out, &mut origin, failed, cx.tol);- Ok((out.into(), closed, read, origin))- }-}--/// A ball written as one face on a sphere bounded only by its seam, run out and back from pole-/// to pole. Truck meshes a face on a revolved surface in parameter space, where that loop-/// encloses nothing, so the ball is built as the kernel's own sphere instead: six patches with-/// no pole or seam inside them (`build::sphere_patch_faces`), turned inside out for a void.-/// `None` for any other face.-fn whole_sphere(cx: &Ctx, file_face: u64, face: &mt::Face) -> Option<Vec<mt::Face>> {- use mt::{ParametricSurface3D, SearchParameter};- let surface = entity(cx, file_face).ok()?.params().get(2).and_then(Param::as_ref_id)?;- if entity(cx, surface).ok()?.name() != "SPHERICAL_SURFACE" {- return None;- }- let wires = face.boundaries();- let edges: Vec<&mt::Edge> = wires.iter().flat_map(|w| w.edge_iter()).collect();- let mut uses: HashMap<mt::EdgeID, usize> = HashMap::new();- let mut poles: Vec<mt::Vertex> = Vec::new();- for e in &edges {- *uses.entry(e.id()).or_default() += 1;- for v in [e.front(), e.back()] {- if !poles.iter().any(|p| p.id() == v.id()) {- poles.push(v.clone());- }- }- }- // Every edge a seam (used once each way), and the two vertices it joins are the poles.- if uses.is_empty() || uses.values().any(|n| *n != 2) {- return None;- }- let [a, b] = poles.as_slice() else { return None };- let (a, b) = (a.point(), b.point());- let center = a + (b - a) * 0.5;- let radius = a.distance(b) * 0.5;- let tol = cx.tol.max(radius * 1e-6);- // The seam is a meridian: all of it on the sphere whose diameter joins the poles.- let samples = |e: &&mt::Edge| {- 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))- };- if !(radius.is_finite() && radius > tol) || !edges.iter().flat_map(samples).all(|p| (p.distance(center) - radius).abs() <= tol) {- return None;- }- // Ball or void: the face's normal at the middle of the seam, against the way out of the centre.- let probe = edges.first().and_then(|e| samples(e).nth(4))?;- let oriented = face.oriented_surface();- let (u, v) = oriented.search_parameter(probe, mt::SPHint2D::None, 100)?;- let outward = oriented.normal(u, v).dot(probe - center) > 0.0;- let z = (crate::body::from_p3(a) - crate::body::from_p3(b)).normalized()?;- let x = z.any_perp();- let c = crate::body::from_p3(center);- let mut patches = guard("step sphere", || crate::build::sphere_patch_faces(c, radius, [x, z.cross(x), z])).ok()?;- if !outward {- for f in &mut patches {- f.invert();- }- }- Some(patches)-}--/// 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;- // The file face each kernel face comes from (in face order).- let mut face_origin = Vec::new();- match e.name() {- "MANIFOLD_SOLID_BREP" | "FACETED_BREP" | "BREP_WITH_VOIDS" => {- let (s, c, n, o) = b.shell(cx, rid(p.get(1), "brep outer shell")?, &mut failed)?;- closed &= c;- file_faces += n;- shells.push(s);- face_origin.extend(o);- if e.name() == "BREP_WITH_VOIDS" {- for v in refs(p.get(2)) {- match b.shell(cx, v, &mut failed) {- Ok((s, c, n, o)) => {- closed &= c;- file_faces += n;- shells.push(s);- face_origin.extend(o);- }- 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, o)) => {- closed &= c;- file_faces += n;- shells.push(s);- face_origin.extend(o);- }- 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()));- }- // `mt::Solid::try_new` only checks each shell (non-empty, connected, closed, no singular- // vertex) and hands the shells back unchanged (truck-topology 0.6.0), so the same checks run- // here on the borrowed shells. The successful path used to clone every face, edge, vertex,- // curve and surface to keep a copy that was then dropped.- let checked = guard("step solid", || {- for shell in &shells {- if shell.is_empty() {- return Err(crate::KernelError::Failed("empty shell".into()));- }- if !shell.is_connected() {- return Err(crate::KernelError::Failed("shell is not connected".into()));- }- if shell.shell_condition() != mt::ShellCondition::Closed {- return Err(crate::KernelError::Failed("shell is not closed".into()));- }- if !shell.singular_vertices().is_empty() {- return Err(crate::KernelError::Failed("shell is not manifold".into()));- }- }- Ok(())- });- if checked.is_err() {- closed = false;- }- // A void's faces face into the cavity, out of the material: it encloses volume of the- // opposite sign to the outer shell. The ORIENTED_CLOSED_SHELL flag alone doesn't say so:- // some exporters write .F. over a shell already facing into the cavity (#3730), others .T.- // A void enclosing volume of the outer shell's sign is turned inside out.- if e.name() == "BREP_WITH_VOIDS"- && checked.is_ok()- && let Some((outer, voids)) = shells.split_first_mut()- && let Some(outside) = crate::body::shell_volume(outer)- {- for void in voids {- if crate::body::shell_volume(void).is_some_and(|v| v * outside > 0.0) {- for face in void.face_iter_mut() {- face.invert();- }- }- }- }- Ok(BrepOut { solid: mt::Solid::new_unchecked(shells), failed, closed, file_faces, face_origin })-}diff --git a/crates/kernel/src/step_in/conic_tests.rs b/crates/kernel/src/step_in/conic_tests.rsindex 5e76a3e600..abbe118960 100644--- a/crates/kernel/src/step_in/conic_tests.rs+++ b/crates/kernel/src/step_in/conic_tests.rs@@ -4,10 +4,6 @@use std::f64::consts::{FRAC_PI_4, PI};-use mt::{BoundedCurve, InnerSpace, ParametricCurve};-use truck_modeling as mt;--use super::geom::{Frame, hyperbola_arc, parabola_arc};use super::*;use crate::{measure, step_export};@@ -18,47 +14,6 @@ const CONTEXT: &str = "#90=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#81),#91);\n#9/// Height of the cone pieces: the 45° cone `x² + y² = z²` up to `z = H`.const H: f64 = 10.0;-#[test]-fn extruded_ellipse_seam_uses_profile_angles_for_oblique_sweeps() {- use mt::{MetricSpace, ParametricSurface};-- let text = format!(- "{HEAD}-#1=CARTESIAN_POINT('',(10.,-20.,3.));-#2=DIRECTION('',(0.,0.,1.));-#3=DIRECTION('',(1.,0.,0.));-#4=AXIS2_PLACEMENT_3D('',#1,#2,#3);-#5=ELLIPSE('',#4,9.,4.);-#6=DIRECTION('',(0.5,0.25,1.));-#7=VECTOR('',#6,1.);-#8=SURFACE_OF_LINEAR_EXTRUSION('',#5,#7);-{TAIL}"- );- let ex = p21::parse(&text).unwrap();- let cx = Ctx { ex: &ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };- let origin = mt::Point3::new(10.0, -20.0, 3.0);- let d = mt::Vector3::new(0.5, 0.25, 1.0).normalize();- let point = |angle: f64, h: f64| origin + mt::Vector3::new(9.0 * angle.cos(), 4.0 * angle.sin(), 0.0) + d * h;- let extent: Vec<_> = [-0.04, 0.0, 0.04].into_iter().flat_map(|a| [point(a, 0.0), point(a, 10.0)]).collect();- for seam in [Vec::new(), vec![point(-0.04, 0.0), point(-0.04, 10.0)]] {- let surface = geom::surface(&cx, 8, &extent, &seam, true, 0).unwrap();- for i in 0..=16 {- for j in 0..=4 {- let q = surface.subs(i as f64 / 16.0, j as f64 / 4.0) - origin;- let q = q - d * (q.z / d.z);- assert!(((q.x / 9.0).powi(2) + (q.y / 4.0).powi(2) - 1.0).abs() < 1e-12);- }- }- let start = surface.subs(0.0, 0.5);- let q = start - d * ((start.z - origin.z) / d.z);- if seam.is_empty() {- assert!(q.distance(point(std::f64::consts::PI, 0.0)) < 1e-9);- } else {- assert!(q.distance(point(-0.04, 0.0)) < 1e-9);- }- }-}-fn rel(a: f64, b: f64) -> f64 {(a - b).abs() / b.abs().max(1e-9)}@@ -190,34 +145,6 @@ fn parabola_bounded_faces_import() {assert!(rel(v, want) < 1e-4, "schema 4: {v} vs {want}");}-/// The kernel curves lie exactly on the conics, end to end, whichever way they run.-#[test]-fn conic_arcs_are_exact() {- let f = Frame { o: mt::Point3::new(1.0, 2.0, 3.0), x: mt::Vector3::unit_y(), y: mt::Vector3::unit_z(), z: mt::Vector3::unit_x() };- let local = |p: mt::Point3| ((p - f.o).dot(f.x), (p - f.o).dot(f.y), (p - f.o).dot(f.z));- for (t0, t1) in [(-1.5, 2.0), (3.0, -0.25), (0.0, 7.5)] {- let c = hyperbola_arc(&f, 3.0, 2.0, t0, t1);- let (s0, s1) = c.range_tuple();- for i in 0..=200 {- let (x, y, z) = local(c.subs(s0 + (s1 - s0) * i as f64 / 200.0));- assert!((x * x / 9.0 - y * y / 4.0 - 1.0).abs() < 1e-9 && x > 0.0 && z.abs() < 1e-12, "{x} {y}");- }- let (x, y, _) = local(c.subs(s0));- assert!((x - 3.0 * f64::cosh(t0)).abs() < 1e-9 && (y - 2.0 * f64::sinh(t0)).abs() < 1e-9);- let (x, y, _) = local(c.subs(s1));- assert!((x - 3.0 * f64::cosh(t1)).abs() < 1e-9 && (y - 2.0 * f64::sinh(t1)).abs() < 1e-9);-- let c = parabola_arc(&f, 1.5, t0, t1);- let (s0, s1) = c.range_tuple();- for i in 0..=200 {- let (x, y, z) = local(c.subs(s0 + (s1 - s0) * i as f64 / 200.0));- assert!((y * y - 4.0 * 1.5 * x).abs() < 1e-9 * (1.0 + x.abs()) && z.abs() < 1e-12, "{x} {y}");- }- let (x, y, _) = local(c.subs(s1));- assert!((x - 1.5 * t1 * t1).abs() < 1e-9 && (y - 3.0 * t1).abs() < 1e-9);- }-}-/// Hostile conics are errors (the face is reported and left out), never panics.#[test]fn hostile_conics_never_panic() {diff --git a/crates/kernel/src/step_in/geom.rs b/crates/kernel/src/step_in/geom.rsdeleted file mode 100644index e5f27f3200..0000000000--- a/crates/kernel/src/step_in/geom.rs+++ /dev/null@@ -1,1237 +0,0 @@-//! STEP geometry (ISO 10303-42 entities) to kernel curves and surfaces.-//!-//! Points, placements, lines, conics (ellipses, hyperbolas and parabolas), B-splines (plain and rational), elementary surfaces and-//! swept surfaces, with exact offsets of planes, cylinders, cones, spheres and regular tori.-//! Free-form offsets and offsets through collapsed radii remain explicit import warnings.-//! 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 solidcraft_geom::Ring;-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,- },- /// Hyperbola branch `o + a·cosh t·x + b·sinh t·y` in the frame's XY plane.- Hyperbola {- f: Frame,- a: f64,- b: f64,- },- /// Parabola `o + focal·(t²·x + 2t·y)` in the frame's XY plane.- Parabola {- f: Frame,- focal: 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)-}--pub(super) 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.-pub(crate) 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))-}--/// `expected` is the knot count the control points and degree imply. Multiplicities are-/// expanded into one value each, so the sum has to be checked before the expansion: 20 million-/// knots of multiplicity 64 would build a 10 GB vector that the length check then rejects, and-/// an allocation failure aborts the process where an error does not.-fn knot_vec(mults: Option<&Param>, knots: Option<&Param>, expected: usize) -> 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());- }- if m.len() > expected || m.iter().try_fold(0usize, |a, v| a.checked_add(*v)) != Some(expected) {- return Err("knot multiplicities do not match the control points".into());- }- mt::KnotVec::from_single_multi(spanning_one(k), m).map_err(|e| format!("knot vector: {e}"))-}--/// Shortest parameter range a spline is read with.-const MIN_KNOT_RANGE: f64 = 1.0;--/// `knots` stretched, when they span less than [`MIN_KNOT_RANGE`], to span exactly that from the-/// same first knot. A STEP writer may parameterize a spline over any range (some write a few-/// millionths, as if in metres of a part drawn in millimetres), and the kernel tells parameters-/// apart only to a fixed tolerance (1e-6): over such a range it took distinct knots for one, and-/// trimming an edge to its vertices dropped a control point. Stretching the knots changes the-/// parameters, never the curve (every point is where it was), and nothing read from the file-/// refers to them: edges are trimmed by their vertices.-fn spanning_one(knots: Vec<f64>) -> Vec<f64> {- let (Some(&first), Some(&last)) = (knots.first(), knots.last()) else { return knots };- let range = last - first;- if !(range > 0.0 && range < MIN_KNOT_RANGE) {- return knots;- }- let scale = MIN_KNOT_RANGE / range;- let mut out: Vec<f64> = knots.iter().map(|k| first + (k - first) * scale).collect();- // The last knot exactly at the end of the range (the product can miss it by a rounding).- if let Some(k) = out.last_mut() {- *k = first + MIN_KNOT_RANGE;- }- out-}--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))-}--/// The ends of the part of a knot vector where a B-spline of `degree` is defined, when its end-/// knots repeat fewer than `degree + 1` times (an unclamped or periodic knot vector, as-/// OpenCascade writes closed B-splines and `UNIFORM_*` curves and surfaces have): only between-/// knot `degree` and knot `len - degree - 1` do the basis functions sum to one. `None` for a-/// clamped vector, whose whole range is the domain, and for one whose domain is a point.-fn unclamped_ends(kv: &mt::KnotVec, degree: usize) -> Option<(Option<f64>, Option<f64>)> {- let n = kv.len();- if n < 2 * (degree + 1) || !(kv[n - 1 - degree] - kv[degree] > mt::TOLERANCE) {- return None;- }- let lo = (kv.multiplicity(0) <= degree).then(|| kv[degree]);- let hi = (kv.multiplicity(n - 1) <= degree).then(|| kv[n - 1 - degree]);- (lo.is_some() || hi.is_some()).then_some((lo, hi))-}--/// `c` restricted to its domain, with clamped ends (exact: knots are inserted at the domain's-/// ends and the control points beyond them dropped). The kernel takes a B-spline's whole knot-/// range as its parameter range, and an unclamped curve evaluated outside its domain leaves-/// its control polygon (a rational one divides by zero at the outermost knots).-fn clamped_curve<P: mt::control_point::ControlPoint<f64> + mt::Tolerance>(mut c: mt::BSplineCurve<P>) -> mt::BSplineCurve<P> {- let Some((lo, hi)) = unclamped_ends(c.knot_vec(), c.degree()) else { return c };- if let Some(lo) = lo {- c = c.cut(lo);- }- if let Some(hi) = hi {- let _ = c.cut(hi);- }- c-}--/// [`clamped_curve`] for a surface, in each direction whose knot vector is unclamped.-fn clamped_surface<P: mt::control_point::ControlPoint<f64> + mt::Tolerance>(mut s: mt::BSplineSurface<P>) -> mt::BSplineSurface<P> {- if let Some((lo, hi)) = unclamped_ends(s.uknot_vec(), s.udegree()) {- if let Some(lo) = lo {- s = s.ucut(lo);- }- if let Some(hi) = hi {- let _ = s.ucut(hi);- }- }- if let Some((lo, hi)) = unclamped_ends(s.vknot_vec(), s.vdegree()) {- if let Some(lo) = lo {- s = s.vcut(lo);- }- if let Some(hi) = hi {- let _ = s.vcut(hi);- }- }- s-}--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, ctrl.len() + degree + 1)?,- 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(mt::NurbsCurve::new(clamped_curve(n.into_non_rationalized()))))- }- None => Ok(CurveGeo::BSpline(clamped_curve(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 })- }- "HYPERBOLA" => {- let f = frame(cx, p.get(1).and_then(Param::as_ref_id).ok_or("HYPERBOLA without placement")?)?;- let (a, b) = (length(cx, p.get(2), "semi axis")?, length(cx, p.get(3), "semi imaginary axis")?);- if a <= 0.0 || b <= 0.0 {- return Err("hyperbola axes must be positive".into());- }- Ok(CurveGeo::Hyperbola { f, a, b })- }- "PARABOLA" => {- let f = frame(cx, p.get(1).and_then(Param::as_ref_id).ok_or("PARABOLA without placement")?)?;- let focal = length(cx, p.get(2), "focal distance")?;- if focal == 0.0 {- return Err("parabola focal distance must not be zero".into());- }- Ok(CurveGeo::Parabola { f, focal })- }- "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))-}--/// Largest hyperbola parameter step one rational quadratic piece spans (keeps its weight-/// `cosh(step / 2)` near 1).-const HYPERBOLA_STEP: f64 = 1.0;--/// Exact rational quadratic NURBS of the hyperbola branch from parameter `t0` to `t1` (either-/// order): pieces whose middle control point is the meeting point of the end tangents, weighted-/// `cosh` of the half step (the hyperbolic counterpart of [`conic_arc`]).-pub(crate) fn hyperbola_arc(f: &Frame, a: f64, b: f64, t0: f64, t1: f64) -> mt::NurbsCurve<mt::Vector4> {- let n = (((t1 - t0).abs() / HYPERBOLA_STEP).ceil() as usize).clamp(1, 64);- let dt = (t1 - t0) / n as f64;- let w = (dt * 0.5).cosh();- let at = |c: f64, s: f64| f.at(a * c, b * s, 0.0);- let mut ctrl = Vec::with_capacity(2 * n + 1);- ctrl.push(at(t0.cosh(), t0.sinh()).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.cosh() / w, tm.sinh() / w);- ctrl.push(mt::Vector4::new(m.x * w, m.y * w, m.z * w, w));- ctrl.push(at(tb.cosh(), tb.sinh()).to_homogeneous());- let k = (i + 1) as f64 / n as f64;- knots.push(k);- knots.push(k);- }- knots.push(1.0);- mt::NurbsCurve::new(mt::BSplineCurve::new(mt::KnotVec::from(knots), ctrl))-}--/// The parabola from parameter `t0` to `t1` (either order): one quadratic Bézier, exact.-pub(crate) fn parabola_arc(f: &Frame, focal: f64, t0: f64, t1: f64) -> mt::BSplineCurve<mt::Point3> {- let at = |t: f64| f.at(focal * t * t, 2.0 * focal * t, 0.0);- // The end tangents meet above the parameter midpoint: o + focal·(t0·t1, t0 + t1).- let mid = f.at(focal * t0 * t1, focal * (t0 + t1), 0.0);- mt::BSplineCurve::new(mt::KnotVec::bezier_knot(2), vec![at(t0), mid, at(t1)])-}--/// Parameter of the open conic at `p`, a point on (or within `tol` of) the curve.-fn open_conic_param(g: &CurveGeo, p: mt::Point3, tol: f64) -> R<f64> {- let (t, q) = match g {- CurveGeo::Hyperbola { f, a, b } => {- let t = ((p - f.o).dot(f.y) / b).asinh();- (t, f.at(a * t.cosh(), b * t.sinh(), 0.0))- }- CurveGeo::Parabola { f, focal } => {- let t = (p - f.o).dot(f.y) / (2.0 * focal);- (t, f.at(focal * t * t, 2.0 * focal * t, 0.0))- }- _ => return Err("not an open conic".into()),- };- let d = q.distance(p);- if !t.is_finite() || !(d <= tol) {- return Err(format!(- "edge vertex is {d:.3e} mm off its {} curve",- if matches!(g, CurveGeo::Parabola { .. }) { "parabola" } else { "hyperbola" }- ));- }- Ok(t)-}--/// The open conic between parameters `t0` and `t1` as a kernel curve.-fn open_conic_curve(g: &CurveGeo, t0: f64, t1: f64) -> R<mt::Curve> {- match g {- CurveGeo::Hyperbola { f, a, b } => Ok(mt::Curve::NurbsCurve(hyperbola_arc(f, *a, *b, t0, t1))),- CurveGeo::Parabola { f, focal } => Ok(mt::Curve::BSplineCurve(parabola_arc(f, *focal, t0, t1))),- _ => Err("not an open conic".into()),- }-}--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). The vertices may-/// be up to `snap` off the curve; `tol` decides whether the curve closes on itself.-fn spline_pieces<C>(c: &C, ps: mt::Point3, pe: mt::Point3, sense: bool, closed: bool, tol: f64, snap: 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 <= snap && de <= snap) {- 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)-}--/// Moves one end of a spline piece (`back`: its end, else its start) onto its vertex `p` by-/// the control point that end sits on, so the piece meets the vertex exactly and keeps its-/// shape away from that end. A piece whose end is not a control point (an unclamped spline) is-/// left as it is.-fn pin_end(c: &mut mt::Curve, p: mt::Point3, back: bool) {- let end = if back { c.back() } else { c.front() };- let d = p - end;- if !(d.magnitude2() > 0.0) {- return;- }- let at_end = |q: mt::Point3| q.distance(end) <= mt::TOLERANCE;- match c {- mt::Curve::BSplineCurve(b) => {- let cp = if back { b.control_points_mut().last() } else { b.control_points_mut().next() };- if let Some(q) = cp.filter(|q| at_end(**q)) {- *q += d;- }- }- mt::Curve::NurbsCurve(n) => {- let cp = if back { n.control_points_mut().last() } else { n.control_points_mut().next() };- if let Some(q) = cp.filter(|q| q.w != 0.0 && at_end(mt::Point3::from_homogeneous(**q))) {- *q = (mt::Point3::from_homogeneous(*q) + d).to_homogeneous() * q.w;- }- }- _ => {}- }-}--/// 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). A spline or open-conic edge's ends are-/// moved onto vertices up to `snap` off its curve, so the pieces meet the vertices exactly.-pub(crate) fn edge_pieces(g: &CurveGeo, ps: mt::Point3, pe: mt::Point3, sense: bool, closed: bool, tol: f64, snap: f64) -> R<Vec<mt::Curve>> {- let mut pieces = curve_pieces(g, ps, pe, sense, closed, tol, snap)?;- if matches!(g, CurveGeo::BSpline(_) | CurveGeo::Nurbs(_) | CurveGeo::Hyperbola { .. } | CurveGeo::Parabola { .. }) {- if let Some(c) = pieces.first_mut() {- pin_end(c, ps, false);- }- if let Some(c) = pieces.last_mut() {- pin_end(c, pe, true);- }- }- Ok(pieces)-}--fn curve_pieces(g: &CurveGeo, ps: mt::Point3, pe: mt::Point3, sense: bool, closed: bool, tol: f64, snap: 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::Hyperbola { .. } | CurveGeo::Parabola { .. } => {- if closed {- return Err("closed edge on an open conic".into());- }- // The curve is open, so the edge is the parameters between its vertices: rising- // for the same sense, falling for the opposite one.- let (ts, te) = (open_conic_param(g, ps, snap)?, open_conic_param(g, pe, snap)?);- let scale = 1.0 + ts.abs().max(te.abs());- if (te - ts).abs() <= 1e-9 * scale {- return Err("degenerate conic edge".into());- }- Ok(vec![open_conic_curve(g, ts, te)?])- }- CurveGeo::BSpline(c) => Ok(spline_pieces(c, ps, pe, sense, closed, tol, snap)?.into_iter().map(mt::Curve::BSplineCurve).collect()),- CurveGeo::Nurbs(c) => Ok(spline_pieces(c, ps, pe, sense, closed, tol, snap)?.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::Hyperbola { f, .. } | CurveGeo::Parabola { f, .. } => {- // Bounded by the face's points (their parameters along the curve), with a margin.- let along = |q: &mt::Point3| match g {- CurveGeo::Hyperbola { b, .. } => ((q - f.o).dot(f.y) / b).asinh(),- CurveGeo::Parabola { focal, .. } => (q - f.o).dot(f.y) / (2.0 * focal),- _ => 0.0,- };- let (mut lo, mut hi) = (f64::INFINITY, f64::NEG_INFINITY);- for t in extent.iter().map(along).filter(|t| t.is_finite()) {- lo = lo.min(t);- hi = hi.max(t);- }- let (lo, hi) = if lo < hi { (lo - (hi - lo) * 0.25 - 1e-3, hi + (hi - lo) * 0.25 + 1e-3) } else { (-1.0, 1.0) };- open_conic_curve(g, lo, hi)?- }- 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);- let a = Ring::new(a);- for (i, (&x, &y)) in a.edges().enumerate() {- 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,- }-}--/// Length of the mean unit direction from the frame origin to the points (1: all in one-/// direction, 0: spread all round).-fn mean_direction(f: &Frame, pts: &[mt::Point3]) -> f64 {- let dirs: Vec<mt::Vector3> = pts- .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 0.0;- }- (dirs.iter().fold(mt::Vector3::new(0.0, 0.0, 0.0), |a, d| a + d) / dirs.len() as f64).magnitude()-}--/// 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)-}--/// A straight profile of a surface of revolution, bounded by the face: boundary points are-/// turned into the profile's meridian plane and projected onto the line, and the line stops at-/// the axis (beyond it the surface would fold over itself).-fn revolved_line(p: mt::Point3, d: mt::Vector3, o: mt::Point3, axis: mt::Vector3, extent: &[mt::Point3]) -> R<mt::Curve> {- let radial = |q: mt::Point3| {- let v = q - o;- v - axis * v.dot(axis)- };- // The meridian half-plane of the profile.- let e = {- let r = radial(p);- let r2 = radial(p + d);- let r = if r.magnitude() >= r2.magnitude() { r } else { r2 };- if r.magnitude() < 1e-12 {- return Err("profile line on the axis".into());- }- r / r.magnitude()- };- let (mut lo, mut hi) = (f64::INFINITY, f64::NEG_INFINITY);- for q in extent {- let v = q - o;- let h = v.dot(axis);- let r = radial(*q).magnitude();- let t = (o + axis * h + e * r - p).dot(d);- lo = lo.min(t);- hi = hi.max(t);- }- if !(lo.is_finite() && hi.is_finite()) {- return Err("surface of revolution without extent".into());- }- let m = (hi - lo) * 0.02 + 1e-6;- let (mut lo, mut hi) = (lo - m, hi + m);- // Where the line meets the axis (radial component along e vanishes).- let de = d.dot(e);- if de.abs() > 1e-12 {- let t_axis = -(p - o).dot(e) / de;- // The meridian half-plane has a non-negative radius along `e`.- if de > 0.0 {- lo = lo.max(t_axis);- } else {- hi = hi.min(t_axis);- }- }- if hi - lo <= 1e-12 {- return Err("degenerate surface of revolution".into());- }- Ok(mt::Curve::Line(mt::Line(p + d * lo, p + d * hi)))-}--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.-pub(crate) 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)-}--pub(crate) 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, nu + du + 1)?, knot_vec(mv, kv, nv + dv + 1)?),- 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(mt::NurbsSurface::new(clamped_surface(n.into_non_rationalized()))))- }- None => Ok(mt::Surface::BSplineSurface(clamped_surface(bsp))),- }-}--/// Resolve exact analytic offsets. Each intermediate offset is checked: an invalid inner-/// offset must not become valid merely because an outer offset cancels its distance.-/// Entity attributes follow ISO 10303-42 (`basis_surface`, `distance`, `self_intersect`).-fn offset_basis(cx: &Ctx, id: u64, depth: usize) -> R<(u64, f64)> {- if depth > MAX_GEOM_DEPTH {- return Err("surface definitions nested too deeply".into());- }- let e = entity(cx, id)?;- if e.name() != "OFFSET_SURFACE" {- return Ok((id, 0.0));- }- let p = e.params();- let basis = p.get(1).and_then(Param::as_ref_id).ok_or("offset surface without basis")?;- let distance = length(cx, p.get(2), "offset distance")?;- if !matches!(p.get(3).and_then(Param::as_enum), Some("T" | "F" | "U")) {- return Err("offset surface without a logical self_intersect flag".into());- }- let (basis, inner) = offset_basis(cx, basis, depth + 1)?;- let offset = inner + distance;- if !offset.is_finite() || offset.abs() >= MAX_COORD {- return Err("offset distance out of range after unit conversion".into());- }- let e = entity(cx, basis)?;- let p = e.params();- match e.name() {- "PLANE" => {}- "CYLINDRICAL_SURFACE" | "SPHERICAL_SURFACE" => {- let radius = length(cx, p.get(2), "radius")?;- if radius <= 0.0 || !(1e-9..MAX_COORD).contains(&(radius + offset)) {- return Err("offset surface collapses or reverses its radius".into());- }- }- "CONICAL_SURFACE" => {- let radius = length(cx, p.get(2), "radius")?;- let angle = num(p.get(3), "semi angle")? * cx.ang;- if radius < 0.0 || !(angle.abs() > 1e-9 && angle.abs() < FRAC_PI_2 - 1e-9) || !(0.0..MAX_COORD).contains(&(radius + offset / angle.cos()))- {- return Err("offset cone has an invalid reference radius or angle".into());- }- }- "TOROIDAL_SURFACE" => {- let major = length(cx, p.get(2), "major radius")?;- let minor = length(cx, p.get(3), "minor radius")?;- if minor <= 0.0 || major <= minor || major >= MAX_COORD || !(1e-9..major).contains(&(minor + offset)) {- return Err("offset torus collapses or becomes self-intersecting".into());- }- }- _ if offset == 0.0 => {}- n => return Err(format!("unsupported OFFSET_SURFACE basis surface {n}")),- }- Ok((basis, offset))-}--/// 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 (id, offset) = offset_basis(cx, id, depth)?;- 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()?;- let o = f.o + f.z * offset;- Ok(flip(mt::Surface::Plane(mt::Plane::new(o, o + f.x, o + f.y))))- }- "CYLINDRICAL_SURFACE" => {- let f = seam_frame(&placement()?, extent, seam);- let r = length(cx, p.get(2), "radius")? + offset;- 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 basis_r = length(cx, p.get(2), "radius")?;- let a = num(p.get(3), "semi angle")? * cx.ang;- let r = basis_r + offset / a.cos();- 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")? + offset;- 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.- // A small patch (a corner blend) gets poles away from it even when the file runs a- // seam through it: a seam ending at a pole on the patch boundary leaves the mesher- // no way to tell the patch from the rest of the sphere.- let f = if seam.is_empty() || mean_direction(&f, extent) > 0.3 {- 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")? + offset);- 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")?)?;- let profile = match &g {- CurveGeo::Line { p, d } => revolved_line(*p, *d, o, axis, extent)?,- _ => bounded_curve(&g, extent)?,- };- // ISO 10303-42 parameterises a surface of revolution by the angle u and the profile- // v, so its normal is ∂S/∂angle × ∂S/∂profile: the opposite of truck's revolution- // (profile first). Strict readers take it this way. Reversed sense turns it back.- Ok(revolved(profile, 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 profile = match &g {- CurveGeo::Conic { f, a, b } if d.dot(f.z).abs() > 1e-12 => {- // Keep the closed profile's parameter seam outside the trim. Otherwise a- // tooth tip crossing it can mesh as almost the whole extruded ellipse.- let dz = d.dot(f.z);- let angle = |p: &mt::Point3| {- let q = p - f.o;- let q = q - d * (q.dot(f.z) / dz);- (q.dot(f.y) / b).atan2(q.dot(f.x) / a)- };- let start = common_angle(seam.iter().map(angle))- .or_else(|| largest_gap(&extent.iter().map(angle).collect::<Vec<_>>()).map(|(mid, _)| mid))- .unwrap_or(0.0);- mt::Curve::NurbsCurve(conic_arc(f, *a, *b, start, TAU))- }- _ => bounded_curve(&g, extent)?,- };- let nurbs: mt::NurbsCurve<mt::Vector4> = match profile {- 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.rsindex ec7828015c..26b8d050f1 100644--- a/crates/kernel/src/step_in/mod.rs+++ b/crates/kernel/src/step_in/mod.rs@@ -1,28 +1,23 @@//! 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.+//! [`solidcraft_step::topology`] reads each solid into its schema 4 record, which SMLib takes+//! as the body ([`parallel`]), 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, and what cannot be read becomes a+//! warning rather than a failure wherever the rest of the file is still usable.-mod brep;-pub(crate) mod geom;pub(crate) mod p21;mod parallel;-pub(crate) mod split;use std::collections::{BTreeMap, HashMap, HashSet};use std::sync::Arc;-use mt::EuclideanSpace as _;use serde::{Deserialize, Serialize};-use truck_modeling as mt;+use solidcraft_step::read::R;use crate::body::Body;-use crate::{KernelError, Result, guard};-use geom::R;+use crate::{KernelError, Result};use p21::{Entity, Exchange, Param};/// Deepest assembly nesting followed.@@ -99,48 +94,21 @@ struct Planned {/// Where the solids of a batch go: their placement and names.struct Batch {- m: mt::Matrix4,+ m: M4,path: Vec<String>,product: String,instance: Option<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,- /// The context's own distance uncertainty (mm), as the file states it (SMLib's reads take it).- #[cfg_attr(not(feature = "smlib"), allow(dead_code))]- uncertainty: Option<f64>,-}+/// The units of a representation context (GLOBAL_UNIT_ASSIGNED_CONTEXT) and its distance+/// uncertainty (mm) as the file states it.+type Units = solidcraft_step::units::Context;-const DEFAULT_UNITS: Units = Units { len: 1.0, ang: 1.0, tol: 0.01, uncertainty: None };--/// Units of a representation context (GLOBAL_UNIT_ASSIGNED_CONTEXT, uncertainty), read by-/// [`solidcraft_step::units::context`]; the vertex-on-curve tolerance is ten times the-/// uncertainty (at least 1e-3 mm), else a hundredth of the length unit, within [1e-4, 1] mm.+/// Units of a representation context, read by [`solidcraft_step::units::context`] (millimetres+/// and radians when the file names none).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 c = solidcraft_step::units::context(ex, id);- let tol = c.uncertainty.map(|t| (t * 10.0).max(1e-3)).unwrap_or(c.units.len * 1e-2).clamp(1e-4, 1.0);- let u = Units { len: c.units.len, ang: c.units.ang, tol, uncertainty: c.uncertainty };- cache.insert(id, u);- u+ let Some(id) = ctx else { return Units::default() };+ *cache.entry(id).or_insert_with(|| solidcraft_step::units::context(ex, id))}/// Items and context of a representation entity.@@ -157,18 +125,48 @@ fn representation(e: &Entity) -> Option<(Vec<u64>, Option<u64>)> {Some((items, p.get(2).and_then(Param::as_ref_id)))}-fn mat_mul(a: &mt::Matrix4, b: &mt::Matrix4) -> mt::Matrix4 {- a * b+/// A placement: a column-major 4×4 matrix (columns 0–2 the images of x, y and z, column 3 the+/// translation), millimetres.+type M4 = [[f64; 4]; 4];++const IDENTITY: M4 = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]];++/// `a · b`.+fn mat_mul(a: &M4, b: &M4) -> M4 {+ let mut out = [[0.0; 4]; 4];+ for (col, out_col) in out.iter_mut().enumerate() {+ for (row, cell) in out_col.iter_mut().enumerate() {+ *cell = (0..4).map(|k| a[k][row] * b[col][k]).sum();+ }+ }+ out}-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]]+/// The inverse of a rigid placement (an orthonormal rotation and a translation): the rotation+/// transposed, and the translation taken back through it.+fn rigid_inverse(m: &M4) -> M4 {+ let mut out = IDENTITY;+ for (i, col) in out.iter_mut().take(3).enumerate() {+ for (j, cell) in col.iter_mut().take(3).enumerate() {+ *cell = m[j][i];+ }+ }+ for i in 0..3 {+ out[3][i] = -(0..3).map(|k| m[i][k] * m[3][k]).sum::<f64>();+ }+ out+}++fn translation(t: [f64; 3]) -> M4 {+ let mut m = IDENTITY;+ m[3] = [t[0], t[1], t[2], 1.0];+ m}-/// 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)+/// The matrix of an AXIS2_PLACEMENT: its frame's axes and origin.+fn frame_matrix(p: &solidcraft_step::geom::Placement) -> M4 {+ let (x, y, z, o) = (p.ref_direction, p.y(), p.axis, p.origin);+ [[x[0], x[1], x[2], 0.0], [y[0], y[1], y[2], 0.0], [z[0], z[1], z[2], 0.0], [o[0], o[1], o[2], 1.0]]}struct Reader {@@ -197,7 +195,7 @@ struct Reader {once: HashSet<u64>,/// An item placed more than once: its first instance's display, shared by every instance/// (with the placement that first instance had), so the part is meshed once.- shown: HashMap<u64, (Arc<crate::body::SharedDisplay>, mt::Matrix4)>,+ shown: HashMap<u64, (Arc<crate::body::SharedDisplay>, M4)>,/// How many planned solids place each item.uses: HashMap<u64, usize>,/// An item placed more than once: read and oriented where the file defines it, so each@@ -489,15 +487,16 @@ impl Reader {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)?;+ /// The placement an item states: an AXIS2_PLACEMENT's frame, or a+ /// CARTESIAN_TRANSFORMATION_OPERATOR_3D's origin.+ fn placement_matrix(&mut self, item: u64, u: Units) -> R<M4> {+ let reader = solidcraft_step::read::Reader::new(&self.ex, u.units);+ let e = self.ex.get(item).ok_or_else(|| format!("missing entity #{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()));+ let o = reader.point(e.params().get(4).and_then(Param::as_ref_id).ok_or("transformation without origin")?)?;+ return Ok(translation(o));}- Ok(geom::frame(&cx, item)?.matrix())+ Ok(frame_matrix(&reader.frame(item)?))}/// Representations of a product (its own shape representations and those linked to them).@@ -535,7 +534,7 @@ impl Reader {}/// 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, instance: Option<&str>, out: &mut Vec<usize>, depth: usize) {+ fn rep_bodies(&mut self, rep: u64, m: &M4, path: &[String], product: &str, instance: Option<&str>, out: &mut Vec<usize>, depth: usize) {if depth > MAX_ASSEMBLY_DEPTH {self.warn("mapped items nested too deeply");return;@@ -660,7 +659,7 @@ impl Reader {Some(part) => parallel::Source::Oriented(part.clone()),None => parallel::Source::Item { item, units },};- let placement = self.batches.get(p.batch).map_or(mt::Matrix4::from_scale(1.0), |b| b.m);+ let placement = self.batches.get(p.batch).map_or(IDENTITY, |b| b.m);sources.push((i, item));jobs.push(parallel::Job { source, placement, check_mesh: !self.unmeshed_checked.contains(&item) });}@@ -715,11 +714,11 @@ impl Reader {// Every instance of a part placed more than once shows its first instance's// mesh, placed (the first one too: meshing its own would mesh the part twice).let body = match self.shown.get(&item) {- Some((shared, first)) => body.with_display_of(shared.clone(), to_array(&mat_mul(&m, &rigid_inverse(first)))),+ Some((shared, first)) => body.with_display_of(shared.clone(), mat_mul(&m, &rigid_inverse(first))),None if self.uses.get(&item).is_some_and(|n| *n > 1) => {let shared = Arc::new(crate::body::SharedDisplay::new(body.clone()));self.shown.insert(item, (shared.clone(), m));- body.with_display_of(shared, to_array(&mt::Matrix4::from_scale(1.0)))+ body.with_display_of(shared, IDENTITY)}None => body,};@@ -780,10 +779,10 @@ impl Reader {}/// 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) };+ fn occurrence_matrix(&mut self, nauo: u64, child_reps: &[u64]) -> M4 {+ let Some(&rel) = self.placements.get(&nauo) else { return IDENTITY };let ex = self.ex.clone();- let r = (|| -> R<mt::Matrix4> {+ let r = (|| -> R<M4> {let e = ex.get(rel).ok_or("missing placement")?;let rr = e.record("REPRESENTATION_RELATIONSHIP").ok_or("placement without representations")?;let (r1, r2) =@@ -814,23 +813,14 @@ impl Reader {Ok(m) => m,Err(e) => {self.warn(format!("component placement #{rel}: {e} (placed at the origin)"));- mt::Matrix4::from_scale(1.0)+ IDENTITY}}}- fn node(- &mut self,- pd: u64,- local: mt::Matrix4,- world: mt::Matrix4,- path: &[String],- instance: Option<&str>,- depth: usize,- stack: &mut Vec<u64>,- ) -> StepNode {+ fn node(&mut self, pd: u64, local: M4, world: M4, path: &[String], instance: Option<&str>, 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() };+ let mut node = StepNode { name: name.clone(), transform: local, bodies: Vec::new(), children: Vec::new() };if self.stop() {return node;}@@ -869,96 +859,29 @@ impl Reader {}}-/// Check a STEP file's structure: it parses, no entity id is defined twice, every reference-/// names a defined entity, nothing but root entities (relationships, definitions,-/// presentation) is left unreferenced, and ids are dense (`#1`…`#n`). Returns the entity count.-/// Faces whose boundary runs the wrong way round their normal, as a strict reader-/// sees them: each face's normal is its surface's own parametric normal (∂S/∂u × ∂S/∂v, ISO-/// 10303-42), reversed when `same_sense` is false, and the outer loop must run counter-clockwise-/// seen from that side. Checked on faces whose loop spans a clear direction (patches, not bands-/// around a closed surface). Returns one message per bad face.+/// Faces whose boundary runs the wrong way round their normal, as a strict reader sees them:+/// each face's normal is its surface's own parametric normal (∂S/∂u × ∂S/∂v, ISO 10303-42),+/// reversed when `same_sense` is false, and the outer loop must run counter-clockwise seen from+/// that side. These are the faces the STEP reader turns over ([`solidcraft_step::topology`]),+/// numbered as the solid's body numbers them. Returns one message per bad face; an error when+/// the file does not parse or has no solid the reader can read.pub fn step_orientation_errors(text: &str) -> std::result::Result<Vec<String>, String> {- use mt::{BoundedCurve, InnerSpace, ParametricCurve, ParametricSurface3D, SearchNearestParameter};- let imp = step_import(text).map_err(|e| e.to_string())?;+ let ex = p21::parse(text)?;+ let read = solidcraft_step::topology::read_solids(&ex);+ if read.solids.is_empty() {+ return Err(read.failures.first().map_or_else(|| "the file has no solids".into(), |f| format!("solid #{}: {}", f.item, f.message)));+ }let mut out = Vec::new();- for b in &imp.bodies {- let r = guard("orientation check", || {- let mut bad = Vec::new();- for (fi, f) in b.body.solid.face_iter().enumerate() {- let bounds = f.boundaries();- // Patches only: a face with several loops (a band between two rings, a face with- // holes) has no single loop direction to compare.- let [w] = bounds.as_slice() else { continue };- // Only revolutions (cylinders, cones, spheres, tori: closed surfaces, where a loop- // read the wrong way round silently gives the rest of the surface). On free-form- // strips the loop's normals vary too much for this test; the round trips' volume- // checks cover those.- if !matches!(f.surface(), mt::Surface::RevolutedCurve(_)) {- continue;- }- // A loop through a vertex twice (a figure eight round a pole) has no single direction.- let fronts: std::collections::HashSet<_> = w.edge_iter().map(|e| e.front().id()).collect();- if fronts.len() != w.len() {- continue;- }- let pts: Vec<mt::Point3> = w- .edge_iter()- .flat_map(|e| {- let c = e.oriented_curve();- let (t0, t1) = c.range_tuple();- (0..16).map(move |i| c.subs(t0 + (t1 - t0) * i as f64 / 16.0)).collect::<Vec<_>>()- })- .collect();- let n = pts.len();- if n < 3 {- continue;- }- let mut newell = mt::Vector3::new(0.0, 0.0, 0.0);- let mut c = mt::Vector3::new(0.0, 0.0, 0.0);- let mut span: f64 = 0.0;- for i in 0..n {- let (Some(a), Some(q)) = (pts.get(i), pts.get((i + 1) % n)) else { continue };- newell += (a.to_vec()).cross(q.to_vec());- c += a.to_vec();- span = span.max((a - pts[0]).magnitude());- }- let c = mt::Point3::from_vec(c / n as f64);- // Bands round a closed surface have no clear loop direction.- if !(newell.magnitude() > 0.05 * span * span) {- continue;- }- // The face normal averaged along the loop (each loop point is on the surface;- // the loop's centroid can be nearer the wrong side of a curved face).- let s = f.oriented_surface();- let mut normal = mt::Vector3::new(0.0, 0.0, 0.0);- let mut count = 0usize;- for p in &pts {- if let Some(uv) = s.search_nearest_parameter(*p, None, 100) {- let n = s.normal(uv.0, uv.1);- if n.x.is_finite() && n.y.is_finite() && n.z.is_finite() {- normal += n;- count += 1;- }- }- }- let _ = c;- // Only patches clearly to one side of their loop are judged: a loop on a closed- // surface (a sphere's cube-face square) bounds either part.- if count == 0 || normal.magnitude() < 0.7 * count as f64 {- continue;- }- if normal.dot(newell) < 0.0 {- bad.push(format!("{}: face {fi} runs clockwise around its normal", b.name));- }- }- Ok(bad)- })- .map_err(|e| e.to_string())?;- out.extend(r);+ for solid in &read.solids {+ let name = if solid.name.trim().is_empty() { format!("solid #{}", solid.item) } else { solid.name.trim().to_string() };+ out.extend(solid.turned.iter().map(|f| format!("{name}: face {f} runs clockwise around its normal")));}Ok(out)}+/// Check a STEP file's structure: it parses, no entity id is defined twice, every reference+/// names a defined entity, nothing but root entities (relationships, definitions,+/// presentation) is left unreferenced, and ids are dense (`#1`…`#n`). Returns the entity count.pub fn step_validate(text: &str) -> std::result::Result<usize, String> {let ex = p21::parse(text)?;if let Some(d) = ex.duplicates.first() {@@ -1129,7 +1052,7 @@ impl StepReading {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 identity = IDENTITY;let mut tree = Vec::new();for pd in roots {tree.push(rd.node(pd, identity, identity, &[], None, 0, &mut Vec::new()));@@ -1155,7 +1078,7 @@ impl StepReading {for r in loose {rd.rep_bodies(r, &identity, &[], "Import", None, &mut bodies, 0);}- tree.push(StepNode { name: "Import".into(), transform: to_array(&identity), bodies, children: Vec::new() });+ tree.push(StepNode { name: "Import".into(), transform: identity, bodies, children: Vec::new() });}let single = workers <= 1;Ok(StepReading { rd, tree, key, small: text.len() <= KEEP_SMALL_BYTES, single })diff --git a/crates/kernel/src/step_in/p21.rs b/crates/kernel/src/step_in/p21.rsindex 969606bd06..fd850160ff 100644--- a/crates/kernel/src/step_in/p21.rs+++ b/crates/kernel/src/step_in/p21.rs@@ -1,6 +1,6 @@//! The Part 21 parser lives in `solidcraft-step`; this reads with the kernel's progress watch.-pub use solidcraft_step::p21::{Entity, Exchange, Param, Record};+pub use solidcraft_step::p21::{Entity, Exchange, Param};struct Watched(std::sync::Arc<dyn crate::watch::Watch>);diff --git a/crates/kernel/src/step_in/parallel.rs b/crates/kernel/src/step_in/parallel.rsindex ec7008eaae..a3332e1199 100644--- a/crates/kernel/src/step_in/parallel.rs+++ b/crates/kernel/src/step_in/parallel.rs@@ -1,18 +1,13 @@//! Bounded desktop preparation of independent imported bodies, collected in file order.use std::sync::Arc;-use super::{Body, Ctx, Exchange, KernelError, Units, brep, guard, mt};+use super::{Body, Exchange, IDENTITY, KernelError, M4, Units};pub(super) struct Job {pub source: Source,/// Where the body goes (its instance's placement in the assembly).- pub placement: mt::Matrix4,+ pub placement: M4,pub check_mesh: bool,- /// The file's point-on-surface tolerance (`super::Units::tol`) for the representation this- /// solid was read from: how far its boundaries may lie off their surfaces (mm). The body- /// keeps it, so the tessellator holds an imported boundary to the file's own uncertainty- /// rather than to a fraction of the part's size (see `crate::body::Body::boundary_tol`).- pub tol: f64,}/// What a job places: a solid item to read from the file (and orient), or a part an earlier@@ -66,51 +61,31 @@ pub(super) fn workers() -> usize {fn prepare(ex: &Exchange, job: &Job) -> Prepared {let (part, read) = match &job.source {Source::Oriented(part) => (part.clone(), None),- Source::Item { item, units } if smlib_backend() => {+ Source::Item { item, units } => {let (part, read) = smlib_part(ex, *item, *units)?;(Arc::new(part), Some(read))}- Source::Item { item, units } => {- let cx = Ctx { ex, len: units.len, ang: units.ang, tol: units.tol, snap: units.snap };- let out = guard("step brep", || brep::read_item(&cx, *item).map_err(KernelError::Failed))- .map_err(|e| Failure { read: true, msg: e.to_string().trim_start_matches("the operation failed: ").to_string() })?;- // Orient once where the file defines the solid; each placement then takes its- // orientation from the matrix instead of meshing the whole part again.- let body = guard("STEP body preparation", || Body::new(out.solid)).map_err(|e| Failure { read: false, msg: e.to_string() })?;- // The file's tolerance is set on the part itself, before anything meshes it: the- // unmeshed-face count below is the import's own warning and must judge the body by- // the file's uncertainty too, and every placement of the part carries the figure on.- let body = body.with_boundary_tol(Some(job.tol));- (Arc::new(Part { body, closed: out.closed, file_faces: out.file_faces, face_origin: out.face_origin }), Some(out.failed))- }};- guard("STEP body preparation", || {- let body = part.body.placed(&job.placement)?;- // Counted where the orientation mesh already counted them (a placement meshes the- // same faces), and on the part, which carries the file's tolerance.- let missing = if job.check_mesh { part.body.unmeshed_faces() } else { 0 };- Ok((body, missing))- })- .map(|(body, missing)| Made { body, missing, part, read })- .map_err(|e| Failure { read: false, msg: e.to_string() })+ let body = placed(&part.body, &job.placement).map_err(|e| Failure { read: false, msg: e.to_string() })?;+ // Counted on the part (a placement meshes the same faces).+ let missing = if job.check_mesh { part.body.unmeshed_faces() } else { 0 };+ Ok(Made { body, missing, part, read })}-/// Whether solids are read into SMLib ([`crate::backend`]). A setting this build can't honour-/// reads them on neither kernel: [`smlib_part`] then says why.-fn smlib_backend() -> bool {- !matches!(crate::backend(), Ok(crate::Backend::Truck))+/// The part's body where its instance goes: the very same body at the identity (it keeps the+/// SMLib body the read made), else its record moved there.+fn placed(body: &Body, m: &M4) -> crate::Result<Body> {+ if *m == IDENTITY {+ return Ok(body.clone());+ }+ Ok(crate::ops::transform_matrix(body, *m)?.without_history())}-/// A solid item read with the STEP reader into its schema 4 record, then into SMLib (healed-/// where SMLib's check refuses it as given), and brought back as a body: the part SMLib made of-/// the file. A solid the reader or SMLib refuses is not imported, with the reason; there is no-/// other kernel to fall back on.-#[cfg(feature = "smlib")]+/// A solid item read with the STEP reader into its schema 4 record, then into SMLib as given,+/// and brought back as a body: the part SMLib made of the file. A solid the reader or SMLib+/// refuses is not imported, with the reason.pub(super) fn smlib_part(ex: &Exchange, item: u64, units: Units) -> std::result::Result<(Part, Vec<String>), Failure> {- crate::backend().map_err(|e| Failure { read: true, msg: e.to_string() })?;- let context =- solidcraft_step::units::Context { units: solidcraft_step::read::Units { len: units.len, ang: units.ang }, uncertainty: units.uncertainty };- let solid = solidcraft_step::topology::read_solid(ex, item, context).map_err(|msg| Failure { read: true, msg })?;+ let solid = solidcraft_step::topology::read_solid(ex, item, units).map_err(|msg| Failure { read: true, msg })?;let failed = |e: KernelError| Failure { read: false, msg: e.to_string().trim_start_matches("the operation failed: ").to_string() };let (brep, smlib_order) = crate::native::smlib_record_ordered(&solid.brep).map_err(failed)?;let (body, body_order) = crate::native::body_from_smlib_ordered(&brep).map_err(failed)?;@@ -133,11 +108,6 @@ pub(super) fn smlib_part(ex: &Exchange, item: u64, units: Units) -> std::result:Ok((part, solid.notes))}-#[cfg(not(feature = "smlib"))]-pub(super) fn smlib_part(_: &Exchange, _: u64, _: Units) -> std::result::Result<(Part, Vec<String>), Failure> {- Err(Failure { read: true, msg: crate::backend().err().map_or_else(|| "this build has no SMLib".into(), |e| e.to_string()) })-}-/// Prepare `jobs`, the results in the jobs' order. Solids still to read and orient (the slow/// part) are shared out between up to `workers` threads, each taking the next job when it is/// done with one, so one large part does not hold up the rest.diff --git a/crates/kernel/src/step_in/split.rs b/crates/kernel/src/step_in/split.rsdeleted file mode 100644index 509c046c1c..0000000000--- a/crates/kernel/src/step_in/split.rs+++ /dev/null@@ -1,582 +0,0 @@-//! 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};--/// How far a band's ring edge may lie off its surface, as a fraction of the body, for a body that-/// declares no accuracy of its own.-const RING_OFF_SURFACE: f64 = 1e-3;--/// 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 direction the split line runs along (the one that does not wrap).-fn along(d: Dir) -> Dir {- match d {- Dir::U => Dir::V,- Dir::V => Dir::U,- }-}--/// The closed, non-periodic direction of a surface with its range; with `periodic`, a revolved-/// surface's turn around its axis too.-fn closed_dirs(s: &mt::Surface, periodic: bool) -> Vec<(Dir, f64, f64)> {- match s {- mt::Surface::RevolutedCurve(p) => {- let c = p.entity().entity_curve();- let (t0, t1) = c.range_tuple();- let mut out = Vec::new();- if c.front().distance(c.back()) < 1e-7 * (1.0 + c.front().to_homogeneous().truncate().magnitude()) {- out.push((Dir::U, t0, t1));- }- if periodic {- out.extend(turn_dir(s));- }- out- }- 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![],- }-}--/// The parameter that turns a revolved surface around its axis, over one turn.-fn turn_dir(s: &mt::Surface) -> Option<(Dir, f64, f64)> {- let mt::Surface::RevolutedCurve(p) = s else { return None };- let (t0, t1) = p.entity().entity_curve().range_tuple();- let tau = std::f64::consts::TAU;- let ts: Vec<f64> = (0..=4).map(|i| t0 + (t1 - t0) * f64::from(i) / 4.0).collect();- [Dir::V, Dir::U].into_iter().find_map(|d| {- let at = |w: f64, t: f64| match d {- Dir::V => s.subs(t, w),- Dir::U => s.subs(w, t),- };- let scale = ts.iter().map(|t| at(0.0, *t).to_homogeneous().truncate().magnitude()).fold(1.0, f64::max);- let closes = ts.iter().all(|t| at(0.0, *t).distance(at(tau, *t)) < scale * 1e-9);- let turns = ts.iter().any(|t| at(0.0, *t).distance(at(std::f64::consts::PI, *t)) > scale * 1e-6);- (closes && turns).then_some((d, 0.0, tau))- })-}--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`. `tol` is how far a ring edge may lie off-/// the surface the split line lies on: a STEP file writes the surface and the curves bounding it-/// to the file's own declared uncertainty only, so the line is matched to the surface points-/// below `q1` and `q2`, not to them.-fn iso_curve(s: &mt::Surface, d: Dir, mid: f64, q1: mt::Point3, q2: mt::Point3, seam: &[mt::Point3], tol: f64) -> R<mt::Curve> {- match s {- // Across the turn of a cylinder or cone: a straight line along it.- mt::Surface::RevolutedCurve(_) if turn_dir(s).is_some_and(|t| t.0 == d) => {- let m = q1 + (q2 - q1) * 0.5;- let on = uv_of(s, m).is_some_and(|(u, v)| s.subs(u, v).distance(m) < 1e-7 * (1.0 + q1.distance(q2)));- if on && q1.distance(q2) > 1e-9 {- Ok(mt::Curve::Line(mt::Line(q1, q2)))- } else {- Err("a revolved face that is not straight along its axis".into())- }- }- 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)).max(tol) {- 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 (t0, t1) = iso.range_tuple();- // Where the split line comes nearest `p`: the point on the surface below `p` (the- // line runs on the surface, `p` only within the file's tolerance of it), looked for- // from its own surface parameter and from a scan of the whole line.- let near = |p: mt::Point3| {- let foot = uv_of(s, p).filter(|uv| s.subs(uv.0, uv.1).distance(p) <= tol);- let target = foot.map_or(p, |uv| s.subs(uv.0, uv.1));- 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(target);- if dd < best.1 {- best = (t, dd);- }- }- let seeds = foot.map(|uv| coord(along(d), uv)).into_iter().chain(iso.search_nearest_parameter(target, best.0, 64));- for t in seeds {- let t = t.clamp(t0, t1);- let dd = iso.subs(t).distance(target);- if dd <= best.1 {- best = (t, dd);- }- }- 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 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`.-pub(crate) 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),-}--/// How to cut `face` in two along the line opposite its seam. `periodic` also cuts a face that-/// runs round the turn of a revolved surface (see [`closed_dirs`]). `tol` is how far a ring edge-/// of the face may lie off the surface it bounds (see [`iso_curve`]).-fn plan(face: &mt::Face, periodic: bool, tol: f64) -> 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, periodic).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])),- }- }- // A cone's tip: the seam runs from the ring to the apex and straight back.- if let [(true, sm), (false, ring)] = chains.as_slice() {- return apex_plan(face, &s, (d, mid, period), sm, ring, &wires, outer_idx, tol).map(Some);- }- 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, tol)?;- 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) }))-}--/// Split a face closing at an apex (loop: seam out to the apex, seam back, the ring) along the-/// iso-line opposite the seam, from the ring to the apex.-fn apex_plan(- face: &mt::Face,- s: &mt::Surface,- (d, mid, period): (Dir, f64, f64),- sm: &[mt::Edge],- ring: &[mt::Edge],- wires: &[mt::Wire],- outer_idx: usize,- tol: f64,-) -> R<Plan> {- let h = sm.len() / 2;- if !sm.len().is_multiple_of(2) || h == 0 {- return Err("seam edges are not used back and forth".into());- }- let (out, back) = (sm.get(..h).ok_or("seam")?, sm.get(h..).ok_or("seam")?);- if out.iter().map(mt::Edge::id).collect::<Vec<_>>() != back.iter().rev().map(mt::Edge::id).collect::<Vec<_>>() {- return Err("seam edges are not used back and forth".into());- }- let apex = out.last().ok_or("seam")?.back().clone();- let (k, t, q) = crossing(s, d, ring, mid, period)?;- let seam_line: Vec<mt::Point3> = out.iter().flat_map(|e| samples(&e.oriented_curve(), 16).into_iter().map(|x| x.1)).collect();- let iso = iso_curve(s, d, mid, q, apex.point(), &seam_line, tol)?;- let (ra, rb, c, vq) = split_chain(ring, k, t, q)?;- let e = mt::Edge::new_unchecked(&vq, &apex, iso);- // Face A: out to the apex, down the split line, the ring's second part; face B the rest.- let mut wa: Vec<mt::Edge> = out.to_vec();- wa.push(e.inverse());- wa.extend(rb.iter().cloned());- let mut wb: Vec<mt::Edge> = vec![e];- wb.extend(back.iter().cloned());- wb.extend(ra);- let (wire_a, wire_b): (mt::Wire, mt::Wire) = (wa.into(), wb.into());- if !wire_a.is_closed() || !wire_b.is_closed() {- return Err("split loops do not close".into());- }- let side_a = rb- .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.clone());- if !face.orientation() {- fa.invert();- fb.invert();- }- Ok(Plan { cuts: c.into_iter().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-}--/// A copy of `body` whose faces that run once round a cylinder or cone along a seam edge-/// (as STEP files have them) are each cut in two along the line opposite the seam, the way the-/// kernel builds such walls itself; the boolean cannot always intersect the whole ones. `None`-/// when the body has no such face, or one can't be cut.-pub(crate) fn split_seams(body: &crate::Body) -> Option<crate::Body> {- let seamed = |f: &mt::Face| {- let mut seen = std::collections::HashSet::new();- f.absolute_boundaries().iter().flat_map(|w| w.edge_iter()).any(|e| !seen.insert(e.id()))- };- if !body.solid.face_iter().any(seamed) {- return None;- }- // How far a ring edge of such a face may lie off the surface it bounds (see `iso_curve`):- // the file's own declared uncertainty for a body read from one, else a thousandth of the body.- let tol = body.boundary_tol.unwrap_or(body.size() * RING_OFF_SURFACE).max(1e-6);- let mut shells: Vec<mt::Shell> = Vec::new();- for sh in body.solid.boundaries() {- let mut faces: Vec<mt::Face> = sh.face_iter().cloned().collect();- let n = faces.len();- for i in 0..n {- let Some(face) = faces.get(i).cloned() else { continue };- if !seamed(&face) {- continue;- }- let p = crate::guard("seam split", || plan(&face, true, tol).map_err(crate::KernelError::Failed)).ok()??;- 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);- }- shells.push(faces.into());- }- let solid = mt::Solid::try_new(shells).ok()?;- let b = crate::Body::new(solid).ok()?;- b.validity().is_empty().then_some(b)-}--/// Split every band face of a shell (see the module docs). Faces that cannot be split stay as-/// they are and are reported.-///-/// `tol` is the file's point-on-surface tolerance (`step_in::mod::Units::tol`): 10x the file's-/// declared uncertainty, floored at 1 µm and clamped to [1e-4, 1] mm. A ring edge is written to-/// within this distance of the surface it bounds, so it is how far `iso_curve` may accept a-/// crossing point as lying on the surface.-pub(crate) fn split_bands(mut faces: Vec<mt::Face>, origin: &mut Vec<u64>, warnings: &mut Vec<String>, tol: f64) -> 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, false, tol).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);- // The second piece comes from the same file face.- let o = origin.get(i).copied().unwrap_or(0);- origin.push(o);- }- 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.rsindex 30604932f4..0ac89ee15a 100644--- a/crates/kernel/src/step_in/tests.rs+++ b/crates/kernel/src/step_in/tests.rs@@ -164,15 +164,14 @@ fn benchmark_independent_step_solids() {let start = std::time::Instant::now();let ex = p21::parse(&text).unwrap();let parse = start.elapsed();- let cx = Ctx { ex: &ex, len: 1.0, ang: 1.0, tol: 0.01 };let mut items: Vec<_> = ex.entities.iter().filter(|(_, e)| e.name() == "MANIFOLD_SOLID_BREP").map(|(id, _)| *id).collect();items.sort();let start = std::time::Instant::now();- let solids: Vec<_> = items.iter().map(|id| guard("benchmark read", || brep::read_item(&cx, *id).map_err(KernelError::Failed)).unwrap()).collect();+ let solids: Vec<_> = items.iter().map(|id| solidcraft_step::topology::read_solid(&ex, *id, Units::default()).unwrap()).collect();let read = start.elapsed();let start = std::time::Instant::now();for solid in solids {- std::hint::black_box(Body::new(solid.solid).unwrap().unmeshed_faces());+ std::hint::black_box(Body::from_record(solid.brep).unwrap().unmeshed_faces());}println!("STEP_PHASE parse_ms={:.3} brep_ms={:.3} body_ms={:.3}",@@ -266,8 +265,8 @@ fn parallel_body_preparation_reports_errors_in_place_and_preserves_placement() {let body = cylinder(Vec3::new(2.0, 2.0, 0.0), Vec3::Z, 2.0, 4.0).unwrap();let ex = p21::parse(&step_export(&[&body], "test").unwrap()).unwrap();let solid = *ex.entities.iter().find(|(_, e)| e.name() == "MANIFOLD_SOLID_BREP").map(|(id, _)| id).unwrap();- let units = DEFAULT_UNITS;- let placement = mt::Matrix4::from_translation(mt::Vector3::new(10.0, 20.0, 30.0));+ let units = Units::default();+ let placement = translation([10.0, 20.0, 30.0]);// The second item is not in the file.let jobs: Vec<_> = [solid, 999_999_999, solid, solid].into_iter()@@ -329,7 +328,7 @@ fn parallel_import_does_not_prepare_past_body_budget_with_duplicates_or_mapped_ireader.bodies = vec![seed.clone(); MAX_BODIES - 2];reader.node_items.insert(2000);let mut out = Vec::new();- reader.rep_bodies(60, &mt::Matrix4::from_scale(1.0), &[], "Budget", None, &mut out, 0);+ reader.rep_bodies(60, &IDENTITY, &[], "Budget", None, &mut out, 0);assert!(reader.oriented.is_empty() && reader.unreadable.is_empty(), "the walk only plans the solids");while reader.convert_next(workers == 1) {}let out = reader.remap(&out);@@ -355,8 +354,8 @@ fn round_trip(b: &Body) -> StepImport {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);- // Pieces of one analytic surface are written as one face (volume and area above check- // that nothing was lost).+ // The file has no more faces than the body (volume and area above check that nothing was+ // lost).assert!(imp.bodies[0].file_faces <= b.face_count());assert!(imp.bodies[0].closed);imp@@ -383,11 +382,9 @@ fn round_trip_features() {round_trip(&donut[0]);}-/// Robustness seed 17: a thin three-quarter tube shelled with its bottom open. truck writes each-/// wall as three quarter-turn B-spline pieces; the export merges them into one 270° face and must-/// write that face's cylinder, not the first piece's quarter sheet. The seam direction came from-/// the mean direction of the face's vertices, which is zero at 0°, 90°, 180° and 270°, so the-/// merged face kept the quarter sheet and read back about 7% short with no warning.+/// Robustness seed 17: a thin three-quarter tube shelled with its bottom open reads back whole+/// (an export once wrote a 270° wall on a quarter of its surface, and the part read back about+/// 7% short with no warning).#[test]fn shelled_three_quarter_tube_round_trips() {let rect =@@ -427,72 +424,6 @@ fn imported_bodies_take_features() {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";-/// Original fixtures: elementary basis surfaces plus offsets, with no external CAD files.-fn offset_geometry(definition: &str, offset: &str, len: f64, sense: bool, points: &[mt::Point3]) -> crate::Result<mt::Surface> {- let text = format!(- "{HEAD}#1=CARTESIAN_POINT('',(0.,0.,0.));\n#2=AXIS2_PLACEMENT_3D('',#1,$,$);\n#3={definition};\n#4=OFFSET_SURFACE('',#3,{offset},.U.);\n{TAIL}"- );- let ex = p21::parse(&text).unwrap();- let cx = Ctx { ex: &ex, len, ang: 1.0, tol: 1e-6 };- crate::guard("test offset surface", || geom::surface(&cx, 4, points, &[], sense, 0).map_err(KernelError::Failed))-}--#[test]-fn offset_surface_analytic_geometry_and_orientation() {- use mt::{InnerSpace, MetricSpace, ParametricSurface, ParametricSurface3D, SearchNearestParameter};- let angle: f64 = 0.4;- let cases = [- ("PLANE('',#2)".to_string(), mt::Point3::new(2.0, 3.0, 1.0), mt::Vector3::unit_z()),- ("CYLINDRICAL_SURFACE('',#2,5.)".to_string(), mt::Point3::new(6.0, 0.0, 2.0), mt::Vector3::unit_x()),- ("SPHERICAL_SURFACE('',#2,5.)".to_string(), mt::Point3::new(6.0, 0.0, 0.0), mt::Vector3::unit_x()),- ("TOROIDAL_SURFACE('',#2,10.,2.)".to_string(), mt::Point3::new(13.0, 0.0, 0.0), mt::Vector3::unit_x()),- (- format!("CONICAL_SURFACE('',#2,5.,{angle})"),- mt::Point3::new(5.0 + 1.0 / angle.cos() + 2.0 * angle.tan(), 0.0, 2.0),- mt::Vector3::new(angle.cos(), 0.0, -angle.sin()),- ),- ];- for (definition, point, normal) in cases {- for sense in [true, false] {- let extent = [point, point + mt::Vector3::unit_z()];- let surface = offset_geometry(&definition, "1.", 1.0, sense, &extent).unwrap();- let uv = surface.search_nearest_parameter(point, None, 100).unwrap();- assert!(surface.subs(uv.0, uv.1).distance(point) < 1e-6, "{definition}");- assert!(surface.normal(uv.0, uv.1).dot(normal) * if sense { 1.0 } else { -1.0 } > 0.99, "{definition}, sense {sense}");- }- }- let p = mt::Point3::new(40.0, 0.0, 2.0);- let surface = offset_geometry("CYLINDRICAL_SURFACE('',#2,5.)", "-1.", 10.0, true, &[p, p + mt::Vector3::unit_z()]).unwrap();- let uv = surface.search_nearest_parameter(p, None, 100).unwrap();- assert!(surface.subs(uv.0, uv.1).distance(p) < 1e-6);-}--#[test]-fn offset_surfaces_nested_and_hostile() {- let points = [mt::Point3::new(0.0, 0.0, 0.0), mt::Point3::new(0.0, 0.0, 1.0)];- for (basis, offset) in [- ("CYLINDRICAL_SURFACE('',#2,5.)", "-5."),- ("SPHERICAL_SURFACE('',#2,5.)", "-6."),- ("TOROIDAL_SURFACE('',#2,10.,2.)", "8."),- ("TOROIDAL_SURFACE('',#2,10.,2.)", "-2."),- ("CONICAL_SURFACE('',#2,5.,0.4)", "-10."),- ("PLANE('',#2)", "1.E100"),- ("PLANE('',#2)", "$"),- ] {- assert!(offset_geometry(basis, offset, 1.0, true, &points).is_err(), "{basis}, {offset}");- }- let text = format!("{HEAD}#1=OFFSET_SURFACE('',#1,1.,.F.);{TAIL}");- let ex = p21::parse(&text).unwrap();- let cx = Ctx { ex: &ex, len: 1.0, ang: 1.0, tol: 1e-6 };- assert!(geom::surface(&cx, 1, &points, &[], true, 0).unwrap_err().contains("nested too deeply"));- let text = format!(- "{HEAD}#1=CARTESIAN_POINT('',(0.,0.,0.));#2=AXIS2_PLACEMENT_3D('',#1,$,$);#3=CYLINDRICAL_SURFACE('',#2,5.);#4=OFFSET_SURFACE('',#3,-6.,.F.);#5=OFFSET_SURFACE('',#4,6.,.F.);{TAIL}"- );- let ex = p21::parse(&text).unwrap();- let cx = Ctx { ex: &ex, len: 1.0, ang: 1.0, tol: 1e-6 };- assert!(geom::surface(&cx, 5, &points, &[], true, 0).is_err());-}-#[test]fn offset_surface_cube_import_is_closed_and_editable() {// Move each basis plane half a file unit inward; nested quarter-unit offsets@@ -743,9 +674,7 @@ fn instanced_assembly_of(parts: u64, n: u64) -> String {fn instanced_parts_are_oriented_once() {let n = 24;let t = instanced_assembly(n);- crate::body::ORIENTED.with(|c| c.set(0));let imp = step_import_with_workers(&t, 1).unwrap();- assert_eq!(crate::body::ORIENTED.with(|c| c.get()), 1, "one distinct part");assert_eq!(imp.bodies.len(), n as usize);assert!(imp.warnings.is_empty(), "{:?}", imp.warnings);for (k, b) in imp.bodies.iter().enumerate() {@@ -776,9 +705,7 @@ fn distinct_parts_convert_together_across_instances() {let threaded = reading.finish().unwrap();assert_eq!(threaded.bodies.len(), n as usize);assert!(threaded.warnings.is_empty(), "{:?}", threaded.warnings);- crate::body::ORIENTED.with(|c| c.set(0));let serial = step_import_with_workers(&t, 1).unwrap();- assert_eq!(crate::body::ORIENTED.with(|c| c.get()), 2, "two parts");assert_same_import(&serial, &threaded);assert_eq!(threaded.bodies[1].name, "Cube1");assert_eq!(threaded.bodies[1].path, vec!["Assembly".to_string(), "Block1".to_string()]);@@ -1108,7 +1035,7 @@ fn hostile_boundaries_mesh_in_bounded_time() {/// A cylinder written as a surface of revolution, oriented the ISO 10303-42 way (normal/// ∂S/∂angle × ∂S/∂profile, outward here, so `same_sense` .T.). Strict readers read such faces this-/// way; reading them with truck's profile-first normal turned faces inside out.+/// way; reading them with the profile's parameter first turned faces inside out.#[test]fn surface_of_revolution_sense_follows_iso() {let mut t = String::from(HEAD);@@ -1156,7 +1083,7 @@ fn horn_torus_written_as_one_spline_face() {}/// Booleans and blends build the same body every time, so an export is byte-identical from-/// run to run (truck used to emit a boolean's faces in hash order of their addresses). The+/// run to run (an export once listed a boolean's faces in hash order of their addresses). The/// tee of oracle 35 with its rolling-ball fillet round the junction.#[test]fn tee_fillet_exports_byte_identical() {@@ -1313,8 +1240,7 @@ fn knot_multiplicities_are_checked_before_they_are_expanded() {};let read = |text: &str| {let ex = p21::parse(text).unwrap();- let cx = Ctx { ex: &ex, len: 1.0, ang: 1.0, tol: 1e-6 };- geom::curve(&cx, 3, 0)+ solidcraft_step::read::Reader::new(&ex, Default::default()).curve(3).map(|_| ())};let error = read(&curve(1_000_000, 64)).unwrap_err();// This diagnostic comes from the check before expansion; wall-clock time depends on CI load.@@ -1559,46 +1485,6 @@ fn periodic_knot_tube(first: u64, x: f64, r: f64, h: f64) -> (String, u64) {(s, face)}-/// A B-spline whose end knots repeat fewer than degree + 1 times (an unclamped knot vector,-/// as OpenCascade writes closed curves and surfaces) is defined only between knot `degree`-/// and knot `len - degree - 1`. Read over the whole knot range, the circle and the tube went-/// on past their domain, and the rational ones divided by zero at the outermost knots.-#[test]-fn periodic_knot_bsplines_are_read_on_their_domain() {- use mt::{BoundedCurve, ParametricCurve, ParametricSurface};- let (r, h) = (1.7, 1.5);- let (tube, face) = periodic_knot_tube(100, 0.0, r, h);- let (circle, row) = circle_net(10, 0.0, r, 0.0);- let text = format!(- "{HEAD}{tube}{circle}#30=(BOUNDED_CURVE()B_SPLINE_CURVE(2,({}),.CIRCULAR_ARC.,.T.,.F.)B_SPLINE_CURVE_WITH_KNOTS(({PERIODIC_MULTS}),({PERIODIC_KNOTS}),.UNSPECIFIED.)CURVE()GEOMETRIC_REPRESENTATION_ITEM()RATIONAL_B_SPLINE_CURVE(({CIRCLE_WEIGHTS}))REPRESENTATION_ITEM(''));\n{TAIL}",- row.join(",")- );- let ex = p21::parse(&text).unwrap();- let cx = Ctx { ex: &ex, len: 1.0, ang: 1.0, tol: 1e-6 };- let pi = std::f64::consts::PI;- let on_tube = |p: mt::Point3| (p.x.hypot(p.y) - r).abs() < 1e-9 && p.z > -1e-9 && p.z < h + 1e-9;-- let surface_id = ex.get(face).and_then(|e| e.params().get(2)).and_then(Param::as_ref_id).unwrap();- let surface = geom::bspline_surface(&cx, ex.get(surface_id).unwrap()).unwrap();- let (Some((u0, u1)), Some((v0, v1))) = surface.try_range_tuple() else { panic!("unbounded surface") };- assert!(u0.abs() < 1e-12 && (u1 - h / r).abs() < 1e-12, "u range {u0} .. {u1}");- assert!((v0 + pi).abs() < 1e-9 && (v1 - pi).abs() < 1e-9, "v range {v0} .. {v1}");- for i in 0..=8 {- for j in 0..=16 {- let (u, v) = (u0 + (u1 - u0) * i as f64 / 8.0, v0 + (v1 - v0) * j as f64 / 16.0);- assert!(on_tube(surface.subs(u, v)), "S({u}, {v}) = {:?}", surface.subs(u, v));- }- }-- let geom::CurveGeo::Nurbs(curve) = geom::curve(&cx, 30, 0).unwrap() else { panic!("not a rational B-spline") };- let (t0, t1) = curve.range_tuple();- assert!((t0 + pi).abs() < 1e-9 && (t1 - pi).abs() < 1e-9, "curve range {t0} .. {t1}");- for j in 0..=16 {- let t = t0 + (t1 - t0) * j as f64 / 16.0;- assert!(on_tube(curve.subs(t)), "C({t}) = {:?}", curve.subs(t));- }-}-/// Two such tubes far apart in one body: the body's size sets a chord tolerance coarse beside/// the tubes, and meshing a face at it divided the surface's whole parameter box, whose/// corners lay outside the domain. The division never converged there (#1374's recursion),@@ -1824,80 +1710,13 @@ fn step_conformance_parts_read_back_their_exact_shape() {}}-/// A schema 4 record as truck's adapter builds it: truck holds a plane by three points, the-/// same plane within a rounding.-fn truck_ready(record: &solidcraft_geom::brep::Brep) -> solidcraft_geom::brep::Brep {- let mut record = record.clone();- for f in &mut record.faces {- if let solidcraft_geom::brep::Surface::Plane { origin, u_axis, v_axis } = f.surface {- let at = |d: [f64; 3]| [origin[0] + d[0], origin[1] + d[1], origin[2] + d[2]];- f.surface = solidcraft_geom::brep::Surface::PlaneThrough { origin, u_point: at(u_axis), v_point: at(v_axis) };- }- }- record-}-/// The volume of the one solid `solidcraft_step::topology` reads from `text` into schema 4,-/// built back into a truck body: negative when its faces point into its material.+/// measured as the body of that record.pub(super) fn schema_4_volume(text: &str) -> f64 {let ex = solidcraft_step::p21::parse(text).unwrap();let r = solidcraft_step::topology::read_solids(&ex);assert!(r.failures.is_empty() && r.solids.len() == 1, "{:?}", r.failures);- let solid = crate::native::solid_of_record(truck_ready(&r.solids[0].brep)).unwrap();- let sign = solid.boundaries().iter().map(crate::body::shell_volume).sum::<Option<f64>>().unwrap().signum();- sign * measure(&crate::body::Body::new(solid).unwrap()).unwrap().volume-}--/// Each STEP file in `SOLIDCRAFT_STEP_CORPUS`: bodies, faces, edges and volume as truck-/// imports it and as `solidcraft_step::topology` reads it into schema 4 records (built back into-/// truck solids for their volume, signed: negative means faces turned into the material).-/// Counts may differ where truck splits faces (bands, balls) or edges and where schema 4 adds-/// seams; volumes are coarse meshes' (1% of the size). This reports, it does not judge. Run-/// with `--ignored --nocapture`.-#[test]-#[ignore = "needs SOLIDCRAFT_STEP_CORPUS"]-fn corpus_truck_and_schema_4_counts() {- let Ok(dir) = std::env::var("SOLIDCRAFT_STEP_CORPUS") else { return };- let mut paths: Vec<_> = std::fs::read_dir(&dir).into_iter().flatten().flatten().map(|e| e.path()).collect();- paths.sort();- let volume = |s: &mt::Solid| s.boundaries().iter().map(crate::body::shell_volume).sum::<Option<f64>>();- for path in paths.iter().filter(|p| p.extension().is_some_and(|e| e.eq_ignore_ascii_case("step") || e.eq_ignore_ascii_case("stp"))) {- let text = std::fs::read_to_string(path).unwrap_or_default();- let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();- let truck = match step_import(&text) {- Ok(imp) => {- // A body per instance: count each STEP item once.- let mut seen = HashSet::new();- let once: Vec<&ImportedBody> = imp.bodies.iter().filter(|b| seen.insert(b.source_item)).collect();- let (f, e) = once.iter().fold((0, 0), |(f, e), b| (f + b.body.face_count(), e + b.body.edge_count()));- let v: f64 = once.iter().filter_map(|b| volume(&b.body.solid)).sum();- format!("{} bodies, {f} faces, {e} edges, volume {v:.4}", once.len())- }- Err(e) => format!("failed: {e}"),- };- let ex = match solidcraft_step::p21::parse(&text) {- Ok(ex) => ex,- Err(e) => {- println!("{name}: parse failed: {e}");- continue;- }- };- let r = solidcraft_step::topology::read_solids(&ex);- let (f, e) = r.solids.iter().fold((0, 0), |(f, e), s| (f + s.brep.faces.len(), e + s.brep.edges.len()));- let (mut v, mut unbuilt) = (0.0, Vec::new());- for s in &r.solids {- match crate::native::solid_of_record(truck_ready(&s.brep)) {- Ok(solid) => v += volume(&solid).unwrap_or(f64::NAN),- Err(err) => unbuilt.push(err.to_string()),- }- }- println!(- "{name}: truck {truck}; schema 4 {} solids ({} refused), {f} faces, {e} edges, volume {v:.4}{}",- r.solids.len(),- r.failures.len(),- if unbuilt.is_empty() { String::new() } else { format!(" ({} not built by truck: {})", unbuilt.len(), unbuilt[0]) }- );- }+ measure(&Body::from_record(r.solids[0].brep.clone()).unwrap()).unwrap().volume}/// The step-conformance parts read into SMLib (`SOLIDCRAFT_KERNEL=smlib`): the STEP reader'sdiff --git a/crates/kernel/src/step_out.rs b/crates/kernel/src/step_out.rsindex ce1851ce89..33957fd335 100644--- a/crates/kernel/src/step_out.rs+++ b/crates/kernel/src/step_out.rs@@ -1,20 +1,19 @@//! STEP (ISO 10303-21) export: AP242 product structure, assemblies, names and colours.//!-//! Each body's B-rep is written by truck's STEP writer (geometry and topology only), read back-//! with our Part 21 parser and copied into a file we assemble ourselves: one header and-//! context, a product per part with its shape representation, named solids, surface colours,-//! and assemblies as next-assembly-usage occurrences placed by item-defined transformations-//! (the structure the CAx-IF recommends and our reader follows). Identical geometric entities-//! (points, directions, placements, curves, surfaces) are written once and referenced; ids are-//! dense from `#1`.+//! Each body's record is written as it is, the exact B-rep, by+//! [`solidcraft_step::write::topology`]: its material regions as solids, its open shells as a+//! surface model. Around it this writes one header and context, a product per part with its+//! shape representation, named solids, surface and face colours, and assemblies as+//! next-assembly-usage occurrences placed by item-defined transformations (the structure the+//! CAx-IF recommends and our reader follows). Identical geometric entities (points, directions,+//! placements, curves, surfaces) are written once and referenced; ids are dense from `#1`.-use std::collections::HashMap;use std::fmt::Write as _;-use solidcraft_geom::Vec3;+use solidcraft_step::p21::Param;+use solidcraft_step::write::{GeomWriter, Writer, string, topology};use crate::body::Body;-use crate::step_in::p21::{self, Param};use crate::{KernelError, Result};/// A named, optionally coloured body to export (coordinates in its part's frame, mm).@@ -45,1547 +44,20 @@ pub struct StepHeader {pub description: String,}-/// Entities whose identity is topological: never merged even when their text is equal.-const TOPOLOGY: &[&str] = &[- "VERTEX_POINT",- "EDGE_CURVE",- "ORIENTED_EDGE",- "EDGE_LOOP",- "FACE_BOUND",- "FACE_OUTER_BOUND",- "FACE_SURFACE",- "ADVANCED_FACE",- "ORIENTED_FACE",- "CLOSED_SHELL",- "OPEN_SHELL",- "ORIENTED_CLOSED_SHELL",- "MANIFOLD_SOLID_BREP",- "BREP_WITH_VOIDS",-];+/// The least distance uncertainty written (mm).+const MIN_UNCERTAINTY: f64 = 1e-6;-fn real(x: f64) -> String {- if !x.is_finite() {- return "0.".into();- }- let s = format!("{x:?}");- match s.split_once('e') {- Some((m, e)) => {- let m = if m.contains('.') { m.to_string() } else { format!("{m}.") };- format!("{m}E{e}")- }- None if s.contains('.') => s,- None => format!("{s}."),- }-}--/// A STEP string literal (quotes doubled, non-ASCII as `\X2\` UTF-16 runs).-fn string(s: &str) -> String {- let mut o = String::from("'");- for c in s.chars() {- match c {- '\'' => o.push_str("''"),- '\\' => o.push_str("\\\\"),- c if c.is_ascii() && !c.is_ascii_control() => o.push(c),- c if c.is_ascii_control() => {}- c => {- o.push_str("\\X2\\");- let mut buf = [0u16; 2];- for u in c.encode_utf16(&mut buf) {- let _ = write!(o, "{u:04X}");- }- o.push_str("\\X0\\");- }- }- }- o.push('\'');- o-}--fn param(p: &Param, map: &HashMap<u64, u64>, o: &mut String) -> std::result::Result<(), String> {- match p {- Param::Int(i) => {- let _ = write!(o, "{i}");- }- Param::Real(x) => o.push_str(&real(*x)),- Param::Str(s) => o.push_str(&string(s)),- Param::Enum(e) => {- let _ = write!(o, ".{e}.");- }- Param::Ref(r) => {- let n = map.get(r).ok_or_else(|| format!("dangling reference #{r}"))?;- let _ = write!(o, "#{n}");- }- Param::List(v) => {- o.push('(');- params(v, map, o)?;- o.push(')');- }- Param::Typed(name, v) => {- o.push_str(name);- o.push('(');- params(v, map, o)?;- o.push(')');- }- Param::Binary(b) => {- let _ = write!(o, "\"{b}\"");- }- Param::Null => o.push('$'),- Param::Derived => o.push('*'),- }- Ok(())-}--fn params(v: &[Param], map: &HashMap<u64, u64>, o: &mut String) -> std::result::Result<(), String> {- for (i, p) in v.iter().enumerate() {- if i > 0 {- o.push(',');- }- param(p, map, o)?;- }- Ok(())-}--/// The DATA section under construction.-#[derive(Default)]-struct Out {- lines: Vec<String>,- /// Geometry text → id (shared entities).- shared: HashMap<String, u64>,- /// Surfaces written with the opposite normal to the one they replace.- flipped: std::collections::HashSet<u64>,- /// B-spline cylinder and cone sheets of the body being copied to write as analytic surfaces,- /// with the direction of their parameter seam.- merged: HashMap<u64, V3>,- /// B-spline sheets of the body being copied to write cut down to their faces.- trimmed: HashMap<u64, truck_modeling::Surface>,- /// Faces of the body being copied: exchange id → written id.- faces_out: HashMap<u64, u64>,-}--impl Out {- fn add(&mut self, text: impl Into<String>) -> u64 {- self.lines.push(text.into());- self.lines.len() as u64- }- /// Add, or reuse an identical earlier entity (geometry only).- fn add_shared(&mut self, text: String) -> u64 {- if let Some(id) = self.shared.get(&text) {- return *id;- }- let id = self.add(text.clone());- self.shared.insert(text, id);- id- }- fn point(&mut self, p: [f64; 3]) -> u64 {- self.add_shared(format!("CARTESIAN_POINT('',({},{},{}))", real(p[0]), real(p[1]), real(p[2])))- }- fn direction(&mut self, d: [f64; 3]) -> u64 {- self.add_shared(format!("DIRECTION('',({},{},{}))", real(d[0]), real(d[1]), real(d[2])))- }- fn write_analytic(&mut self, a: &Analytic) -> u64 {- match a.kind {- AnalyticKind::Plane { o, z, x } => {- let ax = self.placement(o, z, x);- self.add_shared(format!("PLANE('',#{ax})"))- }- AnalyticKind::Cylinder { o, z, x, r } => {- let ax = self.placement(o, z, x);- self.add_shared(format!("CYLINDRICAL_SURFACE('',#{ax},{})", real(r)))- }- AnalyticKind::Cone { o, z, x, r, angle } => {- let ax = self.placement(o, z, x);- self.add_shared(format!("CONICAL_SURFACE('',#{ax},{},{})", real(r), real(angle)))- }- AnalyticKind::Sphere { o, z, x, r } => {- let ax = self.placement(o, z, x);- self.add_shared(format!("SPHERICAL_SURFACE('',#{ax},{})", real(r)))- }- AnalyticKind::Torus { o, z, x, big, small } => {- let ax = self.placement(o, z, x);- self.add_shared(format!("TOROIDAL_SURFACE('',#{ax},{},{})", real(big), real(small)))- }- AnalyticKind::HornTorus { o, z, x, big, small } => {- // Nine-point rational quadratic circles (quarter arcs, corner weights √½): the- // tube from the pole round and back, and the turn about z from x.- let y = cross(z, x);- let ring = |k: usize| {- let ang = std::f64::consts::FRAC_PI_4 * k as f64;- let (scale, w) = if k % 2 == 1 { (std::f64::consts::SQRT_2, std::f64::consts::FRAC_1_SQRT_2) } else { (1.0, 1.0) };- (ang.cos() * scale, ang.sin() * scale, w)- };- let (mut rows, mut weights) = (Vec::new(), Vec::new());- for i in 0..9 {- let (ci, si, wi) = ring(i);- let (rho, h) = (big - small * ci, small * si);- let (mut row, mut wrow) = (Vec::new(), Vec::new());- for j in 0..9 {- let (cj, sj, wj) = ring(j);- let pt = add(add(o, mul(z, h)), add(mul(x, rho * cj), mul(y, rho * sj)));- row.push(format!("#{}", self.point(pt)));- wrow.push(real(wi * wj));- }- rows.push(format!("({})", row.join(",")));- weights.push(format!("({})", wrow.join(",")));- }- self.add_shared(format!(- "(BOUNDED_SURFACE()B_SPLINE_SURFACE(2,2,({}),.UNSPECIFIED.,.T.,.T.,.F.)B_SPLINE_SURFACE_WITH_KNOTS((3,2,2,2,3),(3,2,2,2,3),(0.,0.25,0.5,0.75,1.),(0.,0.25,0.5,0.75,1.),.UNSPECIFIED.)GEOMETRIC_REPRESENTATION_ITEM()RATIONAL_B_SPLINE_SURFACE(({}))REPRESENTATION_ITEM('')SURFACE())",- rows.join(","),- weights.join(",")- ))- }- }- }- /// A B-spline (or NURBS) surface; `None` for other surfaces.- fn write_sheet(&mut self, s: &truck_modeling::Surface) -> Option<u64> {- use truck_modeling::Surface;- let (rows, weights, (ku, kv), (du, dv)): (Vec<Vec<V3>>, Option<Vec<Vec<f64>>>, _, _) = match s {- Surface::BSplineSurface(b) => (- b.control_points().iter().map(|r| r.iter().map(|p| [p.x, p.y, p.z]).collect()).collect(),- None,- b.knot_vecs().clone(),- (b.udegree(), b.vdegree()),- ),- Surface::NurbsSurface(n) => {- let b = n.non_rationalized();- let rows: Option<Vec<Vec<V3>>> = b- .control_points()- .iter()- .map(|r| r.iter().map(|p| (p.w.abs() > 1e-300).then(|| [p.x / p.w, p.y / p.w, p.z / p.w])).collect())- .collect();- (- rows?,- Some(b.control_points().iter().map(|r| r.iter().map(|p| p.w).collect()).collect()),- b.knot_vecs().clone(),- (b.udegree(), b.vdegree()),- )- }- _ => return None,- };- let net = rows- .iter()- .map(|r| format!("({})", r.iter().map(|p| format!("#{}", self.point(*p))).collect::<Vec<_>>().join(",")))- .collect::<Vec<_>>()- .join(",");- let list = |v: Vec<String>| v.join(",");- let ((ku, mu), (kv, mv)) = (ku.to_single_multi(), kv.to_single_multi());- let knots = format!(- "({}),({}),({}),({}),.UNSPECIFIED.",- list(mu.iter().map(|m| m.to_string()).collect()),- list(mv.iter().map(|m| m.to_string()).collect()),- list(ku.iter().map(|k| real(*k)).collect()),- list(kv.iter().map(|k| real(*k)).collect()),- );- let base = format!("{du},{dv},({net}),.UNSPECIFIED.,.U.,.U.,.U.");- Some(match weights {- None => self.add_shared(format!("B_SPLINE_SURFACE_WITH_KNOTS('',{base},{knots})")),- Some(w) => {- let w = w.iter().map(|r| format!("({})", list(r.iter().map(|x| real(*x)).collect()))).collect::<Vec<_>>().join(",");- self.add_shared(format!(- "(BOUNDED_SURFACE()B_SPLINE_SURFACE({base})B_SPLINE_SURFACE_WITH_KNOTS({knots})GEOMETRIC_REPRESENTATION_ITEM()RATIONAL_B_SPLINE_SURFACE(({w}))REPRESENTATION_ITEM('')SURFACE())"- ))- }- })- }- fn placement(&mut self, o: [f64; 3], z: [f64; 3], x: [f64; 3]) -> u64 {- let (po, dz, dx) = (self.point(o), self.direction(z), self.direction(x));- self.add_shared(format!("AXIS2_PLACEMENT_3D('',#{po},#{dz},#{dx})"))- }-- /// Copy a solid entity of a parsed file and everything it uses; returns its new id.- fn copy_solid(&mut self, ex: &p21::Exchange, root: u64, name: &str) -> std::result::Result<u64, String> {- let mut map: HashMap<u64, u64> = HashMap::new();- let seams = horn_seams(ex);- // Iterative post-order walk (children before parents).- let mut stack: Vec<(u64, bool)> = vec![(root, false)];- let mut guard = 0usize;- while let Some((id, done)) = stack.pop() {- guard += 1;- if guard > 50_000_000 {- return Err("solid too large".into());- }- if map.contains_key(&id) {- continue;- }- let e = ex.get(id).ok_or_else(|| format!("missing #{id}"))?;- // Revolutions with analytic profiles become cylinders, cones, spheres, tori and- // planes (what other systems recognise), with the face sense corrected.- if !done- && e.name() == "SURFACE_OF_REVOLUTION"- && let Some(mut a) = analytic_revolution(ex, e)- {- if let AnalyticKind::HornTorus { x, .. } = &mut a.kind- && let Some(s) = seams.get(&id)- {- *x = *s;- }- let new = self.write_analytic(&a);- if a.flip {- self.flipped.insert(new);- }- map.insert(id, new);- continue;- }- // Flat B-spline sheets are planes; ruled ones become cylinders and cones when- // `analytic_sheets` chose them (their pieces merged, or a lone piece's edges allow).- if !done- && let Some(a) = planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| {- let seam = self.merged.get(&id)?;- let mut a = ruled_bspline(ex, e)?;- if let AnalyticKind::Cylinder { x, .. } | AnalyticKind::Cone { x, .. } = &mut a.kind {- *x = *seam;- }- Some(a)- })- {- let new = self.write_analytic(&a);- if a.flip {- self.flipped.insert(new);- }- map.insert(id, new);- continue;- }- if !done && let Some(sheet) = self.trimmed.get(&id).cloned() {- let new = self.write_sheet(&sheet).ok_or_else(|| format!("cannot write the cut sheet #{id}"))?;- map.insert(id, new);- continue;- }- if !done {- stack.push((id, true));- let mut refs = Vec::new();- fn collect(p: &Param, out: &mut Vec<u64>) {- match p {- Param::Ref(r) => out.push(*r),- Param::List(v) | Param::Typed(_, v) => v.iter().for_each(|x| collect(x, out)),- _ => {}- }- }- e.records.iter().flat_map(|r| &r.params).for_each(|p| collect(p, &mut refs));- stack.extend(refs.into_iter().filter(|r| !map.contains_key(r)).map(|r| (r, false)));- continue;- }- let mut text = String::new();- let is_root = id == root;- if e.is_complex() {- text.push('(');- for r in &e.records {- text.push_str(&r.name);- text.push('(');- params(&r.params, &map, &mut text)?;- text.push(')');- }- text.push(')');- } else {- // Advanced breps use advanced faces (same attributes as truck's face surfaces).- let ename = if e.name() == "FACE_SURFACE" { "ADVANCED_FACE" } else { e.name() };- text.push_str(ename);- text.push('(');- let mut ps = e.params().to_vec();- if is_root && let Some(first) = ps.first_mut() {- *first = Param::Str(name.to_string());- }- // A face on a surface written with the opposite normal flips its sense.- if ename == "ADVANCED_FACE"- && ps.get(2).and_then(Param::as_ref_id).and_then(|g| map.get(&g)).is_some_and(|g| self.flipped.contains(g))- && let Some(Param::Enum(sense)) = ps.get_mut(3)- {- *sense = if sense == "T" { "F".into() } else { "T".into() };- }- params(&ps, &map, &mut text)?;- text.push(')');- }- let topo = TOPOLOGY.contains(&e.name());- let new = if topo { self.add(text) } else { self.add_shared(text) };- map.insert(id, new);- if matches!(e.name(), "FACE_SURFACE" | "ADVANCED_FACE") {- self.faces_out.insert(id, new);- }- }- map.get(&root).copied().ok_or_else(|| "solid not copied".into())- }+fn s(text: &str) -> Param {+ Param::Str(text.to_string())}--/// An analytic surface found behind a surface of revolution.-#[derive(Clone, Copy)]-struct Analytic {- kind: AnalyticKind,- /// The analytic surface's normal is opposite to the revolution's (ISO 10303-42 normals).- flip: bool,+fn r(id: u64) -> Param {+ Param::Ref(id)}--#[derive(Clone, Copy)]-enum AnalyticKind {- Plane {- o: V3,- z: V3,- x: V3,- },- Cylinder {- o: V3,- z: V3,- x: V3,- r: f64,- },- Cone {- o: V3,- z: V3,- x: V3,- r: f64,- angle: f64,- },- Sphere {- o: V3,- z: V3,- x: V3,- r: f64,- },- Torus {- o: V3,- z: V3,- x: V3,- big: f64,- small: f64,- },- /// A torus whose tube reaches its axis (a horn torus, as a tight sweep makes): no valid- /// TOROIDAL_SURFACE, so a rational B-spline (tube angle from the pole at the axis, then the- /// turn from x), as other systems write it. x is the turn's parameter seam.- HornTorus {- o: V3,- z: V3,- x: V3,- big: f64,- small: f64,- },+fn refs(ids: &[u64]) -> Param {+ Param::List(ids.iter().map(|i| r(*i)).collect())}-type V3 = [f64; 3];--fn sub(a: V3, b: V3) -> V3 {- [a[0] - b[0], a[1] - b[1], a[2] - b[2]]-}-fn add(a: V3, b: V3) -> V3 {- [a[0] + b[0], a[1] + b[1], a[2] + b[2]]-}-fn mul(a: V3, k: f64) -> V3 {- [a[0] * k, a[1] * k, a[2] * k]-}-fn dot(a: V3, b: V3) -> f64 {- a[0] * b[0] + a[1] * b[1] + a[2] * b[2]-}-fn cross(a: V3, b: V3) -> V3 {- [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]-}-fn norm(a: V3) -> f64 {- dot(a, a).sqrt()-}-fn unit(a: V3) -> Option<V3> {- let n = norm(a);- (n > 1e-12 && n.is_finite()).then(|| mul(a, 1.0 / n))-}--/// Circle through three points: centre, radius, unit normal.-fn circle3(a: V3, b: V3, c: V3) -> Option<(V3, f64, V3)> {- let (ab, ac) = (sub(b, a), sub(c, a));- let n = cross(ab, ac);- let n2 = dot(n, n);- if !(n2 > 1e-24) {- return None;- }- let t = add(mul(cross(n, ab), dot(ac, ac)), mul(cross(ac, n), dot(ab, ab)));- let center = add(a, mul(t, 0.5 / n2));- Some((center, norm(sub(a, center)), unit(n)?))-}--/// The analytic surface a surface of revolution is, if its profile is a line or a circular arc-/// in a plane through the axis.-fn analytic_revolution(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {- use crate::step_in::geom::{self, CurveGeo};- use truck_modeling::{BoundedCurve, ParametricCurve};- let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };- let p = e.params();- let (ao, ad) = geom::axis1(&cx, p.get(2)?.as_ref_id()?).ok()?;- let (oa, a) = ([ao.x, ao.y, ao.z], [ad.x, ad.y, ad.z]);- let g = geom::curve(&cx, p.get(1)?.as_ref_id()?, 0).ok()?;- let radial = |q: V3| {- let v = sub(q, oa);- sub(v, mul(a, dot(v, a)))- };- let on_axis = |q: V3| add(oa, mul(a, dot(sub(q, oa), a)));- // Profile samples and tangents.- let eval: Box<dyn Fn(f64) -> V3> = match &g {- CurveGeo::Line { p, d } => {- let (p, d) = ([p.x, p.y, p.z], [d.x, d.y, d.z]);- Box::new(move |t| add(p, mul(d, t)))- }- CurveGeo::BSpline(c) => {- let c = c.clone();- let (t0, t1) = c.range_tuple();- Box::new(move |s| {- let q = c.subs(t0 + (t1 - t0) * s);- [q.x, q.y, q.z]- })- }- CurveGeo::Nurbs(c) => {- let c = c.clone();- let (t0, t1) = c.range_tuple();- Box::new(move |s| {- let q = c.subs(t0 + (t1 - t0) * s);- [q.x, q.y, q.z]- })- }- CurveGeo::Conic { .. } | CurveGeo::Hyperbola { .. } | CurveGeo::Parabola { .. } => return None,- };- // A sample point off the axis, its revolution normal (∂S/∂angle × ∂S/∂profile).- let sample =- [0.37, 0.61, 0.23, 0.79].into_iter().map(|t| (eval(t), sub(eval(t + 1e-4), eval(t - 1e-4)))).find(|(q, _)| norm(radial(*q)) > 1e-6)?;- let (q, dq) = sample;- let n_rev = cross(cross(a, sub(q, oa)), dq);- let eq = unit(radial(q))?;- let (kind, n_an) = match &g {- CurveGeo::Line { d, .. } => {- let d = unit([d.x, d.y, d.z])?;- // Coplanar with the axis?- if dot(cross(d, a), eq).abs() > 1e-9 {- return None;- }- let (da, dr) = (dot(d, a), dot(d, eq));- if dr.abs() < 1e-12 {- let r = norm(radial(q));- (AnalyticKind::Cylinder { o: oa, z: a, x: eq, r }, eq)- } else if da.abs() < 1e-12 {- (AnalyticKind::Plane { o: on_axis(q), z: a, x: eq }, a)- } else {- // Open the cone along +z: the radius grows that way.- let z = if dr * da > 0.0 { a } else { mul(a, -1.0) };- let angle = (dr.abs() / da.abs()).atan();- let r = norm(radial(q));- let n = sub(mul(eq, angle.cos()), mul(z, angle.sin()));- (AnalyticKind::Cone { o: on_axis(q), z, x: eq, r, angle }, n)- }- }- _ => {- let (c, r, nc) = circle3(eval(0.0), eval(0.5), eval(1.0))?;- // Every sample on the circle, the circle's plane through the axis.- if (0..=8).any(|i| (norm(sub(eval(i as f64 / 8.0), c)) - r).abs() > 1e-7 * (1.0 + r)) {- return None;- }- if dot(nc, a).abs() > 1e-9 || dot(sub(c, oa), nc).abs() > 1e-7 * (1.0 + r) {- return None;- }- let big = norm(radial(c));- if big < 1e-9 * (1.0 + r) {- (AnalyticKind::Sphere { o: c, z: a, x: eq, r }, sub(q, c))- } else {- let ec = unit(radial(c))?;- let o = on_axis(c);- if (big - r).abs() <= 1e-6 * (1.0 + r) {- (AnalyticKind::HornTorus { o, z: a, x: mul(ec, -1.0), big: r, small: r }, sub(q, add(o, mul(eq, r))))- } else if big < r {- // A spindle torus (tube crossing the axis) stays a surface of revolution.- return None;- } else {- (AnalyticKind::Torus { o, z: a, x: ec, big, small: r }, sub(q, add(o, mul(eq, big))))- }- }- }- };- let flip = dot(n_rev, n_an) < 0.0;- if !dot(n_rev, n_an).is_finite() || dot(n_rev, n_an).abs() < 1e-12 {- return None;- }- Some(Analytic { kind, flip })-}--/// Two analytic surfaces are the same surface (same kind, frame-independent parameters).-fn same_analytic(a: &AnalyticKind, b: &AnalyticKind) -> bool {- let close = |x: f64, y: f64| (x - y).abs() <= 1e-7 * (1.0 + x.abs().max(y.abs()));- let same_pt = |p: V3, q: V3| norm(sub(p, q)) <= 1e-7 * (1.0 + norm(p));- let parallel = |p: V3, q: V3| norm(cross(p, q)) <= 1e-9;- let on_line = |p: V3, o: V3, d: V3| norm(cross(sub(p, o), d)) <= 1e-7 * (1.0 + norm(p));- match (a, b) {- (AnalyticKind::Cylinder { o, z, r, .. }, AnalyticKind::Cylinder { o: o2, z: z2, r: r2, .. }) => {- parallel(*z, *z2) && on_line(*o2, *o, *z) && close(*r, *r2)- }- (AnalyticKind::Cone { o, z, r, angle, .. }, AnalyticKind::Cone { o: o2, z: z2, r: r2, angle: a2, .. }) => {- // Same apex, axis direction and angle.- let apex = |o: V3, z: V3, r: f64, an: f64| sub(o, mul(z, r / an.tan()));- dot(*z, *z2) > 1.0 - 1e-9 && close(*angle, *a2) && same_pt(apex(*o, *z, *r, *angle), apex(*o2, *z2, *r2, *a2))- }- (AnalyticKind::Sphere { o, r, .. }, AnalyticKind::Sphere { o: o2, r: r2, .. }) => same_pt(*o, *o2) && close(*r, *r2),- (AnalyticKind::Torus { o, z, big, small, .. }, AnalyticKind::Torus { o: o2, z: z2, big: b2, small: s2, .. }) => {- same_pt(*o, *o2) && parallel(*z, *z2) && close(*big, *b2) && close(*small, *s2)- }- (AnalyticKind::HornTorus { o, z, big, .. }, AnalyticKind::HornTorus { o: o2, z: z2, big: b2, .. }) => {- same_pt(*o, *o2) && parallel(*z, *z2) && close(*big, *b2)- }- (AnalyticKind::Plane { o, z, .. }, AnalyticKind::Plane { o: o2, z: z2, .. }) => {- parallel(*z, *z2) && dot(sub(*o2, *o), *z).abs() <= 1e-7 * (1.0 + norm(*o))- }- _ => false,- }-}--/// The outward normal sign of a face relative to its analytic surface's normal.-fn face_normal_sign(a: &AnalyticKind, z_written: V3, flip: bool, sense: bool) -> f64 {- // Planes compare their written normal directly; the others are always outward-normal kinds.- let base = match a {- AnalyticKind::Plane { z, .. } => dot(*z, z_written).signum(),- _ => 1.0,- };- base * if flip != sense { 1.0 } else { -1.0 }-}--/// A B-spline surface that is flat (a sheet swept along a line, as truck makes for extrusions):-/// the plane with the surface's own normal, so it can be written as a PLANE.-fn planar_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<AnalyticKind> {- use truck_modeling::{BoundedSurface, ParametricSurface, ParametricSurface3D};- if !(e.has("B_SPLINE_SURFACE") || e.name() == "B_SPLINE_SURFACE_WITH_KNOTS") {- return None;- }- let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };- let s = crate::step_in::geom::bspline_surface(&cx, e).ok()?;- let (ctrl, (u0, u1), (v0, v1)) = match &s {- truck_modeling::Surface::BSplineSurface(b) => {- (b.control_points().iter().flatten().map(|p| [p.x, p.y, p.z]).collect::<Vec<V3>>(), b.range_tuple().0, b.range_tuple().1)- }- truck_modeling::Surface::NurbsSurface(n) => {- let pts = n.non_rationalized().control_points().iter().flatten().map(|p| [p.x / p.w, p.y / p.w, p.z / p.w]).collect::<Vec<V3>>();- let (ru, rv) = n.range_tuple();- (pts, ru, rv)- }- _ => return None,- };- let (um, vm) = ((u0 + u1) / 2.0, (v0 + v1) / 2.0);- let n = s.normal(um, vm);- let z = unit([n.x, n.y, n.z])?;- let o = s.subs(um, vm);- let o = [o.x, o.y, o.z];- let du = s.uder(um, vm);- let x = unit(sub([du.x, du.y, du.z], mul(z, dot([du.x, du.y, du.z], z))))?;- let size = ctrl.iter().map(|p| norm(sub(*p, o))).fold(0.0, f64::max);- // Every control point on the plane (a flat net gives a flat surface, rational or not).- if ctrl.iter().any(|p| dot(sub(*p, o), z).abs() > 1e-9 * (1.0 + size)) {- return None;- }- Some(AnalyticKind::Plane { o, z, x })-}--/// A B-spline surface that is a circular cylinder or cone: straight rulings between two coaxial-/// circles or arcs (or an arc and the cone's apex), as truck makes for extruded round profiles,-/// rounds along straight edges and countersinks. With its normal direction relative to the-/// surface's outward normal.-fn ruled_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {- use truck_modeling::{ParametricSurface, ParametricSurface3D};- if !(e.has("B_SPLINE_SURFACE") || e.name() == "B_SPLINE_SURFACE_WITH_KNOTS") {- return None;- }- let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };- let s = crate::step_in::geom::bspline_surface(&cx, e).ok()?;- let (Some((u0, u1)), Some((v0, v1))) = s.try_range_tuple() else { return None };- let at = |u: f64, v: f64| {- let p = s.subs(u, v);- [p.x, p.y, p.z]- };- // Which parameter runs along the rulings: straight from one end to the other at every point- // of the profile.- for along_v in [true, false] {- let point = |t: f64, w: f64| if along_v { at(u0 + (u1 - u0) * t, v0 + (v1 - v0) * w) } else { at(u0 + (u1 - u0) * w, v0 + (v1 - v0) * t) };- let grid: Vec<Vec<V3>> = (0..=4).map(|m| (0..=8).map(|k| point(k as f64 / 8.0, m as f64 / 4.0)).collect()).collect();- let (Some(p0), Some(p1)) = (grid.first(), grid.last()) else { continue };- let Some(&first) = p0.first() else { continue };- let scale = grid.iter().flatten().map(|p| norm(sub(*p, first))).fold(0.0, f64::max);- let tol = 1e-7 * (1.0 + scale);- let straight = (0..=8).all(|k| {- let (Some(&a), Some(&b)) = (p0.get(k), p1.get(k)) else { return false };- let Some(d) = unit(sub(b, a)) else { return false };- grid.iter().all(|row| row.get(k).is_some_and(|q| norm(cross(sub(*q, a), d)) <= tol))- });- if !straight {- continue;- }- // Each end: a circle (centre, radius, axis) or a single point (a cone's apex).- let ring = |prof: &[V3]| -> Option<(V3, f64, Option<V3>)> {- let &a = prof.first()?;- if prof.iter().all(|p| norm(sub(*p, a)) <= tol) {- return Some((a, 0.0, None));- }- let (&b, &c, &h) = (prof.get(4)?, prof.get(8)?, prof.get(2)?);- let (centre, r, n) = circle3(a, b, c).or_else(|| circle3(a, h, b))?;- prof.iter().all(|p| (norm(sub(*p, centre)) - r).abs() <= tol).then_some((centre, r, Some(n)))- };- let ((c0, r0, n0), (c1, r1, n1)) = (ring(p0)?, ring(p1)?);- let axis = unit(sub(c1, c0))?;- if [n0, n1].iter().flatten().any(|n| norm(cross(*n, axis)) > 1e-7) || (n0.is_none() && n1.is_none()) {- return None;- }- let height = norm(sub(c1, c0));- // The radius grows along z (a cylinder keeps the sweep's direction).- let (o, z, r, angle) = if (r1 - r0).abs() <= tol {- (c0, axis, r0, 0.0)- } else if r1 > r0 {- (c1, axis, r1, ((r1 - r0) / height).atan())- } else {- (c0, mul(axis, -1.0), r0, ((r0 - r1) / height).atan())- };- let radius_at = |q: V3| r + dot(sub(q, o), z) * angle.tan();- let radial = |q: V3| {- let v = sub(q, o);- sub(v, mul(z, dot(v, z)))- };- if grid.iter().flatten().any(|q| (norm(radial(*q)) - radius_at(*q)).abs() > tol) {- return None;- }- // The surface's own normal against the outward one, mid-face.- let (um, vm) = ((u0 + u1) / 2.0, (v0 + v1) / 2.0);- let nn = s.normal(um, vm);- let q = at(um, vm);- let eq = unit(radial(q))?;- let outward = sub(mul(eq, angle.cos()), mul(z, angle.sin()));- let flip = dot([nn.x, nn.y, nn.z], outward) < 0.0;- // The parameter seam opposite the middle of the sheet, away from its edges.- let x = mul(eq, -1.0);- let kind = if angle == 0.0 { AnalyticKind::Cylinder { o, z, x, r } } else { AnalyticKind::Cone { o, z, x, r, angle } };- return Some(Analytic { kind, flip });- }- None-}--/// A B-spline surface that is really a plane, a cylinder or a cone.-fn analytic_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {- planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| ruled_bspline(ex, e))-}--/// Every edge of a face on a cylinder or cone is a circle square to its axis or one of its-/// rulings (a line along the axis, or through a cone's apex). Faces bounded by other curves (a-/// hole crossing a tube wall) keep their B-spline sheet: readers lay those curves out far more-/// slowly on the analytic surface than on the sheet they came with.-fn square_or_ruled(ex: &p21::Exchange, fe: &p21::Entity, kind: &AnalyticKind) -> bool {- let (z, apex) = match *kind {- AnalyticKind::Cylinder { z, .. } => (z, None),- AnalyticKind::Cone { o, z, r, angle, .. } if angle.tan() > 1e-12 => (z, Some(sub(o, mul(z, r / angle.tan())))),- _ => return false,- };- face_edges(ex, fe).is_some_and(|ls| {- ls.iter().flatten().all(|(x, _)| {- edge_samples(ex, *x).is_some_and(|pts| {- let Some(&q0) = pts.first() else { return false };- let tol = 1e-7 * (1.0 + norm(q0));- let ruling = match apex {- None => pts.iter().all(|q| norm(cross(sub(*q, q0), z)) <= tol),- Some(a) => pts.iter().all(|q| norm(cross(sub(*q, a), sub(q0, a))) <= tol * (1.0 + norm(sub(q0, a)))),- };- ruling || pts.iter().all(|q| dot(sub(*q, q0), z).abs() <= tol)- })- })- })-}--/// Points along an edge's curve (its ends for a line, None for a conic it cannot sample).-fn edge_samples(ex: &p21::Exchange, edge: u64) -> Option<Vec<V3>> {- edge_points(ex, edge, 4)-}--/// `n + 1` points along an edge's curve, ends included (its ends for a line, None for a conic it-/// cannot sample).-fn edge_points(ex: &p21::Exchange, edge: u64, n: usize) -> Option<Vec<V3>> {- use truck_modeling::{BoundedCurve, ParametricCurve};- let p = ex.get(edge)?.params();- let ends = [vertex_point(ex, p.get(1)?.as_ref_id()?)?, vertex_point(ex, p.get(2)?.as_ref_id()?)?];- let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };- let sample = |f: &dyn Fn(f64) -> truck_modeling::Point3, (t0, t1): (f64, f64)| {- (0..=n).map(|k| f(t0 + (t1 - t0) * k as f64 / n.max(1) as f64)).map(|q| [q.x, q.y, q.z]).collect::<Vec<V3>>()- };- match crate::step_in::geom::curve(&cx, p.get(3)?.as_ref_id()?, 0).ok()? {- crate::step_in::geom::CurveGeo::Line { .. } => Some(ends.to_vec()),- crate::step_in::geom::CurveGeo::BSpline(c) => Some(sample(&|t| c.subs(t), c.range_tuple())),- crate::step_in::geom::CurveGeo::Nurbs(c) => Some(sample(&|t| c.subs(t), c.range_tuple())),- crate::step_in::geom::CurveGeo::Conic { .. }- | crate::step_in::geom::CurveGeo::Hyperbola { .. }- | crate::step_in::geom::CurveGeo::Parabola { .. } => None,- }-}--fn vertex_point(ex: &p21::Exchange, v: u64) -> Option<V3> {- let p = ex.get(ex.get(v)?.params().get(1)?.as_ref_id()?)?;- let c = p.params().get(1)?.as_list()?;- Some([c.first()?.as_f64()?, c.get(1)?.as_f64()?, c.get(2)?.as_f64()?])-}--/// For each horn torus revolution, a turn direction away from its faces (the B-spline's-/// parameter seam must not cross them): opposite their vertices' mean direction about the axis.-fn horn_seams(ex: &p21::Exchange) -> HashMap<u64, V3> {- let mut out = HashMap::new();- for fe in ex.entities.values() {- if !matches!(fe.name(), "FACE_SURFACE" | "ADVANCED_FACE") {- continue;- }- let Some(sid) = fe.params().get(2).and_then(Param::as_ref_id) else { continue };- let Some(se) = ex.get(sid).filter(|e| e.name() == "SURFACE_OF_REVOLUTION") else { continue };- let Some(Analytic { kind: AnalyticKind::HornTorus { o, z, .. }, .. }) = analytic_revolution(ex, se) else { continue };- let Some(loops) = face_edges(ex, fe) else { continue };- let mut mean = [0.0; 3];- for (e, _) in loops.iter().flatten() {- for k in [1, 2] {- let Some(q) = ex.get(*e).and_then(|e| e.params().get(k)).and_then(Param::as_ref_id).and_then(|v| vertex_point(ex, v)) else {- continue;- };- let v = sub(q, o);- if let Some(r) = unit(sub(v, mul(z, dot(v, z)))) {- mean = add(mean, r);- }- }- }- if let Some(m) = unit(mean) {- out.insert(sid, mul(m, -1.0));- }- }- out-}--/// Zero-length edges (truck sweeps a profile point on the axis into one) removed and their-/// vertices joined: other systems reject a pole written as an ordinary edge.-fn collapse_short_edges(ex: &mut p21::Exchange) {- let ends = |e: &p21::Entity| Some((e.params().get(1)?.as_ref_id()?, e.params().get(2)?.as_ref_id()?));- let mut join: HashMap<u64, u64> = HashMap::new();- let mut dead = std::collections::HashSet::new();- let mut ids: Vec<u64> = ex.entities.iter().filter(|(_, e)| e.name() == "EDGE_CURVE").map(|(i, _)| *i).collect();- ids.sort();- for id in ids {- let Some(e) = ex.get(id) else { continue };- let Some((a, b)) = ends(e) else { continue };- let (Some(pa), Some(pb)) = (vertex_point(ex, a), vertex_point(ex, b)) else { continue };- if a == b || norm(sub(pa, pb)) > 1e-6 * (1.0 + norm(pa)) {- continue;- }- // The curve itself must be short too (not a whole circle between two coincident vertices).- let short = e.params().get(3).and_then(Param::as_ref_id).and_then(|c| {- use truck_modeling::{BoundedCurve, ParametricCurve};- let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };- let mid = match crate::step_in::geom::curve(&cx, c, 0).ok()? {- crate::step_in::geom::CurveGeo::Line { .. } => return Some(true),- crate::step_in::geom::CurveGeo::BSpline(c) => c.subs((c.range_tuple().0 + c.range_tuple().1) / 2.0),- crate::step_in::geom::CurveGeo::Nurbs(c) => c.subs((c.range_tuple().0 + c.range_tuple().1) / 2.0),- crate::step_in::geom::CurveGeo::Conic { .. }- | crate::step_in::geom::CurveGeo::Hyperbola { .. }- | crate::step_in::geom::CurveGeo::Parabola { .. } => return Some(false),- };- Some(norm(sub([mid.x, mid.y, mid.z], pa)) <= 1e-6 * (1.0 + norm(pa)))- });- if short != Some(true) {- continue;- }- let find = |join: &HashMap<u64, u64>, mut v: u64| {- while let Some(n) = join.get(&v) {- v = *n;- }- v- };- let (ra, rb) = (find(&join, a), find(&join, b));- if ra != rb {- join.insert(rb, ra);- }- dead.insert(id);- }- if dead.is_empty() {- return;- }- // A loop made only of such edges (a pole loop) keeps them all.- let oe_edge = |ex: &p21::Exchange, oe: &Param| oe.as_ref_id().and_then(|o| ex.get(o)).and_then(|o| o.params().get(3)).and_then(Param::as_ref_id);- let loops: Vec<u64> = ex.entities.iter().filter(|(_, e)| e.name() == "EDGE_LOOP").map(|(i, _)| *i).collect();- for l in &loops {- let Some(list) = ex.get(*l).and_then(|e| e.params().get(1)).and_then(Param::as_list) else { continue };- if list.iter().all(|oe| oe_edge(ex, oe).is_some_and(|e| dead.contains(&e))) {- return;- }- }- for l in loops {- let Some(list) = ex.get(l).and_then(|e| e.params().get(1)).and_then(Param::as_list) else { continue };- let kept: Vec<Param> = list.iter().filter(|oe| !oe_edge(ex, oe).is_some_and(|e| dead.contains(&e))).cloned().collect();- if let Some(r) = ex.entities.get_mut(&l).and_then(|e| e.records.first_mut())- && let Some(slot) = r.params.get_mut(1)- {- *slot = Param::List(kept);- }- }- let find = |mut v: u64| {- while let Some(n) = join.get(&v) {- v = *n;- }- v- };- for e in ex.entities.values_mut() {- if e.name() != "EDGE_CURVE" {- continue;- }- if let Some(r) = e.records.first_mut() {- for k in [1, 2] {- if let Some(slot) = r.params.get_mut(k)- && let Some(v) = slot.as_ref_id()- {- *slot = Param::Ref(find(v));- }- }- }- }-}--/// Oriented edges (edge id, forward) of a face's bounds.-fn face_edges(ex: &p21::Exchange, face: &p21::Entity) -> Option<Vec<Vec<(u64, bool)>>> {- let mut loops = Vec::new();- for b in face.params().get(1)?.as_list()? {- let fb = ex.get(b.as_ref_id()?)?;- let lp = ex.get(fb.params().get(1)?.as_ref_id()?)?;- if lp.name() != "EDGE_LOOP" {- return None;- }- let orient = fb.params().get(2)?.as_bool()?;- let mut v = Vec::new();- for oe in lp.params().get(1)?.as_list()? {- let oe = ex.get(oe.as_ref_id()?)?;- if oe.name() != "ORIENTED_EDGE" {- return None;- }- v.push((oe.params().get(3)?.as_ref_id()?, oe.params().get(4)?.as_bool()?));- }- if !orient {- v.reverse();- v.iter_mut().for_each(|e| e.1 = !e.1);- }- loops.push(v);- }- Some(loops)-}--/// Faces that truck splits (a revolution in two or three turns) joined back into one face per-/// analytic surface, by dropping the edges between them. Faces whose union would lose all its-/// edges, or whose leftover edges do not close into loops, stay apart. Returns the surfaces of-/// merged faces.-fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>, keep: &[Vec<Vec3>]) -> std::collections::HashSet<u64> {- // An edge on a line the user split along: every sample within a hair of the polyline.- let on_split = |ex: &p21::Exchange, e: u64| -> bool {- let Some(pts) = edge_samples(ex, e) else { return false };- let pts: Vec<Vec3> = pts.iter().map(|q| Vec3::new(q[0], q[1], q[2])).collect();- crate::heal::on_split_line(&pts, keep)- };- let mut merged_surfaces = std::collections::HashSet::new();- let mut next = ex.entities.keys().max().copied().unwrap_or(0) + 1;- let shells: Vec<u64> = ex.entities.iter().filter(|(_, e)| matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL")).map(|(i, _)| *i).collect();- // Each surface's analytic form, worked out once (merged faces keep a piece's surface).- let mut cache: HashMap<u64, Option<Analytic>> = HashMap::new();- for sh in shells {- for _round in 0..64 {- let Some(faces) = ex- .get(sh)- .and_then(|e| e.params().get(1))- .and_then(Param::as_list)- .map(|l| l.iter().filter_map(Param::as_ref_id).collect::<Vec<u64>>())- else {- break;- };- // Analytic description and normal sign of each face on a revolution.- let info: Vec<Option<(AnalyticKind, f64)>> = faces- .iter()- .map(|f| {- let fe = ex.get(*f)?;- if !matches!(fe.name(), "FACE_SURFACE" | "ADVANCED_FACE") {- return None;- }- let sid = fe.params().get(2)?.as_ref_id()?;- let an = (*cache.entry(sid).or_insert_with(|| {- let se = ex.get(sid)?;- match se.name() {- "SURFACE_OF_REVOLUTION" => analytic_revolution(ex, se),- // Coplanar pieces (a face split where a mirrored half was glued on).- "PLANE" => {- let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };- let f = crate::step_in::geom::frame(&cx, se.params().get(1)?.as_ref_id()?).ok()?;- let v = |a: truck_modeling::Vector3| [a.x, a.y, a.z];- Some(Analytic { kind: AnalyticKind::Plane { o: [f.o.x, f.o.y, f.o.z], z: v(f.z), x: v(f.x) }, flip: false })- }- // Pieces of a B-spline cylinder or cone merge only when their edges- // are circles square to the axis and rulings (an extruded hole).- _ => analytic_bspline(ex, se).filter(|a| match a.kind {- AnalyticKind::Cylinder { .. } | AnalyticKind::Cone { .. } => square_or_ruled(ex, fe, &a.kind),- _ => true,- }),- }- }))?;- let sense = fe.params().get(3)?.as_bool()?;- let z = match an.kind {- AnalyticKind::Plane { z, .. } => z,- _ => [0.0; 3],- };- let sign = face_normal_sign(&an.kind, z, an.flip, sense);- // Planes: normalise to one written direction for comparisons.- Some((an.kind, sign))- })- .collect();- let mut merged = false;- 'pairs: for i in 0..faces.len() {- for j in (i + 1)..faces.len() {- let (Some(Some((ka, sa))), Some(Some((kb, sb)))) = (info.get(i), info.get(j)) else { continue };- if !same_analytic(ka, kb) {- continue;- }- let plane_dir = |k: &AnalyticKind| match k {- AnalyticKind::Plane { z, .. } => *z,- _ => [0.0, 0.0, 1.0],- };- let (na, nb) = (mul(plane_dir(ka), *sa), mul(plane_dir(kb), *sb));- if dot(na, nb) <= 0.0 {- continue;- }- let (Some(&fa), Some(&fb)) = (faces.get(i), faces.get(j)) else { continue };- // Faces of different colours stay apart.- if paint.get(&fa) != paint.get(&fb) {- continue;- }- let (Some(ea), Some(eb)) = (ex.get(fa).and_then(|f| face_edges(ex, f)), ex.get(fb).and_then(|f| face_edges(ex, f))) else {- continue;- };- let all: Vec<(u64, bool)> = ea.into_iter().chain(eb).flatten().collect();- let shared: std::collections::HashSet<u64> =- all.iter().filter(|(e, d)| all.iter().any(|(e2, d2)| e2 == e && d2 != d)).map(|(e, _)| *e).collect();- if shared.is_empty() || shared.iter().any(|e| on_split(ex, *e)) {- continue;- }- // Chain oriented edges into loops by vertices (None: they do not close).- let ends = |(e, d): (u64, bool)| -> Option<(u64, u64)> {- let p = ex.get(e)?.params();- let (s0, s1) = (p.get(1)?.as_ref_id()?, p.get(2)?.as_ref_id()?);- Some(if d { (s0, s1) } else { (s1, s0) })- };- let chain = |mut pool: Vec<(u64, bool)>| -> Option<Vec<Vec<(u64, bool)>>> {- let mut loops = Vec::new();- while let Some(first) = pool.pop() {- let (start, mut at) = ends(first)?;- let mut lp = vec![first];- while at != start {- if lp.len() > 100_000 {- return None;- }- let k = pool.iter().position(|x| ends(*x).is_some_and(|(s, _)| s == at))?;- let x = pool.remove(k);- at = ends(x)?.1;- lp.push(x);- }- loops.push(lp);- }- Some(loops)- };- // A full turn keeps one shared edge as the face's seam, used both ways (as other- // systems write cylinders and cone tips); otherwise the shared edges go.- // (A horn torus band needs no seam: its rings meet at the pole.)- let mut loops = None;- if shared.len() >= 2 && !matches!(ka, AnalyticKind::HornTorus { .. } | AnalyticKind::Plane { .. }) {- // Without the shared edges: one ring (a cone tip) or two (a band). The seam- // runs from a vertex on the first ring to the second ring (or the apex) and- // back: ring A, seam, ring B, seam reversed.- let rest: Vec<(u64, bool)> = all.iter().copied().filter(|(e, _)| !shared.contains(e)).collect();- if let Some(rings) = chain(rest).filter(|r| matches!(r.len(), 1 | 2)) {- let starts_at = |ring: &Vec<(u64, bool)>, v: u64| ring.iter().position(|x| ends(*x).is_some_and(|(a, _)| a == v));- let on_axis = |v: u64| {- let (o, z) = match ka {- AnalyticKind::Cone { o, z, .. } | AnalyticKind::Sphere { o, z, .. } => (*o, *z),- _ => return false,- };- vertex_point(ex, v).is_some_and(|q| norm(cross(sub(q, o), z)) <= 1e-6 * (1.0 + norm(q)))- };- let rotated =- |ring: &Vec<(u64, bool)>, k: usize| ring.iter().skip(k).chain(ring.iter().take(k)).copied().collect::<Vec<_>>();- // Whether a ring leaves its first vertex turning anticlockwise about a- // cylinder's or cone's axis (the way its angle parameter grows).- let turns_with_angle = |ring: &[(u64, bool)]| -> Option<bool> {- let (o, z) = match ka {- AnalyticKind::Cylinder { o, z, .. } | AnalyticKind::Cone { o, z, .. } => (*o, *z),- _ => return None,- };- let &(edge, dir) = ring.first()?;- let start = vertex_point(ex, ends((edge, dir))?.0)?;- let mut pts = edge_points(ex, edge, 4)?;- if ex.get(edge)?.params().get(4)?.as_bool()? != dir {- pts.reverse();- }- let radial = |q: V3| {- let v = sub(q, o);- sub(v, mul(z, dot(v, z)))- };- let turn = dot(cross(radial(start), radial(*pts.get(1)?)), z);- (turn != 0.0).then_some(turn > 0.0)- };- let mut cands: Vec<u64> = shared.iter().copied().collect();- cands.sort();- 'seam: for keep in cands {- for &(e, d) in all.iter().filter(|(e, _)| *e == keep) {- let Some((a, b)) = ends((e, d)) else { continue };- let (Some(ra), Some(ka0)) = (rings.first(), rings.first().and_then(|r| starts_at(r, a))) else { continue };- let mut lp = rotated(ra, ka0);- let mut back = (e, !d);- match rings.get(1) {- Some(rb) => {- let Some(kb) = starts_at(rb, b) else { continue };- let ring_b = rotated(rb, kb);- // Readers put a seam's first use on the side where the- // angle starts, so the ring after it must turn the way- // the angle grows; else that ring and the seam's other- // use go first (#3394).- if turns_with_angle(&ring_b) == Some(false) {- let ring_a = std::mem::replace(&mut lp, ring_b);- lp.push((e, !d));- lp.extend(ring_a);- back = (e, d);- } else {- lp.push((e, d));- lp.extend(ring_b);- }- }- // A cone tip (or a sphere's pole cap): the seam's far end is- // the apex on the axis, off the ring.- None if starts_at(ra, b).is_none() && on_axis(b) => lp.push((e, d)),- None => continue,- }- lp.push(back);- loops = Some(vec![lp]);- break 'seam;- }- }- }- }- let planar = matches!(ka, AnalyticKind::Plane { .. });- if loops.is_none() && planar {- // A plane needs no seam: an annulus keeps its two rings, a face with a hole- // its hole. The largest loop goes first (the outer bound).- let rest: Vec<(u64, bool)> = all.iter().copied().filter(|(e, _)| !shared.contains(e)).collect();- loops = chain(rest).map(|mut l| {- let size = |lp: &Vec<(u64, bool)>| {- let pts: Vec<V3> = lp.iter().filter_map(|x| ends(*x).and_then(|(a, _)| vertex_point(ex, a))).collect();- let mut lo = [f64::INFINITY; 3];- let mut hi = [f64::NEG_INFINITY; 3];- for p in &pts {- for k in 0..3 {- lo[k] = lo[k].min(p[k]);- hi[k] = hi[k].max(p[k]);- }- }- norm(sub(hi, lo))- };- l.sort_by(|a, b| size(b).total_cmp(&size(a)));- l- });- }- if loops.is_none() && !planar {- let rest: Vec<(u64, bool)> = all.iter().copied().filter(|(e, _)| !shared.contains(e)).collect();- loops = chain(rest)- .map(|mut l| {- // Rings meeting at a vertex (both ends of a horn torus band meet at- // its pole) form one figure-eight loop through it.- while l.len() > 1 {- let Some(second) = l.pop() else { break };- let at = l.iter().enumerate().find_map(|(li, lp)| {- lp.iter().enumerate().find_map(|(k, x)| {- let v = ends(*x)?.1;- let s = second.iter().position(|y| ends(*y).is_some_and(|(a, _)| a == v))?;- Some((li, k, s))- })- });- let Some((li, k, s)) = at else {- l.push(second);- break;- };- let mut second = second;- second.rotate_left(s);- if let Some(lp) = l.get_mut(li) {- for (n, x) in second.into_iter().enumerate() {- lp.insert(k + 1 + n, x);- }- }- }- l- })- .filter(|l| l.len() == 1);- }- let Some(loops) = loops else { continue };- // A loop of seams only (a whole sphere) bounds nothing: keep the faces apart.- if loops.iter().all(|l| l.iter().all(|(e, _)| l.iter().filter(|(e2, _)| e2 == e).count() > 1)) {- continue;- }- // Write the merged face.- let mut bounds = Vec::new();- for lp in loops {- let mut oes = Vec::new();- for (e, d) in lp {- let id = next;- next += 1;- ex.entities.insert(- id,- p21::Entity {- records: vec![p21::Record {- name: "ORIENTED_EDGE".into(),- params: vec![- Param::Str(String::new()),- Param::Derived,- Param::Derived,- Param::Ref(e),- Param::Enum(if d { "T" } else { "F" }.into()),- ],- }],- },- );- oes.push(Param::Ref(id));- }- let lid = next;- next += 1;- ex.entities.insert(- lid,- p21::Entity {- records: vec![p21::Record { name: "EDGE_LOOP".into(), params: vec![Param::Str(String::new()), Param::List(oes)] }],- },- );- let bid = next;- next += 1;- ex.entities.insert(- bid,- p21::Entity {- records: vec![p21::Record {- name: "FACE_BOUND".into(),- params: vec![Param::Str(String::new()), Param::Ref(lid), Param::Enum("T".into())],- }],- },- );- bounds.push(Param::Ref(bid));- }- let Some(old) = ex.get(fa).cloned() else { continue };- let mut params = old.params().to_vec();- if let Some(slot) = params.get_mut(1) {- *slot = Param::List(bounds);- }- let nid = next;- next += 1;- if let Some(sid) = params.get(2).and_then(Param::as_ref_id) {- merged_surfaces.insert(sid);- }- ex.entities.insert(nid, p21::Entity { records: vec![p21::Record { name: old.name().to_string(), params }] });- if let Some(look) = paint.remove(&fa) {- paint.remove(&fb);- paint.insert(nid, look);- }- let new_list: Vec<Param> = faces.iter().filter(|f| **f != fb).map(|f| Param::Ref(if *f == fa { nid } else { *f })).collect();- if let Some(she) = ex.entities.get_mut(&sh)- && let Some(r) = she.records.first_mut()- && let Some(slot) = r.params.get_mut(1)- {- *slot = Param::List(new_list);- }- merged = true;- break 'pairs;- }- }- if !merged {- break;- }- }- }- merged_surfaces-}--/// B-spline cylinder and cone sheets written as CYLINDRICAL_SURFACE and CONICAL_SURFACE (the-/// sheet covers only its own piece, and a fillet's may reach far past it), with the direction of-/// the parameter seam: on the face's seam edge for a full turn, else in the middle of the gap the-/// face leaves (`gap_middle`), else opposite the face's middle.-/// Sheets under faces merged from pieces always; a lone piece when its edges are circles square-/// to the axis and rulings. (Faces replaced by merges stay in the exchange unreferenced: only the-/// shells' faces count.)-fn analytic_sheets(ex: &p21::Exchange, merged_surfaces: &std::collections::HashSet<u64>) -> HashMap<u64, V3> {- let live: Vec<u64> = ex- .entities- .values()- .filter_map(|e| if matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL") { e.params().get(1).and_then(Param::as_list) } else { None })- .flatten()- .filter_map(Param::as_ref_id)- .collect();- let mut out = HashMap::new();- for e in live.iter().filter_map(|f| ex.get(*f)) {- let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) else { continue };- if out.contains_key(&sid) {- continue;- }- let Some(Analytic { kind, .. }) = ex.get(sid).and_then(|se| ruled_bspline(ex, se)) else {- continue;- };- let (AnalyticKind::Cylinder { o, z, .. } | AnalyticKind::Cone { o, z, .. }) = kind else { continue };- if !merged_surfaces.contains(&sid) && !square_or_ruled(ex, e, &kind) {- continue;- }- let Some(loops) = face_edges(ex, e) else { continue };- let radial = |q: V3| {- let v = sub(q, o);- sub(v, mul(z, dot(v, z)))- };- let seam = loops- .iter()- .flat_map(|l| l.iter().map(move |(x, _)| (l, *x)))- .find(|(l, x)| l.iter().filter(|(y, _)| y == x).count() > 1)- .map(|(_, x)| x);- // (A cone tip's seam has one end at the apex, on the axis.)- let seam_dir = seam.and_then(|edge| {- let p = ex.get(edge)?.params();- [p.get(1), p.get(2)].into_iter().filter_map(|v| vertex_point(ex, v?.as_ref_id()?)).find_map(|q| unit(radial(q)))- });- let x = match seam_dir.or_else(|| gap_middle(ex, &loops, z, &radial)) {- Some(x) => Some(x),- None => {- // No single gap to find (a half turn has two corners, a tube cut in pieces- // several). Points along the edges, not just their ends: the corners of a half- // turn (a slot's round end) point both ways and cancel out (#1198). The sheet's- // own middle where even those do.- let mean = loops- .iter()- .flatten()- .filter_map(|(edge, _)| edge_samples(ex, *edge))- .flatten()- .filter_map(|q| unit(radial(q)))- .fold([0.0; 3], add);- let (AnalyticKind::Cylinder { x: middle, .. } | AnalyticKind::Cone { x: middle, .. }) = kind else { continue };- Some(unit(mul(mean, -1.0)).unwrap_or(middle))- }- };- if let Some(x) = x {- out.insert(sid, x);- }- }- out-}--/// The middle of the one angular gap that a face on a cylinder or cone leaves around its axis-/// `z`. The face's boundary vertices are sorted by angle; each two neighbours are joined by one-/// of its edges except across the gap (a 270° face split at 0°, 90°, 180° and 270° leaves-/// 270°–360°). None unless there are three angles or more and exactly one gap: two vertices can-/// be joined either way round.-fn gap_middle(ex: &p21::Exchange, loops: &[Vec<(u64, bool)>], z: V3, radial: &impl Fn(V3) -> V3) -> Option<V3> {- use std::f64::consts::TAU;- let mut edges: Vec<(V3, V3)> = Vec::new();- for (e, _) in loops.iter().flatten() {- let p = ex.get(*e)?.params();- let (a, b) = (vertex_point(ex, p.get(1)?.as_ref_id()?)?, vertex_point(ex, p.get(2)?.as_ref_id()?)?);- edges.push((unit(radial(a))?, unit(radial(b))?));- }- let e1 = edges.first()?.0;- let e2 = unit(cross(z, e1))?;- let angle = |d: V3| dot(d, e2).atan2(dot(d, e1)).rem_euclid(TAU);- let close = |a: f64, b: f64| {- let d = (a - b).rem_euclid(TAU);- d < 1e-6 || TAU - d < 1e-6- };- let mut angles: Vec<f64> = Vec::new();- for (a, b) in &edges {- for t in [angle(*a), angle(*b)] {- if !angles.iter().any(|s| close(*s, t)) {- angles.push(t);- }- }- }- if angles.len() < 3 {- return None;- }- angles.sort_by(f64::total_cmp);- let joined = |s: f64, t: f64| {- edges.iter().any(|(a, b)| {- let (x, y) = (angle(*a), angle(*b));- (close(x, s) && close(y, t)) || (close(x, t) && close(y, s))- })- };- let n = angles.len();- let gaps: Vec<(f64, f64)> = (0..n).filter_map(|i| Some((*angles.get(i)?, *angles.get((i + 1) % n)?))).filter(|(s, t)| !joined(*s, *t)).collect();- let [(s, t)] = gaps[..] else { return None };- let m = s + (t - s).rem_euclid(TAU) / 2.0;- unit(add(mul(e1, m.cos()), mul(e2, m.sin())))-}--/// Margin left round a face when its sheet is cut down to it, as a share of the face's own-/// parameter range on each side.-const SHEET_MARGIN: f64 = 0.02;--/// B-spline sheets that reach well past the one face on them, cut down to that face's parameter-/// range (and a margin), so readers bound the part by its faces (#1198): a round's sheet runs on-/// past both ends of the edge it rounds, and when a later cut crosses the round, the crossing edge-/// keeps it from being written as a cylinder (see `square_or_ruled`). Sheets written as analytic-/// surfaces, flat ones, sheets under several faces, and those whose face's edges do not all lie-/// on the piece cut out (a face across a closed sheet's seam) are left alone.-fn trimmed_sheets(ex: &p21::Exchange, analytic: &HashMap<u64, V3>) -> HashMap<u64, truck_modeling::Surface> {- let live: Vec<u64> = ex- .entities- .values()- .filter_map(|e| if matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL") { e.params().get(1).and_then(Param::as_list) } else { None })- .flatten()- .filter_map(Param::as_ref_id)- .collect();- let mut users: HashMap<u64, usize> = HashMap::new();- for e in live.iter().filter_map(|f| ex.get(*f)) {- if let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) {- *users.entry(sid).or_default() += 1;- }- }- let mut out = HashMap::new();- for e in live.iter().filter_map(|f| ex.get(*f)) {- let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) else { continue };- if users.get(&sid) != Some(&1) || analytic.contains_key(&sid) {- continue;- }- let Some(se) = ex.get(sid) else { continue };- if !(se.has("B_SPLINE_SURFACE") || se.name() == "B_SPLINE_SURFACE_WITH_KNOTS") || planar_bspline(ex, se).is_some() {- continue;- }- let Some(pts) = face_edges(ex, e).and_then(|ls| ls.iter().flatten().map(|(x, _)| edge_points(ex, *x, 16)).collect::<Option<Vec<_>>>()) else {- continue;- };- let pts: Vec<V3> = pts.into_iter().flatten().collect();- let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };- let Ok(sheet) = crate::step_in::geom::bspline_surface(&cx, se) else { continue };- if let Ok(Some(cut)) = crate::guard("STEP sheet trim", || Ok(trim_sheet(&sheet, &pts))) {- out.insert(sid, cut);- }- }- out-}--/// `sheet` cut down to the parameter range `pts` (points on it) cover, with [`SHEET_MARGIN`];-/// `None` when that would not make it much smaller, or when a point is not on the piece cut out.-fn trim_sheet(sheet: &truck_modeling::Surface, pts: &[V3]) -> Option<truck_modeling::Surface> {- use truck_modeling::{ParametricSurface, SearchNearestParameter, Surface};- let (Some((u0, u1)), Some((v0, v1))) = sheet.try_range_tuple() else { return None };- // Edges made by intersecting surfaces are fitted to them, a micron or so off the sheet; a- // point on the wrong piece of it is far further.- let (lo, hi) = pts.iter().fold(([f64::INFINITY; 3], [f64::NEG_INFINITY; 3]), |(lo, hi), p| {- ([lo[0].min(p[0]), lo[1].min(p[1]), lo[2].min(p[2])], [hi[0].max(p[0]), hi[1].max(p[1]), hi[2].max(p[2])])- });- let tol = 1e-3 + 1e-4 * norm(sub(hi, lo));- let near = |s: &Surface, p: V3| -> Option<(f64, f64)> {- let q = truck_modeling::Point3::new(p[0], p[1], p[2]);- let (u, v) = s.search_nearest_parameter(q, None, 100)?;- let r = s.subs(u, v);- (norm(sub([r.x, r.y, r.z], p)) <= tol).then_some((u, v))- };- let (mut ua, mut ub, mut va, mut vb) = (f64::INFINITY, f64::NEG_INFINITY, f64::INFINITY, f64::NEG_INFINITY);- for p in pts {- let (u, v) = near(sheet, *p)?;- (ua, ub, va, vb) = (ua.min(u), ub.max(u), va.min(v), vb.max(v));- }- let (du, dv) = ((ub - ua) * SHEET_MARGIN, (vb - va) * SHEET_MARGIN);- let (ua, ub, va, vb) = ((ua - du).max(u0), (ub + du).min(u1), (va - dv).max(v0), (vb + dv).min(v1));- // Worth it only where a parameter keeps less than four fifths of its range.- let keeps = |a: f64, b: f64, lo: f64, hi: f64| (b - a) / (hi - lo);- if !(ua < ub && va < vb) || (keeps(ua, ub, u0, u1) > 0.8 && keeps(va, vb, v0, v1) > 0.8) {- return None;- }- // The piece between the new ends: `ucut` keeps what lies before the cut and returns the rest.- macro_rules! cut {- ($s:expr) => {{- let mut s = $s.clone();- if ua > u0 {- s = s.ucut(ua);- }- if ub < u1 {- s.ucut(ub);- }- if va > v0 {- s = s.vcut(va);- }- if vb < v1 {- s.vcut(vb);- }- s- }};- }- let piece = match sheet {- Surface::BSplineSurface(b) => Surface::BSplineSurface(cut!(b)),- Surface::NurbsSurface(n) => Surface::NurbsSurface(cut!(n)),- _ => return None,- };- pts.iter().all(|p| near(&piece, *p).is_some()).then_some(piece)-}--/// The B-rep entities of one body as truck writes them, parsed, the B-spline sheets to write-/// as cylinders and cones (see `analytic_sheets`) and those to write cut down to their faces-/// (see `trimmed_sheets`). Without `merge` the file is truck's, as is.-fn brep_exchange(b: &Body, merge: bool) -> Result<(p21::Exchange, HashMap<u64, V3>, HashMap<u64, truck_modeling::Surface>, HashMap<u64, FaceLook>)> {- let text = crate::step::truck_step(&[b], "SolidCraft")?;- let mut ex = p21::parse(&text).map_err(|e| KernelError::Failed(format!("STEP export: {e}")))?;- collapse_short_edges(&mut ex);- // Face colours by exchange face: truck writes each shell's faces in the body's face order.- let mut paint = HashMap::new();- if let Some(p) = b.paint()- && !p.faces.is_empty()- {- let mut shells: Vec<u64> = ex.entities.iter().filter(|(_, e)| matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL")).map(|(i, _)| *i).collect();- shells.sort();- let faces: Vec<u64> = shells.iter().filter_map(|s| ex.get(*s)?.params().get(1)?.as_list()).flatten().filter_map(Param::as_ref_id).collect();- for f in &p.faces {- if let Some(id) = faces.get(f.face) {- paint.insert(*id, (f.color, f.opacity));- }- }- }- let before = shell_face_count(&ex);- let keep = b.split_lines().map(|l| l.as_slice()).unwrap_or(&[]);- let (sheets, trimmed) = if merge {- let merged = merge_split_faces(&mut ex, &mut paint, keep);- let sheets = analytic_sheets(&ex, &merged);- let trimmed = trimmed_sheets(&ex, &sheets);- // Lone sheets rewritten as analytic surfaces, or cut down, count as changes to check too.- MERGES.with(|m| m.set(m.get() + sheets.keys().filter(|s| !merged.contains(s)).count() + trimmed.len()));- (sheets, trimmed)- } else {- Default::default()- };- MERGES.with(|m| m.set(m.get() + before.saturating_sub(shell_face_count(&ex))));- Ok((ex, sheets, trimmed, paint))-}--/// The separate pieces of a body for export, each keeping its face colours: a body of several-/// lumps (a plate and the islands a cut left inside its holes, such as letter counters) is-/// several solids, never one solid whose other pieces are written as voids. A body in one-/// piece, or one whose pieces cannot be told apart, is itself.-fn export_lumps(b: &Body) -> Vec<Body> {- if b.mesh.is_some() || b.solid.boundaries().len() < 2 {- return vec![b.clone()];- }- let lumps = match b.lumps() {- Ok(l) if l.len() > 1 => l,- _ => return vec![b.clone()],- };- let index: HashMap<_, usize> = b.solid.face_iter().enumerate().map(|(i, f)| (f.id(), i)).collect();- lumps- .into_iter()- .map(|lump| {- let paint = b.paint().map(|p| crate::body::Paint {- opacity: p.opacity,- faces: lump- .solid- .face_iter()- .enumerate()- .filter_map(|(k, f)| {- let i = index.get(&f.id())?;- p.faces.iter().find(|fp| fp.face == *i).map(|fp| crate::body::FacePaint { face: k, ..fp.clone() })- })- .collect(),- });- lump.with_color(b.color()).with_split_lines(b.split_lines().cloned()).with_paint(paint)- })- .collect()-}--/// Faces in the exchange's shells (fewer after merging).-fn shell_face_count(ex: &p21::Exchange) -> usize {- ex.entities- .values()- .filter(|e| matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL"))- .filter_map(|e| e.params().get(1).and_then(Param::as_list))- .map(<[Param]>::len)- .sum()-}--/// A face's own colour (0..1) and opacity.-type FaceLook = ([f32; 3], f32);-+/// The placement's origin, z and x axes; refused unless it is a rotation and a translation.fn rigid_frame(m: &[[f64; 4]; 4]) -> Result<([f64; 3], [f64; 3], [f64; 3])> {let x = [m[0][0], m[0][1], m[0][2]];let y = [m[1][0], m[1][1], m[1][2]];@@ -1601,27 +73,6 @@ fn rigid_frame(m: &[[f64; 4]; 4]) -> Result<([f64; 3], [f64; 3], [f64; 3])> {/// STEP text (AP242) for products with bodies and assembly placements; `root` is the top product.pub fn step_export_products(products: &[ExportProduct], root: usize, header: &StepHeader) -> Result<String> {- MERGES.with(|m| m.set(0));- let text = products_text(products, root, header, true)?;- // Faces merged per surface, and sheets rewritten as cylinders and cones, must read back as- // cleanly as truck's pieces (a merge can leave a loop the reader cannot lay out); otherwise- // the pieces are written as truck made them. Without a change there is nothing to check.- let clean = |t: &str| crate::step_in::step_import(t).is_ok_and(|i| i.warnings.is_empty());- if MERGES.with(|m| m.get()) > 0 && !clean(&text) {- let plain = products_text(products, root, header, false)?;- if clean(&plain) {- return Ok(plain);- }- }- Ok(text)-}--thread_local! {- /// Faces merged and sheets rewritten while writing the current export.- static MERGES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };-}--fn products_text(products: &[ExportProduct], root: usize, header: &StepHeader, merge: bool) -> Result<String> {if products.is_empty() || root >= products.len() {return Err(KernelError::Invalid("nothing to export".into()));}@@ -1649,121 +100,131 @@ fn products_text(products: &[ExportProduct], root: usize, header: &StepHeader, mif cyclic(products, root, &mut Vec::new()) {return Err(KernelError::Invalid("the component tree is recursive".into()));}-- let mut o = Out::default();- let app = o.add("APPLICATION_CONTEXT('managed model based 3d engineering')");- o.add(format!("APPLICATION_PROTOCOL_DEFINITION('international standard','ap242_managed_model_based_3d_engineering',2014,#{app})"));- let pctx = o.add(format!("PRODUCT_CONTEXT('',#{app},'mechanical')"));- let pdctx = o.add(format!("PRODUCT_DEFINITION_CONTEXT('part definition',#{app},'design')"));- let mm = o.add("(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))");- let rad = o.add("(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.))");- let sr = o.add("(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT())");- let unc = o.add(format!("UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-06),#{mm},'distance_accuracy_value','confusion accuracy')"));- let ctx = o.add(format!(- "(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#{unc}))GLOBAL_UNIT_ASSIGNED_CONTEXT((#{mm},#{rad},#{sr}))REPRESENTATION_CONTEXT('Context #1','3D Context with UNIT and UNCERTAINTY'))"- ));- let origin = o.placement([0.0; 3], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);-- // Products (only those reachable from the root).+ // Products reachable from the root.let mut reach = vec![false; products.len()];let mut todo = vec![root];while let Some(p) = todo.pop() {- if let Some(r) = reach.get_mut(p)- && !*r+ if let Some(seen) = reach.get_mut(p)+ && !*seen{- *r = true;+ *seen = true;if let Some(x) = products.get(p) {todo.extend(x.children.iter().map(|(c, _, _)| *c));}}}- let mut pd = vec![0u64; products.len()];- let mut shape_rep = vec![0u64; products.len()];- let mut product_ids = Vec::new();- let mut styled = Vec::new();- let mut child_items: Vec<Vec<u64>> = vec![Vec::new(); products.len()];+ let reached: Vec<(usize, &ExportProduct)> = products.iter().enumerate().filter(|(i, _)| reach.get(*i).copied().unwrap_or(false)).collect();+ // The context states the models' accuracy: the loosest of their records' tolerances.+ let uncertainty =+ reached.iter().flat_map(|(_, p)| &p.bodies).map(|b| b.body.record().tolerance).filter(|t| t.is_finite()).fold(MIN_UNCERTAINTY, f64::max);++ let mut w = Writer::new();+ let app = w.add_distinct("APPLICATION_CONTEXT", &[s("managed model based 3d engineering")]);+ w.add_distinct(+ "APPLICATION_PROTOCOL_DEFINITION",+ &[s("international standard"), s("ap242_managed_model_based_3d_engineering"), Param::Int(2014), r(app)],+ );+ let pctx = w.add_distinct("PRODUCT_CONTEXT", &[s(""), r(app), s("mechanical")]);+ let pdctx = w.add_distinct("PRODUCT_DEFINITION_CONTEXT", &[s("part definition"), r(app), s("design")]);+ let mm = w.add_complex(&[+ ("LENGTH_UNIT", vec![]),+ ("NAMED_UNIT", vec![Param::Derived]),+ ("SI_UNIT", vec![Param::Enum("MILLI".into()), Param::Enum("METRE".into())]),+ ]);+ let rad = w.add_complex(&[+ ("NAMED_UNIT", vec![Param::Derived]),+ ("PLANE_ANGLE_UNIT", vec![]),+ ("SI_UNIT", vec![Param::Null, Param::Enum("RADIAN".into())]),+ ]);+ let sr = w.add_complex(&[+ ("NAMED_UNIT", vec![Param::Derived]),+ ("SI_UNIT", vec![Param::Null, Param::Enum("STERADIAN".into())]),+ ("SOLID_ANGLE_UNIT", vec![]),+ ]);+ let unc = w.add_distinct(+ "UNCERTAINTY_MEASURE_WITH_UNIT",+ &[Param::Typed("LENGTH_MEASURE".into(), vec![Param::Real(uncertainty)]), r(mm), s("distance_accuracy_value"), s("confusion accuracy")],+ );+ let ctx = w.add_complex(&[+ ("GEOMETRIC_REPRESENTATION_CONTEXT", vec![Param::Int(3)]),+ ("GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT", vec![refs(&[unc])]),+ ("GLOBAL_UNIT_ASSIGNED_CONTEXT", vec![refs(&[mm, rad, sr])]),+ ("REPRESENTATION_CONTEXT", vec![s("Context #1"), s("3D Context with UNIT and UNCERTAINTY")]),+ ]);+ let origin = GeomWriter::new(&mut w).placement(&solidcraft_step::geom::Placement {+ origin: [0.0; 3],+ axis: [0.0, 0.0, 1.0],+ ref_direction: [1.0, 0.0, 0.0],+ });+// Placements of children inside each parent, made before the parent's representation.let mut placements: Vec<Vec<u64>> = vec![Vec::new(); products.len()];- for (pi, p) in products.iter().enumerate() {- if !reach.get(pi).copied().unwrap_or(false) {- continue;- }+ for &(pi, p) in &reached {for (_, m, _) in &p.children {let (t, z, x) = rigid_frame(m)?;- let (pt, dz, dx) = (o.point(t), o.direction(z), o.direction(x));+ let mut g = GeomWriter::new(&mut w);+ let (pt, dz, dx) = (g.point(t), g.direction(z), g.direction(x));// Its own entity: it is an item of the parent's representation.- let a = o.add(format!("AXIS2_PLACEMENT_3D('',#{pt},#{dz},#{dx})"));+ let a = w.add_distinct("AXIS2_PLACEMENT_3D", &[s(""), r(pt), r(dz), r(dx)]);if let Some(v) = placements.get_mut(pi) {v.push(a);}- if let Some(v) = child_items.get_mut(pi) {- v.push(a);- }}}- for (pi, p) in products.iter().enumerate() {- if !reach.get(pi).copied().unwrap_or(false) {- continue;- }+ let mut pd = vec![0u64; products.len()];+ let mut shape_rep = vec![0u64; products.len()];+ let mut product_ids = Vec::new();+ let mut styled = Vec::new();+ for &(pi, p) in &reached {let name = if p.name.trim().is_empty() { "Part".to_string() } else { p.name.clone() };- let prod = o.add(format!("PRODUCT({},{},'',(#{pctx}))", string(&name), string(&name)));+ let prod = w.add_distinct("PRODUCT", &[s(&name), s(&name), s(""), refs(&[pctx])]);product_ids.push(prod);- let pdf = o.add(format!("PRODUCT_DEFINITION_FORMATION('','',#{prod})"));- let d = o.add(format!("PRODUCT_DEFINITION('design','',#{pdf},#{pdctx})"));- let pds = o.add(format!("PRODUCT_DEFINITION_SHAPE('','',#{d})"));+ let pdf = w.add_distinct("PRODUCT_DEFINITION_FORMATION", &[s(""), s(""), r(prod)]);+ let d = w.add_distinct("PRODUCT_DEFINITION", &[s("design"), s(""), r(pdf), r(pdctx)]);+ let pds = w.add_distinct("PRODUCT_DEFINITION_SHAPE", &[s(""), s(""), r(d)]);let mut items = vec![origin];- items.extend(child_items.get(pi).cloned().unwrap_or_default());- let item_list = items.iter().map(|i| format!("#{i}")).collect::<Vec<_>>().join(",");- let srep = o.add(format!("SHAPE_REPRESENTATION({},({item_list}),#{ctx})", string(&name)));- o.add(format!("SHAPE_DEFINITION_REPRESENTATION(#{pds},#{srep})"));+ items.extend(placements.get(pi).into_iter().flatten().copied());+ let srep = w.add_distinct("SHAPE_REPRESENTATION", &[s(&name), refs(&items), r(ctx)]);+ w.add_distinct("SHAPE_DEFINITION_REPRESENTATION", &[r(pds), r(srep)]);if let Some(slot) = pd.get_mut(pi) {*slot = d;}if let Some(slot) = shape_rep.get_mut(pi) {*slot = srep;}- if !p.bodies.is_empty() {- let mut solids = Vec::new();- for b in &p.bodies {- for lump in export_lumps(b.body) {- let (ex, merged, trimmed, face_paint) = brep_exchange(&lump, merge)?;- o.merged = merged;- o.trimmed = trimmed;- o.faces_out.clear();- let mut roots: Vec<u64> =- ex.entities.iter().filter(|(_, e)| matches!(e.name(), "MANIFOLD_SOLID_BREP" | "BREP_WITH_VOIDS")).map(|(i, _)| *i).collect();- roots.sort();- for r in roots {- let id = o.copy_solid(&ex, r, &b.name).map_err(|e| KernelError::Failed(format!("STEP export: {e}")))?;- solids.push(id);- let opacity = lump.paint().map(|p| p.opacity).unwrap_or(1.0);- if let Some(c) = b.color {- styled.push(style(&mut o, id, c, opacity));- }- }- // Faces with colours of their own.- let mut painted: Vec<(u64, ([f32; 3], f32))> =- face_paint.into_iter().filter_map(|(f, look)| Some((*o.faces_out.get(&f)?, look))).collect();- painted.sort_by_key(|(f, _)| *f);- for (f, (c, op)) in painted {- styled.push(style(&mut o, f, c, op));- }+ let (mut solids, mut sheets) = (Vec::new(), Vec::new());+ for b in &p.bodies {+ let written = topology::brep(&mut GeomWriter::new(&mut w), b.body.record(), &b.name)+ .map_err(|e| KernelError::Failed(format!("STEP export of '{}': {e}", b.name)))?;+ let opacity = b.body.paint().map_or(1.0, |p| p.opacity);+ let items: Vec<u64> = written.solids.iter().copied().chain(written.sheets).collect();+ if let Some(c) = b.color {+ for item in &items {+ styled.push(style(&mut w, *item, c, opacity));+ }+ }+ // Faces with colours of their own.+ for f in b.body.paint().map(|p| p.faces.as_slice()).unwrap_or(&[]) {+ if let Some(&face) = written.faces.get(f.face).filter(|id| **id != 0) {+ styled.push(style(&mut w, face, f.color, f.opacity));}}- let list = solids.iter().chain(std::iter::once(&origin)).map(|i| format!("#{i}")).collect::<Vec<_>>().join(",");- let absr = o.add(format!("ADVANCED_BREP_SHAPE_REPRESENTATION({},({list}),#{ctx})", string(&name)));- o.add(format!("SHAPE_REPRESENTATION_RELATIONSHIP('','',#{srep},#{absr})"));+ solids.extend(written.solids);+ sheets.extend(written.sheets);+ }+ for (kind, list) in [("ADVANCED_BREP_SHAPE_REPRESENTATION", solids), ("MANIFOLD_SURFACE_SHAPE_REPRESENTATION", sheets)] {+ if list.is_empty() {+ continue;+ }+ let rep = w.add_distinct(kind, &[s(&name), refs(&[list, vec![origin]].concat()), r(ctx)]);+ w.add_distinct("SHAPE_REPRESENTATION_RELATIONSHIP", &[s(""), s(""), r(srep), r(rep)]);}}if !product_ids.is_empty() {- let list = product_ids.iter().map(|i| format!("#{i}")).collect::<Vec<_>>().join(",");- o.add(format!("PRODUCT_RELATED_PRODUCT_CATEGORY('part','',({list}))"));+ w.add_distinct("PRODUCT_RELATED_PRODUCT_CATEGORY", &[s("part"), s(""), refs(&product_ids)]);}// Assembly occurrences.- for (pi, p) in products.iter().enumerate() {- if !reach.get(pi).copied().unwrap_or(false) {- continue;- }+ for &(pi, p) in &reached {for (k, (ci, _, oname)) in p.children.iter().enumerate() {let (Some(&parent_pd), Some(&child_pd), Some(&parent_sr), Some(&child_sr), Some(&target)) =(pd.get(pi), pd.get(*ci), shape_rep.get(pi), shape_rep.get(*ci), placements.get(pi).and_then(|v| v.get(k)))@@ -1775,57 +236,56 @@ fn products_text(products: &[ExportProduct], root: usize, header: &StepHeader, m} else {oname.clone()};- let nauo = o.add(format!("NEXT_ASSEMBLY_USAGE_OCCURRENCE({},{},'',#{parent_pd},#{child_pd},$)", string(&nm), string(&nm)));- let pds = o.add(format!("PRODUCT_DEFINITION_SHAPE('','',#{nauo})"));- let idt = o.add(format!("ITEM_DEFINED_TRANSFORMATION('','',#{origin},#{target})"));- let rr = o.add(format!(- "(REPRESENTATION_RELATIONSHIP('','',#{child_sr},#{parent_sr})REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#{idt})SHAPE_REPRESENTATION_RELATIONSHIP())"- ));- o.add(format!("CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#{rr},#{pds})"));+ let nauo = w.add_distinct("NEXT_ASSEMBLY_USAGE_OCCURRENCE", &[s(&nm), s(&nm), s(""), r(parent_pd), r(child_pd), Param::Null]);+ let pds = w.add_distinct("PRODUCT_DEFINITION_SHAPE", &[s(""), s(""), r(nauo)]);+ let idt = w.add_distinct("ITEM_DEFINED_TRANSFORMATION", &[s(""), s(""), r(origin), r(target)]);+ let rr = w.add_complex(&[+ ("REPRESENTATION_RELATIONSHIP", vec![s(""), s(""), r(child_sr), r(parent_sr)]),+ ("REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION", vec![r(idt)]),+ ("SHAPE_REPRESENTATION_RELATIONSHIP", vec![]),+ ]);+ w.add_distinct("CONTEXT_DEPENDENT_SHAPE_REPRESENTATION", &[r(rr), r(pds)]);}}if !styled.is_empty() {- let list = styled.iter().map(|i| format!("#{i}")).collect::<Vec<_>>().join(",");- o.add(format!("MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',({list}),#{ctx})"));+ w.add_distinct("MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION", &[s(""), refs(&styled), r(ctx)]);}- let mut s = String::new();- s.push_str("ISO-10303-21;\nHEADER;\n");+ let mut text = String::new();+ text.push_str("ISO-10303-21;\nHEADER;\n");let description = if header.description.is_empty() { "SolidCraft model" } else { header.description.as_str() };- let _ = writeln!(s, "FILE_DESCRIPTION(({}),'2;1');", string(description));+ let _ = writeln!(text, "FILE_DESCRIPTION(({}),'2;1');", string(description));let _ = writeln!(- s,+ text,"FILE_NAME({},{},({}),({}),'SolidCraft','SolidCraft','');",string(&header.file_name),string(&header.time_stamp),string(&header.author),string(&header.organization));- s.push_str("FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF { 1 0 10303 442 1 1 4 }'));\nENDSEC;\nDATA;\n");- for (i, l) in o.lines.iter().enumerate() {- let _ = writeln!(s, "#{}={l};", i + 1);- }- s.push_str("ENDSEC;\nEND-ISO-10303-21;\n");- Ok(s)+ text.push_str("FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF { 1 0 10303 442 1 1 4 }'));\nENDSEC;\nDATA;\n");+ text.push_str(&w.data());+ text.push_str("ENDSEC;\nEND-ISO-10303-21;\n");+ Ok(text)}-/// A surface colour for a solid (STYLED_ITEM chain).-fn style(o: &mut Out, item: u64, c: [f32; 3], opacity: f32) -> u64 {- let rgb = o.add_shared(format!("COLOUR_RGB('',{},{},{})", real(c[0] as f64), real(c[1] as f64), real(c[2] as f64)));- let fasc = o.add_shared(format!("FILL_AREA_STYLE_COLOUR('',#{rgb})"));- let fas = o.add_shared(format!("FILL_AREA_STYLE('',(#{fasc}))"));- let ssfa = o.add_shared(format!("SURFACE_STYLE_FILL_AREA(#{fas})"));+/// A surface colour for an item (STYLED_ITEM chain; the styles are shared).+fn style(w: &mut Writer, item: u64, c: [f32; 3], opacity: f32) -> u64 {+ let rgb = w.add("COLOUR_RGB", &[s(""), Param::Real(c[0] as f64), Param::Real(c[1] as f64), Param::Real(c[2] as f64)]);+ let fasc = w.add("FILL_AREA_STYLE_COLOUR", &[s(""), r(rgb)]);+ let fas = w.add("FILL_AREA_STYLE", &[s(""), refs(&[fasc])]);+ let ssfa = w.add("SURFACE_STYLE_FILL_AREA", &[r(fas)]);// See-through looks add a transparency (1 = invisible) to the side style.let sides = if opacity < 1.0 {- let tr = o.add_shared(format!("SURFACE_STYLE_TRANSPARENT({})", real((1.0 - opacity as f64).clamp(0.0, 1.0))));- format!("#{ssfa},#{tr}")+ let tr = w.add("SURFACE_STYLE_TRANSPARENT", &[Param::Real((1.0 - opacity as f64).clamp(0.0, 1.0))]);+ vec![ssfa, tr]} else {- format!("#{ssfa}")+ vec![ssfa]};- let sss = o.add_shared(format!("SURFACE_SIDE_STYLE('',({sides}))"));- let ssu = o.add_shared(format!("SURFACE_STYLE_USAGE(.BOTH.,#{sss})"));- let psa = o.add_shared(format!("PRESENTATION_STYLE_ASSIGNMENT((#{ssu}))"));- o.add(format!("STYLED_ITEM('color',(#{psa}),#{item})"))+ let sss = w.add("SURFACE_SIDE_STYLE", &[s(""), refs(&sides)]);+ let ssu = w.add("SURFACE_STYLE_USAGE", &[Param::Enum("BOTH".into()), r(sss)]);+ let psa = w.add("PRESENTATION_STYLE_ASSIGNMENT", &[refs(&[ssu])]);+ w.add_distinct("STYLED_ITEM", &[s("color"), refs(&[psa]), r(item)])}/// STEP text for bodies of one part (names `Body1`…).@@ -1846,6 +306,9 @@ pub fn step_export_bodies(bodies: &[ExportBody], header: &StepHeader) -> Result<#[cfg(test)]mod tests {use super::*;+ use solidcraft_geom::Vec3;+ use solidcraft_step::p21;+ use solidcraft_step::write::real;#[test]fn islands_are_solids_of_their_own_not_voids() {@@ -1875,63 +338,6 @@ mod tests {assert_eq!(text.matches("BREP_WITH_VOIDS").count(), 1, "{text}");}- /// #3394: a plate on four tapered legs and a straight peg. Each leg's cone and the peg's- /// cylinder are written as one face whose loop runs ring, seam, ring, seam. Readers put the- /// seam's first use on the side where the surface's angle starts and lay the next ring out- /// from there, so that ring must turn the way the angle grows (anticlockwise about the- /// written axis); three of the legs came out the other way and other readers dropped their- /// sides.- #[test]- fn seam_loops_turn_the_way_the_angle_grows() {- use solidcraft_geom::{Loop2, Plane, Region2, Vec2};- let plate = crate::box_solid(Vec3::new(-60.0, -40.0, 0.0), Vec3::new(60.0, 40.0, 10.0)).unwrap();- let mut b = plate;- for (x, y) in [(-45.0, -30.0), (45.0, -30.0), (45.0, 30.0), (-45.0, 30.0)] {- let disc = Region2 { outer: Loop2::circle(Vec2::new(x, y), 5.0), holes: vec![] };- let leg = crate::extrude_tapered(&Plane::XY, &disc, 20.0, -1.0, 2f64.to_radians()).unwrap();- b = crate::boolean(&b, &leg, crate::BoolOp::Union).unwrap().unwrap();- }- let peg = crate::cylinder(Vec3::new(0.0, 0.0, 10.0), Vec3::Z, 4.0, 8.0).unwrap();- b = crate::boolean(&b, &peg, crate::BoolOp::Union).unwrap().unwrap();- let text = crate::step_export(&[&b], "test").unwrap();- let ex = p21::parse(&text).unwrap();- let mut seamed = 0;- for face in ex.entities.values().filter(|e| e.name() == "ADVANCED_FACE") {- let surface = ex.get(face.params().get(2).unwrap().as_ref_id().unwrap()).unwrap();- if !matches!(surface.name(), "CONICAL_SURFACE" | "CYLINDRICAL_SURFACE") {- continue;- }- let frame = ex.get(surface.params().get(1).unwrap().as_ref_id().unwrap()).unwrap();- let o = triple(&ex, frame.params().get(1).unwrap().as_ref_id().unwrap());- let z = triple(&ex, frame.params().get(2).unwrap().as_ref_id().unwrap());- for lp in face_edges(&ex, face).unwrap() {- let Some(i) = lp.iter().position(|(e, _)| lp.iter().filter(|(f, _)| f == e).count() == 2) else { continue };- let &(edge, dir) = lp.get((i + 1) % lp.len()).unwrap();- let p = ex.get(edge).unwrap().params();- let (v0, v1) = (p.get(1).unwrap().as_ref_id().unwrap(), p.get(2).unwrap().as_ref_id().unwrap());- let mut pts = edge_points(&ex, edge, 4).unwrap();- if p.get(4).unwrap().as_bool().unwrap() != dir {- pts.reverse();- }- let start = vertex_point(&ex, if dir { v0 } else { v1 }).unwrap();- let radial = |q: V3| {- let v = sub(q, o);- sub(v, mul(z, dot(v, z)))- };- let turn = dot(cross(radial(start), radial(pts[1])), z);- assert!(turn > 0.0, "face #{:?}: the ring after the seam turns against the angle", face.params().first());- seamed += 1;- }- }- assert_eq!(seamed, 5, "{text}");- }-- /// A CARTESIAN_POINT's or DIRECTION's three numbers.- fn triple(ex: &p21::Exchange, id: u64) -> V3 {- let c = ex.get(id).unwrap().params().get(1).unwrap().as_list().unwrap();- [c[0].as_f64().unwrap(), c[1].as_f64().unwrap(), c[2].as_f64().unwrap()]- }-#[test]fn numbers_and_strings() {assert_eq!(real(1.0), "1.0");