SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 223/509: brep: meridians, revolutions and whole turns exact on their forms (and 3 more)
jyviko9767f95c31b3
diff --git a/crates/geom/src/brep.rs b/crates/geom/src/brep.rsindex 6e5ab55137..dbc3cab743 100644--- a/crates/geom/src/brep.rs+++ b/crates/geom/src/brep.rs@@ -89,10 +89,11 @@ pub struct Face {/// What the face is: its surface as the producer names it (a cylinder, a NURBS…).pub surface: Surface,/// The NURBS form the face is parameterised on, when it differs from `surface`'s own- /// parameters: a cylinder, cone, sphere or torus as SMLib holds it (every SMLib analytic- /// surface is a B-spline surface, its trims in that NURBS's parameters). When given, `domain`- /// and every pcurve are in this surface's (u, v), and `surface` only says what it is; it is a- /// `Spline` or `RationalSpline` and `surface` is a cylinder, cone, sphere or torus+ /// parameters: a cylinder, cone, sphere, torus or placed revolution as SMLib holds it (every+ /// SMLib analytic surface is a B-spline surface, its trims in that NURBS's parameters). When+ /// given, `domain` and every pcurve are in this surface's (u, v), and `surface` only says what+ /// it is; it is a `Spline` or `RationalSpline` and `surface` is a cylinder, cone, sphere, torus+ /// or placed revolution/// (docs/native-brep.md, "Surfaces").#[serde(default, skip_serializing_if = "Option::is_none")]pub nurbs: Option<Surface>,@@ -589,6 +590,8 @@ impl Brep {"NURBS form on a curve that is not a line, circle or ellipse",)?;}+ // A circle or ellipse is a label: its geometry is its NURBS form.+ require(e.nurbs.is_some() || !matches!(e.curve, Curve::Circle { .. } | Curve::Ellipse { .. }), "a circle or ellipse without its NURBS form")?;interval(&e.interval, curve_natural(e.parameters()))?;require(e.vertices.iter().all(|&v| (v as usize) < self.vertices.len()), "edge vertices")?;tolerance(e.tolerance)?;@@ -600,10 +603,26 @@ impl Brep {surface(n, 0, &mut budget)?;require(matches!(n, Surface::Spline { .. } | Surface::RationalSpline { .. }), "NURBS form is not a NURBS")?;require(- matches!(f.surface, Surface::Cylinder { .. } | Surface::Cone { .. } | Surface::Sphere { .. } | Surface::Torus { .. }),- "NURBS form on a surface that is not a cylinder, cone, sphere or torus",+ matches!(+ f.surface,+ Surface::Cylinder { .. }+ | Surface::Cone { .. }+ | Surface::Sphere { .. }+ | Surface::Torus { .. }+ | Surface::PlacedRevolution { .. }+ ),+ "NURBS form on a surface that is not a cylinder, cone, sphere, torus or revolution",)?;}+ // A cylinder, cone, sphere, torus or revolution is a label: its geometry is its form.+ require(+ f.nurbs.is_some()+ || !matches!(+ f.surface,+ Surface::Cylinder { .. } | Surface::Cone { .. } | Surface::Sphere { .. } | Surface::Torus { .. } | Surface::PlacedRevolution { .. }+ ),+ "a cylinder, cone, sphere, torus or revolution without its NURBS form",+ )?;let [u, v] = surface_natural(f.parameters());interval(&f.domain[0], u)?;interval(&f.domain[1], v)?;diff --git a/crates/geom/src/brep/form.rs b/crates/geom/src/brep/form.rsindex caff2ea7b4..55f8a53cf8 100644--- a/crates/geom/src/brep/form.rs+++ b/crates/geom/src/brep/form.rs@@ -61,6 +61,18 @@ fn quarters([a0, a1]: [f64; 2]) -> Option<(f64, usize)> {(n <= 5).then_some((q0, n))}+/// A face's quarters along an angle direction and its domain there: a whole turn is exactly+/// four quarters from the one it starts in (the form closes on itself, so it is periodic and the+/// face's seam uses lie a period apart), anything less the quarters it needs.+fn face_quarters(a: [f64; 2]) -> Option<((f64, usize), [f64; 2])> {+ if a[1] - a[0] >= TAU * (1.0 - 1e-9) {+ let q0 = quarter_of(a[0]);+ return Some(((q0, 4), [q0, q0 + 4.0]));+ }+ let grid = quarters(a)?;+ Some((grid, params(a, grid)))+}+/// The form parameters of an angle interval on the quarters `quarters` chose for it (its ends kept/// on them: an end within rounding past a quarter's end stays in that quarter).fn params([a0, a1]: [f64; 2], (q0, n): (f64, usize)) -> [f64; 2] {@@ -128,9 +140,8 @@ fn conic(frame: &Frame, [rx, ry]: [f64; 2], t: [f64; 2]) -> Option<(Curve, [f64;/// parameters: angles, and the height along the axis of a cylinder or cone) and the domain in the/// form's parameters; `None` for another kind, or a domain of more than one turn.pub fn surface(s: &Surface, [u, v]: [[f64; 2]; 2]) -> Option<(Surface, [[f64; 2]; 2])> {- let grid = quarters(u)?;+ let (grid, fu) = face_quarters(u)?;let (u_knots, ring) = arcs(grid.0, grid.1);- let fu = params(u, grid);// The ring of arcs times a profile `(control, weight)` mapped to (radial, axial) about the// frame: a rational tensor product, its weights the products.let net = |f: &Frame, profile: &[([f64; 2], f64)], at: &dyn Fn([f64; 2]) -> (f64, f64)| -> Option<Vec<Vec<[f64; 4]>>> {@@ -168,10 +179,45 @@ pub fn surface(s: &Surface, [u, v]: [[f64; 2]; 2]) -> Option<(Surface, [[f64; 2]Some((Surface::RationalSpline { u_knots, v_knots, homogeneous }, [fu, params(v, vgrid)]))}Surface::Torus { frame, major_radius, minor_radius } => {- let vgrid = quarters(v)?;+ let (vgrid, fv) = face_quarters(v)?;let (v_knots, tube) = arcs(vgrid.0, vgrid.1);let homogeneous = net(frame, &tube, &|[c, s]| (major_radius + minor_radius * c, minor_radius * s))?;- Some((Surface::RationalSpline { u_knots, v_knots, homogeneous }, [fu, params(v, vgrid)]))+ Some((Surface::RationalSpline { u_knots, v_knots, homogeneous }, [fu, fv]))+ }+ Surface::PlacedRevolution { profile, origin, axis, matrix, forward } => {+ // The profile's control points turned about the axis on the quarter grid from angle+ // zero (the profile): (a + ib)(c + is) for each point's radial (a, b) in the frame and+ // each arc control point (c, s), weights multiplied; then the matrix.+ let (angles, along) = if *forward { (v, u) } else { (u, v) };+ let (ring_grid, fa) = face_quarters(angles)?;+ let (a_knots, arcs_r) = arcs(ring_grid.0, ring_grid.1);+ let (p_knots, h) = profile_nurbs(profile, Some(along))?;+ let fp = match profile.as_ref() {+ Curve::Circle { .. } | Curve::Ellipse { .. } => curve(profile, along)?.1,+ _ => along,+ };+ let (o, x, y, k) = revolution_frame(&h, *origin, *axis)?;+ let net: Vec<Vec<[f64; 4]>> = arcs_r+ .iter()+ .map(|([c, s], wu)| {+ h.iter()+ .map(|hp| {+ let d = Vec3::new(hp[0] / hp[3], hp[1] / hp[3], hp[2] / hp[3]) - o;+ let (a, b, z) = (d.dot(x), d.dot(y), d.dot(k));+ let q = o + k * z + x * (a * c - b * s) + y * (a * s + b * c);+ hom(affine(matrix, q), wu * hp[3])+ })+ .collect()+ })+ .collect();+ if *forward {+ // u the profile, v the angle: the net turned over.+ let n = net.first()?.len();+ let t: Vec<Vec<[f64; 4]>> = (0..n).map(|j| net.iter().filter_map(|r| r.get(j).copied()).collect()).collect();+ Some((Surface::RationalSpline { u_knots: p_knots, v_knots: a_knots, homogeneous: t }, [fp, fa]))+ } else {+ Some((Surface::RationalSpline { u_knots: a_knots, v_knots: p_knots, homogeneous: net }, [fa, fp]))+ }}_ => None,}@@ -196,14 +242,60 @@ pub fn on_frame(c: &Curve, [t0, t1]: [f64; 2], frame: &Frame, tol: f64) -> OptioSome((Curve::Circle { frame: relabel, radius: *radius }, [t0 + shift, t1 + shift]))}-/// The frame of a cylinder, cone, sphere or torus (`None` for another surface).-pub fn frame_of(s: &Surface) -> Option<&Frame> {+/// The frame of a cylinder, cone, sphere or torus, or of a placed revolution (its axis, angle+/// zero at its profile: [`revolution_frame`]); `None` for another surface.+pub fn frame_of(s: &Surface) -> Option<Frame> {match s {- Surface::Cylinder { frame, .. } | Surface::Cone { frame, .. } | Surface::Sphere { frame, .. } | Surface::Torus { frame, .. } => Some(frame),+ Surface::Cylinder { frame, .. } | Surface::Cone { frame, .. } | Surface::Sphere { frame, .. } | Surface::Torus { frame, .. } => {+ Some(frame.clone())+ }+ Surface::PlacedRevolution { profile, origin, axis, matrix, .. } => {+ let (_, h) = profile_nurbs(profile, None)?;+ let (o, x, y, _) = revolution_frame(&h, *origin, *axis)?;+ let m = |p: Vec3| affine(matrix, p);+ let (mo, mx, my) = (m(o), m(o + x) - m(o), m(o + y) - m(o));+ Some(Frame { origin: [mo.x, mo.y, mo.z], x_axis: [mx.x, mx.y, mx.z], y_axis: [my.x, my.y, my.z] })+ }+ _ => None,+ }+}++/// `matrix` (column-major, `matrix[column][row]`) applied to `p`.+fn affine(matrix: &[[f64; 4]; 4], p: Vec3) -> Vec3 {+ let row = |r: usize| matrix[0][r] * p.x + matrix[1][r] * p.y + matrix[2][r] * p.z + matrix[3][r];+ Vec3::new(row(0), row(1), row(2))+}++/// A revolution's profile as a NURBS: its knots and homogeneous control points (a B-spline or+/// NURBS as it is, a line or conic as its form over `range`; `None` without a range).+fn profile_nurbs(profile: &Curve, range: Option<[f64; 2]>) -> Option<(Vec<f64>, Vec<[f64; 4]>)> {+ let formed;+ let c = match profile {+ Curve::Spline { .. } | Curve::RationalSpline { .. } => profile,+ other => {+ formed = curve(other, range?)?.0;+ &formed+ }+ };+ match c {+ Curve::Spline { knots, points } => Some((knots.clone(), points.iter().map(|p| [p[0], p[1], p[2], 1.0]).collect())),+ Curve::RationalSpline { knots, homogeneous } => Some((knots.clone(), homogeneous.clone())),_ => None,}}+/// A revolution's frame: the origin and unit axis, x the radial direction of the profile's+/// first control point off the axis (angle zero), y = axis × x.+fn revolution_frame(h: &[[f64; 4]], origin: [f64; 3], axis: [f64; 3]) -> Option<(Vec3, Vec3, Vec3, Vec3)> {+ let (o, k) = (v3(origin), v3(axis).normalized()?);+ let x = h.iter().find_map(|h| {+ let d = Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3]) - o;+ let r = d - k * d.dot(k);+ if r.len() > 1e-12 * (1.0 + d.len()) { r.normalized() } else { None }+ })?;+ Some((o, x, k.cross(x), k))+}+/// An edge's label and NURBS form: a circle about the axis of one of `frames` (the cylinder,/// cone, sphere and torus faces it bounds) is labelled on that frame ([`on_frame`]), so its form/// lies on that face's quarter grid; a circle or ellipse then has its form ([`curve`]). The label@@ -221,3 +313,52 @@ pub fn edge<'a>(};Some((label, iv, form))}++/// Points per edge along a loop taken for a face's extent.+const EXTENT_POINTS: usize = 32;++/// The parameter box of a face on `label` over its boundary: each loop's points (`loops`, in+/// order along each loop) projected onto the label, a periodic parameter unwrapped from one point+/// to the next. What the face's NURBS form ([`surface`]) is built over; no pcurve is involved.+pub fn extent(label: &Surface, loops: &[Vec<(&Curve, [f64; 2], bool)>]) -> Option<[[f64; 2]; 2]> {+ let eval = super::eval::SurfaceEval::new(label).ok()?;+ let period = eval.domain().period;+ let (mut lo, mut hi) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]);+ for l in loops {+ let mut prev: Option<[f64; 2]> = None;+ for (c, [t0, t1], forward) in l {+ let curve = super::eval::CurveEval::new(c).ok()?;+ for k in 0..=EXTENT_POINTS {+ let f = k as f64 / EXTENT_POINTS as f64;+ let t = if *forward { t0 * (1.0 - f) + t1 * f } else { t1 * (1.0 - f) + t0 * f };+ let mut q = eval.project(curve.point(t)?, prev, f64::INFINITY)?;+ if let Some(p) = prev {+ for d in 0..2 {+ if let Some(Some(per)) = period.get(d) {+ q[d] += ((p[d] - q[d]) / per).round() * per;+ }+ }+ }+ // At a pole the collapsed parameter is anything: it bounds nothing.+ let pole = eval.pole(q);+ for d in 0..2 {+ if !pole.get(d).copied().unwrap_or(false) {+ lo[d] = lo[d].min(q[d]);+ hi[d] = hi[d].max(q[d]);+ }+ }+ if !pole.iter().any(|p| *p) {+ prev = Some(q);+ }+ }+ }+ }+ // At most one turn round a periodic direction; a boundary that never goes round it (a face+ // bounded by its seam alone) covers the whole turn from there.+ for d in 0..2 {+ if let Some(Some(per)) = period.get(d) {+ hi[d] = if hi[d] - lo[d] <= 1e-9 * per { lo[d] + per } else { hi[d].min(lo[d] + per) };+ }+ }+ (lo[0] < hi[0] && lo[1] < hi[1]).then_some([[lo[0], hi[0]], [lo[1], hi[1]]])+}diff --git a/crates/geom/src/brep/pcurve.rs b/crates/geom/src/brep/pcurve.rsindex 4cfd38c4d7..88b86a6bc8 100644--- a/crates/geom/src/brep/pcurve.rs+++ b/crates/geom/src/brep/pcurve.rs@@ -212,7 +212,7 @@ impl On {}fn pcurve(&self, record: &Curve, curve: &CurveEval, range: [f64; 2], tol: f64) -> Result<Curve2> {- if let Some(pc) = self.exact(record, curve, range)?+ if let Some(pc) = self.exact(record, curve, range, tol)?&& self.lifts(&pc, curve, range, 0.5 * tol){return Ok(pc);@@ -221,7 +221,7 @@ impl On {}/// The closed-form pcurve where there is one (unchecked).- fn exact(&self, record: &Curve, curve: &CurveEval, [t0, t1]: [f64; 2]) -> Result<Option<Curve2>> {+ fn exact(&self, record: &Curve, curve: &CurveEval, [t0, t1]: [f64; 2], tol: f64) -> Result<Option<Curve2>> {let segment = |a: [f64; 2], b: [f64; 2]| Curve2::Spline { knots: vec![t0, t0, t1, t1], points: vec![a, b] };let at = |t: f64| curve.point(t).ok_or_else(|| Error::Failed(format!("the curve has no point at {t}")));Ok(match (&self.surface, record) {@@ -283,7 +283,7 @@ impl On {let c = super::eval::Axes::new(frame);let turn = c.z.dot(axes.z);if (turn.abs() - 1.0).abs() > 1e-9 {- return Ok(None);+ return Ok(self.meridian(axes, &c, *radius, curve, [t0, t1]));}let sign = turn.signum();let u0 = c.x.dot(axes.y).atan2(c.x.dot(axes.x));@@ -305,28 +305,69 @@ impl On {let u = b.atan2(a);Some(segment([u, height(t0)?], [u, height(t1)?]))}- (SurfaceEval::Eval(..), _) => self.along(curve, [t0, t1]),+ (SurfaceEval::Eval(..), _) => self.along(curve, [t0, t1], tol),_ => None,})}+ /// A meridian of a sphere or a tube circle of a torus (a circle in a plane through the axis,+ /// centred on the sphere's centre or on the torus's ring): u fixed at the arc's azimuth, v its+ /// angle from the outward radial toward the axis, `α + s·t` (`s` ±1 as the circle runs).+ /// `None` for any other circle.+ fn meridian(&self, axes: &super::eval::Axes, c: &super::eval::Axes, radius: f64, curve: &CurveEval, [t0, t1]: [f64; 2]) -> Option<Curve2> {+ let ring = match &self.surface {+ SurfaceEval::Sphere { radius: r, .. } => (0.0, *r),+ SurfaceEval::Torus { major, minor, .. } => (*major, *minor),+ _ => return None,+ };+ let size = 1.0 + ring.0 + ring.1;+ if c.z.dot(axes.z).abs() > 1e-9 || (radius - ring.1).abs() > 1e-9 * size {+ return None;+ }+ let tm = 0.5 * (t0 + t1);+ let m = curve.point(tm)?;+ let [mx, my, _] = axes.local(m);+ let u0 = my.atan2(mx);+ let radial = (axes.x * mx + axes.y * my).normalized()?;+ // The circle's centre: the sphere's, or the torus's ring at that azimuth.+ let centre = axes.o + radial * ring.0;+ if c.o.dist(centre) > 1e-9 * size {+ return None;+ }+ let s = c.z.dot(radial.cross(axes.z)).signum();+ let d = m - centre;+ let vm = d.dot(axes.z).atan2(d.dot(radial));+ let alpha = vm - s * tm;+ Some(Curve2::Spline { knots: vec![t0, t0, t1, t1], points: vec![[u0, alpha + s * t0], [u0, alpha + s * t1]] })+ }+/// On a spline face (a NURBS form, or another spline), the edge's pcurve where it runs along/// the face's parameters at its own parameter's pace: a straight line in (u, v), between the/// ends' parameters, or with u (or v) the edge's parameter itself (a rim of a revolved form on/// the same quarter grid, whose two ends are one point on the seam). A candidate is taken only- /// where it lifts onto the edge to within rounding, so it is the exact pcurve; none is fitted.- fn along(&self, curve: &CurveEval, [t0, t1]: [f64; 2]) -> Option<Curve2> {+ /// where it lifts onto the edge within the record's tolerance, as the closed forms on analytic+ /// surfaces must: the closed form the geometry has, never a fit.+ fn along(&self, curve: &CurveEval, [t0, t1]: [f64; 2], tol: f64) -> Option<Curve2> {let (p0, p1, pm) = (curve.point(t0)?, curve.point(t1)?, curve.point(0.5 * (t0 + t1))?);let size = [p0, p1, pm].iter().flat_map(|p| [p.x.abs(), p.y.abs(), p.z.abs()]).fold(1.0, f64::max);- let exact = EXACT * size;+ // Within the record's tolerance, as the closed forms on analytic surfaces are, and never+ // looser than rounding.+ let exact = (0.5 * tol).max(EXACT * size);let line = |a: [f64; 2], b: [f64; 2]| Curve2::Spline { knots: vec![t0, t0, t1, t1], points: vec![a, b] };let mut candidates = Vec::with_capacity(3);- if let (Some(a), Some(b)) = (self.project(p0, None, exact), self.project(p1, None, exact)) {+ let ends = (self.project_in(p0, exact), self.project_in(p1, exact));+ if let (Some(a), Some(b)) = ends {candidates.push(line(a, b));}+ // One parameter fixed where the edge's middle is (an end on a seam or at an apex may+ // project anywhere along it), the other from the ends.+ if let (Some(a), Some(b), Some(m)) = (ends.0, ends.1, self.project_in(pm, exact)) {+ candidates.push(line([m[0], a[1]], [m[0], b[1]]));+ candidates.push(line([a[0], m[1]], [b[0], m[1]]));+ }// u or v the edge's own parameter, either way along and offset (forms on one frame's// quarter grid, or on the same grid turned over), the other fixed.- if let Some([u, v]) = self.project(pm, None, exact) {+ if let Some([u, v]) = self.project_in(pm, exact) {let tm = 0.5 * (t0 + t1);for sign in [1.0, -1.0] {let (cu, cv) = (u - sign * tm, v - sign * tm);@@ -351,6 +392,17 @@ impl On {})}+ /// The parameters of `p` within `accept` inside the face's parameter box when it has one: a+ /// spline extended past its knots, or a profile turned past where the face lies, has other+ /// preimages outside it. The global search first, then from the box's centre.+ fn project_in(&self, p: Vec3, accept: f64) -> Option<[f64; 2]> {+ let Some(b) = self.face else { return self.project(p, None, accept) };+ let pad = |d: usize| 1e-9 * (1.0 + (b[d][1] - b[d][0]).abs());+ let inside = |q: [f64; 2]| (0..2).all(|d| q[d] >= b[d][0] - pad(d) && q[d] <= b[d][1] + pad(d));+ let centre = [0.5 * (b[0][0] + b[0][1]), 0.5 * (b[1][0] + b[1][1])];+ [None, Some(centre)].into_iter().filter_map(|near| self.project(p, near, accept)).find(|q| inside(*q))+ }+/// The parameters of `p` within `accept`, from `near` (and unwrapped to it) when given.fn project(&self, p: Vec3, near: Option<[f64; 2]>, accept: f64) -> Option<[f64; 2]> {let mut q = self.surface.project_with(&self.starts, p, near, accept)?;diff --git a/crates/geom/src/brep/pcurve_tests.rs b/crates/geom/src/brep/pcurve_tests.rsindex 93d314dd77..04d5f096f8 100644--- a/crates/geom/src/brep/pcurve_tests.rs+++ b/crates/geom/src/brep/pcurve_tests.rs@@ -128,10 +128,10 @@ fn rulings_are_v_lines() {}}-/// Curves with no closed form are fitted cubic B-splines within the tolerance: a tilted circle-/// on a sphere, a plane's ellipse on a cylinder, a circle off the axis on a plane.+/// Curves with no closed form on their face are refused, never fitted: a tilted circle on a+/// sphere, a plane's ellipse on a cylinder, a circle off the axis on a plane.#[test]-fn other_curves_are_fitted_within_tolerance() {+fn curves_without_a_closed_form_are_refused() {let (s, c) = 0.5f64.sin_cos();let sphere = Surface::Sphere { frame: about_z([0.; 3], false), radius: 6. };let great = Curve::Circle { frame: frame([0.; 3], [1., 0., 0.], [0., c, s]), radius: 6. };@@ -143,22 +143,10 @@ fn other_curves_are_fitted_within_tolerance() {let plane = Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] };let circle = Curve::Circle { frame: about_z([3., 1., 0.], false), radius: 2. };for (surface, curve, interval) in [(&sphere, &great, [0., TAU]), (&cylinder, &ellipse, [0.2, 6.]), (&plane, &circle, [0., 3.])] {- for tol in [1e-3, 1e-6] {- let pc = &pcurves(surface, &one(curve, interval), tol).unwrap()[0][0];- let Curve2::Spline { knots, .. } = pc else { panic!("a B-spline") };- assert_eq!(knots.len() - pc_count(pc) - 1, 3, "cubic");- let e = lift_error(surface, curve, interval, pc);- assert!(e <= tol, "{curve:?} at {tol}: {e}");- }- }-}-fn pc_count(pc: &Curve2) -> usize {- match pc {- Curve2::Spline { points, .. } => points.len(),- Curve2::RationalSpline { homogeneous, .. } => homogeneous.len(),+ let r = pcurves(surface, &one(curve, interval), 1e-6);+ assert!(matches!(&r, Err(Error::Failed(m)) if m.contains("not supported yet: no exact pcurve")), "{curve:?}: {r:?}");}}-/// The ends of each use in loop order and the loop's signed area in (u, v).fn walk(l: &[EdgeUse<'_>], pcs: &[Curve2]) -> (Vec<([f64; 2], [f64; 2])>, f64) {let mut ring = Vec::new();@@ -288,27 +276,30 @@ fn a_seam_from_pole_to_pole_encloses_the_whole_sphere() {knots: vec![0., 0., 0., 0.5, 0.5, 1., 1., 1.],homogeneous: vec![h(o - z + side, 1.), h(o - z + r, w), h(o + r, 1.), h(o + z + r, w), h(o + z - side, 1.)],};- for (seam, iv) in [(&circle, [-FRAC_PI_2, FRAC_PI_2]), (&nurbs, [0., 1.])] {+ // The circle on the sphere as it is; the NURBS meridian, on a parameter of its own,+ // on the sphere's NURBS form (one turn is four quarters there, the latitude two).+ let (form, _) = crate::brep::form::surface(&sphere, [[0., TAU], [-FRAC_PI_2, FRAC_PI_2]]).unwrap();+ for (seam, iv, on, period, height) in [(&circle, [-FRAC_PI_2, FRAC_PI_2], &sphere, TAU, PI), (&nurbs, [0., 1.], &form, 4., 2.)] {for order in [[true, false], [false, true]] {let l: Vec<EdgeUse> = order.iter().map(|&forward| EdgeUse { edge: 0, curve: seam, interval: iv, forward, tolerance: 0.0, given: None }).collect();- let pcs = &pcurves(&sphere, std::slice::from_ref(&l), tol).unwrap()[0];+ let pcs = &pcurves(on, std::slice::from_ref(&l), tol).unwrap()[0];let what = format!("{sf:?} {turn} {off} {seam:?} {order:?}");for pc in pcs {- assert!(lift_error(&sphere, seam, iv, pc) <= tol, "{what}");+ assert!(lift_error(on, seam, iv, pc) <= tol, "{what}");}let mid = 0.5 * (iv[0] + iv[1]);let (a, b) = (pcs[0].eval(mid).unwrap(), pcs[1].eval(mid).unwrap());- assert!(((a[0] - b[0]).abs() - TAU).abs() < 1e-6 && (a[1] - b[1]).abs() < 1e-12, "a period apart: {a:?} {b:?} {what}");+ assert!(((a[0] - b[0]).abs() - period).abs() < 1e-6 && (a[1] - b[1]).abs() < 1e-12, "a period apart: {a:?} {b:?} {what}");let (ends, area) = walk(&l, pcs);for k in 0..2 {assert!((ends[k].1[1] - ends[(k + 1) % 2].0[1]).abs() < 1e-6, "closed in v: {ends:?} {what}");}// The box less the corners `walk` cuts (it joins each use's 16th// sample to the next use's start): about 15/16 of it.- assert!((area / (TAU * PI * 15. / 16.) - 1.).abs() < 1e-2, "counter-clockwise around the box: {area} {what}");+ assert!((area / (period * height * 15. / 16.) - 1.).abs() < 1e-2, "counter-clockwise around the box: {area} {what}");}}}@@ -346,28 +337,6 @@ fn a_torus_bounded_by_its_seams_spans_both_periods() {}}-/// A surface of revolution about +z as a rational spline closed in u, as SMLib writes a fillet-/// ring round a hole's rim and STEP a NURBS cylinder: u the nine-point rational quadratic-/// circle on [0, 1] (first and last rows the same), v the profile's `[radius, height, weight]`-/// points on `v_knots`.-pub(crate) fn closed_ring(profile: &[[f64; 3]], v_knots: &[f64]) -> Surface {- let w = std::f64::consts::FRAC_1_SQRT_2;- let around = [[1., 0., 1.], [1., 1., w], [0., 1., 1.], [-1., 1., w], [-1., 0., 1.], [-1., -1., w], [0., -1., 1.], [1., -1., w], [1., 0., 1.]];- let homogeneous = around- .iter()- .map(|&[cx, cy, wu]| {- profile- .iter()- .map(|&[r, z, wv]| {- let wt = wu * wv;- [r * cx * wt, r * cy * wt, z * wt, wt]- })- .collect()- })- .collect();- Surface::RationalSpline { u_knots: vec![0., 0., 0., 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1., 1., 1.], v_knots: v_knots.to_vec(), homogeneous }-}-/// The pcurves of a loop on a spline closed in u (period 1): each lifts within `tol`, the/// seam's two uses (`seam`: their positions) lie one period apart, the loop closes (in v alone/// where it meets a pole) and turns counter-clockwise once around the whole (u, v) box, all in@@ -380,7 +349,9 @@ fn closes_around_the_box(surface: &Surface, l: &[EdgeUse<'_>], seam: [usize; 2],let iv = l[seam[0]].interval;let mid = 0.5 * (iv[0] + iv[1]);let (a, b) = (pcs[seam[0]].eval(mid).unwrap(), pcs[seam[1]].eval(mid).unwrap());- assert!(((a[0] - b[0]).abs() - 1.).abs() < 1e-9 && (a[1] - b[1]).abs() < 1e-9, "{what}: seam uses a period apart: {a:?} {b:?}");+ let dom = SurfaceEval::new(surface).unwrap().domain();+ let period = dom.period[0].unwrap();+ assert!(((a[0] - b[0]).abs() - period).abs() < 1e-9 && (a[1] - b[1]).abs() < 1e-9, "{what}: seam uses a period apart: {a:?} {b:?}");let (ends, area) = walk(l, pcs);let n = l.len();for k in 0..n {@@ -390,6 +361,8 @@ fn closes_around_the_box(surface: &Surface, l: &[EdgeUse<'_>], seam: [usize; 2],}// At a pole `walk` cuts the corner (it joins each use's 16th sample to the next use's// start, across the pole's line): a sliver of the box less.+ let [u, v] = dom.range.map(|r| r.unwrap());+ let area = area / ((u.1 - u.0) * (v.1 - v.0));let least = if pole.is_some() { 0.9 } else { 1. - 1e-6 };assert!(area >= least && area < 1. + 1e-6, "{what}: counter-clockwise around the box: {area}");for pc in pcs {@@ -397,7 +370,7 @@ fn closes_around_the_box(surface: &Surface, l: &[EdgeUse<'_>], seam: [usize; 2],for k in 0..=32 {let t = knots[0] + (knots[knots.len() - 1] - knots[0]) * k as f64 / 32.;let q = pc.eval(t).unwrap();- assert!((-1e-9..=1. + 1e-9).contains(&q[0]), "{what}: base period: {q:?}");+ assert!((u.0 - 1e-9..=u.1 + 1e-9).contains(&q[0]), "{what}: base period: {q:?}");}}}@@ -408,43 +381,45 @@ fn closes_around_the_box(surface: &Surface, l: &[EdgeUse<'_>], seam: [usize; 2],/// into its pole. Each seam's uses come out a period apart, never both on u = 0.#[test]fn a_seam_on_a_spline_closed_in_u_gets_pcurves_a_period_apart() {- let w = std::f64::consts::FRAC_1_SQRT_2;let full = [0., TAU];let (big, small) = (5., 1.);- // The torus band: the tube's quarter from its outer equator (v = 0) to its top (v = 1).- let band = closed_ring(&[[big + small, 0., 1.], [big + small, small, w], [big, small, 1.]], &[0., 0., 0., 1., 1., 1.]);- let outer = Curve::Circle { frame: about_z([0.; 3], false), radius: big + small };- let top = Curve::Circle { frame: about_z([0., 0., small], false), radius: big };- let quarter = Curve::Circle { frame: frame([big, 0., 0.], [1., 0., 0.], [0., 0., 1.]), radius: small };+ // Each surface and circle on its NURBS form (`form`), as SolidCraft's builders give them.+ let on = |c: &Curve, iv: [f64; 2]| crate::brep::form::curve(c, iv).unwrap();+ // The torus band: the tube's quarter from its outer equator to its top.+ let torus = Surface::Torus { frame: about_z([0.; 3], false), major_radius: big, minor_radius: small };+ let (band, _) = crate::brep::form::surface(&torus, [full, [0., FRAC_PI_2]]).unwrap();+ let outer = on(&Curve::Circle { frame: about_z([0.; 3], false), radius: big + small }, full);+ let top = on(&Curve::Circle { frame: about_z([0., 0., small], false), radius: big }, full);+ let quarter = on(&Curve::Circle { frame: frame([big, 0., 0.], [1., 0., 0.], [0., 0., 1.]), radius: small }, [0., FRAC_PI_2]);let l = vec![- EdgeUse { edge: 0, curve: &outer, interval: full, forward: true, tolerance: 0.0, given: None },- EdgeUse { edge: 1, curve: &quarter, interval: [0., FRAC_PI_2], forward: true, tolerance: 0.0, given: None },- EdgeUse { edge: 2, curve: &top, interval: full, forward: false, tolerance: 0.0, given: None },- EdgeUse { edge: 1, curve: &quarter, interval: [0., FRAC_PI_2], forward: false, tolerance: 0.0, given: None },+ EdgeUse { edge: 0, curve: &outer.0, interval: outer.1, forward: true, tolerance: 0.0, given: None },+ EdgeUse { edge: 1, curve: &quarter.0, interval: quarter.1, forward: true, tolerance: 0.0, given: None },+ EdgeUse { edge: 2, curve: &top.0, interval: top.1, forward: false, tolerance: 0.0, given: None },+ EdgeUse { edge: 1, curve: &quarter.0, interval: quarter.1, forward: false, tolerance: 0.0, given: None },];for tol in [1e-4, 1e-7] {closes_around_the_box(&band, &l, [1, 3], None, tol, &format!("torus band, tol {tol}"));}- // The cylinder: radius 3 from z = 0 (v = 0) to z = 4 (v = 1), its seam a line.- let cylinder = closed_ring(&[[3., 0., 1.], [3., 4., 1.]], &[0., 0., 1., 1.]);- let (low, high) =- (Curve::Circle { frame: about_z([0.; 3], false), radius: 3. }, Curve::Circle { frame: about_z([0., 0., 4.], false), radius: 3. });+ // The cylinder: radius 3 from z = 0 to z = 4, its seam a line.+ let (cylinder, _) = crate::brep::form::surface(&Surface::Cylinder { frame: about_z([0.; 3], false), radius: 3. }, [full, [0., 4.]]).unwrap();+ let low = on(&Curve::Circle { frame: about_z([0.; 3], false), radius: 3. }, full);+ let high = on(&Curve::Circle { frame: about_z([0., 0., 4.], false), radius: 3. }, full);let line = Curve::Line { start: [3., 0., 0.], end: [3., 0., 4.] };let l = vec![- EdgeUse { edge: 0, curve: &low, interval: full, forward: true, tolerance: 0.0, given: None },+ EdgeUse { edge: 0, curve: &low.0, interval: low.1, forward: true, tolerance: 0.0, given: None },EdgeUse { edge: 1, curve: &line, interval: [0., 1.], forward: true, tolerance: 0.0, given: None },- EdgeUse { edge: 2, curve: &high, interval: full, forward: false, tolerance: 0.0, given: None },+ EdgeUse { edge: 2, curve: &high.0, interval: high.1, forward: false, tolerance: 0.0, given: None },EdgeUse { edge: 1, curve: &line, interval: [0., 1.], forward: false, tolerance: 0.0, given: None },];closes_around_the_box(&cylinder, &l, [1, 3], None, 1e-7, "cylinder");- // The dome: radius 6 from its equator (v = 0) to its pole (v = 1), the seam a meridian.- let dome = closed_ring(&[[6., 0., 1.], [6., 6., w], [0., 6., 1.]], &[0., 0., 0., 1., 1., 1.]);- let equator = Curve::Circle { frame: about_z([0.; 3], false), radius: 6. };- let meridian = Curve::Circle { frame: frame([0.; 3], [1., 0., 0.], [0., 0., 1.]), radius: 6. };+ // The dome: radius 6 from its equator to its pole, the seam a meridian.+ let (dome, _) = crate::brep::form::surface(&Surface::Sphere { frame: about_z([0.; 3], false), radius: 6. }, [full, [0., FRAC_PI_2]]).unwrap();+ let equator = on(&Curve::Circle { frame: about_z([0.; 3], false), radius: 6. }, full);+ let meridian = on(&Curve::Circle { frame: frame([0.; 3], [1., 0., 0.], [0., 0., 1.]), radius: 6. }, [0., FRAC_PI_2]);let l = vec![- EdgeUse { edge: 0, curve: &equator, interval: full, forward: true, tolerance: 0.0, given: None },- EdgeUse { edge: 1, curve: &meridian, interval: [0., FRAC_PI_2], forward: true, tolerance: 0.0, given: None },- EdgeUse { edge: 1, curve: &meridian, interval: [0., FRAC_PI_2], forward: false, tolerance: 0.0, given: None },+ EdgeUse { edge: 0, curve: &equator.0, interval: equator.1, forward: true, tolerance: 0.0, given: None },+ EdgeUse { edge: 1, curve: &meridian.0, interval: meridian.1, forward: true, tolerance: 0.0, given: None },+ EdgeUse { edge: 1, curve: &meridian.0, interval: meridian.1, forward: false, tolerance: 0.0, given: None },];closes_around_the_box(&dome, &l, [1, 2], Some(2), 1e-7, "dome");// A spline whose ends merely come near each other stays open: no period, so the seam's@@ -454,11 +429,11 @@ fn a_seam_on_a_spline_closed_in_u_gets_pcurves_a_period_apart() {open[8][0][1] += 1e-3;let open = Surface::RationalSpline { u_knots: u_knots.clone(), v_knots: v_knots.clone(), homogeneous: open };assert_eq!(SurfaceEval::new(&open).unwrap().domain().period, [None, None]);- assert_eq!(SurfaceEval::new(&cylinder).unwrap().domain().period, [Some(1.), None]);+ assert_eq!(SurfaceEval::new(&cylinder).unwrap().domain().period, [Some(4.), None]);}/// An intersection record evaluates to the point of both surfaces in the leader's normal-/// plane, and its pcurves on either surface fit.+/// plane; it has no exact pcurve on either.#[test]fn intersection_curves_lie_on_both_surfaces() {// The cylinder x² + y² = 25 cut by the plane z = 20 + x tan 0.4: an ellipse.@@ -482,9 +457,10 @@ fn intersection_curves_lie_on_both_surfaces() {let p = eval.point(12. * i as f64 / 48.).unwrap();assert!((p.x.hypot(p.y) - 5.).abs() < 1e-11 && (p.z - 20. - p.x * k).abs() < 1e-11, "{i}: {p:?}");}+ // It has no closed-form pcurve on either surface (an intersection record is a construction,+ // not a NURBS): refused, never fitted.for surface in [&cylinder, &plane] {- let pc = &pcurves(surface, &one(&curve, [0., 12.]), 1e-6).unwrap()[0][0];- assert!(lift_error(surface, &curve, [0., 12.], pc) <= 1e-6);+ assert!(matches!(pcurves(surface, &one(&curve, [0., 12.]), 1e-6), Err(Error::Failed(m)) if m.contains("no exact pcurve")));}}@@ -555,13 +531,11 @@ fn an_edge_along_the_rim_of_a_band_winding_close_to_itself_stays_on_its_turn() {}}-/// A curve that is smooth through a knot of full multiplicity (one smooth curve with the knot-/// inserted three times, as SMLib's intersection curves come) gets a pcurve with one tangent-/// there. Two pieces fitted apart meet at an angle in (u, v) (a tenth of a degree here, over the-/// degree SMLib's check allows on a real thread), sharp where u runs hundreds of times as fast as-/// v.+/// A curve weaving across a thread flank, smooth through a knot of full multiplicity (one smooth+/// curve with the knot inserted three times, as SMLib's intersection curves come), has no+/// closed-form pcurve on the flank: it is refused, never fitted (SMLib gives its own trims).#[test]-fn a_smooth_curve_through_a_full_knot_gets_a_pcurve_with_a_tangent_there() {+fn a_curve_weaving_across_a_thread_flank_is_refused() {let (surface, _) = thread_flank();let s = SurfaceEval::new(&surface).unwrap();// Along the flank as it winds, a third of a turn (u = t), weaving a little across it.@@ -576,13 +550,8 @@ fn a_smooth_curve_through_a_full_knot_gets_a_pcurve_with_a_tangent_there() {(knots, ctrl) = crate::bspline::insert_knot(3, &knots, &ctrl, k).unwrap();}let weave = Curve::Spline { knots, points: ctrl.iter().map(|h| h.project().unwrap()).map(|p| [p.x, p.y, p.z]).collect() };- let pc = &pcurves(&surface, &one(&weave, [a, b]), 1e-3).unwrap()[0][0];- assert!(lift_error(&surface, &weave, [a, b], pc) <= 1e-3);- let h = 1e-7;- let (l, m, r) = (pc.eval(k - h).unwrap(), pc.eval(k).unwrap(), pc.eval(k + h).unwrap());- let (dl, dr) = ([m[0] - l[0], m[1] - l[1]], [r[0] - m[0], r[1] - m[1]]);- let cos = (dl[0] * dr[0] + dl[1] * dr[1]) / (dl[0].hypot(dl[1]) * dr[0].hypot(dr[1]));- assert!(cos > 1. - 1e-6, "the pcurve turns by {} degrees at the knot", cos.min(1.).acos().to_degrees());+ // A curve weaving across the flank has no closed-form pcurve there: refused, never fitted.+ assert!(matches!(pcurves(&surface, &one(&weave, [a, b]), 1e-3), Err(Error::Failed(m)) if m.contains("no exact pcurve")));}/// Hostile records give errors, never a panic.@@ -607,11 +576,12 @@ fn hostile_records_give_errors() {// Too many uses, refused before any work.let many = vec![vec![EdgeUse { edge: 0, curve: &line, interval: [0., 1.], forward: true, tolerance: 0.0, given: None }; MAX_USES + 1]];assert!(matches!(pcurves(&plane, &many, 1e-6), Err(Error::TooLarge(_))));- // A polyline of many points on a curved surface: too many spans for one pcurve.+ // A polyline of many points across a curved surface: it has no exact pcurve there, and is+ // refused as such (nothing is fitted).let cylinder = Surface::Cylinder { frame: about_z([0.; 3], false), radius: 1. };let n = 5000;let zigzag = Curve::Polyline { points: (0..n).map(|i| [(i as f64 * 0.01).cos(), (i as f64 * 0.01).sin(), (i % 2) as f64]).collect() };- assert!(matches!(pcurves(&cylinder, &one(&zigzag, [0., (n - 1) as f64]), 1e-6), Err(Error::TooLarge(_))));+ assert!(matches!(pcurves(&cylinder, &one(&zigzag, [0., (n - 1) as f64]), 1e-6), Err(Error::Failed(m)) if m.contains("no exact pcurve")));// A degree the evaluators do not take.let high = Curve::Spline { knots: [vec![0.; 10], vec![1.; 10]].concat(), points: (0..10).map(|i| [i as f64, 0., 0.]).collect() };assert!(matches!(pcurves(&cylinder, &one(&high, [0., 1.]), 1e-6), Err(Error::Failed(_))));diff --git a/crates/geom/src/brep/tests.rs b/crates/geom/src/brep/tests.rsindex 0fdd82bc80..62bdc35cbf 100644--- a/crates/geom/src/brep/tests.rs+++ b/crates/geom/src/brep/tests.rs@@ -25,6 +25,26 @@ fn list_uses(b: &mut Brep) {}}+/// Every analytic face and conic edge on its NURBS form, as producers make them: a face's form+/// over its stated domain, a circle about a face's axis labelled on its frame (`form::edge`).+fn on_forms(b: &mut Brep) {+ let frames: Vec<Frame> = b.faces.iter().filter(|f| f.nurbs.is_none()).filter_map(|f| form::frame_of(&f.surface)).collect();+ for f in &mut b.faces {+ if f.nurbs.is_none()+ && let Some((n, d)) = form::surface(&f.surface, f.domain)+ {+ (f.nurbs, f.domain) = (Some(n), d);+ }+ }+ for e in &mut b.edges {+ if e.nurbs.is_none()+ && let Some((label, _, Some((n, iv)))) = form::edge(&e.curve, e.interval, &frames, b.tolerance)+ {+ (e.curve, e.nurbs, e.interval) = (label, Some(n), iv);+ }+ }+}+/// Every oriented edge's pcurve from its face's surface and its edge (`pcurve::pcurves`).fn fit_pcurves(b: &mut Brep) {for f in &mut b.faces {@@ -38,7 +58,7 @@ fn fit_pcurves(b: &mut Brep) {let e = &b.edges[u.edge as usize];pcurve::EdgeUse {edge: u.edge,- curve: &e.curve,+ curve: e.parameters(),interval: e.interval,forward: u.forward,tolerance: e.tolerance,@@ -49,7 +69,7 @@ fn fit_pcurves(b: &mut Brep) {Loop::Vertex { .. } => vec![],}).collect();- let fitted = pcurve::pcurves(&f.surface, &loops, 1e-7).unwrap();+ let fitted = pcurve::pcurves_within(f.parameters(), &loops, 1e-7, Some(f.domain)).unwrap();for (l, pcs) in f.loops.iter_mut().zip(fitted) {if let Loop::Edges { edges } = l {for (u, pc) in edges.iter_mut().zip(pcs) {@@ -166,6 +186,7 @@ fn tube() -> Brep {vertices: vec![Vertex { point: [3., 2., 3.], tolerance: 1e-7 }, Vertex { point: [3., 2., 8.], tolerance: 1e-7 }],};list_uses(&mut b);+ on_forms(&mut b);fit_pcurves(&mut b);b}@@ -190,21 +211,22 @@ fn one_face(surface: Surface, domain: [[f64; 2]; 2], edges: Vec<(Curve, [f64; 2]vertices: vertices.iter().map(|&point| Vertex { point, tolerance: 1e-7 }).collect(),};list_uses(&mut b);+ on_forms(&mut b);fit_pcurves(&mut b);b}-/// A ring of a torus as a rational spline closed in u (first and last control rows the same),-/// as SMLib writes the fillet round a hole's rim: bounded by its two circles and the tube's-/// quarter at u = 0, a seam used twice.+/// A ring of a torus on its NURBS form, closed in u (first and last control rows the same), as+/// SMLib holds the fillet round a hole's rim: bounded by its two circles and the tube's quarter+/// at u = 0, a seam used twice, each on its form.fn closed_band() -> Brep {- let w = std::f64::consts::FRAC_1_SQRT_2;let (big, small) = (5., 1.);- let surface = pcurve::tests::closed_ring(&[[big + small, 0., 1.], [big + small, small, w], [big, small, 1.]], &[0., 0., 0., 1., 1., 1.]);+ let torus =+ Surface::Torus { frame: Frame { origin: [0., 0., 0.], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] }, major_radius: big, minor_radius: small };let about = |z: f64| Frame { origin: [0., 0., z], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] };let quarter = Curve::Circle { frame: Frame { origin: [big, 0., 0.], x_axis: [1., 0., 0.], y_axis: [0., 0., 1.] }, radius: small };one_face(- surface,- [[0., 1.], [0., 1.]],+ torus,+ [[0., TAU], [0., FRAC_PI_2]],vec![(Curve::Circle { frame: about(0.), radius: big + small }, [0., TAU], [0, 0]),(quarter, [0., FRAC_PI_2], [0, 1]),@@ -359,9 +381,9 @@ fn one_defect_fixtures_are_refused() {}b}),- ("edge interval past one turn", "parameter interval exceeds one turn", {+ ("edge interval past its form", "parameter interval outside the natural domain", {let mut b = tube();- b.edges[0].interval = [0., TAU + 0.1];+ b.edges[0].interval = [0., 4.1];b}),("edge interval outside a spline", "parameter interval outside the natural domain", {@@ -377,13 +399,13 @@ fn one_defect_fixtures_are_refused() {}),("face domain outside the sphere", "parameter interval outside the natural domain", {let mut b = sheet();- b.faces[0].surface = Surface::Sphere { frame: a_frame(), radius: 2. };- b.faces[0].domain = [[0., TAU], [-FRAC_PI_2 - 0.1, FRAC_PI_2]];+ formed(&mut b, Surface::Sphere { frame: a_frame(), radius: 2. }, [[0., TAU], [-FRAC_PI_2, FRAC_PI_2]]);+ b.faces[0].domain[1][0] -= 0.1;b}),- ("face domain past one turn", "parameter interval exceeds one turn", {+ ("face domain past its form", "parameter interval outside the natural domain", {let mut b = tube();- b.faces[0].domain[0] = [0., TAU + 0.1];+ b.faces[0].domain[0] = [0., 4.1];b}),("face domain outside a spline surface", "parameter interval outside the natural domain", {@@ -480,8 +502,8 @@ fn one_defect_fixtures_are_refused() {}),("cone domain past its apex", "parameter interval outside the natural domain", {let mut b = sheet();- b.faces[0].surface = Surface::Cone { frame: a_frame(), radius_at_origin: 1., half_angle: 0.25 * std::f64::consts::PI };- b.faces[0].domain = [[0., 1.], [-2., 1.]];+ formed(&mut b, Surface::Cone { frame: a_frame(), radius_at_origin: 1., half_angle: 0.25 * std::f64::consts::PI }, [[0., 1.], [-1., 1.]]);+ b.faces[0].domain[1][0] = -2.;b}),];@@ -491,6 +513,12 @@ fn one_defect_fixtures_are_refused() {}}+/// Face 0 relabelled `surface` on its NURBS form over `domain` (its loops left as they were).+fn formed(b: &mut Brep, surface: Surface, domain: [[f64; 2]; 2]) {+ let (nurbs, domain) = form::surface(&surface, domain).expect("a form");+ let f = &mut b.faces[0];+ (f.surface, f.nurbs, f.domain) = (surface, Some(nurbs), domain);+}fn pcurve_of(b: &mut Brep, face: usize, position: usize) -> &mut Curve2 {let Loop::Edges { edges } = &mut b.faces[face].loops[0] else { panic!("an edge loop") };&mut edges[position].pcurve@@ -536,8 +564,9 @@ fn geometric_defects_are_refused_by_record() {Record::Use { face: 0, r#loop: 0, position: 1 },Box::new(|p: &Problem| matches!(p, Problem::Period { .. })),{+ // One turn of the tube's NURBS form is four quarters.let mut b = tube();- shift(pcurve_of(&mut b, 0, 1), [TAU, 0.]);+ shift(pcurve_of(&mut b, 0, 1), [4., 0.]);b},),@@ -549,10 +578,11 @@ fn geometric_defects_are_refused_by_record() {("seam uses of a closed spline on one line",Record::Use { face: 0, r#loop: 0, position: 1 },- Box::new(|p: &Problem| *p == Problem::Period { gap: 1., period: 1. }),+ // On the ring's NURBS form one turn is four quarters.+ Box::new(|p: &Problem| *p == Problem::Period { gap: 4., period: 4. }),{let mut b = closed_band();- shift(pcurve_of(&mut b, 0, 1), [-1., 0.]);+ shift(pcurve_of(&mut b, 0, 1), [-4., 0.]);b},),@@ -566,7 +596,8 @@ fn geometric_defects_are_refused_by_record() {let mut b = ball();let mid = |b: &mut Brep, k: usize| pcurve_of(b, 0, k).eval(0.).unwrap()[0];let by = mid(&mut b, 0) - mid(&mut b, 1);- assert!((by.abs() - TAU).abs() < 1e-9, "a period apart: {by}");+ // On the sphere's NURBS form one turn is four quarters.+ assert!((by.abs() - 4.).abs() < 1e-9, "a period apart: {by}");shift(pcurve_of(&mut b, 0, 1), [by, 0.]);b},@@ -626,7 +657,9 @@ fn hostile_records_never_panic_the_geometry_check() {b.faces[0].loops[1] = Loop::Vertex { vertex: u32::MAX };cases.push(b);let mut b = tube();- b.faces[0].surface = Surface::Cylinder { frame: a_frame(), radius: f64::NAN };+ if let Some(Surface::RationalSpline { homogeneous, .. }) = &mut b.faces[0].nurbs {+ homogeneous[0][0][0] = f64::NAN;+ }cases.push(b);let mut b = tube();b.edges[0].tolerance = f64::NAN;diff --git a/crates/kernel/src/assemble.rs b/crates/kernel/src/assemble.rsindex 829f381358..65d2458971 100644--- a/crates/kernel/src/assemble.rs+++ b/crates/kernel/src/assemble.rs@@ -12,7 +12,9 @@use solidcraft_geom::Vec3;use solidcraft_geom::brep::pcurve::{EdgeUse, pcurves_within};-use solidcraft_geom::brep::{Brep, Curve, Curve2, Edge, Face, Loop, Natural, OrientedEdge, OrientedFace, Region, Shell, Surface, VERSION, Vertex};+use solidcraft_geom::brep::{+ Brep, Curve, Curve2, Edge, Face, Frame, Loop, Natural, OrientedEdge, OrientedFace, Region, Shell, Surface, VERSION, Vertex, form,+};use crate::body::Body;use crate::history::{EdgeOrigin, FaceProv};@@ -62,13 +64,6 @@ pub(crate) struct AFace {pub domain: Option<[[f64; 2]; 2]>,}-impl AFace {- /// The surface the face's (u, v) are on, as `Face::parameters`.- pub fn parameters(&self) -> &Surface {- self.nurbs.as_ref().unwrap_or(&self.surface)- }-}-/// A body taken apart: vertices, edges and faces that [`Assembly::finish`] builds into a record.#[derive(Clone, Debug)]pub(crate) struct Assembly {@@ -215,10 +210,11 @@ impl Assembly {let mut by_shell: Vec<Vec<u32>> = vec![Vec::new(); self.shells];let mut faces: Vec<Face> = Vec::with_capacity(kept.len());let mut sides: Vec<bool> = Vec::with_capacity(kept.len());+ let formed = self.formed()?;for (k, &i) in kept.iter().enumerate() {let f = self.faces.get(i).and_then(Option::as_ref).ok_or_else(|| invalid("face reference"))?;by_shell.get_mut(f.shell).ok_or_else(|| invalid("shell reference"))?.push(index(k)?);- faces.push(self.stored(i, f)?);+ faces.push(self.stored(i, f, &formed)?);sides.push(f.natural_out);}let shells = by_shell@@ -237,10 +233,10 @@ impl Assembly {regions.push(Region { shells: region.shells.iter().copied().filter(|s| used(*s)).collect(), void: region.void });}}- let edges = self.edges.iter().map(|a| Edge {- nurbs: a.nurbs.clone(),- curve: a.curve.clone(),- interval: a.interval,+ let edges = self.edges.iter().zip(&formed.edges).map(|(a, f)| Edge {+ nurbs: f.nurbs.clone(),+ curve: f.label.clone(),+ interval: f.interval,vertices: a.vertices,tolerance: a.tolerance,uses: Vec::new(),@@ -258,9 +254,64 @@ impl Assembly {Ok(Finished { record: part.brep, faces: face_map, edges: part.edges.iter().map(|e| *e as usize).collect() })}+ /// Which faces and edges go on a NURBS form, and theirs. A cylinder, cone, sphere, torus or+ /// revolution face without one takes one where none of its uses brings its own pcurve (those+ /// are on its label's parameters); an edge without one takes one (a circle about such a+ /// face's axis labelled on its frame, `form::edge`) where none of its uses brings a pcurve+ /// and every face it bounds is a plane, a spline or on a form.+ fn formed(&self) -> Result<Formed> {+ let takes: Vec<bool> = self+ .faces+ .iter()+ .map(|f| {+ f.as_ref()+ .is_some_and(|f| f.nurbs.is_none() && form::frame_of(&f.surface).is_some() && f.loops.iter().flatten().all(|u| u.given.is_none()))+ })+ .collect();+ let n = self.edges.len();+ let (mut frames, mut open, mut given): (Vec<Vec<Frame>>, Vec<bool>, Vec<bool>) = (vec![Vec::new(); n], vec![true; n], vec![false; n]);+ for (f, takes) in self.faces.iter().zip(&takes) {+ let Some(f) = f else { continue };+ let on_form = f.nurbs.is_some()+ || *takes+ || matches!(+ f.surface,+ Surface::Plane { .. } | Surface::PlaneThrough { .. } | Surface::Spline { .. } | Surface::RationalSpline { .. }+ );+ let frame = if *takes { form::frame_of(&f.surface) } else { None };+ for u in f.loops.iter().flatten() {+ let e = u.edge as usize;+ if u.given.is_some() {+ if let Some(g) = given.get_mut(e) {+ *g = true;+ }+ }+ if !on_form && let Some(o) = open.get_mut(e) {+ *o = false;+ }+ if let (Some(fr), Some(slot)) = (&frame, frames.get_mut(e)) {+ slot.push(fr.clone());+ }+ }+ }+ let mut edges = Vec::with_capacity(n);+ for (i, a) in self.edges.iter().enumerate() {+ let free = a.nurbs.is_none() && !given.get(i).copied().unwrap_or(true) && open.get(i).copied().unwrap_or(false);+ let fr = frames.get(i).map(Vec::as_slice).unwrap_or(&[]);+ edges.push(match (free, form::edge(&a.curve, a.interval, fr, self.tolerance)) {+ (true, Some((label, iv, Some((nurbs, interval))))) => {+ FormedEdge { label: label.clone(), label_interval: iv, nurbs: Some(nurbs), interval }+ }+ _ => FormedEdge { label: a.curve.clone(), label_interval: a.interval, nurbs: a.nurbs.clone(), interval: a.interval },+ });+ }+ Ok(Formed { faces: takes, edges })+ }+/// Face `i` as the record stores it: its loops relative to its surface's natural normal, each- /// use with its pcurve (the record's own where the use kept one), and its parameter box.- fn stored(&self, i: usize, f: &AFace) -> Result<Face> {+ /// use with its pcurve (the record's own where the use kept one), on its NURBS form (its own,+ /// or the one [`Assembly::formed`] gives it, over its boundary's extent), and its parameter box.+ fn stored(&self, i: usize, f: &AFace, formed: &Formed) -> Result<Face> {let loops: Vec<Vec<AUse>> = f.loops.iter()@@ -278,10 +329,11 @@ impl Assembly {l.iter().map(|u| {let e = self.edges.get(u.edge as usize).ok_or_else(|| invalid("edge reference"))?;+ let fe = formed.edges.get(u.edge as usize).ok_or_else(|| invalid("edge reference"))?;Ok(EdgeUse {edge: u.edge,- curve: e.nurbs.as_ref().unwrap_or(&e.curve),- interval: e.interval,+ curve: fe.nurbs.as_ref().unwrap_or(&fe.label),+ interval: fe.interval,forward: u.forward,tolerance: e.tolerance,given: u.given.as_ref(),@@ -290,8 +342,21 @@ impl Assembly {.collect::<Result<Vec<_>>>()}).collect::<Result<_>>()?;- let pcurves = pcurves_within(f.parameters(), &uses, self.tolerance, f.domain).map_err(|e| invalid(format!("face {i}: {e}")))?;- let domain = domain_of(f.parameters(), &pcurves, f.domain).ok_or_else(|| invalid(format!("face {i}: no parameter box")))?;+ // A face taking a form: its form over its boundary's extent on its label.+ let (nurbs, kept) = if formed.faces.get(i).copied().unwrap_or(false) {+ let boundary: Vec<Vec<(&Curve, [f64; 2], bool)>> = loops+ .iter()+ .map(|l| l.iter().filter_map(|u| formed.edges.get(u.edge as usize).map(|e| (&e.label, e.label_interval, u.forward))).collect())+ .collect();+ let extent = form::extent(&f.surface, &boundary).ok_or_else(|| invalid(format!("face {i}: its boundary is not on its surface")))?;+ let (n, d) = form::surface(&f.surface, extent).ok_or_else(|| invalid(format!("face {i}: more than one turn")))?;+ (Some(n), Some(d))+ } else {+ (f.nurbs.clone(), f.domain)+ };+ let on = nurbs.as_ref().unwrap_or(&f.surface);+ let pcurves = pcurves_within(on, &uses, self.tolerance, kept).map_err(|e| invalid(format!("face {i}: {e}")))?;+ let domain = domain_of(on, &pcurves, kept).ok_or_else(|| invalid(format!("face {i}: no parameter box")))?;let stored = loops.iter().zip(&pcurves)@@ -299,10 +364,24 @@ impl Assembly {edges: l.iter().zip(pc).map(|(u, pcurve)| OrientedEdge { edge: u.edge, forward: u.forward, pcurve: pcurve.clone() }).collect(),}).collect();- Ok(Face { nurbs: f.nurbs.clone(), surface: f.surface.clone(), domain, loops: stored })+ Ok(Face { nurbs, surface: f.surface.clone(), domain, loops: stored })}}+/// What [`Assembly::formed`] decides: which faces take a NURBS form, and each edge's label (a+/// circle relabelled on a face's frame), its interval there, and its form with its interval.+struct Formed {+ faces: Vec<bool>,+ edges: Vec<FormedEdge>,+}++struct FormedEdge {+ label: Curve,+ label_interval: [f64; 2],+ nurbs: Option<Curve>,+ interval: [f64; 2],+}+/// Reverse a loop: the same edges, the other way round.fn reverse(l: &mut [AUse]) {l.reverse();diff --git a/crates/kernel/src/sew.rs b/crates/kernel/src/sew.rsindex f4e62e469d..f83b314cf3 100644--- a/crates/kernel/src/sew.rs+++ b/crates/kernel/src/sew.rs@@ -1365,12 +1365,12 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result<Assembled> {// Each edge's label and NURBS form (`form::edge`): a circle about a revolved face's axis on// that face's frame, so its form lies on the face's quarter grid; an edge the caller gave a// pcurve for keeps the parameter that pcurve is on.- let mut frames_of: Vec<Vec<&b::Frame>> = vec![Vec::new(); edges.len()];+ let mut frames_of: Vec<Vec<b::Frame>> = vec![Vec::new(); edges.len()];for f in &faces {let Some(frame) = b::form::frame_of(&f.surface) else { continue };for u in f.loops.iter().flatten() {if let Some(slot) = frames_of.get_mut(u.edge as usize) {- slot.push(frame);+ slot.push(frame.clone());}}}@@ -1383,7 +1383,7 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result<Assembled> {continue;}let (label, interval, form) =- b::form::edge(&e.curve, e.interval, frames.iter().copied(), tol).ok_or_else(|| fail("an arc of more than one turn".into()))?;+ b::form::edge(&e.curve, e.interval, frames.iter(), tol).ok_or_else(|| fail("an arc of more than one turn".into()))?;labels.push((label, interval));forms.push(form);}@@ -1405,18 +1405,26 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result<Assembled> {}).collect()};- let folded_label = folded_on(None);+ // A cylinder, cone, sphere or torus on its NURBS form, over the extent of its boundary on+ // its label.let form = match f.surface {b::Surface::Cylinder { .. } | b::Surface::Cone { .. } | b::Surface::Sphere { .. } | b::Surface::Torus { .. } => {- let label = pcurve::pcurves(&f.surface, &uses_of(&edges, &forms, ls, false, &folded_label, tol)?, tol).map_err(failed)?;- let extent = domain_of(&f.surface, &label).ok_or_else(|| fail(format!("face {fi} has no area in its parameters")))?;- Some(b::form::surface(&f.surface, extent).ok_or_else(|| fail(format!("face {fi}: more than one turn")))?.0)+ let boundary: Vec<Vec<(&b::Curve, [f64; 2], bool)>> = ls+ .iter()+ .map(|l| l.iter().filter_map(|&(e, forward, _)| labels.get(e as usize).map(|(c, i)| (c, *i, forward))).collect())+ .collect();+ let extent = b::form::extent(&f.surface, &boundary).ok_or_else(|| fail(format!("face {fi}: its boundary is not on its surface")))?;+ Some(b::form::surface(&f.surface, extent).ok_or_else(|| fail(format!("face {fi}: more than one turn")))?)}_ => None,};+ let (form, form_box) = match form {+ Some((s, d)) => (Some(s), Some(d)),+ None => (None, None),+ };let on = form.as_ref().unwrap_or(&f.surface);let folded_form = if form.is_some() { folded_on(form.as_ref()) } else { Vec::new() };- let pc = pcurve::pcurves(on, &uses_of(&edges, &forms, ls, true, &folded_form, tol)?, tol).map_err(failed)?;+ let pc = pcurve::pcurves_within(on, &uses_of(&edges, &forms, ls, &folded_form, tol)?, tol, form_box).map_err(failed)?;domains.push(domain_of(on, &pc).ok_or_else(|| fail(format!("face {fi} has no area in its parameters")))?);pcs.push(pc);face_forms.push(form);@@ -1568,14 +1576,13 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result<Assembled> {/// A face's parameter box: around its pcurves' control points (a B-spline lies in their hull),/// held inside the surface's natural domain (one turn where periodic). None when it has no/// width in either direction.-/// A face's edge uses for `pcurve::pcurves`: on each edge's NURBS form where it has one and-/// `formed`, else on its curve as given; `folded` gives the pcurves of edges folded across the-/// face (see [`folded_pcurve`]).+/// A face's edge uses for `pcurve::pcurves`: on each edge's NURBS form where it has one, else on+/// its curve as given; `folded` gives the pcurves of edges folded across the face (see+/// [`folded_pcurve`]).fn uses_of<'a>(edges: &'a [PartEdge],forms: &'a [Option<(b::Curve, [f64; 2])>],ls: &[Vec<(u32, bool, Option<&'a Curve2>)>],- formed: bool,folded: &'a [(u32, Curve2)],tol: f64,) -> Result<Vec<Vec<pcurve::EdgeUse<'a>>>> {@@ -1585,7 +1592,7 @@ fn uses_of<'a>(.map(|&(e, forward, given)| {let edge = edges.get(e as usize).ok_or_else(|| KernelError::Invalid("sew: edge reference".into()))?;let (curve, interval) = match forms.get(e as usize).and_then(Option::as_ref) {- Some((c, i)) if formed => (c, *i),+ Some((c, i)) => (c, *i),_ => (&edge.curve, edge.interval),};let given = given.or_else(|| folded.iter().find(|(f, _)| *f == e).map(|(_, c)| c));diff --git a/crates/step/src/topology.rs b/crates/step/src/topology.rsindex 0683b24b3c..a238544cb1 100644--- a/crates/step/src/topology.rs+++ b/crates/step/src/topology.rs@@ -965,34 +965,47 @@ impl<'b, 'a> Builder<'b, 'a> {// Which loop index in `face.loops` each edge loop is.let positions: Vec<usize> = face.loops.iter().enumerate().filter(|(_, l)| matches!(l, LoopB::Edges(_))).map(|(i, _)| i).collect();let tol = self.tol;- // The face's pcurves on `on`, each edge on its NURBS form when `formed`.- let pcurves_on = |on: &BSurface, formed: bool| -> R<Vec<Vec<Curve2>>> {+ // The face's pcurves on `on`, each edge on its NURBS form.+ let pcurves_on = |on: &BSurface, domain: Option<[[f64; 2]; 2]>| -> R<Vec<Vec<Curve2>>> {let mut uses = Vec::with_capacity(edge_loops.len());for l in &edge_loops {let mut u = Vec::with_capacity(l.len());for &(e, forward) in l {let edge = self.edges.get(e as usize).ok_or("edge reference")?;let (curve, interval) = match &edge.form {- Some((c, i)) if formed => (c, *i),+ Some((c, i)) => (c, *i),_ => (&edge.curve, edge.interval),};u.push(EdgeUse { edge: e, curve, interval, forward, tolerance: 0.0, given: None });}uses.push(u);}- pcurve::pcurves(on, &uses, tol).map_err(|e| e.to_string())+ pcurve::pcurves_within(on, &uses, tol, domain).map_err(|e| e.to_string())};- // A cylinder, cone, sphere or torus on its NURBS form, over the extent its label's pcurves- // give; then every pcurve on the forms.+ // A cylinder, cone, sphere, torus or revolution on its NURBS form, over the extent of its+ // boundary on its label; then every pcurve on the forms.let form = match brep::form::frame_of(&label) {Some(_) => {- let extent = face_domain(&label, &pcurves_on(&label, false)?)?;- Some(brep::form::surface(&label, extent).ok_or_else(|| unsupported("a face of more than one turn"))?.0)+ let mut boundary = Vec::with_capacity(edge_loops.len());+ for l in &edge_loops {+ let mut b = Vec::with_capacity(l.len());+ for &(e, forward) in l {+ let edge = self.edges.get(e as usize).ok_or("edge reference")?;+ b.push((&edge.curve, edge.interval, forward));+ }+ boundary.push(b);+ }+ let extent = brep::form::extent(&label, &boundary).ok_or_else(|| unsupported("a face whose boundary does not lie on its surface"))?;+ Some(brep::form::surface(&label, extent).ok_or_else(|| unsupported("a face of more than one turn"))?)}None => None,};+ let (form, box_on_form) = match form {+ Some((f, d)) => (Some(f), Some(d)),+ None => (None, None),+ };let surface = form.clone().unwrap_or(label);- let pcs = pcurves_on(&surface, true)?;+ let pcs = pcurves_on(&surface, box_on_form)?;// Signed areas of the loops that close in (u, v).let periods = natural_periods(&surface);// Each use starts near where the one before it ends, along a bounded direction thatdiff --git a/crates/step/src/topology/swept.rs b/crates/step/src/topology/swept.rsindex 3ff7441b3c..2279026599 100644--- a/crates/step/src/topology/swept.rs+++ b/crates/step/src/topology/swept.rs@@ -237,6 +237,14 @@ fn whole(c: &Curve) -> R<Option<BCurve>> {/// The middle parameter of a TRIMMED_CURVE trimmed by parameters (on a closed conic, the/// middle of the arc its sense runs over).fn trimmed_middle(c: &Curve) -> Option<f64> {+ let (a, b) = trimmed_range(c)?;+ let m = 0.5 * (a + b);+ m.is_finite().then_some(m)+}++/// A trimmed profile's range on its basis, low end first, where both trims are parameters: on+/// a closed basis (a circle, an ellipse) the way round `sense` gives.+fn trimmed_range(c: &Curve) -> Option<(f64, f64)> {let Curve::Trimmed { basis, trim_1, trim_2, sense, .. } = c else { return None };let param = |t: &[crate::geom::Trim]| {t.iter().find_map(|x| match x {@@ -248,8 +256,8 @@ fn trimmed_middle(c: &Curve) -> Option<f64> {if is_closed(basis) {b = if *sense { a + (b - a).rem_euclid(TAU) } else { a - (a - b).rem_euclid(TAU) };}- let m = 0.5 * (a + b);- m.is_finite().then_some(m)+ let (lo, hi) = (a.min(b), a.max(b));+ (lo.is_finite() && hi.is_finite() && lo < hi).then_some((lo, hi))}fn is_closed(c: &Curve) -> bool {@@ -309,7 +317,12 @@ fn revolution(profile: &Curve, axis: &Axis1, ext: &Extent) -> R<BSurface> {// The profile's side of the axis where the face is.let mid = ts.get(ts.len() / 2).copied().ok_or("a face without boundary points")?;let e = probe(mid).map(radial).and_then(|r| r.normalized()).unwrap_or(e);- let s = span(&ts, &seam, is_closed(c))?;+ // A trimmed profile is the file's range of its basis exactly; otherwise the face's+ // reach along it.+ let s = match trimmed_range(profile) {+ Some(r) => Span::Open { inner: r, outer: r },+ None => span(&ts, &seam, is_closed(c))?,+ };// Stop where the profile crosses the axis outside the face.let side = |t: f64| probe(t).map(|q| (q - o).dot(e));let s = match s {@@ -394,7 +407,11 @@ fn extrusion(profile: &Curve, direction: P3, magnitude: f64, ext: &Extent) -> R<return Err(unsupported("an extrusion along its profile's plane"));}let seam: Vec<f64> = ext.seam.iter().filter_map(|q| onto(*q)).collect();- bounded(c, span(&ts, &seam, is_closed(c))?)?+ let s = match trimmed_range(profile) {+ Some(r) => Span::Open { inner: r, outer: r },+ None => span(&ts, &seam, is_closed(c))?,+ };+ bounded(c, s)?}};let (knots, homogeneous, rational) = match curve {diff --git a/crates/step/src/topology_tests.rs b/crates/step/src/topology_tests.rsindex e5ba31defb..37bebece56 100644--- a/crates/step/src/topology_tests.rs+++ b/crates/step/src/topology_tests.rs@@ -373,14 +373,20 @@ fn a_cylinder_has_a_seam_used_twice_by_its_side() {assert_eq!(seam.uses[0].face, seam.uses[1].face);for e in &s.brep.edges {if matches!(e.curve, BCurve::Circle { .. }) {- assert!((e.interval[1] - e.interval[0] - TAU).abs() < 1e-12);+ // On its NURBS form: a whole turn in angle, its interval in the form's parameter.+ let [a0, a1] = e.curve_interval().unwrap();+ assert!(e.nurbs.is_some() && (a1 - a0 - TAU).abs() < 1e-12);assert_eq!(e.vertices[0], e.vertices[1]);}}faces_away(&s.brep, 0, |p| [1.0, 2.0, p[2].clamp(1.0, 9.0)]);- // The side face spans one turn of the cylinder and its height.+ // The side face spans one turn of the cylinder (four quarters of its NURBS form) and its height.let f = s.brep.faces.iter().find(|f| matches!(f.surface, BSurface::Cylinder { .. })).unwrap();- assert!((f.domain[0][1] - f.domain[0][0] - TAU).abs() < 1e-9 && f.domain[1][0] < 1e-6 && f.domain[1][1] > 10.0 - 1e-6, "{:?}", f.domain);+ assert!(+ f.nurbs.is_some() && (f.domain[0][1] - f.domain[0][0] - 4.0).abs() < 1e-9 && f.domain[1][0] < 1e-6 && f.domain[1][1] > 10.0 - 1e-6,+ "{:?}",+ f.domain+ );}#[test]@@ -402,7 +408,8 @@ fn a_ball_bounded_by_its_seam_alone() {let s = one_solid(&w.file(&[solid]));assert_eq!(counts(&s.brep), [2, 1, 1, 1, 2]);let e = &s.brep.edges[0];- assert!((e.interval[1] - e.interval[0] - PI).abs() < 1e-12, "{:?}", e.interval);+ let [a0, a1] = e.curve_interval().unwrap();+ assert!((a1 - a0 - PI).abs() < 1e-12, "{:?}", e.interval);faces_away(&s.brep, 0, |_| [0.0; 3]);}}