diff --git a/Cargo.lock b/Cargo.lock index d5273808b..af4b1e2a3 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 8bc9f6aa6..6cb6b7308 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 67fceb832..4eee0553e 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 e862774b3..969606bd0 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); -/// 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), - /// `NAME(params)` (a typed value such as `LENGTH_MEASURE(1.)`). - Typed(String, Vec), - Binary(String), - /// `$` - Null, - /// `*` - Derived, -} - -impl Param { - pub fn as_f64(&self) -> Option { - 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, - } +impl solidcraft_step::p21::Progress for Watched { + fn cancelled(&self) -> bool { + self.0.cancelled() } - pub fn as_i64(&self) -> Option { - 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 { - 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 { - 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, - } + fn progress(&self, stage: &'static str, done: usize, total: usize) { + self.0.progress(stage, done, total); } } -/// 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, -} - -/// An entity instance. -#[derive(Clone, Debug, PartialEq)] -pub struct Entity { - pub records: Vec, -} - -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, - /// 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, - /// Ids defined more than once (the first definition is kept). - pub duplicates: Vec, - /// [`Exchange::vertex_extent`], worked out on first use. - extent: std::sync::OnceLock, -} - -impl Exchange { - pub fn get(&self, id: u64) -> Option<&Entity> { - self.entities.get(&id) - } - - /// 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 = 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::().sqrt(); - if d.is_finite() { d } else { 0.0 } - }) - } -} - -struct Lexer<'a> { - s: &'a [u8], - i: usize, -} - -fn err(msg: impl Into) -> Result { - 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(&self, msg: &str) -> Result { - err(format!("STEP syntax error at line {}: {msg}", self.line())) - } - fn peek(&self) -> Option { - 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 { - 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 { - 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 { - 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::() - { - 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::() { - Ok(x) => Ok(Param::Real(x)), - Err(_) => self.fail(&format!("bad number `{t}`")), - } - } - fn string(&mut self) -> Result { - // 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 { - 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::().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, 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 { - 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 = body.chunks(width).filter_map(hex).collect(); - if width == 4 { - let u16s: Vec = 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 { - 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::>().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 = 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 000000000..e92b2635d --- /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 000000000..b55eba410 --- /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> { + 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 { + 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::>()?; + 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 { + (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 { + 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 { + 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 { + self.point_at(t, 0) + } + + fn point_at(&self, t: f64, depth: usize) -> Option { + 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 { + 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 { + self.normal_at(u, v, 0) + } + + fn normal_at(&self, u: f64, v: f64, depth: usize) -> Option { + 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 { + 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 000000000..25844f764 --- /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, + /// Present for a rational curve, one positive weight per point. + pub weights: Option>, + pub knots: Vec, + pub multiplicities: Vec, + 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>, + pub weights: Option>>, + pub u_knots: Vec, + pub u_multiplicities: Vec, + pub v_knots: Vec, + pub v_multiplicities: Vec, + 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, + /// A 2D curve: every point and placement has z = 0 and every placement axis is +Z. + pub curve: Arc, +} + +/// An item of a SURFACE_CURVE's `associated_geometry`. +#[derive(Clone, Debug, PartialEq)] +pub enum Associated { + Pcurve(Pcurve), + Surface(Arc), +} + +/// 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), + /// Segment `i` (from 0) is the parameters `[i, i + 1]`. + Polyline(Vec), + Trimmed { + basis: Arc, + trim_1: Vec, + trim_2: Vec, + sense: bool, + preference: TrimPreference, + }, + SurfaceCurve { + kind: SurfaceCurveKind, + curve_3d: Arc, + associated: Vec, + master: PreferredRep, + }, + OffsetCurve3d { + basis: Arc, + 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), + /// The profile at `v` turned by the angle `u` about the axis. + Revolution { + profile: Arc, + axis: Axis1, + }, + /// `profile(u) + v·magnitude·direction`. + Extrusion { + profile: Arc, + direction: P3, + magnitude: f64, + }, + Offset { + basis: Arc, + distance: f64, + self_intersect: Logical, + }, + RectangularTrimmed { + basis: Arc, + 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 000000000..244aa2aee --- /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 { + 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 { + 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 = Default::default(); + let mut ids: Vec = 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 = curves.iter().map(|c| g.curve(c)).collect(); + let sids: Vec = 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::() + ); + for (e, n) in &errors { + println!(" {n} × {e}"); + } + failed += mismatched + errors.values().sum::(); + } + assert_eq!(failed, 0); +} diff --git a/crates/step/src/lib.rs b/crates/step/src/lib.rs new file mode 100644 index 000000000..2d66f20e8 --- /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 000000000..add33a46c --- /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), + /// `NAME(params)` (a typed value such as `LENGTH_MEASURE(1.)`). + Typed(String, Vec), + Binary(String), + /// `$` + Null, + /// `*` + Derived, +} + +impl Param { + pub fn as_f64(&self) -> Option { + 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 { + 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 { + 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 { + 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, +} + +/// An entity instance. +#[derive(Clone, Debug, PartialEq)] +pub struct Entity { + pub records: Vec, +} + +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, + /// FILE_NAME originating system. + pub originating_system: String, + pub entities: HashMap, + /// Ids defined more than once (the first definition is kept). + pub duplicates: Vec, +} + +impl Exchange { + pub fn get(&self, id: u64) -> Option<&Entity> { + self.entities.get(&id) + } +} + +struct Lexer<'a> { + s: &'a [u8], + i: usize, +} + +fn err(msg: impl Into) -> Result { + 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(&self, msg: &str) -> Result { + err(format!("STEP syntax error at line {}: {msg}", self.line())) + } + fn peek(&self) -> Option { + 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 { + 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 { + 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 { + 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::() + { + 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::() { + Ok(x) => Ok(Param::Real(x)), + Err(_) => self.fail(&format!("bad number `{t}`")), + } + } + fn string(&mut self) -> Result { + // 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 { + 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::().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, 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 { + 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 = body.chunks(width).filter_map(hex).collect(); + if width == 4 { + let u16s: Vec = 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 { + 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 { + 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 = 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 000000000..86652586c --- /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 = Result; + +/// 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>, + curves_2d: HashMap<(u64, [u64; 2]), Arc>, + surfaces: HashMap>, +} + +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 { + p.and_then(Param::as_ref_id).ok_or_else(|| format!("{what}: expected a reference")) +} + +fn num(p: Option<&Param>, what: &str) -> R { + 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 { + 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 { + p.and_then(Param::as_bool).ok_or_else(|| format!("{what}: expected a boolean")) +} + +fn unit(v: P3, what: &str) -> R { + 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, Vec)> { + let m: Vec = 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::>()?; + let raw: Vec = values.and_then(Param::as_list).ok_or("B-spline without knots")?.iter().map(|x| num(Some(x), "knot")).collect::>()?; + 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, Vec) = (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, Vec)> { + 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> { + let w: Vec = 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::>()?; + if w.len() != n { Err("weights do not match the control points".into()) } else { Ok(w) } +} + +fn degree(p: Option<&Param>) -> R { + 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, Option>)> { + 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 { + Ok(num(p, what)? * self.units.len) + } + + fn angle(&self, p: Option<&Param>, what: &str) -> R { + 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 { + 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 { 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 { + 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 { + 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 { 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 { + 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 { + 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 { + let l = self.units.len; + self.placement_scaled(id, [l, l, l], 3) + } + + pub fn axis1(&self, id: u64) -> R { + 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> { + self.curve_in(id, 0) + } + + fn curve_in(&mut self, id: u64, depth: usize) -> R> { + 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> { + 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 { + 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 { + 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::>()?; + 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> { + 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 { + 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 { + 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 = ids.iter().map(|c| self.point_scaled(reference(Some(c), "control point")?, s, dim)).collect::>()?; + 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> { + self.surface_in(id, 0) + } + + fn surface_in(&mut self, id: u64, depth: usize) -> R> { + 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 { + 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 { + 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::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::>()?); + } + 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::>()?) + } + 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 000000000..acdf01d83 --- /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, + shared: HashMap, +} + +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)]) -> u64 { + let mut sorted: Vec<&(&str, Vec)> = 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::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, +} + +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 e5c07f1ee..309bf4074 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));