Files
solidcraft/crates/step/src/read.rs
T
Brennen HerbruckandClaude Opus 5.5 7f7358f918 Wave 13/509: STEP geometry as plain data: read and write ISO 10303-42 curves and surfaces without truck
1 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.

- f06581ca5 Brennen Herbruck: STEP geometry as plain data: read and write ISO 10303-42 curves and surfaces without truck

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
2026-10-20 22:21:19 -04:00

763 lines
34 KiB
Rust

//! STEP geometry entities to [`crate::geom`]. Written from ISO 10303-42 (geometry) and
//! ISO 10303-21 (the exchange structure). Input is hostile: every count, number and reference is
//! checked, nesting is capped, and shared entities are read once.
use std::collections::HashMap;
use std::sync::Arc;
use crate::geom::{
Associated, Axis1, BSplineCurve, BSplineSurface, Curve, CurveForm, KnotSpec, Logical, P3, Pcurve, Placement, PreferredRep, Surface,
SurfaceCurveKind, SurfaceForm, Trim, TrimPreference, dot, norm, scale, sub,
};
use crate::p21::{Entity, Exchange, Param};
pub type R<T> = Result<T, String>;
/// Geometry nesting we follow (a trimmed curve of a surface curve of …).
pub const MAX_GEOM_DEPTH: usize = 12;
/// Most control points in one B-spline (the whole net for a surface).
pub const MAX_CTRL: usize = 1_000_000;
/// Largest coordinate or length, in file units.
pub const MAX_COORD: f64 = 1e9;
/// Highest B-spline degree.
pub const MAX_DEGREE: usize = 32;
/// The units of a representation context.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Units {
/// Millimetres per file length unit.
pub len: f64,
/// Radians per file plane angle unit.
pub ang: f64,
}
impl Default for Units {
fn default() -> Self {
Units { len: 1.0, ang: 1.0 }
}
}
/// How a parameter of a curve or surface scales from file units: angles by the angle unit,
/// lengths by the length unit, anything else (B-spline knots, ratios) not at all.
#[derive(Clone, Copy, Debug, PartialEq)]
enum ParamKind {
Length,
Angle,
Plain,
}
/// Reads geometry from one exchange structure, in one context's units.
pub struct Reader<'a> {
ex: &'a Exchange,
units: Units,
curves: HashMap<u64, Arc<Curve>>,
curves_2d: HashMap<(u64, [u64; 2]), Arc<Curve>>,
surfaces: HashMap<u64, Arc<Surface>>,
}
fn entity(ex: &Exchange, id: u64) -> R<&Entity> {
ex.get(id).ok_or_else(|| format!("missing entity #{id}"))
}
fn reference(p: Option<&Param>, what: &str) -> R<u64> {
p.and_then(Param::as_ref_id).ok_or_else(|| format!("{what}: expected a reference"))
}
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 logical(p: Option<&Param>, what: &str) -> R<Logical> {
match p.and_then(Param::as_enum) {
Some("T") => Ok(Logical::True),
Some("F") => Ok(Logical::False),
Some("U") => Ok(Logical::Unknown),
_ => Err(format!("{what}: expected a logical")),
}
}
fn boolean(p: Option<&Param>, what: &str) -> R<bool> {
p.and_then(Param::as_bool).ok_or_else(|| format!("{what}: expected a boolean"))
}
fn unit(v: P3, what: &str) -> R<P3> {
let m = norm(v);
if m > 1e-12 && m.is_finite() { Ok(scale(v, 1.0 / m)) } else { Err(format!("{what}: zero direction")) }
}
fn any_perpendicular(z: P3) -> P3 {
let a = if z[0].abs() < 0.9 { [1.0, 0.0, 0.0] } else { [0.0, 1.0, 0.0] };
let x = sub(a, scale(z, dot(a, z)));
scale(x, 1.0 / norm(x))
}
fn curve_form(p: Option<&Param>) -> CurveForm {
match p.and_then(Param::as_enum) {
Some("POLYLINE_FORM") => CurveForm::PolylineForm,
Some("CIRCULAR_ARC") => CurveForm::CircularArc,
Some("ELLIPTIC_ARC") => CurveForm::EllipticArc,
Some("PARABOLIC_ARC") => CurveForm::ParabolicArc,
Some("HYPERBOLIC_ARC") => CurveForm::HyperbolicArc,
_ => CurveForm::Unspecified,
}
}
fn surface_form(p: Option<&Param>) -> SurfaceForm {
match p.and_then(Param::as_enum) {
Some("PLANE_SURF") => SurfaceForm::PlaneSurf,
Some("CYLINDRICAL_SURF") => SurfaceForm::CylindricalSurf,
Some("CONICAL_SURF") => SurfaceForm::ConicalSurf,
Some("SPHERICAL_SURF") => SurfaceForm::SphericalSurf,
Some("TOROIDAL_SURF") => SurfaceForm::ToroidalSurf,
Some("SURF_OF_REVOLUTION") => SurfaceForm::SurfOfRevolution,
Some("RULED_SURF") => SurfaceForm::RuledSurf,
Some("GENERALISED_CONE") => SurfaceForm::GeneralisedCone,
Some("QUADRIC_SURF") => SurfaceForm::QuadricSurf,
Some("SURF_OF_LINEAR_EXTRUSION") => SurfaceForm::SurfOfLinearExtrusion,
_ => SurfaceForm::Unspecified,
}
}
fn knot_spec(p: Option<&Param>) -> KnotSpec {
match p.and_then(Param::as_enum) {
Some("UNIFORM_KNOTS") => KnotSpec::UniformKnots,
Some("QUASI_UNIFORM_KNOTS") => KnotSpec::QuasiUniformKnots,
Some("PIECEWISE_BEZIER_KNOTS") => KnotSpec::PiecewiseBezierKnots,
_ => KnotSpec::Unspecified,
}
}
/// Distinct knots and multiplicities, checked against `n_ctrl` points of `degree` before
/// anything is expanded (a file can claim multiplicities that would need gigabytes).
fn knots(mults: Option<&Param>, values: Option<&Param>, n_ctrl: usize, degree: usize) -> R<(Vec<f64>, Vec<usize>)> {
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| *v >= 1 && *v as usize <= degree + 1).map(|v| v as usize).ok_or_else(|| "bad knot multiplicity".to_string()))
.collect::<R<_>>()?;
let raw: Vec<f64> = values.and_then(Param::as_list).ok_or("B-spline without knots")?.iter().map(|x| num(Some(x), "knot")).collect::<R<_>>()?;
if m.len() != raw.len() || raw.windows(2).any(|w| w.first() > w.get(1)) {
return Err("knots must not decrease, one multiplicity each".into());
}
// Some writers list a knot twice; that is one knot with both multiplicities.
let (mut k, mut mm): (Vec<f64>, Vec<usize>) = (Vec::with_capacity(raw.len()), Vec::with_capacity(raw.len()));
for (x, n) in raw.into_iter().zip(m) {
match (k.last(), mm.last_mut()) {
(Some(last), Some(lm)) if *last == x => *lm += n,
_ => {
k.push(x);
mm.push(n);
}
}
}
let m = mm;
if k.len() < 2 || m.iter().any(|v| *v > degree + 1) {
return Err("bad knot vector".into());
}
if m.iter().try_fold(0usize, |a, v| a.checked_add(*v)) != Some(n_ctrl + degree + 1) {
return Err("knot multiplicities do not match the control points".into());
}
Ok((k, m))
}
/// Knots of a B-spline given by its type alone (BEZIER_, UNIFORM_, QUASI_UNIFORM_CURVE).
fn implied_knots(spec: KnotSpec, n_ctrl: usize, degree: usize) -> R<(Vec<f64>, Vec<usize>)> {
if n_ctrl <= degree {
return Err("too few control points".into());
}
match spec {
KnotSpec::PiecewiseBezierKnots => {
// Segments of `degree`, full interior multiplicity.
let segs = (n_ctrl - 1) / degree;
if segs * degree + 1 != n_ctrl {
return Err("Bezier control point count".into());
}
let k = (0..=segs).map(|s| s as f64).collect();
let mut m = vec![degree; segs + 1];
if let Some(f) = m.first_mut() {
*f = degree + 1;
}
if let Some(l) = m.last_mut() {
*l = degree + 1;
}
Ok((k, m))
}
KnotSpec::UniformKnots => {
let n = n_ctrl + degree + 1;
Ok(((0..n).map(|i| i as f64 - degree as f64).collect(), vec![1; n]))
}
_ => {
// Quasi-uniform: clamped ends, uniform interior.
let inner = n_ctrl - degree;
let k = (0..=inner).map(|i| i as f64).collect();
let mut m = vec![1; inner + 1];
if let Some(f) = m.first_mut() {
*f = degree + 1;
}
if let Some(l) = m.last_mut() {
*l = degree + 1;
}
Ok((k, m))
}
}
}
fn weights(p: Option<&Param>, n: usize) -> R<Vec<f64>> {
let w: 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::<R<_>>()?;
if w.len() != n { Err("weights do not match the control points".into()) } else { Ok(w) }
}
fn degree(p: Option<&Param>) -> R<usize> {
p.and_then(Param::as_i64).filter(|d| (1..=MAX_DEGREE as i64).contains(d)).map(|d| d as usize).ok_or_else(|| "bad B-spline degree".into())
}
/// The knot type a B-spline entity's (sub)type implies when it lists no knots.
fn spec_of_type(e: &Entity) -> KnotSpec {
let has = |n: &str| e.name() == n || e.has(n);
if has("BEZIER_CURVE") || has("BEZIER_SURFACE") {
KnotSpec::PiecewiseBezierKnots
} else if has("UNIFORM_CURVE") || has("UNIFORM_SURFACE") {
KnotSpec::UniformKnots
} else {
KnotSpec::QuasiUniformKnots
}
}
/// The parameters of a simple or complex B-spline entity, as the simple form lays them out:
/// the name first, then the `B_SPLINE_*` attributes, then the `*_WITH_KNOTS` ones.
fn bspline_params(e: &Entity, base: &str, with_knots: &str) -> R<(Vec<Param>, Option<Vec<Param>>)> {
if e.is_complex() {
let b = e.record(base).ok_or_else(|| format!("complex entity without {base}"))?;
let mut p = vec![Param::Str(String::new())];
p.extend(b.iter().cloned());
Ok((p, e.record(with_knots).map(<[Param]>::to_vec)))
} else {
let p = e.params();
let n = if base == "B_SPLINE_CURVE" { 6 } else { 8 };
let k = (e.name() == with_knots).then(|| p.get(n..).map(<[Param]>::to_vec).unwrap_or_default());
Ok((p.to_vec(), k))
}
}
impl<'a> Reader<'a> {
pub fn new(ex: &'a Exchange, units: Units) -> Self {
Reader { ex, units, curves: HashMap::new(), curves_2d: HashMap::new(), surfaces: HashMap::new() }
}
pub fn units(&self) -> Units {
self.units
}
fn length(&self, p: Option<&Param>, what: &str) -> R<f64> {
Ok(num(p, what)? * self.units.len)
}
fn angle(&self, p: Option<&Param>, what: &str) -> R<f64> {
Ok(num(p, what)? * self.units.ang)
}
/// A CARTESIAN_POINT, scaled per coordinate (`s` are the factors).
fn point_scaled(&self, id: u64, s: [f64; 3], dim: usize) -> R<P3> {
let e = entity(self.ex, 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")?;
if c.is_empty() || c.len() > dim {
return Err(format!("#{id}: point with {} coordinates", c.len()));
}
let g = |i: usize| -> R<f64> { if i < c.len() { num(c.get(i), "coordinate") } else { Ok(0.0) } };
Ok([g(0)? * s[0], g(1)? * s[1], if dim == 3 { g(2)? * s[2] } else { 0.0 }])
}
/// A CARTESIAN_POINT in millimetres.
pub fn point(&self, id: u64) -> R<P3> {
let l = self.units.len;
self.point_scaled(id, [l, l, l], 3)
}
/// A DIRECTION, as a unit vector (with 2D axes scaled by `s` first).
fn direction_scaled(&self, id: u64, s: [f64; 3], dim: usize) -> R<P3> {
let e = entity(self.ex, 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")?;
if c.is_empty() || c.len() > dim {
return Err(format!("#{id}: direction with {} ratios", c.len()));
}
let g = |i: usize| -> R<f64> { if i < c.len() { num(c.get(i), "direction ratio") } else { Ok(0.0) } };
unit([g(0)? * s[0], g(1)? * s[1], if dim == 3 { g(2)? * s[2] } else { 0.0 }], &format!("#{id}"))
}
pub fn direction(&self, id: u64) -> R<P3> {
self.direction_scaled(id, [1.0; 3], 3)
}
/// AXIS2_PLACEMENT_3D, or AXIS2_PLACEMENT_2D as a placement in the XY plane.
fn placement_scaled(&self, id: u64, s: [f64; 3], dim: usize) -> R<Placement> {
let e = entity(self.ex, id)?;
let p = e.params();
let origin = self.point_scaled(reference(p.get(1), "placement location")?, s, dim)?;
let (axis, rf) = match (e.name(), dim) {
("AXIS2_PLACEMENT_3D", 3) => {
let z = match p.get(2).and_then(Param::as_ref_id) {
Some(d) => self.direction_scaled(d, s, dim)?,
None => [0.0, 0.0, 1.0],
};
(z, p.get(3).and_then(Param::as_ref_id))
}
("AXIS2_PLACEMENT_2D", 2) => ([0.0, 0.0, 1.0], p.get(2).and_then(Param::as_ref_id)),
(n, _) => return Err(format!("#{id}: unexpected placement {n} in {dim}D")),
};
let x = match rf {
Some(d) => {
let r = self.direction_scaled(d, s, dim)?;
let x = sub(r, scale(axis, dot(r, axis)));
if norm(x) > 1e-9 { scale(x, 1.0 / norm(x)) } else { any_perpendicular(axis) }
}
None => any_perpendicular(axis),
};
Ok(Placement { origin, axis, ref_direction: x })
}
pub fn placement(&self, id: u64) -> R<Placement> {
let l = self.units.len;
self.placement_scaled(id, [l, l, l], 3)
}
pub fn axis1(&self, id: u64) -> R<Axis1> {
let e = entity(self.ex, id)?;
if e.name() != "AXIS1_PLACEMENT" {
return Err(format!("#{id}: expected AXIS1_PLACEMENT, found {}", e.name()));
}
let p = e.params();
let origin = self.point(reference(p.get(1), "axis location")?)?;
let direction = match p.get(2).and_then(Param::as_ref_id) {
Some(d) => self.direction(d)?,
None => [0.0, 0.0, 1.0],
};
Ok(Axis1 { origin, direction })
}
/// A VECTOR: unit direction and magnitude (scaled as a length by `len`).
fn vector_scaled(&self, id: u64, s: [f64; 3], dim: usize) -> R<(P3, f64)> {
let e = entity(self.ex, id)?;
if e.name() != "VECTOR" {
return Err(format!("#{id}: expected VECTOR, found {}", e.name()));
}
let p = e.params();
// Scaling a 2D direction unevenly changes the magnitude too.
let raw = self.direction_scaled(reference(p.get(1), "vector orientation")?, [1.0; 3], dim)?;
let m = num(p.get(2), "vector magnitude")?;
if m < 0.0 {
return Err("negative vector magnitude".into());
}
let v = [raw[0] * s[0] * m, raw[1] * s[1] * m, raw[2] * s[2] * m];
let len = norm(v);
if !(len > 0.0) {
return Err("zero vector".into());
}
Ok((scale(v, 1.0 / len), len))
}
/// A 3D curve entity.
pub fn curve(&mut self, id: u64) -> R<Arc<Curve>> {
self.curve_in(id, 0)
}
fn curve_in(&mut self, id: u64, depth: usize) -> R<Arc<Curve>> {
if let Some(c) = self.curves.get(&id) {
return Ok(c.clone());
}
if depth > MAX_GEOM_DEPTH {
return Err("curve definitions nested too deeply".into());
}
let l = self.units.len;
let c = Arc::new(self.read_curve(id, [l, l, l], 3, depth)?);
self.curves.insert(id, c.clone());
Ok(c)
}
/// A 2D curve in a surface's parameter space, scaled by the surface's parameter units.
fn curve_2d(&mut self, id: u64, kinds: (ParamKind, ParamKind), depth: usize) -> R<Arc<Curve>> {
let s = [self.factor(kinds.0), self.factor(kinds.1), 1.0];
let key = (id, [s[0].to_bits(), s[1].to_bits()]);
if let Some(c) = self.curves_2d.get(&key) {
return Ok(c.clone());
}
if depth > MAX_GEOM_DEPTH {
return Err("curve definitions nested too deeply".into());
}
let c = Arc::new(self.read_curve(id, s, 2, depth)?);
self.curves_2d.insert(key, c.clone());
Ok(c)
}
fn factor(&self, k: ParamKind) -> f64 {
match k {
ParamKind::Length => self.units.len,
ParamKind::Angle => self.units.ang,
ParamKind::Plain => 1.0,
}
}
/// A conic radius: a length, scaled evenly (`s` must be even for a conic).
fn conic_scale(s: [f64; 3]) -> R<f64> {
if (s[0] - s[1]).abs() > 1e-12 * s[0].abs().max(s[1].abs()) {
return Err("not supported yet: a conic in a parameter space with mixed units".into());
}
Ok(s[0])
}
fn read_curve(&mut self, id: u64, s: [f64; 3], dim: usize, depth: usize) -> R<Curve> {
let e = entity(self.ex, id)?;
if e.is_complex() {
return self.bspline_curve(e, s, dim);
}
let p = e.params();
let positive = |x: f64, what: &str| if x > 0.0 { Ok(x) } else { Err(format!("{what} must be positive")) };
match e.name() {
"LINE" => {
let origin = self.point_scaled(reference(p.get(1), "line point")?, s, dim)?;
let (direction, magnitude) = self.vector_scaled(reference(p.get(2), "line vector")?, s, dim)?;
Ok(Curve::Line { origin, direction, magnitude })
}
"CIRCLE" => {
let k = Self::conic_scale(s)?;
let position = self.placement_scaled(reference(p.get(1), "circle placement")?, s, dim)?;
Ok(Curve::Circle { position, radius: positive(num(p.get(2), "radius")? * k, "circle radius")? })
}
"ELLIPSE" => {
let k = Self::conic_scale(s)?;
let position = self.placement_scaled(reference(p.get(1), "ellipse placement")?, s, dim)?;
Ok(Curve::Ellipse {
position,
semi_axis_1: positive(num(p.get(2), "semi axis")? * k, "ellipse axis")?,
semi_axis_2: positive(num(p.get(3), "semi axis")? * k, "ellipse axis")?,
})
}
"HYPERBOLA" => {
let k = Self::conic_scale(s)?;
let position = self.placement_scaled(reference(p.get(1), "hyperbola placement")?, s, dim)?;
Ok(Curve::Hyperbola {
position,
semi_axis: positive(num(p.get(2), "semi axis")? * k, "hyperbola axis")?,
semi_imag_axis: positive(num(p.get(3), "semi imaginary axis")? * k, "hyperbola axis")?,
})
}
"PARABOLA" => {
let k = Self::conic_scale(s)?;
let position = self.placement_scaled(reference(p.get(1), "parabola placement")?, s, dim)?;
let focal_dist = num(p.get(2), "focal distance")? * k;
if focal_dist == 0.0 {
return Err("parabola focal distance must not be zero".into());
}
Ok(Curve::Parabola { position, focal_dist })
}
"B_SPLINE_CURVE_WITH_KNOTS" | "BEZIER_CURVE" | "UNIFORM_CURVE" | "QUASI_UNIFORM_CURVE" => self.bspline_curve(e, s, dim),
"POLYLINE" => {
let ids = p.get(1).and_then(Param::as_list).ok_or("POLYLINE without points")?;
if ids.len() < 2 || ids.len() > MAX_CTRL {
return Err("polyline point count".into());
}
let pts = ids.iter().map(|c| self.point_scaled(reference(Some(c), "polyline point")?, s, dim)).collect::<R<_>>()?;
Ok(Curve::Polyline(pts))
}
"TRIMMED_CURVE" => {
let b = reference(p.get(1), "trimmed curve basis")?;
let basis = if dim == 3 { self.curve_in(b, depth + 1)? } else { Arc::new(self.read_curve(b, s, dim, depth + 1)?) };
// Conic parameters are angles; every other basis curve's are plain numbers.
let kind = match &*basis {
Curve::Circle { .. } | Curve::Ellipse { .. } => ParamKind::Angle,
_ => ParamKind::Plain,
};
let trim_1 = self.trims(p.get(2), kind, s, dim)?;
let trim_2 = self.trims(p.get(3), kind, s, dim)?;
let sense = boolean(p.get(4), "trimmed curve sense")?;
let preference = match p.get(5).and_then(Param::as_enum) {
Some("CARTESIAN") => TrimPreference::Cartesian,
Some("PARAMETER") => TrimPreference::Parameter,
_ => TrimPreference::Unspecified,
};
Ok(Curve::Trimmed { basis, trim_1, trim_2, sense, preference })
}
"SURFACE_CURVE" | "SEAM_CURVE" | "INTERSECTION_CURVE" | "BOUNDED_SURFACE_CURVE" if dim == 3 => {
let kind = match e.name() {
"SEAM_CURVE" => SurfaceCurveKind::Seam,
"INTERSECTION_CURVE" => SurfaceCurveKind::Intersection,
"BOUNDED_SURFACE_CURVE" => SurfaceCurveKind::BoundedSurface,
_ => SurfaceCurveKind::Surface,
};
let curve_3d = self.curve_in(reference(p.get(1), "surface curve 3D curve")?, depth + 1)?;
let items = p.get(2).and_then(Param::as_list).ok_or("surface curve without associated geometry")?;
if items.len() > 2 {
return Err("surface curve with more than two associated items".into());
}
let mut associated = Vec::with_capacity(items.len());
for item in items {
associated.push(self.associated(reference(Some(item), "associated geometry")?, depth + 1)?);
}
let master = match p.get(3).and_then(Param::as_enum) {
Some("PCURVE_S1") => PreferredRep::PcurveS1,
Some("PCURVE_S2") => PreferredRep::PcurveS2,
_ => PreferredRep::Curve3d,
};
Ok(Curve::SurfaceCurve { kind, curve_3d, associated, master })
}
"OFFSET_CURVE_3D" if dim == 3 => {
let basis = self.curve_in(reference(p.get(1), "offset curve basis")?, depth + 1)?;
let distance = self.length(p.get(2), "offset distance")?;
let self_intersect = logical(p.get(3), "offset curve self_intersect")?;
let ref_direction = self.direction(reference(p.get(4), "offset curve direction")?)?;
Ok(Curve::OffsetCurve3d { basis, distance, self_intersect, ref_direction })
}
n => Err(format!("not supported yet: curve {n}{}", if dim == 2 { " in parameter space" } else { "" })),
}
}
fn trims(&self, p: Option<&Param>, kind: ParamKind, s: [f64; 3], dim: usize) -> R<Vec<Trim>> {
let items = p.and_then(Param::as_list).ok_or("trimmed curve without trims")?;
if items.is_empty() || items.len() > 2 {
return Err("trimmed curve trim count".into());
}
items
.iter()
.map(|t| match t {
Param::Ref(r) => Ok(Trim::Point(self.point_scaled(*r, s, dim)?)),
Param::Typed(name, v) if name == "PARAMETER_VALUE" => Ok(Trim::Parameter(num(v.first(), "trim parameter")? * self.factor(kind))),
Param::Real(_) | Param::Int(_) => Ok(Trim::Parameter(num(Some(t), "trim parameter")? * self.factor(kind))),
_ => Err("bad trim".into()),
})
.collect()
}
fn associated(&mut self, id: u64, depth: usize) -> R<Associated> {
let e = entity(self.ex, id)?;
if e.name() != "PCURVE" {
return Ok(Associated::Surface(self.surface_in(id, depth)?));
}
let p = e.params();
let surface = self.surface_in(reference(p.get(1), "pcurve surface")?, depth)?;
let rep = entity(self.ex, reference(p.get(2), "pcurve representation")?)?;
if rep.name() != "DEFINITIONAL_REPRESENTATION" {
return Err(format!("pcurve representation is {}", rep.name()));
}
let items = rep.params().get(1).and_then(Param::as_list).ok_or("pcurve representation without items")?;
let [item] = items else { return Err("pcurve representation must hold one curve".into()) };
let kinds = Self::param_kinds(&surface);
let curve = self.curve_2d(reference(Some(item), "pcurve curve")?, kinds, depth)?;
Ok(Associated::Pcurve(Pcurve { surface, curve }))
}
/// How a surface's (u, v) parameters scale from file units.
fn param_kinds(s: &Surface) -> (ParamKind, ParamKind) {
use ParamKind::*;
match s {
Surface::Plane { .. } => (Length, Length),
Surface::Cylinder { .. } | Surface::Cone { .. } => (Angle, Length),
Surface::Sphere { .. } | Surface::Torus { .. } | Surface::DegenerateTorus { .. } => (Angle, Angle),
Surface::Revolution { profile, .. } => (Angle, Self::curve_param_kind(profile)),
Surface::Extrusion { profile, .. } => (Self::curve_param_kind(profile), Plain),
Surface::BSpline(_) => (Plain, Plain),
Surface::Offset { basis, .. } | Surface::RectangularTrimmed { basis, .. } => Self::param_kinds(basis),
}
}
fn curve_param_kind(c: &Curve) -> ParamKind {
match c {
Curve::Circle { .. } | Curve::Ellipse { .. } => ParamKind::Angle,
Curve::Trimmed { basis, .. } | Curve::OffsetCurve3d { basis, .. } => Self::curve_param_kind(basis),
Curve::SurfaceCurve { curve_3d, .. } => Self::curve_param_kind(curve_3d),
_ => ParamKind::Plain,
}
}
fn bspline_curve(&mut self, e: &Entity, s: [f64; 3], dim: usize) -> R<Curve> {
let (base, with_knots) = bspline_params(e, "B_SPLINE_CURVE", "B_SPLINE_CURVE_WITH_KNOTS")?;
let degree = degree(base.get(1))?;
let ids = base.get(2).and_then(Param::as_list).ok_or("B-spline without control points")?;
if ids.len() > MAX_CTRL {
return Err("B-spline with too many control points".into());
}
let points: Vec<P3> = ids.iter().map(|c| self.point_scaled(reference(Some(c), "control point")?, s, dim)).collect::<R<_>>()?;
let (knots, multiplicities, knot_spec) = match &with_knots {
Some(k) => {
let (kv, m) = knots(k.first(), k.get(1), points.len(), degree)?;
(kv, m, knot_spec(k.get(2)))
}
None => {
let spec = spec_of_type(e);
let (kv, m) = implied_knots(spec, points.len(), degree)?;
(kv, m, spec)
}
};
let weights = match e.record("RATIONAL_B_SPLINE_CURVE") {
Some(r) => Some(weights(r.first(), points.len())?),
None => None,
};
Ok(Curve::BSpline(Box::new(BSplineCurve {
degree,
points,
weights,
knots,
multiplicities,
form: curve_form(base.get(3)),
closed: logical(base.get(4), "B-spline closed_curve").unwrap_or(Logical::Unknown),
self_intersect: logical(base.get(5), "B-spline self_intersect").unwrap_or(Logical::Unknown),
knot_spec,
})))
}
/// A surface entity.
pub fn surface(&mut self, id: u64) -> R<Arc<Surface>> {
self.surface_in(id, 0)
}
fn surface_in(&mut self, id: u64, depth: usize) -> R<Arc<Surface>> {
if let Some(s) = self.surfaces.get(&id) {
return Ok(s.clone());
}
if depth > MAX_GEOM_DEPTH {
return Err("surface definitions nested too deeply".into());
}
let s = Arc::new(self.read_surface(id, depth)?);
self.surfaces.insert(id, s.clone());
Ok(s)
}
fn read_surface(&mut self, id: u64, depth: usize) -> R<Surface> {
let e = entity(self.ex, id)?;
if e.is_complex() {
return self.bspline_surface(e);
}
let p = e.params();
let position = |r: &Self| r.placement(reference(p.get(1), "surface placement")?);
let positive = |x: f64, what: &str| if x > 0.0 { Ok(x) } else { Err(format!("{what} must be positive")) };
match e.name() {
"PLANE" => Ok(Surface::Plane { position: position(self)? }),
"CYLINDRICAL_SURFACE" => {
Ok(Surface::Cylinder { position: position(self)?, radius: positive(self.length(p.get(2), "radius")?, "cylinder radius")? })
}
"CONICAL_SURFACE" => {
let radius = self.length(p.get(2), "radius")?;
let semi_angle = self.angle(p.get(3), "semi angle")?;
if radius < 0.0 || !(semi_angle.abs() > 1e-12 && semi_angle.abs() < std::f64::consts::FRAC_PI_2 - 1e-12) {
return Err("cone with a negative radius or a semi angle outside (0, 90°)".into());
}
Ok(Surface::Cone { position: position(self)?, radius, semi_angle })
}
"SPHERICAL_SURFACE" => {
Ok(Surface::Sphere { position: position(self)?, radius: positive(self.length(p.get(2), "radius")?, "sphere radius")? })
}
"TOROIDAL_SURFACE" | "DEGENERATE_TOROIDAL_SURFACE" => {
let major_radius = self.length(p.get(2), "major radius")?;
let minor_radius = positive(self.length(p.get(3), "minor radius")?, "torus minor radius")?;
if major_radius < 0.0 {
return Err("torus major radius must not be negative".into());
}
let position = position(self)?;
if e.name() == "DEGENERATE_TOROIDAL_SURFACE" {
let select_outer = boolean(p.get(4), "degenerate torus select_outer")?;
Ok(Surface::DegenerateTorus { position, major_radius, minor_radius, select_outer })
} else {
Ok(Surface::Torus { position, major_radius, minor_radius })
}
}
"B_SPLINE_SURFACE_WITH_KNOTS" | "BEZIER_SURFACE" | "UNIFORM_SURFACE" | "QUASI_UNIFORM_SURFACE" => self.bspline_surface(e),
"SURFACE_OF_REVOLUTION" => {
let profile = self.curve_in(reference(p.get(1), "revolution profile")?, depth + 1)?;
let axis = self.axis1(reference(p.get(2), "revolution axis")?)?;
Ok(Surface::Revolution { profile, axis })
}
"SURFACE_OF_LINEAR_EXTRUSION" => {
let profile = self.curve_in(reference(p.get(1), "extrusion profile")?, depth + 1)?;
let l = self.units.len;
let (direction, magnitude) = self.vector_scaled(reference(p.get(2), "extrusion vector")?, [l, l, l], 3)?;
Ok(Surface::Extrusion { profile, direction, magnitude })
}
"OFFSET_SURFACE" => {
let basis = self.surface_in(reference(p.get(1), "offset basis")?, depth + 1)?;
let distance = self.length(p.get(2), "offset distance")?;
let self_intersect = logical(p.get(3), "offset self_intersect")?;
Ok(Surface::Offset { basis, distance, self_intersect })
}
"RECTANGULAR_TRIMMED_SURFACE" => {
let basis = self.surface_in(reference(p.get(1), "trimmed surface basis")?, depth + 1)?;
let (ku, kv) = Self::param_kinds(&basis);
let (fu, fv) = (self.factor(ku), self.factor(kv));
Ok(Surface::RectangularTrimmed {
u1: num(p.get(2), "u1")? * fu,
u2: num(p.get(3), "u2")? * fu,
v1: num(p.get(4), "v1")? * fv,
v2: num(p.get(5), "v2")? * fv,
u_sense: boolean(p.get(6), "usense")?,
v_sense: boolean(p.get(7), "vsense")?,
basis,
})
}
n => Err(format!("not supported yet: surface {n}")),
}
}
fn bspline_surface(&mut self, e: &Entity) -> R<Surface> {
let (base, with_knots) = bspline_params(e, "B_SPLINE_SURFACE", "B_SPLINE_SURFACE_WITH_KNOTS")?;
let (u_degree, v_degree) = (degree(base.get(1))?, degree(base.get(2))?);
let rows = base.get(3).and_then(Param::as_list).ok_or("B-spline surface without control points")?;
let mut points: Vec<Vec<P3>> = Vec::with_capacity(rows.len().min(MAX_CTRL));
let mut total = 0usize;
for r in rows {
let r = r.as_list().ok_or("bad control point row")?;
total = total.saturating_add(r.len());
if total > MAX_CTRL {
return Err("B-spline surface with too many control points".into());
}
points.push(r.iter().map(|c| self.point(reference(Some(c), "control point")?)).collect::<R<_>>()?);
}
let nu = points.len();
let nv = points.first().map(Vec::len).unwrap_or(0);
if nu == 0 || nv == 0 || points.iter().any(|r| r.len() != nv) {
return Err("ragged B-spline control net".into());
}
let ((u_knots, u_multiplicities), (v_knots, v_multiplicities), knot_spec) = match &with_knots {
Some(k) => (knots(k.first(), k.get(2), nu, u_degree)?, knots(k.get(1), k.get(3), nv, v_degree)?, knot_spec(k.get(4))),
None => {
let spec = spec_of_type(e);
(implied_knots(spec, nu, u_degree)?, implied_knots(spec, nv, v_degree)?, spec)
}
};
let weights = match e.record("RATIONAL_B_SPLINE_SURFACE") {
Some(r) => {
let w = r.first().and_then(Param::as_list).ok_or("rational surface without weights")?;
if w.len() != nu {
return Err("weights do not match the control net".into());
}
Some(w.iter().map(|row| weights(Some(row), nv)).collect::<R<_>>()?)
}
None => None,
};
Ok(Surface::BSpline(Box::new(BSplineSurface {
u_degree,
v_degree,
points,
weights,
u_knots,
u_multiplicities,
v_knots,
v_multiplicities,
form: surface_form(base.get(4)),
u_closed: logical(base.get(5), "u_closed").unwrap_or(Logical::Unknown),
v_closed: logical(base.get(6), "v_closed").unwrap_or(Logical::Unknown),
self_intersect: logical(base.get(7), "self_intersect").unwrap_or(Logical::Unknown),
knot_spec,
})))
}
}