diff --git a/crates/kernel/src/iges_in.rs b/crates/kernel/src/iges_in.rs index da387dad3..cbb6716ec 100644 --- a/crates/kernel/src/iges_in.rs +++ b/crates/kernel/src/iges_in.rs @@ -347,6 +347,11 @@ struct Nurbs { impl Nurbs { fn eval(&self, t: f64) -> Option { + let h = self.eval_h(t)?; + (h[3].abs() > 1e-300).then(|| [h[0] / h[3], h[1] / h[3], h[2] / h[3]]) + } + /// The homogeneous point (x·w, y·w, z·w, w) at `t`. + fn eval_h(&self, t: f64) -> Option<[f64; 4]> { let p = self.deg; let n = self.pts.len(); if n == 0 || self.knots.len() != n + p + 1 { @@ -368,8 +373,7 @@ impl Nurbs { d[j] = [0, 1, 2, 3].map(|c| (1.0 - alpha) * x[c] + alpha * y[c]); } } - let h = d[p]; - (h[3].abs() > 1e-300).then(|| [h[0] / h[3], h[1] / h[3], h[2] / h[3]]) + d.get(p).copied() } fn range(&self) -> (f64, f64) { (self.knots.get(self.deg).copied().unwrap_or(0.0), self.knots.get(self.pts.len()).copied().unwrap_or(0.0)) @@ -459,6 +463,11 @@ impl<'a> Tr<'a> { } /// The entity's own transformation (its chain), in millimetres. fn own_xf(&self, seq: i64, depth: usize) -> R { + self.own_xf_in(seq, depth, self.f.unit) + } + /// The entity's own transformation with translations in units of `unit` millimetres (1 for + /// a curve in a surface's parameter space, which has no length unit). + fn own_xf_in(&self, seq: i64, depth: usize, unit: f64) -> R { let de = self.de(seq)?; if de.xform <= 0 || depth > MAX_DEPTH { return Ok(Xf::ID); @@ -473,13 +482,15 @@ impl<'a> Tr<'a> { for (col, x) in r.iter_mut().enumerate() { *x = self.n(t, 1 + row * 4 + col)?; } - r[3] *= self.f.unit; + r[3] *= unit; } - let parent = self.own_xf(t, depth + 1)?; + let parent = self.own_xf_in(t, depth + 1, unit)?; Ok(parent.then(&Xf(m))) } fn pt(&self, seq: i64, i: usize) -> R { - let u = self.f.unit; + self.pt_in(seq, i, self.f.unit) + } + fn pt_in(&self, seq: i64, i: usize, u: f64) -> R { Ok([self.n(seq, i)? * u, self.n(seq, i + 1)? * u, self.n(seq, i + 2)? * u]) } /// A point entity (116) or direction (123), placed. @@ -646,6 +657,9 @@ impl<'a> Tr<'a> { } fn nurbs_curve(&self, seq: i64, x: &Xf) -> R { + self.nurbs_curve_in(seq, x, self.f.unit) + } + fn nurbs_curve_in(&self, seq: i64, x: &Xf, unit: f64) -> R { let k = self.i(seq, 1)?; let m = self.i(seq, 2)?; if !(0..=MAX_LIST as i64).contains(&k) || !(1..=32).contains(&m) || m > k.max(1) + 1 { @@ -665,7 +679,7 @@ impl<'a> Tr<'a> { if !(w > 0.0) { return Err(format!("entity {seq}: non-positive weight")); } - let p = x.point(self.pt(seq, base_p + 3 * j)?); + let p = x.point(self.pt_in(seq, base_p + 3 * j, unit)?); pts.push([p[0] * w, p[1] * w, p[2] * w, w]); } if knots.windows(2).any(|w| w[1] < w[0]) { @@ -883,6 +897,61 @@ impl<'a> Tr<'a> { } } + /// The start point of a curve in a surface's parameter space (the B curve of a curve on a + /// surface, 142): its (u, v) are the first two coordinates. Lines, arcs, B-splines and + /// composites of them, as the specification lists for parameter-space curves. + fn param_start(&self, seq: i64, depth: usize) -> R { + if depth > MAX_DEPTH { + return Err("parameter-space curves nested too deeply".into()); + } + let de = self.de(seq)?; + let x = self.own_xf_in(seq, 0, 1.0)?; + let p = match de.typ { + 110 => self.pt_in(seq, 1, 1.0)?, + 100 => [self.n(seq, 4)?, self.n(seq, 5)?, self.n(seq, 1)?], + 126 => { + let nb = self.nurbs_curve_in(seq, &Xf::ID, 1.0)?; + nb.eval(nb.range().0).ok_or_else(|| format!("entity {seq}: B-spline cannot be evaluated"))? + } + 102 if self.i(seq, 1)? > 0 => self.param_start(self.i(seq, 2)?, depth + 1)?, + t => return Err(format!("parameter-space curve type {t} is not read")), + }; + Ok(x.point(p)) + } + + /// The point of a B-spline surface (128) at parameters (u, v), placed as `surface` places it. + fn surface_point(&self, seq: i64, xf: &Xf, u: f64, v: f64) -> R { + if self.de(seq)?.typ != 128 { + return Err(format!("entity {seq}: only B-spline surfaces are evaluated")); + } + let x = xf.then(&self.own_xf(seq, 0)?); + let (k1, k2, m1, m2) = (self.i(seq, 1)?, self.i(seq, 2)?, self.i(seq, 3)?, self.i(seq, 4)?); + if !(0..=4096).contains(&k1) || !(0..=4096).contains(&k2) || !(1..=32).contains(&m1) || !(1..=32).contains(&m2) { + return Err(format!("entity {seq}: bad B-spline surface size")); + } + let (k1, k2, m1, m2) = (k1 as usize, k2 as usize, m1 as usize, m2 as usize); + let (n1, n2) = (k1 + m1 + 2, k2 + m2 + 2); + let s_knots: Vec = (0..n1).map(|j| self.n(seq, 10 + j)).collect::>()?; + let t_knots: Vec = (0..n2).map(|j| self.n(seq, 10 + n1 + j)).collect::>()?; + let base_w = 10 + n1 + n2; + let base_p = base_w + (k1 + 1) * (k2 + 1); + // Each row of the net at u, then the column of those points at v (homogeneous, so the + // weights combine as the rational tensor product does). + let mut column = Vec::with_capacity(k2 + 1); + for j in 0..=k2 { + let mut row = Vec::with_capacity(k1 + 1); + for i in 0..=k1 { + let idx = j * (k1 + 1) + i; + let w = self.n(seq, base_w + idx)?; + let p = x.point(self.pt(seq, base_p + 3 * idx)?); + row.push([p[0] * w, p[1] * w, p[2] * w, w]); + } + let h = Nurbs { deg: m1, knots: s_knots.clone(), pts: row }.eval_h(u).ok_or("surface cannot be evaluated")?; + column.push(h); + } + Nurbs { deg: m2, knots: t_knots, pts: column }.eval(v).ok_or_else(|| "surface cannot be evaluated".into()) + } + /// The natural boundary of a B-spline surface (its four edge curves), for trimmed surfaces /// with no outer curve. fn natural_boundary(&mut self, seq: i64, xf: &Xf) -> R> { @@ -1274,10 +1343,10 @@ fn trimmed(t: &mut Tr, sw: &mut Sewer, seq: i64) -> R { let n1 = t.i(seq, 2)?; let n2 = t.i(seq, 3)?.clamp(0, MAX_LIST as i64) as usize; let mut loops = Vec::new(); - let outer = if n1 == 0 { t.natural_boundary(surf_seq, &xf)? } else { cos_curve(t, t.i(seq, 4)?, &xf)? }; + let outer = if n1 == 0 { t.natural_boundary(surf_seq, &xf)? } else { cos_curve(t, t.i(seq, 4)?, &xf, surf_seq)? }; loops.push(loop_of(t, sw, outer)); for k in 0..n2 { - let segs = cos_curve(t, t.i(seq, 5 + k)?, &xf)?; + let segs = cos_curve(t, t.i(seq, 5 + k)?, &xf, surf_seq)?; loops.push(loop_of(t, sw, segs)); } loops.retain(|l| !l.is_empty()); @@ -1311,8 +1380,16 @@ fn trimmed(t: &mut Tr, sw: &mut Sewer, seq: i64) -> R { } } -/// The model-space curve of a curve on a surface (142). -fn cos_curve(t: &mut Tr, seq: i64, xf: &Xf) -> R> { +/// The model-space curve of a curve on a surface (142) bounding a trimmed `surface`, its pieces +/// head to tail. +/// +/// A curve on a surface is one curve given twice: B in the surface's parameter space and C in +/// model space, both running the same way (C = S∘B). A composite C must run each piece on from +/// the end of the one before, but some exporters write its pieces in order with some of them +/// reversed, so the loop does not close and the face is lost. The pieces are turned to run on, +/// starting where S(B) starts (the end of the first piece there), so the loop also keeps the +/// sense the file gives it (outer loop and holes the opposite ways round). +fn cos_curve(t: &mut Tr, seq: i64, xf: &Xf, surface: i64) -> R> { let de = t.de(seq)?; if de.typ != 142 { return t.curve(seq, xf, 0); @@ -1322,7 +1399,27 @@ fn cos_curve(t: &mut Tr, seq: i64, xf: &Xf) -> R> { if c <= 0 { return Err("a curve on a surface without its model-space curve".into()); } - t.curve(c, &x, 0) + let segs = t.curve(c, &x, 0)?; + let b = t.i(seq, 3).unwrap_or(0); + let start = if b > 0 { t.param_start(b, 0).and_then(|p| t.surface_point(surface, xf, p[0], p[1])).ok() } else { None }; + Ok(head_to_tail(segs, start, t.tol)) +} + +/// Pieces of a composite curve turned so that each starts where the one before ends, the first +/// at the end nearer `start` (when known). A closed piece (its ends within `tol`, the sewing +/// tolerance that decides they are one vertex) keeps its direction. +fn head_to_tail(segs: Vec, start: Option, tol: f64) -> Vec { + let mut prev = start; + segs.into_iter() + .map(|s| { + let s = match prev { + Some(p) if norm(sub(s.a, s.b)) > tol && norm(sub(s.b, p)) < norm(sub(s.a, p)) => s.reversed(), + _ => s, + }; + prev = Some(s.b); + s + }) + .collect() } /// The model-space curves of a boundary (141), each in its sense. diff --git a/crates/kernel/src/iges_in/tests.rs b/crates/kernel/src/iges_in/tests.rs index 6b8052ef0..c10950c36 100644 --- a/crates/kernel/src/iges_in/tests.rs +++ b/crates/kernel/src/iges_in/tests.rs @@ -257,3 +257,88 @@ fn directory_entries_cannot_share_their_way_past_the_file_size() { assert!(error.contains("parameter data is too large"), "{error}"); assert!(t.elapsed() < std::time::Duration::from_secs(10), "took {:?}", t.elapsed()); } + +/// A curve on a surface (142) for a trimmed patch: model-space lines through `corners` with the +/// pieces `reversed` written end to start (as some exporters write composite trim curves), and +/// the same loop in the patch's parameter space through `uv`. Returns the 142's pointer. +fn trim_loop(ents: &mut Vec<(i64, i64, String)>, surface: usize, corners: &[[f64; 3]], uv: &[[f64; 2]], reversed: &[usize]) -> usize { + let fmt = |p: [f64; 3]| format!("{:?},{:?},{:?}", p[0], p[1], p[2]); + let mut model = Vec::new(); + let mut param = Vec::new(); + for k in 0..corners.len() { + let (p0, p1) = (corners[k], corners[(k + 1) % corners.len()]); + let (p0, p1) = if reversed.contains(&k) { (p1, p0) } else { (p0, p1) }; + ents.push((110, 0, format!("{},{}", fmt(p0), fmt(p1)))); + model.push(2 * ents.len() - 1); + let (q0, q1) = (uv[k], uv[(k + 1) % uv.len()]); + ents.push((110, 0, format!("{},{}", fmt([q0[0], q0[1], 0.0]), fmt([q1[0], q1[1], 0.0])))); + param.push(2 * ents.len() - 1); + } + let list = |v: &[usize]| v.iter().map(|x| x.to_string()).collect::>().join(","); + ents.push((102, 0, format!("{},{}", model.len(), list(&model)))); + let c = 2 * ents.len() - 1; + ents.push((102, 0, format!("{},{}", param.len(), list(¶m)))); + let b = 2 * ents.len() - 1; + // Created by projection, preferring the parameter-space curve (PREF 1). + ents.push((142, 0, format!("0,{surface},{b},{c},1"))); + 2 * ents.len() - 1 +} + +/// A bilinear B-spline patch through corners `a` (u, v = 0), `b` (u = 1), `c` (u, v = 1) and +/// `d` (v = 1). +fn bilinear_patch(a: [f64; 3], b: [f64; 3], c: [f64; 3], d: [f64; 3]) -> (i64, i64, String) { + let fmt = |p: [f64; 3]| format!("{:?},{:?},{:?}", p[0], p[1], p[2]); + (128, 0, format!("1,1,1,1,0,0,1,0,0,0.,0.,1.,1.,0.,0.,1.,1.,1.,1.,1.,1.,{},{},{},{},0.,1.,0.,1.", fmt(a), fmt(b), fmt(d), fmt(c))) +} + +/// The box of `trimmed_surfaces_sew_into_a_solid` with some pieces of every trim curve written +/// end to start (the first piece on half the faces): each face's loop still closes and the box +/// is a solid. +#[test] +fn trim_curves_with_reversed_pieces_still_close_their_faces() { + let c = + |i: usize| -> [f64; 3] { [if i & 1 != 0 { 10.0 } else { 0.0 }, if i & 2 != 0 { 20.0 } else { 0.0 }, if i & 4 != 0 { 30.0 } else { 0.0 }] }; + let quads = [[0, 2, 3, 1], [4, 5, 7, 6], [0, 1, 5, 4], [2, 6, 7, 3], [0, 4, 6, 2], [1, 3, 7, 5]]; + let mut ents: Vec<(i64, i64, String)> = Vec::new(); + for (fi, q) in quads.iter().enumerate() { + let corners = q.map(c); + ents.push(bilinear_patch(corners[0], corners[1], corners[2], corners[3])); + let surface = 2 * ents.len() - 1; + let reversed: &[usize] = if fi % 2 == 0 { &[0, 2] } else { &[1, 3] }; + let cos = trim_loop(&mut ents, surface, &corners, &[[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]], reversed); + ents.push((144, 0, format!("{surface},1,0,{cos}"))); + } + let imp = iges_import(&iges_file(&ents)).unwrap(); + assert!(imp.warnings.is_empty(), "{:?}", imp.warnings); + assert!(imp.bodies[0].closed); + let m = measure(&imp.bodies[0].body).unwrap(); + assert!(rel(m.volume, 6000.0) < 1e-6 && rel(m.area, 2200.0) < 1e-6, "{} {}", m.volume, m.area); +} + +/// A plate with a square hole whose trim curve starts with a reversed piece: where the +/// parameter-space curve starts decides which way the hole runs, so it stays a hole. +#[test] +fn a_hole_whose_first_trim_piece_is_reversed_stays_a_hole() { + let mut ents: Vec<(i64, i64, String)> = vec![bilinear_patch([0.0; 3], [10.0, 0.0, 0.0], [10.0, 10.0, 0.0], [0.0, 10.0, 0.0])]; + let outer = trim_loop( + &mut ents, + 1, + &[[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 10.0, 0.0], [0.0, 10.0, 0.0]], + &[[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]], + &[], + ); + // Clockwise about the patch's normal, as a hole runs. + let hole = trim_loop( + &mut ents, + 1, + &[[3.0, 3.0, 0.0], [3.0, 7.0, 0.0], [7.0, 7.0, 0.0], [7.0, 3.0, 0.0]], + &[[0.3, 0.3], [0.3, 0.7], [0.7, 0.7], [0.7, 0.3]], + &[0], + ); + ents.push((144, 0, format!("1,1,1,{outer},{hole}"))); + let imp = iges_import(&iges_file(&ents)).unwrap(); + assert_eq!(imp.bodies.len(), 1); + assert!(!imp.warnings.iter().any(|w| w.contains("not read") || w.contains("face #")), "{:?}", imp.warnings); + let m = measure(&imp.bodies[0].body).unwrap(); + assert!(rel(m.area, 84.0) < 1e-6, "area {}", m.area); +}