Skip to content

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

Wave 13/509: STEP geometry as plain data: read and write ISO 10303-42 curves and surfaces without truck

Brennen Herbruck7f7358f9183e
diff --git a/Cargo.lock b/Cargo.lock
index d5273808bc..af4b1e2a3c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4367,6 +4367,7 @@ dependencies = [
"serde_json",
"solidcraft-geom",
"solidcraft-smlib",
+ "solidcraft-step",
"spade",
"thiserror 2.0.21",
"truck-meshalgo",
@@ -4426,6 +4427,10 @@ dependencies = [
"serde",
]
+[[package]]
+name = "solidcraft-step"
+version = "0.18.1"
+
[[package]]
name = "solidcraft-ui-egui"
version = "0.24.0"
diff --git a/Cargo.toml b/Cargo.toml
index 8bc9f6aa63..6cb6b73087 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,6 +19,7 @@ solidcraft-geom = { path = "crates/geom" }
solidcraft-sketch = { path = "crates/sketch" }
solidcraft-kernel = { path = "crates/kernel" }
solidcraft-smlib = { path = "crates/smlib" }
+solidcraft-step = { path = "crates/step" }
solidcraft-render = { path = "crates/render" }
solidcraft-gpu = { path = "crates/gpu" }
solidcraft-doc = { path = "crates/doc" }
diff --git a/crates/kernel/Cargo.toml b/crates/kernel/Cargo.toml
index 67fceb832e..4eee0553ec 100644
--- a/crates/kernel/Cargo.toml
+++ b/crates/kernel/Cargo.toml
@@ -16,6 +16,7 @@ smlib = ["dep:solidcraft-smlib", "solidcraft-smlib/native"]
[dependencies]
solidcraft-geom = { workspace = true }
solidcraft-smlib = { workspace = true, optional = true }
+solidcraft-step = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
diff --git a/crates/kernel/src/step_in/p21.rs b/crates/kernel/src/step_in/p21.rs
index e862774b3b..969606bd06 100644
--- a/crates/kernel/src/step_in/p21.rs
+++ b/crates/kernel/src/step_in/p21.rs
@@ -1,601 +1,20 @@
-//! ISO 10303-21 ("Part 21") exchange structure parser: the HEADER and the DATA section's entity
-//! instances, simple (`#1=NAME(...)`) and complex (`#2=(A(...) B(...))`). Written from the
-//! public standard. Input is hostile: sizes, entity counts and nesting depth are capped and every
-//! error is a message, never a panic.
+//! The Part 21 parser lives in `solidcraft-step`; this reads with the kernel's progress watch.
-use std::collections::HashMap;
+pub use solidcraft_step::p21::{Entity, Exchange, Param, Record};
-/// Largest STEP text we parse.
-pub const MAX_BYTES: usize = 512 << 20;
-/// Most entity instances in one file.
-pub const MAX_ENTITIES: usize = 20_000_000;
-/// Deepest parameter list nesting.
-const MAX_DEPTH: usize = 64;
+struct Watched(std::sync::Arc<dyn crate::watch::Watch>);
-/// A parameter value.
-#[derive(Clone, Debug, PartialEq)]
-pub enum Param {
- Int(i64),
- Real(f64),
- Str(String),
- /// `.NAME.` (`.T.`/`.F.` included).
- Enum(String),
- Ref(u64),
- List(Vec<Param>),
- /// `NAME(params)` (a typed value such as `LENGTH_MEASURE(1.)`).
- Typed(String, Vec<Param>),
- Binary(String),
- /// `$`
- Null,
- /// `*`
- Derived,
-}
-
-impl Param {
- pub fn as_f64(&self) -> Option<f64> {
- match self {
- Param::Real(x) => Some(*x).filter(|x| x.is_finite()),
- Param::Int(i) => Some(*i as f64),
- Param::Typed(_, v) if v.len() == 1 => v.first().and_then(Param::as_f64),
- _ => None,
- }
- }
- pub fn as_i64(&self) -> Option<i64> {
- match self {
- Param::Int(i) => Some(*i),
- Param::Real(x) if x.fract() == 0.0 && x.abs() < 9e15 => Some(*x as i64),
- _ => None,
- }
- }
- pub fn as_ref_id(&self) -> Option<u64> {
- match self {
- Param::Ref(r) => Some(*r),
- _ => None,
- }
- }
- pub fn as_str(&self) -> Option<&str> {
- match self {
- Param::Str(s) => Some(s),
- _ => None,
- }
- }
- pub fn as_enum(&self) -> Option<&str> {
- match self {
- Param::Enum(s) => Some(s),
- _ => None,
- }
- }
- /// `.T.` → true, `.F.` → false (`.U.` and anything else → None).
- pub fn as_bool(&self) -> Option<bool> {
- match self.as_enum()? {
- "T" => Some(true),
- "F" => Some(false),
- _ => None,
- }
- }
- pub fn as_list(&self) -> Option<&[Param]> {
- match self {
- Param::List(v) => Some(v),
- _ => None,
- }
- }
-}
-
-/// One record of an entity instance: a simple instance has one, a complex one several.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Record {
- pub name: String,
- pub params: Vec<Param>,
-}
-
-/// An entity instance.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Entity {
- pub records: Vec<Record>,
-}
-
-impl Entity {
- pub fn is_complex(&self) -> bool {
- self.records.len() > 1
- }
- /// Name of a simple instance (the first record of a complex one).
- pub fn name(&self) -> &str {
- self.records.first().map(|r| r.name.as_str()).unwrap_or("")
- }
- /// Parameters of the record called `name`.
- pub fn record(&self, name: &str) -> Option<&[Param]> {
- self.records.iter().find(|r| r.name == name).map(|r| r.params.as_slice())
- }
- pub fn has(&self, name: &str) -> bool {
- self.records.iter().any(|r| r.name == name)
- }
- /// Parameters of a simple instance.
- pub fn params(&self) -> &[Param] {
- self.records.first().map(|r| r.params.as_slice()).unwrap_or(&[])
- }
-}
-
-/// A parsed exchange file.
-#[derive(Clone, Debug, Default)]
-pub struct Exchange {
- /// FILE_SCHEMA names.
- pub schemas: Vec<String>,
- /// FILE_NAME originating system.
- pub originating_system: String,
- /// FILE_NAME preprocessor version.
- pub preprocessor: String,
- /// FILE_DESCRIPTION text, its lines joined by a space.
- pub description: String,
- pub entities: HashMap<u64, Entity>,
- /// Ids defined more than once (the first definition is kept).
- pub duplicates: Vec<u64>,
- /// [`Exchange::vertex_extent`], worked out on first use.
- extent: std::sync::OnceLock<f64>,
-}
-
-impl Exchange {
- pub fn get(&self, id: u64) -> Option<&Entity> {
- self.entities.get(&id)
+impl solidcraft_step::p21::Progress for Watched {
+ fn cancelled(&self) -> bool {
+ self.0.cancelled()
}
-
- /// The size of the model in the file's own coordinates: the diagonal of the box around every
- /// VERTEX_POINT (0 for a file without one). Non-finite coordinates are skipped.
- pub fn vertex_extent(&self) -> f64 {
- *self.extent.get_or_init(|| {
- let (mut lo, mut hi) = ([f64::INFINITY; 3], [f64::NEG_INFINITY; 3]);
- for e in self.entities.values().filter(|e| e.name() == "VERTEX_POINT") {
- let Some(p) = e.params().get(1).and_then(Param::as_ref_id).and_then(|id| self.get(id)) else { continue };
- let Some(xyz) = p.params().get(1).and_then(Param::as_list) else { continue };
- let c: Vec<f64> = xyz.iter().take(3).filter_map(Param::as_f64).collect();
- if c.len() != 3 || !c.iter().all(|x| x.is_finite()) {
- continue;
- }
- for ((l, h), x) in lo.iter_mut().zip(hi.iter_mut()).zip(c) {
- *l = l.min(x);
- *h = h.max(x);
- }
- }
- let d = lo.iter().zip(&hi).map(|(l, h)| (h - l).powi(2)).sum::<f64>().sqrt();
- if d.is_finite() { d } else { 0.0 }
- })
+ fn progress(&self, stage: &'static str, done: usize, total: usize) {
+ self.0.progress(stage, done, total);
}
}
-struct Lexer<'a> {
- s: &'a [u8],
- i: usize,
-}
-
-fn err<T>(msg: impl Into<String>) -> Result<T, String> {
- Err(msg.into())
-}
-
-impl<'a> Lexer<'a> {
- fn line(&self) -> usize {
- self.s.get(..self.i).map(|b| b.iter().filter(|c| **c == b'\n').count() + 1).unwrap_or(0)
- }
- fn fail<T>(&self, msg: &str) -> Result<T, String> {
- err(format!("STEP syntax error at line {}: {msg}", self.line()))
- }
- fn peek(&self) -> Option<u8> {
- self.s.get(self.i).copied()
- }
- /// Skip whitespace and comments.
- fn ws(&mut self) -> Result<(), String> {
- loop {
- match self.peek() {
- Some(c) if c.is_ascii_whitespace() => self.i += 1,
- Some(b'/') if self.s.get(self.i + 1) == Some(&b'*') => {
- let rest = self.s.get(self.i + 2..).unwrap_or(&[]);
- match rest.windows(2).position(|w| w == b"*/") {
- Some(p) => self.i += p + 4,
- None => return self.fail("unterminated comment"),
- }
- }
- _ => return Ok(()),
- }
- }
- }
- fn eat(&mut self, c: u8) -> Result<bool, String> {
- self.ws()?;
- if self.peek() == Some(c) {
- self.i += 1;
- Ok(true)
- } else {
- Ok(false)
- }
- }
- fn expect(&mut self, c: u8) -> Result<(), String> {
- if self.eat(c)? { Ok(()) } else { self.fail(&format!("expected `{}`", c as char)) }
- }
- fn keyword(&mut self) -> Result<String, String> {
- self.ws()?;
- let st = self.i;
- if self.peek() == Some(b'!') {
- self.i += 1;
- }
- while let Some(c) = self.peek() {
- if c.is_ascii_alphanumeric() || c == b'_' || c == b'-' {
- self.i += 1;
- } else {
- break;
- }
- }
- if self.i == st {
- return self.fail("expected a keyword");
- }
- Ok(String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).to_ascii_uppercase())
- }
- fn number(&mut self) -> Result<Param, String> {
- let st = self.i;
- while let Some(c) = self.peek() {
- if c.is_ascii_digit() || matches!(c, b'+' | b'-' | b'.' | b'E' | b'e') {
- self.i += 1;
- } else {
- break;
- }
- }
- let t = std::str::from_utf8(self.s.get(st..self.i).unwrap_or(&[])).unwrap_or("");
- if !t.contains(['.', 'E', 'e'])
- && let Ok(i) = t.parse::<i64>()
- {
- return Ok(Param::Int(i));
- }
- // STEP allows `1.` and `1.E-3`.
- let fixed = t.replace(".E", ".0E").replace(".e", ".0e");
- let fixed = if fixed.ends_with('.') { format!("{fixed}0") } else { fixed };
- match fixed.parse::<f64>() {
- Ok(x) => Ok(Param::Real(x)),
- Err(_) => self.fail(&format!("bad number `{t}`")),
- }
- }
- fn string(&mut self) -> Result<String, String> {
- // Opening quote consumed by the caller.
- let mut raw = Vec::new();
- loop {
- match self.peek() {
- None => return self.fail("unterminated string"),
- Some(b'\'') => {
- if self.s.get(self.i + 1) == Some(&b'\'') {
- raw.push(b'\'');
- self.i += 2;
- } else {
- self.i += 1;
- break;
- }
- }
- Some(b'\n') | Some(b'\r') => self.i += 1,
- Some(c) => {
- raw.push(c);
- self.i += 1;
- }
- }
- }
- Ok(decode_string(&raw))
- }
- fn param(&mut self, depth: usize) -> Result<Param, String> {
- if depth > MAX_DEPTH {
- return self.fail("parameters nested too deeply");
- }
- self.ws()?;
- let Some(c) = self.peek() else { return self.fail("unexpected end of file") };
- match c {
- b'$' => {
- self.i += 1;
- Ok(Param::Null)
- }
- b'*' => {
- self.i += 1;
- Ok(Param::Derived)
- }
- b'\'' => {
- self.i += 1;
- Ok(Param::Str(self.string()?))
- }
- b'"' => {
- self.i += 1;
- let st = self.i;
- while self.peek().is_some_and(|c| c != b'"') {
- self.i += 1;
- }
- let v = String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).to_string();
- self.expect(b'"')?;
- Ok(Param::Binary(v))
- }
- b'#' => {
- self.i += 1;
- let st = self.i;
- while self.peek().is_some_and(|c| c.is_ascii_digit()) {
- self.i += 1;
- }
- let t = std::str::from_utf8(self.s.get(st..self.i).unwrap_or(&[])).unwrap_or("");
- t.parse::<u64>().map(Param::Ref).or_else(|_| self.fail("bad entity reference"))
- }
- b'.' if self.s.get(self.i + 1).is_some_and(|c| c.is_ascii_alphabetic() || *c == b'_') => {
- self.i += 1;
- let st = self.i;
- while self.peek().is_some_and(|c| c != b'.') {
- self.i += 1;
- }
- let v = String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).trim().to_ascii_uppercase();
- self.expect(b'.')?;
- Ok(Param::Enum(v))
- }
- b'(' => {
- self.i += 1;
- Ok(Param::List(self.list_rest(depth + 1)?))
- }
- c if c.is_ascii_digit() || matches!(c, b'+' | b'-' | b'.') => self.number(),
- c if c.is_ascii_alphabetic() || c == b'!' => {
- let name = self.keyword()?;
- self.expect(b'(')?;
- Ok(Param::Typed(name, self.list_rest(depth + 1)?))
- }
- _ => self.fail(&format!("unexpected `{}`", c as char)),
- }
- }
- /// Parameters after an opening `(` up to and including the `)`.
- fn list_rest(&mut self, depth: usize) -> Result<Vec<Param>, String> {
- let mut v = Vec::new();
- if self.eat(b')')? {
- return Ok(v);
- }
- loop {
- v.push(self.param(depth)?);
- if self.eat(b',')? {
- continue;
- }
- self.expect(b')')?;
- return Ok(v);
- }
- }
- fn record(&mut self) -> Result<Record, String> {
- let name = self.keyword()?;
- self.expect(b'(')?;
- Ok(Record { name, params: self.list_rest(1)? })
- }
-}
-
-/// Decode the Part 21 string escapes (`\X\hh`, `\X2\…\X0\`, `\X4\…\X0\`, `\S\c`, `\\`).
-fn decode_string(raw: &[u8]) -> String {
- let mut out = String::new();
- let mut i = 0;
- let hex = |b: &[u8]| std::str::from_utf8(b).ok().and_then(|t| u32::from_str_radix(t, 16).ok());
- while let Some(&c) = raw.get(i) {
- if c == b'\\' {
- let rest = raw.get(i..).unwrap_or(&[]);
- if rest.starts_with(b"\\\\") {
- out.push('\\');
- i += 2;
- continue;
- }
- if rest.starts_with(b"\\X\\")
- && let Some(v) = rest.get(3..5).and_then(hex)
- {
- out.push(char::from_u32(v).unwrap_or('?'));
- i += 5;
- continue;
- }
- let mut run = false;
- for (tag, width) in [(&b"\\X2\\"[..], 4usize), (&b"\\X4\\"[..], 8)] {
- if rest.starts_with(tag)
- && let Some(end) = rest.windows(4).position(|w| w == b"\\X0\\")
- {
- let body = rest.get(4..end).unwrap_or(&[]);
- let units: Vec<u32> = body.chunks(width).filter_map(hex).collect();
- if width == 4 {
- let u16s: Vec<u16> = units.iter().map(|u| *u as u16).collect();
- out.push_str(&String::from_utf16_lossy(&u16s));
- } else {
- out.extend(units.iter().map(|u| char::from_u32(*u).unwrap_or('?')));
- }
- i += end + 4;
- run = true;
- break;
- }
- }
- // A run may be followed straight away by the backslash of the next escape (#2344).
- if run {
- continue;
- }
- if rest.starts_with(b"\\S\\")
- && let Some(&ch) = rest.get(3)
- {
- out.push(char::from_u32(ch as u32 + 128).unwrap_or('?'));
- i += 4;
- continue;
- }
- out.push('\\');
- i += 1;
- continue;
- }
- // Plain bytes: keep UTF-8 runs intact.
- let st = i;
- while raw.get(i).is_some_and(|c| *c != b'\\') {
- i += 1;
- }
- out.push_str(&String::from_utf8_lossy(raw.get(st..i).unwrap_or(&[])));
- }
- out
-}
-
-/// Parse a Part 21 file.
+/// [`solidcraft_step::p21::parse`] under the current [`crate::watch`].
pub fn parse(text: &str) -> Result<Exchange, String> {
- if text.len() > MAX_BYTES {
- return err(format!("STEP file too large ({} MB, limit {} MB)", text.len() >> 20, MAX_BYTES >> 20));
- }
- let mut lx = Lexer { s: text.as_bytes(), i: 0 };
- let magic = lx.keyword()?;
- if magic != "ISO-10303-21" {
- return err("not a STEP file (no ISO-10303-21 header)");
- }
- lx.expect(b';')?;
- let mut ex = Exchange::default();
- let watch = crate::watch::current();
- loop {
- lx.ws()?;
- if lx.peek().is_none() {
- return err("STEP file ends without END-ISO-10303-21");
- }
- let kw = lx.keyword()?;
- match kw.as_str() {
- "HEADER" => {
- lx.expect(b';')?;
- loop {
- let k = lx.keyword()?;
- if k == "ENDSEC" {
- lx.expect(b';')?;
- break;
- }
- lx.expect(b'(')?;
- let params = lx.list_rest(1)?;
- lx.expect(b';')?;
- match k.as_str() {
- "FILE_SCHEMA" => {
- if let Some(Param::List(v)) = params.first() {
- ex.schemas = v.iter().filter_map(|p| p.as_str().map(str::to_string)).collect();
- }
- }
- "FILE_DESCRIPTION" => {
- if let Some(Param::List(v)) = params.first() {
- ex.description = v.iter().filter_map(|p| p.as_str()).collect::<Vec<_>>().join(" ");
- }
- }
- "FILE_NAME" => {
- ex.preprocessor = params.get(4).and_then(Param::as_str).unwrap_or("").to_string();
- ex.originating_system = params.get(5).and_then(Param::as_str).unwrap_or("").to_string();
- }
- _ => {}
- }
- }
- }
- "DATA" => {
- // Optional `DATA('name', ('schema'));`
- if lx.eat(b'(')? {
- lx.list_rest(1)?;
- }
- lx.expect(b';')?;
- loop {
- lx.ws()?;
- if lx.peek() != Some(b'#') {
- let k = lx.keyword()?;
- if k == "ENDSEC" {
- lx.expect(b';')?;
- break;
- }
- return lx.fail(&format!("unexpected `{k}` in DATA"));
- }
- lx.i += 1;
- let st = lx.i;
- while lx.peek().is_some_and(|c| c.is_ascii_digit()) {
- lx.i += 1;
- }
- let id: u64 = match std::str::from_utf8(lx.s.get(st..lx.i).unwrap_or(&[])).ok().and_then(|t| t.parse().ok()) {
- Some(id) => id,
- None => return lx.fail("bad entity id"),
- };
- lx.expect(b'=')?;
- let records = if lx.eat(b'(')? {
- let mut rs = Vec::new();
- while !lx.eat(b')')? {
- if rs.len() > 64 {
- return lx.fail("complex entity with too many parts");
- }
- rs.push(lx.record()?);
- }
- rs
- } else {
- vec![lx.record()?]
- };
- lx.expect(b';')?;
- if ex.entities.len() % 4096 == 0
- && let Some(w) = &watch
- {
- if w.cancelled() {
- return err("STEP import cancelled");
- }
- w.progress("reading", lx.i, lx.s.len());
- }
- if ex.entities.len() >= MAX_ENTITIES {
- return err(format!("STEP file has more than {MAX_ENTITIES} entities"));
- }
- // A duplicate id is invalid; some writers emit them for geometry nobody
- // reads. Keep the first definition and report it.
- match ex.entities.entry(id) {
- std::collections::hash_map::Entry::Occupied(_) => ex.duplicates.push(id),
- std::collections::hash_map::Entry::Vacant(v) => {
- v.insert(Entity { records });
- }
- }
- }
- }
- "END-ISO-10303-21" => {
- lx.expect(b';')?;
- return Ok(ex);
- }
- // ANCHOR / REFERENCE / SIGNATURE sections (Part 21 edition 3): skip to ENDSEC.
- "ANCHOR" | "REFERENCE" | "SIGNATURE" => {
- let rest = lx.s.get(lx.i..).unwrap_or(&[]);
- match rest.windows(7).position(|w| w == b"ENDSEC;") {
- Some(p) => lx.i += p + 7,
- None => return lx.fail("unterminated section"),
- }
- }
- _ => return lx.fail(&format!("unexpected `{kw}`")),
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn parses_simple_and_complex() {
- let t = "ISO-10303-21;\nHEADER;FILE_DESCRIPTION((''),'2;1');\nFILE_NAME('a','',(''),(''),'','sys','');\nFILE_SCHEMA(('AUTOMOTIVE_DESIGN'));ENDSEC;\nDATA;\n#1=CARTESIAN_POINT('p',(0.,1.5E1,-2));\n/* c */ #2=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));\n#3=X('it''s','\\X2\\00E9\\X0\\',$,#1,LENGTH_MEASURE(1.E-3),\"0F\");\nENDSEC;\nEND-ISO-10303-21;\n";
- let ex = parse(t).unwrap();
- assert_eq!(ex.schemas, vec!["AUTOMOTIVE_DESIGN"]);
- assert_eq!(ex.originating_system, "sys");
- let p = ex.get(1).unwrap();
- assert_eq!(p.name(), "CARTESIAN_POINT");
- let xyz: Vec<f64> = p.params()[1].as_list().unwrap().iter().filter_map(Param::as_f64).collect();
- assert_eq!(xyz, vec![0.0, 15.0, -2.0]);
- let u = ex.get(2).unwrap();
- assert!(u.is_complex() && u.has("SI_UNIT"));
- assert_eq!(u.record("SI_UNIT").unwrap()[0].as_enum(), Some("MILLI"));
- let x = ex.get(3).unwrap().params();
- assert_eq!(x[0].as_str(), Some("it's"));
- assert_eq!(x[1].as_str(), Some("\u{e9}"));
- assert_eq!(x[2], Param::Null);
- assert_eq!(x[3].as_ref_id(), Some(1));
- assert_eq!(x[4].as_f64(), Some(1e-3));
- }
-
- #[test]
- fn hostile_text_is_an_error() {
- for t in [
- "",
- "garbage",
- "ISO-10303-21;",
- "ISO-10303-21;DATA;#1=A(",
- "ISO-10303-21;DATA;#1=A('x",
- "ISO-10303-21;DATA;#1=A(/*",
- "ISO-10303-21;DATA;#=A();ENDSEC;END-ISO-10303-21;",
- "ISO-10303-21;DATA;#99999999999999999999999=A();ENDSEC;END-ISO-10303-21;",
- "ISO-10303-21;DATA;#1=A(1e999999.);ENDSEC;END-ISO-10303-21;",
- ] {
- let _ = parse(t);
- }
- let deep = format!("ISO-10303-21;DATA;#1=A({}{});ENDSEC;END-ISO-10303-21;", "(".repeat(10_000), ")".repeat(10_000));
- assert!(parse(&deep).is_err());
- let dup = parse("ISO-10303-21;DATA;#1=A(1);#1=B();ENDSEC;END-ISO-10303-21;").unwrap();
- assert_eq!(dup.duplicates, vec![1]);
- assert_eq!(dup.get(1).unwrap().name(), "A");
- assert_eq!(decode_string(b"\\X\\E9"), "\u{e9}");
- assert_eq!(decode_string(b"a\\X2\\00E900E8\\X0\\b"), "a\u{e9}\u{e8}b");
- assert_eq!(decode_string(b"\\"), "\\");
- // One run per character, as `step_out` writes them (#2344).
- assert_eq!(decode_string(b"\\X2\\5706\\X0\\\\X2\\89D2\\X0\\20"), "\u{5706}\u{89d2}20");
- assert_eq!(decode_string(b"\\X4\\0001F600\\X0\\\\X2\\00E9\\X0\\\\S\\a"), "\u{1f600}\u{e9}\u{e1}");
- }
+ let watch = crate::watch::current().map(Watched);
+ solidcraft_step::p21::parse_with(text, watch.as_ref().map(|w| w as &dyn solidcraft_step::p21::Progress))
}
diff --git a/crates/step/Cargo.toml b/crates/step/Cargo.toml
new file mode 100644
index 0000000000..e92b2635d7
--- /dev/null
+++ b/crates/step/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "solidcraft-step"
+description = "SolidCraft STEP (ISO 10303) exchange: the Part 21 exchange structure and Part 42 geometry as plain data, with no modelling backend"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[lints]
+workspace = true
diff --git a/crates/step/src/eval.rs b/crates/step/src/eval.rs
new file mode 100644
index 0000000000..b55eba4102
--- /dev/null
+++ b/crates/step/src/eval.rs
@@ -0,0 +1,193 @@
+//! Points on STEP curves and surfaces, in STEP's own parameterisation (ISO 10303-42), so tests
+//! and the topology reader can check that vertices lie on their curves. `None` for a parameter
+//! the geometry is not defined at, or for geometry too inconsistent to evaluate.
+
+use crate::geom::{BSplineCurve, BSplineSurface, Curve, P3, Surface, add, cross, dot, norm, scale, sub};
+
+/// Every knot repeated by its multiplicity.
+fn expanded(knots: &[f64], mults: &[usize]) -> Option<Vec<f64>> {
+ if knots.len() != mults.len() {
+ return None;
+ }
+ let total = mults.iter().try_fold(0usize, |a, m| a.checked_add(*m))?;
+ let mut v = Vec::with_capacity(total);
+ for (k, m) in knots.iter().zip(mults) {
+ v.extend(std::iter::repeat_n(*k, *m));
+ }
+ Some(v)
+}
+
+/// Index `i` of the knot span `[U[i], U[i+1])` holding `t`, with `degree <= i < n` for `n`
+/// control points (the last span takes the domain's upper end).
+fn span(u: &[f64], degree: usize, n: usize, t: f64) -> Option<usize> {
+ let lo = *u.get(degree)?;
+ let hi = *u.get(n)?;
+ if !(t >= lo - 1e-12 * (1.0 + lo.abs()) && t <= hi + 1e-12 * (1.0 + hi.abs())) {
+ return None;
+ }
+ let mut i = degree;
+ while i + 1 < n && *u.get(i + 1)? <= t {
+ i += 1;
+ }
+ Some(i)
+}
+
+/// De Boor on homogeneous points `[x·w, y·w, z·w, w]`.
+fn de_boor(u: &[f64], degree: usize, ctrl: &[[f64; 4]], t: f64) -> Option<[f64; 4]> {
+ let k = span(u, degree, ctrl.len(), t)?;
+ let mut d: Vec<[f64; 4]> = (0..=degree).map(|j| ctrl.get(j + k - degree).copied()).collect::<Option<_>>()?;
+ for r in 1..=degree {
+ for j in (r..=degree).rev() {
+ let i = j + k - degree;
+ let a = *u.get(i)?;
+ let b = *u.get(i + 1 + degree - r)?;
+ let alpha = if b - a > 0.0 { (t - a) / (b - a) } else { 0.0 };
+ let p = *d.get(j - 1)?;
+ let q = *d.get(j)?;
+ *d.get_mut(j)? = [0, 1, 2, 3].map(|c| (1.0 - alpha) * p[c] + alpha * q[c]);
+ }
+ }
+ d.get(degree).copied()
+}
+
+fn from_homogeneous(h: [f64; 4]) -> Option<P3> {
+ (h[3].abs() > 1e-300).then(|| [h[0] / h[3], h[1] / h[3], h[2] / h[3]]).filter(|p| p.iter().all(|x| x.is_finite()))
+}
+
+fn homogeneous(p: P3, w: f64) -> [f64; 4] {
+ [p[0] * w, p[1] * w, p[2] * w, w]
+}
+
+impl BSplineCurve {
+ /// Parameter range: from knot `degree` to knot `n` of the expanded knot vector.
+ pub fn domain(&self) -> Option<(f64, f64)> {
+ let u = expanded(&self.knots, &self.multiplicities)?;
+ Some((*u.get(self.degree)?, *u.get(self.points.len())?))
+ }
+ pub fn point(&self, t: f64) -> Option<P3> {
+ let u = expanded(&self.knots, &self.multiplicities)?;
+ if u.len() != self.points.len() + self.degree + 1 {
+ return None;
+ }
+ let ctrl: Vec<[f64; 4]> = match &self.weights {
+ Some(w) if w.len() == self.points.len() => self.points.iter().zip(w).map(|(p, w)| homogeneous(*p, *w)).collect(),
+ Some(_) => return None,
+ None => self.points.iter().map(|p| homogeneous(*p, 1.0)).collect(),
+ };
+ from_homogeneous(de_boor(&u, self.degree, &ctrl, t)?)
+ }
+}
+
+impl BSplineSurface {
+ pub fn point(&self, s: f64, t: f64) -> Option<P3> {
+ let uk = expanded(&self.u_knots, &self.u_multiplicities)?;
+ let vk = expanded(&self.v_knots, &self.v_multiplicities)?;
+ let nu = self.points.len();
+ let nv = self.points.first()?.len();
+ if uk.len() != nu + self.u_degree + 1 || vk.len() != nv + self.v_degree + 1 {
+ return None;
+ }
+ // Each u row evaluated along v, then the column of results along u.
+ let mut column = Vec::with_capacity(nu);
+ for (i, row) in self.points.iter().enumerate() {
+ if row.len() != nv {
+ return None;
+ }
+ let ctrl: Vec<[f64; 4]> = match &self.weights {
+ Some(w) => {
+ let w = w.get(i).filter(|w| w.len() == nv)?;
+ row.iter().zip(w).map(|(p, w)| homogeneous(*p, *w)).collect()
+ }
+ None => row.iter().map(|p| homogeneous(*p, 1.0)).collect(),
+ };
+ column.push(de_boor(&vk, self.v_degree, &ctrl, t)?);
+ }
+ from_homogeneous(de_boor(&uk, self.u_degree, &column, s)?)
+ }
+}
+
+impl Curve {
+ /// The point at parameter `t`.
+ pub fn point(&self, t: f64) -> Option<P3> {
+ self.point_at(t, 0)
+ }
+
+ fn point_at(&self, t: f64, depth: usize) -> Option<P3> {
+ if depth > 16 || !t.is_finite() {
+ return None;
+ }
+ let p = match self {
+ Curve::Line { origin, direction, magnitude } => add(*origin, scale(*direction, t * magnitude)),
+ Curve::Circle { position, radius } => position.at(radius * t.cos(), radius * t.sin(), 0.0),
+ Curve::Ellipse { position, semi_axis_1, semi_axis_2 } => position.at(semi_axis_1 * t.cos(), semi_axis_2 * t.sin(), 0.0),
+ Curve::Hyperbola { position, semi_axis, semi_imag_axis } => position.at(semi_axis * t.cosh(), semi_imag_axis * t.sinh(), 0.0),
+ Curve::Parabola { position, focal_dist } => position.at(focal_dist * t * t, 2.0 * focal_dist * t, 0.0),
+ Curve::BSpline(b) => b.point(t)?,
+ Curve::Polyline(pts) => {
+ if pts.len() < 2 || t < 0.0 || t > (pts.len() - 1) as f64 {
+ return None;
+ }
+ let i = (t.floor() as usize).min(pts.len() - 2);
+ let (a, b) = (*pts.get(i)?, *pts.get(i + 1)?);
+ add(a, scale(sub(b, a), t - i as f64))
+ }
+ Curve::Trimmed { basis, .. } => basis.point_at(t, depth + 1)?,
+ Curve::SurfaceCurve { curve_3d, .. } => curve_3d.point_at(t, depth + 1)?,
+ // Needs the basis curve's derivative; not evaluated yet.
+ Curve::OffsetCurve3d { .. } => return None,
+ };
+ p.iter().all(|x| x.is_finite()).then_some(p)
+ }
+}
+
+impl Surface {
+ /// The point at parameters `(u, v)`.
+ pub fn point(&self, u: f64, v: f64) -> Option<P3> {
+ self.point_at(u, v, 0)
+ }
+
+ /// The unit normal `∂S/∂u × ∂S/∂v` at `(u, v)`, by central differences.
+ pub fn normal(&self, u: f64, v: f64) -> Option<P3> {
+ self.normal_at(u, v, 0)
+ }
+
+ fn normal_at(&self, u: f64, v: f64, depth: usize) -> Option<P3> {
+ let h = 1e-6;
+ let du = sub(self.point_at(u + h, v, depth)?, self.point_at(u - h, v, depth)?);
+ let dv = sub(self.point_at(u, v + h, depth)?, self.point_at(u, v - h, depth)?);
+ let n = cross(du, dv);
+ let m = norm(n);
+ (m > 1e-30 && m.is_finite()).then(|| scale(n, 1.0 / m))
+ }
+
+ fn point_at(&self, u: f64, v: f64, depth: usize) -> Option<P3> {
+ if depth > 16 || !u.is_finite() || !v.is_finite() {
+ return None;
+ }
+ let p = match self {
+ Surface::Plane { position } => position.at(u, v, 0.0),
+ Surface::Cylinder { position, radius } => position.at(radius * u.cos(), radius * u.sin(), v),
+ Surface::Cone { position, radius, semi_angle } => {
+ let r = radius + v * semi_angle.tan();
+ position.at(r * u.cos(), r * u.sin(), v)
+ }
+ Surface::Sphere { position, radius } => position.at(radius * v.cos() * u.cos(), radius * v.cos() * u.sin(), radius * v.sin()),
+ Surface::Torus { position, major_radius, minor_radius } | Surface::DegenerateTorus { position, major_radius, minor_radius, .. } => {
+ let r = major_radius + minor_radius * v.cos();
+ position.at(r * u.cos(), r * u.sin(), minor_radius * v.sin())
+ }
+ Surface::BSpline(b) => b.point(u, v)?,
+ Surface::Revolution { profile, axis } => {
+ // Rodrigues: the profile point turned by u about the axis.
+ let q = sub(profile.point_at(v, depth + 1)?, axis.origin);
+ let k = axis.direction;
+ let (s, c) = u.sin_cos();
+ add(axis.origin, add(add(scale(q, c), scale(cross(k, q), s)), scale(k, dot(k, q) * (1.0 - c))))
+ }
+ Surface::Extrusion { profile, direction, magnitude } => add(profile.point_at(u, depth + 1)?, scale(*direction, v * magnitude)),
+ Surface::Offset { basis, distance, .. } => add(basis.point_at(u, v, depth + 1)?, scale(basis.normal_at(u, v, depth + 1)?, *distance)),
+ Surface::RectangularTrimmed { basis, .. } => basis.point_at(u, v, depth + 1)?,
+ };
+ p.iter().all(|x| x.is_finite()).then_some(p)
+ }
+}
diff --git a/crates/step/src/geom.rs b/crates/step/src/geom.rs
new file mode 100644
index 0000000000..25844f764c
--- /dev/null
+++ b/crates/step/src/geom.rs
@@ -0,0 +1,307 @@
+//! STEP geometry (ISO 10303-42) as plain data: the curves and surfaces a file defines, exactly
+//! as it defines them, in millimetres and radians. Nothing is approximated, bounded or turned
+//! into another kind on the way in: a circle stays a circle with its placement, an unbounded
+//! cylinder stays unbounded, and a B-spline keeps its own knots and form. Every curve and surface
+//! keeps STEP's own parameterisation, so a 2D curve in a surface's parameter space means the same
+//! thing here as in the file (SMLib's `SmSTEPSurface` evaluates the same parameterisation, with
+//! angles in degrees where we use radians).
+//!
+//! Entities the file shares (one surface under many edges' pcurves) are shared here too, through
+//! `Arc`, so reading is linear in the file however often an entity is referenced.
+
+use std::sync::Arc;
+
+/// A point or vector.
+pub type P3 = [f64; 3];
+
+/// AXIS2_PLACEMENT_3D (or _2D, with `axis` = +Z): an origin and two orthogonal unit directions.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Placement {
+ pub origin: P3,
+ /// Local Z.
+ pub axis: P3,
+ /// Local X (`ref_direction`, made orthogonal to `axis`).
+ pub ref_direction: P3,
+}
+
+impl Placement {
+ /// Local Y (`axis` × `ref_direction`).
+ pub fn y(&self) -> P3 {
+ cross(self.axis, self.ref_direction)
+ }
+ /// `origin + x·X + y·Y + z·Z`.
+ pub fn at(&self, x: f64, y: f64, z: f64) -> P3 {
+ let yy = self.y();
+ add(self.origin, add(scale(self.ref_direction, x), add(scale(yy, y), scale(self.axis, z))))
+ }
+}
+
+/// AXIS1_PLACEMENT: an origin and a unit direction.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Axis1 {
+ pub origin: P3,
+ pub direction: P3,
+}
+
+/// A STEP LOGICAL.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Logical {
+ True,
+ False,
+ Unknown,
+}
+
+/// `b_spline_curve_form`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CurveForm {
+ PolylineForm,
+ CircularArc,
+ EllipticArc,
+ ParabolicArc,
+ HyperbolicArc,
+ Unspecified,
+}
+
+/// `b_spline_surface_form`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SurfaceForm {
+ PlaneSurf,
+ CylindricalSurf,
+ ConicalSurf,
+ SphericalSurf,
+ ToroidalSurf,
+ SurfOfRevolution,
+ RuledSurf,
+ GeneralisedCone,
+ QuadricSurf,
+ SurfOfLinearExtrusion,
+ Unspecified,
+}
+
+/// `knot_type`. A curve given without knots (BEZIER_CURVE, UNIFORM_CURVE, QUASI_UNIFORM_CURVE)
+/// has them worked out on reading, and keeps the matching type here.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum KnotSpec {
+ UniformKnots,
+ QuasiUniformKnots,
+ PiecewiseBezierKnots,
+ Unspecified,
+}
+
+/// A B-spline curve: distinct knots with their multiplicities, as STEP writes them.
+#[derive(Clone, Debug, PartialEq)]
+pub struct BSplineCurve {
+ pub degree: usize,
+ pub points: Vec<P3>,
+ /// Present for a rational curve, one positive weight per point.
+ pub weights: Option<Vec<f64>>,
+ pub knots: Vec<f64>,
+ pub multiplicities: Vec<usize>,
+ pub form: CurveForm,
+ pub closed: Logical,
+ pub self_intersect: Logical,
+ pub knot_spec: KnotSpec,
+}
+
+/// A B-spline surface; `points[i][j]` runs along u with `i`, along v with `j`.
+#[derive(Clone, Debug, PartialEq)]
+pub struct BSplineSurface {
+ pub u_degree: usize,
+ pub v_degree: usize,
+ pub points: Vec<Vec<P3>>,
+ pub weights: Option<Vec<Vec<f64>>>,
+ pub u_knots: Vec<f64>,
+ pub u_multiplicities: Vec<usize>,
+ pub v_knots: Vec<f64>,
+ pub v_multiplicities: Vec<usize>,
+ pub form: SurfaceForm,
+ pub u_closed: Logical,
+ pub v_closed: Logical,
+ pub self_intersect: Logical,
+ pub knot_spec: KnotSpec,
+}
+
+/// One end of a TRIMMED_CURVE: a point on the basis curve, its parameter, or both.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Trim {
+ Point(P3),
+ Parameter(f64),
+}
+
+/// `trimming_preference`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TrimPreference {
+ Cartesian,
+ Parameter,
+ Unspecified,
+}
+
+/// `preferred_surface_curve_representation`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PreferredRep {
+ Curve3d,
+ PcurveS1,
+ PcurveS2,
+}
+
+/// Which SURFACE_CURVE subtype.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SurfaceCurveKind {
+ Surface,
+ Seam,
+ Intersection,
+ BoundedSurface,
+}
+
+/// PCURVE: a 2D curve in the parameter space of `surface`. Its coordinates are the surface's
+/// own parameters (lengths in mm, angles in radians).
+#[derive(Clone, Debug, PartialEq)]
+pub struct Pcurve {
+ pub surface: Arc<Surface>,
+ /// A 2D curve: every point and placement has z = 0 and every placement axis is +Z.
+ pub curve: Arc<Curve>,
+}
+
+/// An item of a SURFACE_CURVE's `associated_geometry`.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Associated {
+ Pcurve(Pcurve),
+ Surface(Arc<Surface>),
+}
+
+/// A STEP curve.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Curve {
+ /// `origin + t·magnitude·direction`.
+ Line {
+ origin: P3,
+ direction: P3,
+ magnitude: f64,
+ },
+ /// Parameter: the angle from `ref_direction`.
+ Circle {
+ position: Placement,
+ radius: f64,
+ },
+ Ellipse {
+ position: Placement,
+ semi_axis_1: f64,
+ semi_axis_2: f64,
+ },
+ /// `origin + a·cosh t·X + b·sinh t·Y`.
+ Hyperbola {
+ position: Placement,
+ semi_axis: f64,
+ semi_imag_axis: f64,
+ },
+ /// `origin + f·t²·X + 2f·t·Y`.
+ Parabola {
+ position: Placement,
+ focal_dist: f64,
+ },
+ BSpline(Box<BSplineCurve>),
+ /// Segment `i` (from 0) is the parameters `[i, i + 1]`.
+ Polyline(Vec<P3>),
+ Trimmed {
+ basis: Arc<Curve>,
+ trim_1: Vec<Trim>,
+ trim_2: Vec<Trim>,
+ sense: bool,
+ preference: TrimPreference,
+ },
+ SurfaceCurve {
+ kind: SurfaceCurveKind,
+ curve_3d: Arc<Curve>,
+ associated: Vec<Associated>,
+ master: PreferredRep,
+ },
+ OffsetCurve3d {
+ basis: Arc<Curve>,
+ distance: f64,
+ self_intersect: Logical,
+ ref_direction: P3,
+ },
+}
+
+/// A STEP surface.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Surface {
+ /// `origin + u·X + v·Y`.
+ Plane {
+ position: Placement,
+ },
+ /// `origin + r·(cos u·X + sin u·Y) + v·Z`.
+ Cylinder {
+ position: Placement,
+ radius: f64,
+ },
+ /// `origin + (r + v·tan a)·(cos u·X + sin u·Y) + v·Z`.
+ Cone {
+ position: Placement,
+ radius: f64,
+ semi_angle: f64,
+ },
+ /// `origin + r·cos v·(cos u·X + sin u·Y) + r·sin v·Z`.
+ Sphere {
+ position: Placement,
+ radius: f64,
+ },
+ /// `origin + (R + r·cos v)·(cos u·X + sin u·Y) + r·sin v·Z`.
+ Torus {
+ position: Placement,
+ major_radius: f64,
+ minor_radius: f64,
+ },
+ /// A torus whose minor radius reaches the axis; `select_outer` keeps the outer part.
+ DegenerateTorus {
+ position: Placement,
+ major_radius: f64,
+ minor_radius: f64,
+ select_outer: bool,
+ },
+ BSpline(Box<BSplineSurface>),
+ /// The profile at `v` turned by the angle `u` about the axis.
+ Revolution {
+ profile: Arc<Curve>,
+ axis: Axis1,
+ },
+ /// `profile(u) + v·magnitude·direction`.
+ Extrusion {
+ profile: Arc<Curve>,
+ direction: P3,
+ magnitude: f64,
+ },
+ Offset {
+ basis: Arc<Surface>,
+ distance: f64,
+ self_intersect: Logical,
+ },
+ RectangularTrimmed {
+ basis: Arc<Surface>,
+ u1: f64,
+ u2: f64,
+ v1: f64,
+ v2: f64,
+ u_sense: bool,
+ v_sense: bool,
+ },
+}
+
+pub(crate) fn add(a: P3, b: P3) -> P3 {
+ [a[0] + b[0], a[1] + b[1], a[2] + b[2]]
+}
+pub(crate) fn sub(a: P3, b: P3) -> P3 {
+ [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
+}
+pub(crate) fn scale(a: P3, s: f64) -> P3 {
+ [a[0] * s, a[1] * s, a[2] * s]
+}
+pub(crate) fn dot(a: P3, b: P3) -> f64 {
+ a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+}
+pub(crate) fn cross(a: P3, b: P3) -> P3 {
+ [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
+}
+pub(crate) fn norm(a: P3) -> f64 {
+ dot(a, a).sqrt()
+}
diff --git a/crates/step/src/geom_tests.rs b/crates/step/src/geom_tests.rs
new file mode 100644
index 0000000000..244aa2aee7
--- /dev/null
+++ b/crates/step/src/geom_tests.rs
@@ -0,0 +1,492 @@
+//! STEP geometry, one entity at a time: reading (values, units, evaluation in STEP's own
+//! parameterisation), writing, and read → write → read round trips. Expected values are
+//! analytic.
+
+use std::f64::consts::{FRAC_PI_2, FRAC_PI_4, PI};
+use std::sync::Arc;
+
+use crate::geom::{Associated, Curve, CurveForm, KnotSpec, Logical, P3, PreferredRep, Surface, SurfaceCurveKind, Trim};
+use crate::p21::{self, Exchange};
+use crate::read::{Reader, Units};
+use crate::write::{GeomWriter, Writer, real};
+
+const MM: Units = Units { len: 1.0, ang: 1.0 };
+
+fn file(data: &str) -> Exchange {
+ let t = format!("ISO-10303-21;\nHEADER;FILE_SCHEMA(('AUTOMOTIVE_DESIGN'));ENDSEC;\nDATA;\n{data}\nENDSEC;\nEND-ISO-10303-21;\n");
+ match p21::parse(&t) {
+ Ok(ex) => ex,
+ Err(e) => panic!("{e}\n{t}"),
+ }
+}
+
+/// Common entities: #1 origin, #2 +Z, #3 +X, #4 the world placement, #5 +Y.
+const BASE: &str = "#1=CARTESIAN_POINT('',(0.,0.,0.));#2=DIRECTION('',(0.,0.,1.));#3=DIRECTION('',(1.,0.,0.));\
+#4=AXIS2_PLACEMENT_3D('',#1,#2,#3);#5=DIRECTION('',(0.,1.,0.));";
+
+fn curve(data: &str, id: u64, units: Units) -> Arc<Curve> {
+ let ex = file(&format!("{BASE}{data}"));
+ match Reader::new(&ex, units).curve(id) {
+ Ok(c) => c,
+ Err(e) => panic!("{e}"),
+ }
+}
+
+fn surface(data: &str, id: u64, units: Units) -> Arc<Surface> {
+ let ex = file(&format!("{BASE}{data}"));
+ match Reader::new(&ex, units).surface(id) {
+ Ok(s) => s,
+ Err(e) => panic!("{e}"),
+ }
+}
+
+fn close(a: P3, b: P3) -> bool {
+ a.iter().zip(b).all(|(x, y)| (x - y).abs() <= 1e-9 * (1.0 + y.abs()))
+}
+
+#[track_caller]
+fn at_curve(c: &Curve, t: f64, want: P3) {
+ let got = c.point(t);
+ assert!(got.is_some_and(|g| close(g, want)), "at {t}: got {got:?}, want {want:?}");
+}
+
+#[track_caller]
+fn at_surface(s: &Surface, u: f64, v: f64, want: P3) {
+ let got = s.point(u, v);
+ assert!(got.is_some_and(|g| close(g, want)), "at ({u}, {v}): got {got:?}, want {want:?}");
+}
+
+/// Writes a curve or surface, reads it back, writes it again: the second file must equal the
+/// first, and the geometry read back must evaluate like the original.
+fn round_trip_curve(c: &Curve, params: &[f64]) {
+ let mut w = Writer::new();
+ let id = GeomWriter::new(&mut w).curve(c);
+ let text = w.file("t", "AUTOMOTIVE_DESIGN");
+ let ex = p21::parse(&text).unwrap_or_else(|e| panic!("{e}\n{text}"));
+ let back = Reader::new(&ex, MM).curve(id).unwrap_or_else(|e| panic!("{e}\n{text}"));
+ assert_eq!(std::mem::discriminant(c), std::mem::discriminant(&*back), "{text}");
+ for &t in params {
+ let (a, b) = (c.point(t), back.point(t));
+ assert!(matches!((a, b), (Some(a), Some(b)) if close(a, b)) || (a.is_none() && b.is_none()), "at {t}: {a:?} vs {b:?}\n{text}");
+ }
+ let mut w2 = Writer::new();
+ GeomWriter::new(&mut w2).curve(&back);
+ assert_eq!(w2.data(), w.data(), "a second write differs");
+}
+
+fn round_trip_surface(s: &Surface, params: &[(f64, f64)]) {
+ let mut w = Writer::new();
+ let id = GeomWriter::new(&mut w).surface(s);
+ let text = w.file("t", "AUTOMOTIVE_DESIGN");
+ let ex = p21::parse(&text).unwrap_or_else(|e| panic!("{e}\n{text}"));
+ let back = Reader::new(&ex, MM).surface(id).unwrap_or_else(|e| panic!("{e}\n{text}"));
+ assert_eq!(std::mem::discriminant(s), std::mem::discriminant(&*back), "{text}");
+ for &(u, v) in params {
+ let (a, b) = (s.point(u, v), back.point(u, v));
+ assert!(matches!((a, b), (Some(a), Some(b)) if close(a, b)), "at ({u}, {v}): {a:?} vs {b:?}\n{text}");
+ }
+ let mut w2 = Writer::new();
+ GeomWriter::new(&mut w2).surface(&back);
+ assert_eq!(w2.data(), w.data(), "a second write differs");
+}
+
+const TS: [f64; 5] = [0.0, 0.3, 1.0, FRAC_PI_2, 2.5];
+const UVS: [(f64, f64); 4] = [(0.0, 0.0), (0.4, 0.2), (FRAC_PI_2, 1.0), (2.0, -0.5)];
+
+#[test]
+fn line() {
+ let c = curve("#10=CARTESIAN_POINT('',(1.,2.,3.));#11=VECTOR('',#3,5.);#12=LINE('',#10,#11);", 12, MM);
+ assert!(matches!(*c, Curve::Line { magnitude, .. } if magnitude == 5.0));
+ at_curve(&c, 2.0, [11.0, 2.0, 3.0]);
+ round_trip_curve(&c, &TS);
+}
+
+#[test]
+fn circle_and_ellipse() {
+ let c = curve("#10=CIRCLE('',#4,10.);", 10, MM);
+ at_curve(&c, 0.0, [10.0, 0.0, 0.0]);
+ at_curve(&c, FRAC_PI_2, [0.0, 10.0, 0.0]);
+ round_trip_curve(&c, &TS);
+ let e = curve("#10=ELLIPSE('',#4,10.,4.);", 10, MM);
+ at_curve(&e, FRAC_PI_2, [0.0, 4.0, 0.0]);
+ at_curve(&e, PI, [-10.0, 0.0, 0.0]);
+ round_trip_curve(&e, &TS);
+}
+
+#[test]
+fn hyperbola_and_parabola() {
+ let h = curve("#10=HYPERBOLA('',#4,2.,3.);", 10, MM);
+ at_curve(&h, 1.0, [2.0 * 1f64.cosh(), 3.0 * 1f64.sinh(), 0.0]);
+ round_trip_curve(&h, &TS);
+ let p = curve("#10=PARABOLA('',#4,0.5);", 10, MM);
+ at_curve(&p, 2.0, [2.0, 2.0, 0.0]);
+ round_trip_curve(&p, &TS);
+}
+
+#[test]
+fn bspline_curve_with_knots() {
+ // A quadratic Bézier from (0,0) through control (1,2) to (2,0): its middle is (1, 1).
+ let c = curve(
+ "#10=CARTESIAN_POINT('',(0.,0.,0.));#11=CARTESIAN_POINT('',(1.,2.,0.));#12=CARTESIAN_POINT('',(2.,0.,0.));\
+ #13=B_SPLINE_CURVE_WITH_KNOTS('',2,(#10,#11,#12),.UNSPECIFIED.,.F.,.F.,(3,3),(0.,1.),.PIECEWISE_BEZIER_KNOTS.);",
+ 13,
+ MM,
+ );
+ let Curve::BSpline(b) = &*c else { panic!("{c:?}") };
+ assert_eq!((b.degree, b.multiplicities.clone(), b.knot_spec), (2, vec![3, 3], KnotSpec::PiecewiseBezierKnots));
+ assert_eq!(b.domain(), Some((0.0, 1.0)));
+ at_curve(&c, 0.5, [1.0, 1.0, 0.0]);
+ round_trip_curve(&c, &[0.0, 0.25, 0.5, 1.0]);
+}
+
+#[test]
+fn rational_bspline_curve_is_an_exact_quarter_circle() {
+ let w = std::f64::consts::FRAC_1_SQRT_2;
+ let c = curve(
+ &format!(
+ "#10=CARTESIAN_POINT('',(1.,0.,0.));#11=CARTESIAN_POINT('',(1.,1.,0.));#12=CARTESIAN_POINT('',(0.,1.,0.));\
+ #13=(BOUNDED_CURVE()B_SPLINE_CURVE(2,(#10,#11,#12),.CIRCULAR_ARC.,.F.,.F.)B_SPLINE_CURVE_WITH_KNOTS((3,3),(0.,1.),.UNSPECIFIED.)\
+ CURVE()GEOMETRIC_REPRESENTATION_ITEM()RATIONAL_B_SPLINE_CURVE((1.,{},1.))REPRESENTATION_ITEM(''));",
+ real(w)
+ ),
+ 13,
+ MM,
+ );
+ let Curve::BSpline(b) = &*c else { panic!("{c:?}") };
+ assert_eq!(b.form, CurveForm::CircularArc);
+ assert!(b.weights.is_some());
+ for t in [0.1, 0.5, 0.9] {
+ let p = c.point(t).unwrap_or_default();
+ assert!((p[0].hypot(p[1]) - 1.0).abs() < 1e-12, "{p:?}");
+ }
+ round_trip_curve(&c, &[0.0, 0.3, 0.7, 1.0]);
+}
+
+#[test]
+fn implied_knots_and_repeated_knots() {
+ let pts = "#10=CARTESIAN_POINT('',(0.,0.,0.));#11=CARTESIAN_POINT('',(1.,1.,0.));#12=CARTESIAN_POINT('',(2.,0.,0.));#13=CARTESIAN_POINT('',(3.,1.,0.));";
+ let q = curve(&format!("{pts}#14=QUASI_UNIFORM_CURVE('',2,(#10,#11,#12,#13),.UNSPECIFIED.,.F.,.F.);"), 14, MM);
+ let Curve::BSpline(b) = &*q else { panic!("{q:?}") };
+ assert_eq!((b.knots.clone(), b.multiplicities.clone()), (vec![0.0, 1.0, 2.0], vec![3, 1, 3]));
+ at_curve(&q, 0.0, [0.0, 0.0, 0.0]);
+ at_curve(&q, 2.0, [3.0, 1.0, 0.0]);
+ let bez = curve(&format!("{pts}#14=BEZIER_CURVE('',3,(#10,#11,#12,#13),.UNSPECIFIED.,.F.,.F.);"), 14, MM);
+ let Curve::BSpline(b) = &*bez else { panic!("{bez:?}") };
+ assert_eq!((b.knots.clone(), b.multiplicities.clone()), (vec![0.0, 1.0], vec![4, 4]));
+ // A knot written twice is one knot.
+ let rep = curve(
+ &format!("{pts}#14=B_SPLINE_CURVE_WITH_KNOTS('',2,(#10,#11,#12,#13),.UNSPECIFIED.,.F.,.F.,(3,1,1,2),(0.,1.,1.,2.),.UNSPECIFIED.);"),
+ 14,
+ MM,
+ );
+ let Curve::BSpline(b) = &*rep else { panic!("{rep:?}") };
+ assert_eq!((b.knots.clone(), b.multiplicities.clone()), (vec![0.0, 1.0, 2.0], vec![3, 2, 2]));
+ assert_eq!(b.domain(), Some((0.0, 1.0)));
+ round_trip_curve(&rep, &[0.0, 0.5, 1.0]);
+}
+
+#[test]
+fn polyline_and_trimmed_curve() {
+ let pl = curve(
+ "#10=CARTESIAN_POINT('',(0.,0.,0.));#11=CARTESIAN_POINT('',(4.,0.,0.));#12=CARTESIAN_POINT('',(4.,2.,0.));#13=POLYLINE('',(#10,#11,#12));",
+ 13,
+ MM,
+ );
+ at_curve(&pl, 0.5, [2.0, 0.0, 0.0]);
+ at_curve(&pl, 1.5, [4.0, 1.0, 0.0]);
+ round_trip_curve(&pl, &[0.0, 0.5, 1.0, 1.5, 2.0]);
+ // A circle trimmed in degrees: the parameters become radians.
+ let deg = Units { len: 1.0, ang: PI / 180.0 };
+ let t = curve(
+ "#10=CIRCLE('',#4,10.);#11=CARTESIAN_POINT('',(10.,0.,0.));#12=TRIMMED_CURVE('',#10,(#11,PARAMETER_VALUE(0.)),(PARAMETER_VALUE(90.)),.T.,.PARAMETER.);",
+ 12,
+ deg,
+ );
+ let Curve::Trimmed { trim_1, trim_2, sense, .. } = &*t else { panic!("{t:?}") };
+ assert_eq!(trim_1.first(), Some(&Trim::Point([10.0, 0.0, 0.0])));
+ assert!(matches!(trim_2.first(), Some(Trim::Parameter(a)) if (a - FRAC_PI_2).abs() < 1e-15));
+ assert!(*sense);
+ round_trip_curve(&t, &TS);
+}
+
+#[test]
+fn surface_curve_with_pcurves_shares_its_surface() {
+ // A seam on a cylinder of radius 5: the line x = 5 with pcurves u = 0 on both sides.
+ let c = curve(
+ "#10=CYLINDRICAL_SURFACE('',#4,5.);#11=CARTESIAN_POINT('',(5.,0.,0.));#12=VECTOR('',#2,1.);#13=LINE('',#11,#12);\
+ #20=CARTESIAN_POINT('',(0.,0.));#21=DIRECTION('',(0.,1.));#22=VECTOR('',#21,1.);#23=LINE('',#20,#22);\
+ #24=(GEOMETRIC_REPRESENTATION_CONTEXT(2)PARAMETRIC_REPRESENTATION_CONTEXT()REPRESENTATION_CONTEXT('2D SPACE',''));\
+ #25=DEFINITIONAL_REPRESENTATION('',(#23),#24);#26=PCURVE('',#10,#25);\
+ #27=CARTESIAN_POINT('',(6.28318530717959,0.));#28=LINE('',#27,#22);#29=DEFINITIONAL_REPRESENTATION('',(#28),#24);#30=PCURVE('',#10,#29);\
+ #31=SEAM_CURVE('',#13,(#26,#30),.PCURVE_S1.);",
+ 31,
+ MM,
+ );
+ let Curve::SurfaceCurve { kind, associated, master, curve_3d } = &*c else { panic!("{c:?}") };
+ assert_eq!((*kind, *master), (SurfaceCurveKind::Seam, PreferredRep::PcurveS1));
+ at_curve(curve_3d, 3.0, [5.0, 0.0, 3.0]);
+ let [Associated::Pcurve(a), Associated::Pcurve(b)] = associated.as_slice() else { panic!("{associated:?}") };
+ assert!(Arc::ptr_eq(&a.surface, &b.surface), "one surface entity, read once");
+ // Each pcurve, lifted onto the surface, is the 3D curve.
+ for t in [0.0, 2.0] {
+ for pc in [a, b] {
+ let uv = pc.curve.point(t).unwrap_or_default();
+ let p = pc.surface.point(uv[0], uv[1]).unwrap_or_default();
+ assert!(close(p, curve_3d.point(t).unwrap_or_default()), "{p:?}");
+ }
+ }
+ round_trip_curve(&c, &[0.0, 1.0, 4.0]);
+}
+
+#[test]
+fn pcurves_scale_with_the_surface_parameters() {
+ // Inches and degrees: a cylinder pcurve's u is an angle, v a length.
+ let units = Units { len: 25.4, ang: PI / 180.0 };
+ let c = curve(
+ "#10=CYLINDRICAL_SURFACE('',#4,1.);#11=CARTESIAN_POINT('',(1.,0.,0.));#12=VECTOR('',#2,1.);#13=LINE('',#11,#12);\
+ #20=CARTESIAN_POINT('',(90.,0.));#21=DIRECTION('',(0.,1.));#22=VECTOR('',#21,1.);#23=LINE('',#20,#22);\
+ #24=(GEOMETRIC_REPRESENTATION_CONTEXT(2)PARAMETRIC_REPRESENTATION_CONTEXT()REPRESENTATION_CONTEXT('2D SPACE',''));\
+ #25=DEFINITIONAL_REPRESENTATION('',(#23),#24);#26=PCURVE('',#10,#25);#27=SURFACE_CURVE('',#13,(#26),.CURVE_3D.);",
+ 27,
+ units,
+ );
+ let Curve::SurfaceCurve { associated, .. } = &*c else { panic!("{c:?}") };
+ let Some(Associated::Pcurve(pc)) = associated.first() else { panic!("{associated:?}") };
+ let uv = pc.curve.point(2.0).unwrap_or_default();
+ assert!((uv[0] - FRAC_PI_2).abs() < 1e-12 && (uv[1] - 2.0 * 25.4).abs() < 1e-9, "{uv:?}");
+ at_surface(&pc.surface, uv[0], uv[1], [0.0, 25.4, 50.8]);
+}
+
+#[test]
+fn analytic_surfaces() {
+ let p = surface("#10=PLANE('',#4);", 10, MM);
+ at_surface(&p, 2.0, 3.0, [2.0, 3.0, 0.0]);
+ round_trip_surface(&p, &UVS);
+ let c = surface("#10=CYLINDRICAL_SURFACE('',#4,5.);", 10, MM);
+ at_surface(&c, FRAC_PI_2, 7.0, [0.0, 5.0, 7.0]);
+ round_trip_surface(&c, &UVS);
+ let k = surface("#10=CONICAL_SURFACE('',#4,5.,0.785398163397448);", 10, MM);
+ at_surface(&k, 0.0, 2.0, [7.0, 0.0, 2.0]);
+ round_trip_surface(&k, &UVS);
+ let s = surface("#10=SPHERICAL_SURFACE('',#4,3.);", 10, MM);
+ at_surface(&s, 0.0, FRAC_PI_2, [0.0, 0.0, 3.0]);
+ at_surface(&s, PI, 0.0, [-3.0, 0.0, 0.0]);
+ round_trip_surface(&s, &UVS);
+ let t = surface("#10=TOROIDAL_SURFACE('',#4,10.,2.);", 10, MM);
+ at_surface(&t, FRAC_PI_2, PI, [0.0, 8.0, 0.0]);
+ round_trip_surface(&t, &UVS);
+ let d = surface("#10=DEGENERATE_TOROIDAL_SURFACE('',#4,1.,2.,.T.);", 10, MM);
+ assert!(matches!(*d, Surface::DegenerateTorus { select_outer: true, .. }));
+ round_trip_surface(&d, &UVS);
+}
+
+#[test]
+fn units_scale_lengths_and_angles() {
+ let units = Units { len: 25.4, ang: PI / 180.0 };
+ let k = surface("#10=CONICAL_SURFACE('',#4,1.,45.);", 10, units);
+ let Surface::Cone { radius, semi_angle, .. } = *k else { panic!("{k:?}") };
+ assert!((radius - 25.4).abs() < 1e-12 && (semi_angle - FRAC_PI_4).abs() < 1e-15);
+ let c = curve("#10=CARTESIAN_POINT('',(1.,0.,0.));#11=VECTOR('',#3,2.);#12=LINE('',#10,#11);", 12, units);
+ at_curve(&c, 1.0, [76.2, 0.0, 0.0]);
+}
+
+#[test]
+fn placement_axes_are_made_orthonormal() {
+ // A reference direction not perpendicular to the axis is projected; the axis is unit.
+ let s = surface("#10=DIRECTION('',(0.,0.,2.));#11=DIRECTION('',(1.,0.,1.));#12=AXIS2_PLACEMENT_3D('',#1,#10,#11);#13=PLANE('',#12);", 13, MM);
+ let Surface::Plane { position } = *s else { panic!("{s:?}") };
+ assert_eq!((position.axis, position.ref_direction), ([0.0, 0.0, 1.0], [1.0, 0.0, 0.0]));
+}
+
+#[test]
+fn bspline_surfaces() {
+ // A bilinear patch over the unit square, then the same as a rational complex entity.
+ let pts = "#10=CARTESIAN_POINT('',(0.,0.,0.));#11=CARTESIAN_POINT('',(0.,1.,0.));#12=CARTESIAN_POINT('',(1.,0.,0.));#13=CARTESIAN_POINT('',(1.,1.,1.));";
+ let s = surface(
+ &format!(
+ "{pts}#14=B_SPLINE_SURFACE_WITH_KNOTS('',1,1,((#10,#11),(#12,#13)),.UNSPECIFIED.,.F.,.F.,.F.,(2,2),(2,2),(0.,1.),(0.,1.),.UNSPECIFIED.);"
+ ),
+ 14,
+ MM,
+ );
+ at_surface(&s, 0.5, 0.5, [0.5, 0.5, 0.25]);
+ at_surface(&s, 1.0, 0.0, [1.0, 0.0, 0.0]);
+ round_trip_surface(&s, &[(0.0, 0.0), (0.3, 0.7), (1.0, 1.0)]);
+ let r = surface(
+ &format!(
+ "{pts}#14=(BOUNDED_SURFACE()B_SPLINE_SURFACE(1,1,((#10,#11),(#12,#13)),.UNSPECIFIED.,.F.,.F.,.F.)\
+ B_SPLINE_SURFACE_WITH_KNOTS((2,2),(2,2),(0.,1.),(0.,1.),.UNSPECIFIED.)GEOMETRIC_REPRESENTATION_ITEM()\
+ RATIONAL_B_SPLINE_SURFACE(((1.,1.),(1.,1.)))REPRESENTATION_ITEM('')SURFACE());"
+ ),
+ 14,
+ MM,
+ );
+ let Surface::BSpline(b) = &*r else { panic!("{r:?}") };
+ assert!(b.weights.is_some());
+ at_surface(&r, 0.5, 0.5, [0.5, 0.5, 0.25]);
+ round_trip_surface(&r, &[(0.0, 0.0), (0.3, 0.7), (1.0, 1.0)]);
+}
+
+#[test]
+fn swept_surfaces() {
+ // A circle of radius 2 about the Z axis, centred at x = 10: revolved, a torus.
+ let rev = surface(
+ "#10=CARTESIAN_POINT('',(10.,0.,0.));#11=AXIS2_PLACEMENT_3D('',#10,#5,#3);#12=CIRCLE('',#11,2.);\
+ #13=AXIS1_PLACEMENT('',#1,#2);#14=SURFACE_OF_REVOLUTION('',#12,#13);",
+ 14,
+ MM,
+ );
+ at_surface(&rev, 0.0, 0.0, [12.0, 0.0, 0.0]);
+ at_surface(&rev, FRAC_PI_2, 0.0, [0.0, 12.0, 0.0]);
+ round_trip_surface(&rev, &UVS);
+ let ext = surface("#10=CIRCLE('',#4,3.);#11=VECTOR('',#2,4.);#12=SURFACE_OF_LINEAR_EXTRUSION('',#10,#11);", 12, MM);
+ at_surface(&ext, FRAC_PI_2, 0.5, [0.0, 3.0, 2.0]);
+ round_trip_surface(&ext, &UVS);
+}
+
+#[test]
+fn offset_and_trimmed_surfaces() {
+ let o = surface("#10=CYLINDRICAL_SURFACE('',#4,5.);#11=OFFSET_SURFACE('',#10,1.5,.F.);", 11, MM);
+ at_surface(&o, 0.0, 1.0, [6.5, 0.0, 1.0]);
+ round_trip_surface(&o, &UVS);
+ let deg = Units { len: 1.0, ang: PI / 180.0 };
+ let t = surface("#10=CYLINDRICAL_SURFACE('',#4,5.);#11=RECTANGULAR_TRIMMED_SURFACE('',#10,0.,90.,0.,10.,.T.,.T.);", 11, deg);
+ let Surface::RectangularTrimmed { u2, v2, .. } = *t else { panic!("{t:?}") };
+ assert!((u2 - FRAC_PI_2).abs() < 1e-15 && v2 == 10.0, "{u2} {v2}");
+ round_trip_surface(&t, &UVS);
+}
+
+#[test]
+fn offset_curve_reads_and_round_trips() {
+ let c = curve("#10=CIRCLE('',#4,10.);#11=OFFSET_CURVE_3D('',#10,1.,.F.,#2);", 11, MM);
+ assert!(matches!(*c, Curve::OffsetCurve3d { distance, self_intersect: Logical::False, .. } if distance == 1.0));
+ round_trip_curve(&c, &[]);
+}
+
+#[test]
+fn shared_entities_are_written_once() {
+ let c = Arc::new(Curve::Circle {
+ position: crate::geom::Placement { origin: [0.0; 3], axis: [0.0, 0.0, 1.0], ref_direction: [1.0, 0.0, 0.0] },
+ radius: 1.0,
+ });
+ let mut w = Writer::new();
+ let mut g = GeomWriter::new(&mut w);
+ let a = g.curve(&c);
+ let b = g.curve(&c);
+ assert_eq!(a, b);
+ // Point, two directions, placement, circle.
+ assert_eq!(w.len(), 5);
+}
+
+#[test]
+fn hostile_geometry_is_an_error_never_a_panic() {
+ let cases = [
+ "#10=CIRCLE('',#4,-1.);",
+ "#10=CIRCLE('',#99,1.);",
+ "#10=CIRCLE('',#4,1.E300);",
+ "#10=LINE('',#1,#1);",
+ "#10=DIRECTION('',(0.,0.,0.));#11=VECTOR('',#10,1.);#12=LINE('',#1,#11);",
+ "#10=B_SPLINE_CURVE_WITH_KNOTS('',2,(#1,#1),.UNSPECIFIED.,.F.,.F.,(3,3),(0.,1.),.UNSPECIFIED.);",
+ "#10=B_SPLINE_CURVE_WITH_KNOTS('',99,(#1,#1),.UNSPECIFIED.,.F.,.F.,(1,1),(0.,1.),.UNSPECIFIED.);",
+ "#10=B_SPLINE_CURVE_WITH_KNOTS('',1,(#1,#1),.UNSPECIFIED.,.F.,.F.,(4000000000000,1),(0.,1.),.UNSPECIFIED.);",
+ "#10=B_SPLINE_CURVE_WITH_KNOTS('',1,(#1,#1),.UNSPECIFIED.,.F.,.F.,(2,2),(1.,0.),.UNSPECIFIED.);",
+ "#10=(B_SPLINE_CURVE(1,(#1,#1),.UNSPECIFIED.,.F.,.F.)B_SPLINE_CURVE_WITH_KNOTS((2,2),(0.,1.),.UNSPECIFIED.)RATIONAL_B_SPLINE_CURVE((1.,-1.)));",
+ "#10=TRIMMED_CURVE('',#10,(PARAMETER_VALUE(0.)),(PARAMETER_VALUE(1.)),.T.,.PARAMETER.);",
+ "#10=SURFACE_CURVE('',#10,(),.CURVE_3D.);",
+ "#10=POLYLINE('',(#1));",
+ "#10=UNKNOWN_CURVE('');",
+ ];
+ for c in cases {
+ let ex = file(&format!("{BASE}{c}"));
+ assert!(Reader::new(&ex, MM).curve(10).is_err(), "{c}");
+ }
+ let surfaces = [
+ "#10=CYLINDRICAL_SURFACE('',#4,0.);",
+ "#10=CONICAL_SURFACE('',#4,1.,2.);",
+ "#10=TOROIDAL_SURFACE('',#4,1.,-2.);",
+ "#10=OFFSET_SURFACE('',#10,1.,.F.);",
+ "#10=B_SPLINE_SURFACE_WITH_KNOTS('',1,1,((#1,#1),(#1)),.UNSPECIFIED.,.F.,.F.,.F.,(2,2),(2,2),(0.,1.),(0.,1.),.UNSPECIFIED.);",
+ "#10=SURFACE_OF_REVOLUTION('',#10,#4);",
+ "#10=PLANE('',#3);",
+ ];
+ for s in surfaces {
+ let ex = file(&format!("{BASE}{s}"));
+ assert!(Reader::new(&ex, MM).surface(10).is_err(), "{s}");
+ }
+}
+
+/// Every edge curve and face surface of every STEP file in `SOLIDCRAFT_STEP_CORPUS` (the
+/// tangency-labs/models files): read, written, read back. Run with `--ignored`.
+#[test]
+#[ignore = "needs SOLIDCRAFT_STEP_CORPUS"]
+fn corpus_geometry_reads_and_round_trips() {
+ 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 mut failed = 0;
+ 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 t0 = std::time::Instant::now();
+ let ex = p21::parse(&text).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
+ let mut reader = Reader::new(&ex, MM);
+ let (mut curves, mut surfaces) = (Vec::new(), Vec::new());
+ let mut errors: std::collections::BTreeMap<String, usize> = Default::default();
+ let mut ids: Vec<u64> = ex.entities.keys().copied().collect();
+ ids.sort_unstable();
+ for id in ids {
+ let Some(e) = ex.get(id) else { continue };
+ let (r, is_curve) = match e.name() {
+ "EDGE_CURVE" => (e.params().get(3).and_then(p21::Param::as_ref_id), true),
+ "ADVANCED_FACE" | "FACE_SURFACE" => (e.params().get(2).and_then(p21::Param::as_ref_id), false),
+ _ => continue,
+ };
+ let Some(r) = r else { continue };
+ let got = if is_curve { reader.curve(r).map(|c| curves.push(c)) } else { reader.surface(r).map(|s| surfaces.push(s)) };
+ if let Err(e) = got {
+ *errors.entry(e).or_default() += 1;
+ }
+ }
+ let read = t0.elapsed();
+ let mut w = Writer::new();
+ let mut g = GeomWriter::new(&mut w);
+ let cids: Vec<u64> = curves.iter().map(|c| g.curve(c)).collect();
+ let sids: Vec<u64> = surfaces.iter().map(|s| g.surface(s)).collect();
+ let out = w.file("corpus", "AUTOMOTIVE_DESIGN");
+ let back = p21::parse(&out).unwrap_or_else(|e| panic!("{}: written file: {e}", path.display()));
+ let mut again = Reader::new(&back, MM);
+ let mut mismatched = 0;
+ for (c, id) in curves.iter().zip(&cids) {
+ match again.curve(*id) {
+ Ok(b)
+ if (0..=4).map(|i| i as f64 * 0.25).all(|t| match (c.point(t), b.point(t)) {
+ (Some(x), Some(y)) => close(x, y),
+ (x, y) => x.is_none() && y.is_none(),
+ }) => {}
+ _ => mismatched += 1,
+ }
+ }
+ for (s, id) in surfaces.iter().zip(&sids) {
+ match again.surface(*id) {
+ Ok(b)
+ if [(0.0, 0.0), (0.3, 0.6)].iter().all(|&(u, v)| match (s.point(u, v), b.point(u, v)) {
+ (Some(x), Some(y)) => close(x, y),
+ (x, y) => x.is_none() && y.is_none(),
+ }) => {}
+ _ => mismatched += 1,
+ }
+ }
+ let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+ println!(
+ "{name}: {} edge curves, {} face surfaces read in {:.0} ms; {} unread; {mismatched} differ after a round trip",
+ curves.len(),
+ surfaces.len(),
+ read.as_secs_f64() * 1e3,
+ errors.values().sum::<usize>()
+ );
+ for (e, n) in &errors {
+ println!(" {n} × {e}");
+ }
+ failed += mismatched + errors.values().sum::<usize>();
+ }
+ assert_eq!(failed, 0);
+}
diff --git a/crates/step/src/lib.rs b/crates/step/src/lib.rs
new file mode 100644
index 0000000000..2d66f20e8d
--- /dev/null
+++ b/crates/step/src/lib.rs
@@ -0,0 +1,16 @@
+//! STEP (ISO 10303) for SolidCraft, independent of any modelling backend. [`p21`] reads the
+//! exchange structure, [`read`] turns its geometry entities into the plain curves and surfaces
+//! of [`geom`], and [`write`] writes them back. Written from the public ISO 10303-21 and -42
+//! specifications. Topology (vertices to solids) builds on the kernel-neutral B-rep and comes
+//! next.
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+#![forbid(unsafe_code)]
+
+mod eval;
+pub mod geom;
+pub mod p21;
+pub mod read;
+pub mod write;
+
+#[cfg(test)]
+mod geom_tests;
diff --git a/crates/step/src/p21.rs b/crates/step/src/p21.rs
new file mode 100644
index 0000000000..add33a46c3
--- /dev/null
+++ b/crates/step/src/p21.rs
@@ -0,0 +1,580 @@
+//! ISO 10303-21 ("Part 21") exchange structure parser: the HEADER and the DATA section's entity
+//! instances, simple (`#1=NAME(...)`) and complex (`#2=(A(...) B(...))`). Written from the
+//! public standard. Input is hostile: sizes, entity counts and nesting depth are capped and every
+//! error is a message, never a panic.
+
+use std::collections::HashMap;
+
+/// Largest STEP text we parse.
+pub const MAX_BYTES: usize = 512 << 20;
+/// Most entity instances in one file.
+pub const MAX_ENTITIES: usize = 20_000_000;
+/// Deepest parameter list nesting.
+const MAX_DEPTH: usize = 64;
+
+/// A parameter value.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Param {
+ Int(i64),
+ Real(f64),
+ Str(String),
+ /// `.NAME.` (`.T.`/`.F.` included).
+ Enum(String),
+ Ref(u64),
+ List(Vec<Param>),
+ /// `NAME(params)` (a typed value such as `LENGTH_MEASURE(1.)`).
+ Typed(String, Vec<Param>),
+ Binary(String),
+ /// `$`
+ Null,
+ /// `*`
+ Derived,
+}
+
+impl Param {
+ pub fn as_f64(&self) -> Option<f64> {
+ match self {
+ Param::Real(x) => Some(*x).filter(|x| x.is_finite()),
+ Param::Int(i) => Some(*i as f64),
+ Param::Typed(_, v) if v.len() == 1 => v.first().and_then(Param::as_f64),
+ _ => None,
+ }
+ }
+ pub fn as_i64(&self) -> Option<i64> {
+ match self {
+ Param::Int(i) => Some(*i),
+ Param::Real(x) if x.fract() == 0.0 && x.abs() < 9e15 => Some(*x as i64),
+ _ => None,
+ }
+ }
+ pub fn as_ref_id(&self) -> Option<u64> {
+ match self {
+ Param::Ref(r) => Some(*r),
+ _ => None,
+ }
+ }
+ pub fn as_str(&self) -> Option<&str> {
+ match self {
+ Param::Str(s) => Some(s),
+ _ => None,
+ }
+ }
+ pub fn as_enum(&self) -> Option<&str> {
+ match self {
+ Param::Enum(s) => Some(s),
+ _ => None,
+ }
+ }
+ /// `.T.` → true, `.F.` → false (`.U.` and anything else → None).
+ pub fn as_bool(&self) -> Option<bool> {
+ match self.as_enum()? {
+ "T" => Some(true),
+ "F" => Some(false),
+ _ => None,
+ }
+ }
+ pub fn as_list(&self) -> Option<&[Param]> {
+ match self {
+ Param::List(v) => Some(v),
+ _ => None,
+ }
+ }
+}
+
+/// One record of an entity instance: a simple instance has one, a complex one several.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Record {
+ pub name: String,
+ pub params: Vec<Param>,
+}
+
+/// An entity instance.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Entity {
+ pub records: Vec<Record>,
+}
+
+impl Entity {
+ pub fn is_complex(&self) -> bool {
+ self.records.len() > 1
+ }
+ /// Name of a simple instance (the first record of a complex one).
+ pub fn name(&self) -> &str {
+ self.records.first().map(|r| r.name.as_str()).unwrap_or("")
+ }
+ /// Parameters of the record called `name`.
+ pub fn record(&self, name: &str) -> Option<&[Param]> {
+ self.records.iter().find(|r| r.name == name).map(|r| r.params.as_slice())
+ }
+ pub fn has(&self, name: &str) -> bool {
+ self.records.iter().any(|r| r.name == name)
+ }
+ /// Parameters of a simple instance.
+ pub fn params(&self) -> &[Param] {
+ self.records.first().map(|r| r.params.as_slice()).unwrap_or(&[])
+ }
+}
+
+/// A parsed exchange file.
+#[derive(Clone, Debug, Default)]
+pub struct Exchange {
+ /// FILE_SCHEMA names.
+ pub schemas: Vec<String>,
+ /// FILE_NAME originating system.
+ pub originating_system: String,
+ pub entities: HashMap<u64, Entity>,
+ /// Ids defined more than once (the first definition is kept).
+ pub duplicates: Vec<u64>,
+}
+
+impl Exchange {
+ pub fn get(&self, id: u64) -> Option<&Entity> {
+ self.entities.get(&id)
+ }
+}
+
+struct Lexer<'a> {
+ s: &'a [u8],
+ i: usize,
+}
+
+fn err<T>(msg: impl Into<String>) -> Result<T, String> {
+ Err(msg.into())
+}
+
+impl<'a> Lexer<'a> {
+ fn line(&self) -> usize {
+ self.s.get(..self.i).map(|b| b.iter().filter(|c| **c == b'\n').count() + 1).unwrap_or(0)
+ }
+ fn fail<T>(&self, msg: &str) -> Result<T, String> {
+ err(format!("STEP syntax error at line {}: {msg}", self.line()))
+ }
+ fn peek(&self) -> Option<u8> {
+ self.s.get(self.i).copied()
+ }
+ /// Skip whitespace and comments.
+ fn ws(&mut self) -> Result<(), String> {
+ loop {
+ match self.peek() {
+ Some(c) if c.is_ascii_whitespace() => self.i += 1,
+ Some(b'/') if self.s.get(self.i + 1) == Some(&b'*') => {
+ let rest = self.s.get(self.i + 2..).unwrap_or(&[]);
+ match rest.windows(2).position(|w| w == b"*/") {
+ Some(p) => self.i += p + 4,
+ None => return self.fail("unterminated comment"),
+ }
+ }
+ _ => return Ok(()),
+ }
+ }
+ }
+ fn eat(&mut self, c: u8) -> Result<bool, String> {
+ self.ws()?;
+ if self.peek() == Some(c) {
+ self.i += 1;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ }
+ fn expect(&mut self, c: u8) -> Result<(), String> {
+ if self.eat(c)? { Ok(()) } else { self.fail(&format!("expected `{}`", c as char)) }
+ }
+ fn keyword(&mut self) -> Result<String, String> {
+ self.ws()?;
+ let st = self.i;
+ if self.peek() == Some(b'!') {
+ self.i += 1;
+ }
+ while let Some(c) = self.peek() {
+ if c.is_ascii_alphanumeric() || c == b'_' || c == b'-' {
+ self.i += 1;
+ } else {
+ break;
+ }
+ }
+ if self.i == st {
+ return self.fail("expected a keyword");
+ }
+ Ok(String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).to_ascii_uppercase())
+ }
+ fn number(&mut self) -> Result<Param, String> {
+ let st = self.i;
+ while let Some(c) = self.peek() {
+ if c.is_ascii_digit() || matches!(c, b'+' | b'-' | b'.' | b'E' | b'e') {
+ self.i += 1;
+ } else {
+ break;
+ }
+ }
+ let t = std::str::from_utf8(self.s.get(st..self.i).unwrap_or(&[])).unwrap_or("");
+ if !t.contains(['.', 'E', 'e'])
+ && let Ok(i) = t.parse::<i64>()
+ {
+ return Ok(Param::Int(i));
+ }
+ // STEP allows `1.` and `1.E-3`.
+ let fixed = t.replace(".E", ".0E").replace(".e", ".0e");
+ let fixed = if fixed.ends_with('.') { format!("{fixed}0") } else { fixed };
+ match fixed.parse::<f64>() {
+ Ok(x) => Ok(Param::Real(x)),
+ Err(_) => self.fail(&format!("bad number `{t}`")),
+ }
+ }
+ fn string(&mut self) -> Result<String, String> {
+ // Opening quote consumed by the caller.
+ let mut raw = Vec::new();
+ loop {
+ match self.peek() {
+ None => return self.fail("unterminated string"),
+ Some(b'\'') => {
+ if self.s.get(self.i + 1) == Some(&b'\'') {
+ raw.push(b'\'');
+ self.i += 2;
+ } else {
+ self.i += 1;
+ break;
+ }
+ }
+ Some(b'\n') | Some(b'\r') => self.i += 1,
+ Some(c) => {
+ raw.push(c);
+ self.i += 1;
+ }
+ }
+ }
+ Ok(decode_string(&raw))
+ }
+ fn param(&mut self, depth: usize) -> Result<Param, String> {
+ if depth > MAX_DEPTH {
+ return self.fail("parameters nested too deeply");
+ }
+ self.ws()?;
+ let Some(c) = self.peek() else { return self.fail("unexpected end of file") };
+ match c {
+ b'$' => {
+ self.i += 1;
+ Ok(Param::Null)
+ }
+ b'*' => {
+ self.i += 1;
+ Ok(Param::Derived)
+ }
+ b'\'' => {
+ self.i += 1;
+ Ok(Param::Str(self.string()?))
+ }
+ b'"' => {
+ self.i += 1;
+ let st = self.i;
+ while self.peek().is_some_and(|c| c != b'"') {
+ self.i += 1;
+ }
+ let v = String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).to_string();
+ self.expect(b'"')?;
+ Ok(Param::Binary(v))
+ }
+ b'#' => {
+ self.i += 1;
+ let st = self.i;
+ while self.peek().is_some_and(|c| c.is_ascii_digit()) {
+ self.i += 1;
+ }
+ let t = std::str::from_utf8(self.s.get(st..self.i).unwrap_or(&[])).unwrap_or("");
+ t.parse::<u64>().map(Param::Ref).or_else(|_| self.fail("bad entity reference"))
+ }
+ b'.' if self.s.get(self.i + 1).is_some_and(|c| c.is_ascii_alphabetic() || *c == b'_') => {
+ self.i += 1;
+ let st = self.i;
+ while self.peek().is_some_and(|c| c != b'.') {
+ self.i += 1;
+ }
+ let v = String::from_utf8_lossy(self.s.get(st..self.i).unwrap_or(&[])).trim().to_ascii_uppercase();
+ self.expect(b'.')?;
+ Ok(Param::Enum(v))
+ }
+ b'(' => {
+ self.i += 1;
+ Ok(Param::List(self.list_rest(depth + 1)?))
+ }
+ c if c.is_ascii_digit() || matches!(c, b'+' | b'-' | b'.') => self.number(),
+ c if c.is_ascii_alphabetic() || c == b'!' => {
+ let name = self.keyword()?;
+ self.expect(b'(')?;
+ Ok(Param::Typed(name, self.list_rest(depth + 1)?))
+ }
+ _ => self.fail(&format!("unexpected `{}`", c as char)),
+ }
+ }
+ /// Parameters after an opening `(` up to and including the `)`.
+ fn list_rest(&mut self, depth: usize) -> Result<Vec<Param>, String> {
+ let mut v = Vec::new();
+ if self.eat(b')')? {
+ return Ok(v);
+ }
+ loop {
+ v.push(self.param(depth)?);
+ if self.eat(b',')? {
+ continue;
+ }
+ self.expect(b')')?;
+ return Ok(v);
+ }
+ }
+ fn record(&mut self) -> Result<Record, String> {
+ let name = self.keyword()?;
+ self.expect(b'(')?;
+ Ok(Record { name, params: self.list_rest(1)? })
+ }
+}
+
+/// Decode the Part 21 string escapes (`\X\hh`, `\X2\…\X0\`, `\X4\…\X0\`, `\S\c`, `\\`).
+fn decode_string(raw: &[u8]) -> String {
+ let mut out = String::new();
+ let mut i = 0;
+ let hex = |b: &[u8]| std::str::from_utf8(b).ok().and_then(|t| u32::from_str_radix(t, 16).ok());
+ while let Some(&c) = raw.get(i) {
+ if c == b'\\' {
+ let rest = raw.get(i..).unwrap_or(&[]);
+ if rest.starts_with(b"\\\\") {
+ out.push('\\');
+ i += 2;
+ continue;
+ }
+ if rest.starts_with(b"\\X\\")
+ && let Some(v) = rest.get(3..5).and_then(hex)
+ {
+ out.push(char::from_u32(v).unwrap_or('?'));
+ i += 5;
+ continue;
+ }
+ let mut run = false;
+ for (tag, width) in [(&b"\\X2\\"[..], 4usize), (&b"\\X4\\"[..], 8)] {
+ if rest.starts_with(tag)
+ && let Some(end) = rest.windows(4).position(|w| w == b"\\X0\\")
+ {
+ let body = rest.get(4..end).unwrap_or(&[]);
+ let units: Vec<u32> = body.chunks(width).filter_map(hex).collect();
+ if width == 4 {
+ let u16s: Vec<u16> = units.iter().map(|u| *u as u16).collect();
+ out.push_str(&String::from_utf16_lossy(&u16s));
+ } else {
+ out.extend(units.iter().map(|u| char::from_u32(*u).unwrap_or('?')));
+ }
+ i += end + 4;
+ run = true;
+ break;
+ }
+ }
+ // A run may be followed straight away by the backslash of the next escape (#2344).
+ if run {
+ continue;
+ }
+ if rest.starts_with(b"\\S\\")
+ && let Some(&ch) = rest.get(3)
+ {
+ out.push(char::from_u32(ch as u32 + 128).unwrap_or('?'));
+ i += 4;
+ continue;
+ }
+ out.push('\\');
+ i += 1;
+ continue;
+ }
+ // Plain bytes: keep UTF-8 runs intact.
+ let st = i;
+ while raw.get(i).is_some_and(|c| *c != b'\\') {
+ i += 1;
+ }
+ out.push_str(&String::from_utf8_lossy(raw.get(st..i).unwrap_or(&[])));
+ }
+ out
+}
+
+/// Parse a Part 21 file.
+/// Someone waiting for a long parse: told how far it is, and able to stop it.
+pub trait Progress {
+ /// Stop at the next check.
+ fn cancelled(&self) -> bool;
+ /// `done` of `total` bytes read.
+ fn progress(&self, stage: &'static str, done: usize, total: usize);
+}
+
+/// Parse an exchange structure.
+pub fn parse(text: &str) -> Result<Exchange, String> {
+ parse_with(text, None)
+}
+
+/// [`parse`], reporting progress to `watch` and stopping when it cancels.
+pub fn parse_with(text: &str, watch: Option<&dyn Progress>) -> Result<Exchange, String> {
+ if text.len() > MAX_BYTES {
+ return err(format!("STEP file too large ({} MB, limit {} MB)", text.len() >> 20, MAX_BYTES >> 20));
+ }
+ let mut lx = Lexer { s: text.as_bytes(), i: 0 };
+ let magic = lx.keyword()?;
+ if magic != "ISO-10303-21" {
+ return err("not a STEP file (no ISO-10303-21 header)");
+ }
+ lx.expect(b';')?;
+ let mut ex = Exchange::default();
+ loop {
+ lx.ws()?;
+ if lx.peek().is_none() {
+ return err("STEP file ends without END-ISO-10303-21");
+ }
+ let kw = lx.keyword()?;
+ match kw.as_str() {
+ "HEADER" => {
+ lx.expect(b';')?;
+ loop {
+ let k = lx.keyword()?;
+ if k == "ENDSEC" {
+ lx.expect(b';')?;
+ break;
+ }
+ lx.expect(b'(')?;
+ let params = lx.list_rest(1)?;
+ lx.expect(b';')?;
+ match k.as_str() {
+ "FILE_SCHEMA" => {
+ if let Some(Param::List(v)) = params.first() {
+ ex.schemas = v.iter().filter_map(|p| p.as_str().map(str::to_string)).collect();
+ }
+ }
+ "FILE_NAME" => {
+ ex.originating_system = params.get(5).and_then(Param::as_str).unwrap_or("").to_string();
+ }
+ _ => {}
+ }
+ }
+ }
+ "DATA" => {
+ // Optional `DATA('name', ('schema'));`
+ if lx.eat(b'(')? {
+ lx.list_rest(1)?;
+ }
+ lx.expect(b';')?;
+ loop {
+ lx.ws()?;
+ if lx.peek() != Some(b'#') {
+ let k = lx.keyword()?;
+ if k == "ENDSEC" {
+ lx.expect(b';')?;
+ break;
+ }
+ return lx.fail(&format!("unexpected `{k}` in DATA"));
+ }
+ lx.i += 1;
+ let st = lx.i;
+ while lx.peek().is_some_and(|c| c.is_ascii_digit()) {
+ lx.i += 1;
+ }
+ let id: u64 = match std::str::from_utf8(lx.s.get(st..lx.i).unwrap_or(&[])).ok().and_then(|t| t.parse().ok()) {
+ Some(id) => id,
+ None => return lx.fail("bad entity id"),
+ };
+ lx.expect(b'=')?;
+ let records = if lx.eat(b'(')? {
+ let mut rs = Vec::new();
+ while !lx.eat(b')')? {
+ if rs.len() > 64 {
+ return lx.fail("complex entity with too many parts");
+ }
+ rs.push(lx.record()?);
+ }
+ rs
+ } else {
+ vec![lx.record()?]
+ };
+ lx.expect(b';')?;
+ if ex.entities.len() % 4096 == 0
+ && let Some(w) = watch
+ {
+ if w.cancelled() {
+ return err("STEP import cancelled");
+ }
+ w.progress("reading", lx.i, lx.s.len());
+ }
+ if ex.entities.len() >= MAX_ENTITIES {
+ return err(format!("STEP file has more than {MAX_ENTITIES} entities"));
+ }
+ // A duplicate id is invalid; some writers emit them for geometry nobody
+ // reads. Keep the first definition and report it.
+ match ex.entities.entry(id) {
+ std::collections::hash_map::Entry::Occupied(_) => ex.duplicates.push(id),
+ std::collections::hash_map::Entry::Vacant(v) => {
+ v.insert(Entity { records });
+ }
+ }
+ }
+ }
+ "END-ISO-10303-21" => {
+ lx.expect(b';')?;
+ return Ok(ex);
+ }
+ // ANCHOR / REFERENCE / SIGNATURE sections (Part 21 edition 3): skip to ENDSEC.
+ "ANCHOR" | "REFERENCE" | "SIGNATURE" => {
+ let rest = lx.s.get(lx.i..).unwrap_or(&[]);
+ match rest.windows(7).position(|w| w == b"ENDSEC;") {
+ Some(p) => lx.i += p + 7,
+ None => return lx.fail("unterminated section"),
+ }
+ }
+ _ => return lx.fail(&format!("unexpected `{kw}`")),
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn parses_simple_and_complex() {
+ let t = "ISO-10303-21;\nHEADER;FILE_DESCRIPTION((''),'2;1');\nFILE_NAME('a','',(''),(''),'','sys','');\nFILE_SCHEMA(('AUTOMOTIVE_DESIGN'));ENDSEC;\nDATA;\n#1=CARTESIAN_POINT('p',(0.,1.5E1,-2));\n/* c */ #2=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));\n#3=X('it''s','\\X2\\00E9\\X0\\',$,#1,LENGTH_MEASURE(1.E-3),\"0F\");\nENDSEC;\nEND-ISO-10303-21;\n";
+ let ex = parse(t).unwrap();
+ assert_eq!(ex.schemas, vec!["AUTOMOTIVE_DESIGN"]);
+ assert_eq!(ex.originating_system, "sys");
+ let p = ex.get(1).unwrap();
+ assert_eq!(p.name(), "CARTESIAN_POINT");
+ let xyz: Vec<f64> = p.params()[1].as_list().unwrap().iter().filter_map(Param::as_f64).collect();
+ assert_eq!(xyz, vec![0.0, 15.0, -2.0]);
+ let u = ex.get(2).unwrap();
+ assert!(u.is_complex() && u.has("SI_UNIT"));
+ assert_eq!(u.record("SI_UNIT").unwrap()[0].as_enum(), Some("MILLI"));
+ let x = ex.get(3).unwrap().params();
+ assert_eq!(x[0].as_str(), Some("it's"));
+ assert_eq!(x[1].as_str(), Some("\u{e9}"));
+ assert_eq!(x[2], Param::Null);
+ assert_eq!(x[3].as_ref_id(), Some(1));
+ assert_eq!(x[4].as_f64(), Some(1e-3));
+ }
+
+ #[test]
+ fn hostile_text_is_an_error() {
+ for t in [
+ "",
+ "garbage",
+ "ISO-10303-21;",
+ "ISO-10303-21;DATA;#1=A(",
+ "ISO-10303-21;DATA;#1=A('x",
+ "ISO-10303-21;DATA;#1=A(/*",
+ "ISO-10303-21;DATA;#=A();ENDSEC;END-ISO-10303-21;",
+ "ISO-10303-21;DATA;#99999999999999999999999=A();ENDSEC;END-ISO-10303-21;",
+ "ISO-10303-21;DATA;#1=A(1e999999.);ENDSEC;END-ISO-10303-21;",
+ ] {
+ let _ = parse(t);
+ }
+ let deep = format!("ISO-10303-21;DATA;#1=A({}{});ENDSEC;END-ISO-10303-21;", "(".repeat(10_000), ")".repeat(10_000));
+ assert!(parse(&deep).is_err());
+ let dup = parse("ISO-10303-21;DATA;#1=A(1);#1=B();ENDSEC;END-ISO-10303-21;").unwrap();
+ assert_eq!(dup.duplicates, vec![1]);
+ assert_eq!(dup.get(1).unwrap().name(), "A");
+ assert_eq!(decode_string(b"\\X\\E9"), "\u{e9}");
+ assert_eq!(decode_string(b"a\\X2\\00E900E8\\X0\\b"), "a\u{e9}\u{e8}b");
+ assert_eq!(decode_string(b"\\"), "\\");
+ // One run per character, as `step_out` writes them (#2344).
+ assert_eq!(decode_string(b"\\X2\\5706\\X0\\\\X2\\89D2\\X0\\20"), "\u{5706}\u{89d2}20");
+ assert_eq!(decode_string(b"\\X4\\0001F600\\X0\\\\X2\\00E9\\X0\\\\S\\a"), "\u{1f600}\u{e9}\u{e1}");
+ }
+}
diff --git a/crates/step/src/read.rs b/crates/step/src/read.rs
new file mode 100644
index 0000000000..86652586c4
--- /dev/null
+++ b/crates/step/src/read.rs
@@ -0,0 +1,762 @@
+//! 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,
+ })))
+ }
+}
diff --git a/crates/step/src/write.rs b/crates/step/src/write.rs
new file mode 100644
index 0000000000..acdf01d832
--- /dev/null
+++ b/crates/step/src/write.rs
@@ -0,0 +1,503 @@
+//! 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![]),
+ ]),
+ }
+ }
+}
diff --git a/xtask/src/layers.rs b/xtask/src/layers.rs
index e5c07f1ee2..309bf40744 100644
--- a/xtask/src/layers.rs
+++ b/xtask/src/layers.rs
@@ -45,6 +45,8 @@ pub const TABLE: &[(&str, Class)] = &[
("sketch", Class::Layer(1)),
// NVIDIA's SMLib behind its C API (kernel-smlib branch, ADR 0002); only the kernel uses it
("smlib", Class::Layer(1)),
+ // STEP (ISO 10303) exchange structure and geometry, no modelling backend
+ ("step", Class::Layer(1)),
("kernel", Class::Layer(1)),
("render", Class::Layer(1)),
("doc", Class::Layer(2)),
@@ -63,8 +65,8 @@ pub const TABLE: &[(&str, Class)] = &[
/// Explicit orderings *within* a layer (earlier may be used by later).
/// The viewport draws display plans the GPU crate evaluates and draws with its pipelines; the MCP
-/// server's tests draw screenshots with them.
-pub const INTRA_LAYER_ORDER: &[&[&str]] = &[&["gpu", "ui-egui"], &["gpu", "mcp"], &["smlib", "kernel"]];
+/// server's tests draw screenshots with them. The kernel reads and writes STEP through `step`.
+pub const INTRA_LAYER_ORDER: &[&[&str]] = &[&["gpu", "ui-egui"], &["gpu", "mcp"], &["smlib", "kernel"], &["step", "kernel"]];
fn intra_layer_allowed(from: &str, to: &str) -> bool {
let (from, to) = (short_name(from), short_name(to));