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>
763 lines
34 KiB
Rust
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,
|
|
})))
|
|
}
|
|
}
|