Files
solidcraft/crates/step/src/write.rs
T
Brennen HerbruckandClaude Opus 5.5 f06581ca50 STEP geometry as plain data: read and write ISO 10303-42 curves and surfaces without truck
A new crate, solidcraft-step (L1, no modelling backend), holds the Part 21
parser (moved from the kernel, which now reads through it) and STEP geometry
as plain data: lines, conics, B-splines (rational and implied knots),
polylines, trimmed curves, surface curves with their pcurves, 3D offset
curves; planes, cylinders, cones, spheres, tori (degenerate too), B-spline
surfaces, revolutions, linear extrusions, offset and rectangular trimmed
surfaces. Each keeps STEP's own definition and parameterisation, in mm and
radians, with pcurves scaled by their surface's parameter units. Shared
entities stay shared. A writer emits the same entities back, deduplicated.

Tests per entity check values against analytic points, units, round trips
and hostile input; an ignored test reads and round-trips every edge curve
and face surface of the tangency-labs/models STEP files.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 02:28:44 -04:00

504 lines
18 KiB
Rust

//! Writing ISO 10303-21: a DATA section built entity by entity, and [`crate::geom`] curves and
//! surfaces as ISO 10303-42 entities. Identical entities are written once and shared, as the
//! reader shares them.
use std::collections::HashMap;
use std::fmt::Write as _;
use crate::geom::{
Associated, Axis1, BSplineCurve, BSplineSurface, Curve, CurveForm, KnotSpec, Logical, P3, Placement, PreferredRep, Surface, SurfaceCurveKind,
SurfaceForm, Trim, TrimPreference,
};
use crate::p21::Param;
/// A real as Part 21 writes it: always with a decimal point, exponent as `E`.
pub 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 string literal: quotes doubled, non-ASCII as `\X2\` UTF-16 runs.
pub 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, o: &mut 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 _ = write!(o, "#{r}");
}
Param::List(v) => {
o.push('(');
params(v, o);
o.push(')');
}
Param::Typed(name, v) => {
o.push_str(name);
o.push('(');
params(v, o);
o.push(')');
}
Param::Binary(b) => {
let _ = write!(o, "\"{b}\"");
}
Param::Null => o.push('$'),
Param::Derived => o.push('*'),
}
}
fn params(v: &[Param], o: &mut String) {
for (i, p) in v.iter().enumerate() {
if i > 0 {
o.push(',');
}
param(p, o);
}
}
/// A DATA section under construction. Entities are numbered from 1 in the order they are added;
/// adding an entity identical to an earlier one returns the earlier one's id.
#[derive(Default)]
pub struct Writer {
lines: Vec<String>,
shared: HashMap<String, u64>,
}
impl Writer {
pub fn new() -> Self {
Self::default()
}
fn push(&mut self, body: String) -> u64 {
if let Some(id) = self.shared.get(&body) {
return *id;
}
let id = self.lines.len() as u64 + 1;
self.lines.push(format!("#{id}={body};"));
self.shared.insert(body, id);
id
}
/// A simple entity instance.
pub fn add(&mut self, name: &str, p: &[Param]) -> u64 {
let mut body = format!("{name}(");
params(p, &mut body);
body.push(')');
self.push(body)
}
/// A complex entity instance; its records are written in alphabetical order, as Part 21 asks.
pub fn add_complex(&mut self, records: &[(&str, Vec<Param>)]) -> u64 {
let mut sorted: Vec<&(&str, Vec<Param>)> = records.iter().collect();
sorted.sort_by(|a, b| a.0.cmp(b.0));
let mut body = String::from("(");
for (name, p) in sorted {
body.push_str(name);
body.push('(');
params(p, &mut body);
body.push(')');
}
body.push(')');
self.push(body)
}
/// Entities added so far.
pub fn len(&self) -> usize {
self.lines.len()
}
pub fn is_empty(&self) -> bool {
self.lines.is_empty()
}
/// The DATA section's entity lines.
pub fn data(&self) -> String {
let mut o = String::new();
for l in &self.lines {
o.push_str(l);
o.push('\n');
}
o
}
/// A whole exchange file around the entities written so far.
pub fn file(&self, name: &str, schema: &str) -> String {
format!(
"ISO-10303-21;\nHEADER;\nFILE_DESCRIPTION((''),'2;1');\nFILE_NAME({},'',(''),(''),'SolidCraft','SolidCraft','');\nFILE_SCHEMA(({}));\nENDSEC;\nDATA;\n{}ENDSEC;\nEND-ISO-10303-21;\n",
string(name),
string(schema),
self.data()
)
}
}
fn s() -> Param {
Param::Str(String::new())
}
fn r(id: u64) -> Param {
Param::Ref(id)
}
fn f(x: f64) -> Param {
Param::Real(x)
}
fn e(name: &str) -> Param {
Param::Enum(name.into())
}
fn list(v: Vec<Param>) -> Param {
Param::List(v)
}
fn reals(v: &[f64]) -> Param {
list(v.iter().map(|x| f(*x)).collect())
}
fn ints(v: &[usize]) -> Param {
list(v.iter().map(|x| Param::Int(*x as i64)).collect())
}
fn logical(l: Logical) -> Param {
e(match l {
Logical::True => "T",
Logical::False => "F",
Logical::Unknown => "U",
})
}
fn boolean(b: bool) -> Param {
e(if b { "T" } else { "F" })
}
fn curve_form(f: CurveForm) -> Param {
e(match f {
CurveForm::PolylineForm => "POLYLINE_FORM",
CurveForm::CircularArc => "CIRCULAR_ARC",
CurveForm::EllipticArc => "ELLIPTIC_ARC",
CurveForm::ParabolicArc => "PARABOLIC_ARC",
CurveForm::HyperbolicArc => "HYPERBOLIC_ARC",
CurveForm::Unspecified => "UNSPECIFIED",
})
}
fn surface_form(f: SurfaceForm) -> Param {
e(match f {
SurfaceForm::PlaneSurf => "PLANE_SURF",
SurfaceForm::CylindricalSurf => "CYLINDRICAL_SURF",
SurfaceForm::ConicalSurf => "CONICAL_SURF",
SurfaceForm::SphericalSurf => "SPHERICAL_SURF",
SurfaceForm::ToroidalSurf => "TOROIDAL_SURF",
SurfaceForm::SurfOfRevolution => "SURF_OF_REVOLUTION",
SurfaceForm::RuledSurf => "RULED_SURF",
SurfaceForm::GeneralisedCone => "GENERALISED_CONE",
SurfaceForm::QuadricSurf => "QUADRIC_SURF",
SurfaceForm::SurfOfLinearExtrusion => "SURF_OF_LINEAR_EXTRUSION",
SurfaceForm::Unspecified => "UNSPECIFIED",
})
}
fn knot_spec(k: KnotSpec) -> Param {
e(match k {
KnotSpec::UniformKnots => "UNIFORM_KNOTS",
KnotSpec::QuasiUniformKnots => "QUASI_UNIFORM_KNOTS",
KnotSpec::PiecewiseBezierKnots => "PIECEWISE_BEZIER_KNOTS",
KnotSpec::Unspecified => "UNSPECIFIED",
})
}
/// Writes geometry into a [`Writer`]. Lengths are written in millimetres and angles in radians:
/// the representation context the caller writes must say so.
pub struct GeomWriter<'w> {
pub w: &'w mut Writer,
/// The 2D parameter-space context pcurves refer to, once written.
pcurve_context: Option<u64>,
}
impl<'w> GeomWriter<'w> {
pub fn new(w: &'w mut Writer) -> Self {
GeomWriter { w, pcurve_context: None }
}
fn coords(p: P3, dim: usize) -> Param {
reals(p.get(..dim).unwrap_or(&p))
}
pub fn point(&mut self, p: P3) -> u64 {
self.point_in(p, 3)
}
fn point_in(&mut self, p: P3, dim: usize) -> u64 {
self.w.add("CARTESIAN_POINT", &[s(), Self::coords(p, dim)])
}
fn direction_in(&mut self, d: P3, dim: usize) -> u64 {
self.w.add("DIRECTION", &[s(), Self::coords(d, dim)])
}
pub fn direction(&mut self, d: P3) -> u64 {
self.direction_in(d, 3)
}
fn vector_in(&mut self, d: P3, magnitude: f64, dim: usize) -> u64 {
let d = self.direction_in(d, dim);
self.w.add("VECTOR", &[s(), r(d), f(magnitude)])
}
fn placement_in(&mut self, p: &Placement, dim: usize) -> u64 {
let o = self.point_in(p.origin, dim);
let x = self.direction_in(p.ref_direction, dim);
if dim == 2 {
self.w.add("AXIS2_PLACEMENT_2D", &[s(), r(o), r(x)])
} else {
let z = self.direction_in(p.axis, dim);
self.w.add("AXIS2_PLACEMENT_3D", &[s(), r(o), r(z), r(x)])
}
}
pub fn placement(&mut self, p: &Placement) -> u64 {
self.placement_in(p, 3)
}
pub fn axis1(&mut self, a: &Axis1) -> u64 {
let o = self.point(a.origin);
let d = self.direction(a.direction);
self.w.add("AXIS1_PLACEMENT", &[s(), r(o), r(d)])
}
/// A 3D curve.
pub fn curve(&mut self, c: &Curve) -> u64 {
self.curve_in(c, 3)
}
fn curve_in(&mut self, c: &Curve, dim: usize) -> u64 {
match c {
Curve::Line { origin, direction, magnitude } => {
let p = self.point_in(*origin, dim);
let v = self.vector_in(*direction, *magnitude, dim);
self.w.add("LINE", &[s(), r(p), r(v)])
}
Curve::Circle { position, radius } => {
let p = self.placement_in(position, dim);
self.w.add("CIRCLE", &[s(), r(p), f(*radius)])
}
Curve::Ellipse { position, semi_axis_1, semi_axis_2 } => {
let p = self.placement_in(position, dim);
self.w.add("ELLIPSE", &[s(), r(p), f(*semi_axis_1), f(*semi_axis_2)])
}
Curve::Hyperbola { position, semi_axis, semi_imag_axis } => {
let p = self.placement_in(position, dim);
self.w.add("HYPERBOLA", &[s(), r(p), f(*semi_axis), f(*semi_imag_axis)])
}
Curve::Parabola { position, focal_dist } => {
let p = self.placement_in(position, dim);
self.w.add("PARABOLA", &[s(), r(p), f(*focal_dist)])
}
Curve::BSpline(b) => self.bspline_curve(b, dim),
Curve::Polyline(pts) => {
let ids = pts.iter().map(|p| r(self.point_in(*p, dim))).collect();
self.w.add("POLYLINE", &[s(), list(ids)])
}
Curve::Trimmed { basis, trim_1, trim_2, sense, preference } => {
let b = self.curve_in(basis, dim);
let t1 = self.trims(trim_1, dim);
let t2 = self.trims(trim_2, dim);
let pref = e(match preference {
TrimPreference::Cartesian => "CARTESIAN",
TrimPreference::Parameter => "PARAMETER",
TrimPreference::Unspecified => "UNSPECIFIED",
});
self.w.add("TRIMMED_CURVE", &[s(), r(b), t1, t2, boolean(*sense), pref])
}
Curve::SurfaceCurve { kind, curve_3d, associated, master } => {
let c3 = self.curve_in(curve_3d, 3);
let items = associated
.iter()
.map(|a| match a {
Associated::Pcurve(pc) => {
let surf = self.surface(&pc.surface);
let c2 = self.curve_in(&pc.curve, 2);
let ctx = self.pcurve_context();
let rep = self.w.add("DEFINITIONAL_REPRESENTATION", &[s(), list(vec![r(c2)]), r(ctx)]);
r(self.w.add("PCURVE", &[s(), r(surf), r(rep)]))
}
Associated::Surface(sf) => r(self.surface(sf)),
})
.collect();
let name = match kind {
SurfaceCurveKind::Surface => "SURFACE_CURVE",
SurfaceCurveKind::Seam => "SEAM_CURVE",
SurfaceCurveKind::Intersection => "INTERSECTION_CURVE",
SurfaceCurveKind::BoundedSurface => "BOUNDED_SURFACE_CURVE",
};
let m = e(match master {
PreferredRep::Curve3d => "CURVE_3D",
PreferredRep::PcurveS1 => "PCURVE_S1",
PreferredRep::PcurveS2 => "PCURVE_S2",
});
self.w.add(name, &[s(), r(c3), list(items), m])
}
Curve::OffsetCurve3d { basis, distance, self_intersect, ref_direction } => {
let b = self.curve_in(basis, 3);
let d = self.direction(*ref_direction);
self.w.add("OFFSET_CURVE_3D", &[s(), r(b), f(*distance), logical(*self_intersect), r(d)])
}
}
}
fn pcurve_context(&mut self) -> u64 {
if let Some(c) = self.pcurve_context {
return c;
}
let c = self.w.add_complex(&[
("GEOMETRIC_REPRESENTATION_CONTEXT", vec![Param::Int(2)]),
("PARAMETRIC_REPRESENTATION_CONTEXT", vec![]),
("REPRESENTATION_CONTEXT", vec![Param::Str("2D SPACE".into()), s()]),
]);
self.pcurve_context = Some(c);
c
}
fn trims(&mut self, t: &[Trim], dim: usize) -> Param {
list(
t.iter()
.map(|t| match t {
Trim::Point(p) => r(self.point_in(*p, dim)),
Trim::Parameter(x) => Param::Typed("PARAMETER_VALUE".into(), vec![f(*x)]),
})
.collect(),
)
}
fn bspline_curve(&mut self, b: &BSplineCurve, dim: usize) -> u64 {
let ctrl = list(b.points.iter().map(|p| r(self.point_in(*p, dim))).collect());
let common = vec![Param::Int(b.degree as i64), ctrl, curve_form(b.form), logical(b.closed), logical(b.self_intersect)];
let knots = vec![ints(&b.multiplicities), reals(&b.knots), knot_spec(b.knot_spec)];
match &b.weights {
None => {
let mut p = vec![s()];
p.extend(common);
p.extend(knots);
self.w.add("B_SPLINE_CURVE_WITH_KNOTS", &p)
}
Some(w) => self.w.add_complex(&[
("BOUNDED_CURVE", vec![]),
("B_SPLINE_CURVE", common),
("B_SPLINE_CURVE_WITH_KNOTS", knots),
("CURVE", vec![]),
("GEOMETRIC_REPRESENTATION_ITEM", vec![]),
("RATIONAL_B_SPLINE_CURVE", vec![reals(w)]),
("REPRESENTATION_ITEM", vec![s()]),
]),
}
}
/// A surface.
pub fn surface(&mut self, sf: &Surface) -> u64 {
match sf {
Surface::Plane { position } => {
let p = self.placement(position);
self.w.add("PLANE", &[s(), r(p)])
}
Surface::Cylinder { position, radius } => {
let p = self.placement(position);
self.w.add("CYLINDRICAL_SURFACE", &[s(), r(p), f(*radius)])
}
Surface::Cone { position, radius, semi_angle } => {
let p = self.placement(position);
self.w.add("CONICAL_SURFACE", &[s(), r(p), f(*radius), f(*semi_angle)])
}
Surface::Sphere { position, radius } => {
let p = self.placement(position);
self.w.add("SPHERICAL_SURFACE", &[s(), r(p), f(*radius)])
}
Surface::Torus { position, major_radius, minor_radius } => {
let p = self.placement(position);
self.w.add("TOROIDAL_SURFACE", &[s(), r(p), f(*major_radius), f(*minor_radius)])
}
Surface::DegenerateTorus { position, major_radius, minor_radius, select_outer } => {
let p = self.placement(position);
self.w.add("DEGENERATE_TOROIDAL_SURFACE", &[s(), r(p), f(*major_radius), f(*minor_radius), boolean(*select_outer)])
}
Surface::BSpline(b) => self.bspline_surface(b),
Surface::Revolution { profile, axis } => {
let c = self.curve(profile);
let a = self.axis1(axis);
self.w.add("SURFACE_OF_REVOLUTION", &[s(), r(c), r(a)])
}
Surface::Extrusion { profile, direction, magnitude } => {
let c = self.curve(profile);
let v = self.vector_in(*direction, *magnitude, 3);
self.w.add("SURFACE_OF_LINEAR_EXTRUSION", &[s(), r(c), r(v)])
}
Surface::Offset { basis, distance, self_intersect } => {
let b = self.surface(basis);
self.w.add("OFFSET_SURFACE", &[s(), r(b), f(*distance), logical(*self_intersect)])
}
Surface::RectangularTrimmed { basis, u1, u2, v1, v2, u_sense, v_sense } => {
let b = self.surface(basis);
self.w.add("RECTANGULAR_TRIMMED_SURFACE", &[s(), r(b), f(*u1), f(*u2), f(*v1), f(*v2), boolean(*u_sense), boolean(*v_sense)])
}
}
}
fn bspline_surface(&mut self, b: &BSplineSurface) -> u64 {
let ctrl = list(b.points.iter().map(|row| list(row.iter().map(|p| r(self.point(*p))).collect())).collect());
let common = vec![
Param::Int(b.u_degree as i64),
Param::Int(b.v_degree as i64),
ctrl,
surface_form(b.form),
logical(b.u_closed),
logical(b.v_closed),
logical(b.self_intersect),
];
let knots = vec![ints(&b.u_multiplicities), ints(&b.v_multiplicities), reals(&b.u_knots), reals(&b.v_knots), knot_spec(b.knot_spec)];
match &b.weights {
None => {
let mut p = vec![s()];
p.extend(common);
p.extend(knots);
self.w.add("B_SPLINE_SURFACE_WITH_KNOTS", &p)
}
Some(w) => self.w.add_complex(&[
("BOUNDED_SURFACE", vec![]),
("B_SPLINE_SURFACE", common),
("B_SPLINE_SURFACE_WITH_KNOTS", knots),
("GEOMETRIC_REPRESENTATION_ITEM", vec![]),
("RATIONAL_B_SPLINE_SURFACE", vec![list(w.iter().map(|row| reals(row)).collect())]),
("REPRESENTATION_ITEM", vec![s()]),
("SURFACE", vec![]),
]),
}
}
}