From 61a1f8bf26997ed718d46277bf1e17a84d5a15f2 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Wed, 28 Oct 2026 14:57:53 -0400 Subject: [PATCH] STEP import: a face's NURBS form ends where its boundary does, within its tolerance A face's form covers the quarters of its box, and the box is the extent of its boundary's points, which run past a quarter's end by as much as the edges lie off the surface (nanometres in a file of 1e-11 mm digits). A half tube's form then took the quarter past each end and went round the whole tube, which SMLib does not take for a torus: 16 parts of an alternator came in as meshes. An end within the tolerance of a quarter's end (the angle on the face's widest circle there) is now on it. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01DtL5Lzv2n8fyKqD61NCHSF --- crates/geom/src/brep/form.rs | 52 +++++++++++++++++++++++------- crates/kernel/src/step_in/tests.rs | 32 ++++++++++++++++++ crates/step/src/topology.rs | 2 +- 3 files changed, 74 insertions(+), 12 deletions(-) diff --git a/crates/geom/src/brep/form.rs b/crates/geom/src/brep/form.rs index ea616c877..05d6f98c1 100644 --- a/crates/geom/src/brep/form.rs +++ b/crates/geom/src/brep/form.rs @@ -50,11 +50,18 @@ pub fn angle(s: f64) -> f64 { q * FRAC_PI_2 + quarter_psi(s - q) } -/// The quarters an angle interval needs: the first one and how many. -fn quarters([a0, a1]: [f64; 2]) -> Option<(f64, usize)> { +/// The quarters an angle interval needs: the first one and how many. An end within `reach` (an +/// angle) of a quarter's end is on it: a face whose boundary lies within its tolerance of a +/// quarter's end needs no part of the quarter past it. +fn quarters([a0, a1]: [f64; 2], reach: f64) -> Option<(f64, usize)> { if !(a0.is_finite() && a1.is_finite() && a1 > a0 && a1 - a0 <= TAU * (1.0 + 1e-9)) { return None; } + let on_end = |a: f64| { + let end = (a / FRAC_PI_2).round() * FRAC_PI_2; + if (a - end).abs() <= reach { end } else { a } + }; + let (a0, a1) = (on_end(a0), on_end(a1)); let q0 = quarter_of(a0); let q1 = (a1 / FRAC_PI_2 - SLACK).ceil(); let n = (q1 - q0).max(1.0) as usize; @@ -63,13 +70,14 @@ fn quarters([a0, a1]: [f64; 2]) -> Option<(f64, usize)> { /// 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])> { +/// face's seam uses lie a period apart), anything less the quarters it needs ([`quarters`], ends +/// within `reach` of a quarter's end on it). +fn face_quarters(a: [f64; 2], reach: f64) -> 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)?; + let grid = quarters(a, reach)?; Some((grid, params(a, grid))) } @@ -130,7 +138,7 @@ pub fn curve(c: &Curve, [t0, t1]: [f64; 2]) -> Option<(Curve, [f64; 2])> { fn conic(frame: &Frame, [rx, ry]: [f64; 2], t: [f64; 2]) -> Option<(Curve, [f64; 2])> { let (o, x, y, _) = axes(frame)?; - let grid = quarters(t)?; + let grid = quarters(t, 0.0)?; let (knots, pts) = arcs(grid.0, grid.1); let homogeneous = pts.iter().map(|([c, s], w)| hom(o + x * (rx * c) + y * (ry * s), *w)).collect(); Some((Curve::RationalSpline { knots, homogeneous }, params(t, grid))) @@ -139,8 +147,30 @@ fn conic(frame: &Frame, [rx, ry]: [f64; 2], t: [f64; 2]) -> Option<(Curve, [f64; /// The NURBS form of a cylinder, cone, sphere or torus face over `domain` (in the label's /// 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, fu) = face_quarters(u)?; +pub fn surface(s: &Surface, domain: [[f64; 2]; 2]) -> Option<(Surface, [[f64; 2]; 2])> { + surface_within(s, domain, 0.0) +} + +/// [`surface`] for a face whose boundary lies within `tolerance` (mm) of its surface: where the +/// domain ends within `tolerance` of a quarter's end (the angle that far along the widest circle +/// of the face in that direction), the form ends there too. A face's box is the extent of its +/// boundary's points ([`extent`]), which may run past a quarter's end by as much as its edges lie +/// off the surface; the form then covers no quarter for that alone (a torus face of half a tube +/// would otherwise go round the whole tube). +pub fn surface_within(s: &Surface, [u, v]: [[f64; 2]; 2], tolerance: f64) -> Option<(Surface, [[f64; 2]; 2])> { + // The angle `tolerance` makes on a circle of `radius`. + let reach = |radius: f64| if tolerance > 0.0 && radius > 0.0 && radius.is_finite() { tolerance / radius } else { 0.0 }; + let (reach_u, reach_v) = match s { + Surface::Cylinder { radius, .. } => (reach(radius.abs()), 0.0), + Surface::Cone { radius_at_origin, half_angle, .. } => { + let slope = half_angle.tan(); + (reach(v.iter().map(|h| (radius_at_origin + h * slope).abs()).fold(0.0, f64::max)), 0.0) + } + Surface::Sphere { radius, .. } => (reach(radius.abs()), reach(radius.abs())), + Surface::Torus { major_radius, minor_radius, .. } => (reach(major_radius.abs() + minor_radius.abs()), reach(minor_radius.abs())), + _ => (0.0, 0.0), + }; + let (grid, fu) = face_quarters(u, reach_u)?; let (u_knots, ring) = arcs(grid.0, grid.1); // The ring of arcs times a profile `(control, weight)` mapped to (radial, axial) about the // frame: a rational tensor product, its weights the products. @@ -173,13 +203,13 @@ pub fn surface(s: &Surface, [u, v]: [[f64; 2]; 2]) -> Option<(Surface, [[f64; 2] Some((Surface::RationalSpline { u_knots, v_knots: vec![v[0], v[0], v[1], v[1]], homogeneous }, [fu, v])) } Surface::Sphere { frame, radius } => { - let vgrid = quarters(v)?; + let vgrid = quarters(v, reach_v)?; let (v_knots, meridian) = arcs(vgrid.0, vgrid.1); let homogeneous = net(frame, &meridian, &|[c, s]| (radius * c, radius * s))?; Some((Surface::RationalSpline { u_knots, v_knots, homogeneous }, [fu, params(v, vgrid)])) } Surface::Torus { frame, major_radius, minor_radius } => { - let (vgrid, fv) = face_quarters(v)?; + let (vgrid, fv) = face_quarters(v, reach_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, fv])) @@ -189,7 +219,7 @@ pub fn surface(s: &Surface, [u, v]: [[f64; 2]; 2]) -> Option<(Surface, [[f64; 2] // 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 (ring_grid, fa) = face_quarters(angles, 0.0)?; 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() { diff --git a/crates/kernel/src/step_in/tests.rs b/crates/kernel/src/step_in/tests.rs index 6deee1275..13497ab01 100644 --- a/crates/kernel/src/step_in/tests.rs +++ b/crates/kernel/src/step_in/tests.rs @@ -394,6 +394,38 @@ fn shelled_three_quarter_tube_round_trips() { round_trip(&b); } +/// A half tube (half a torus's tube, half way round, closed by a flat annulus and +/// two flat ends) whose torus the file places 5 nm off the rest, well within the file's +/// accuracy: the torus face's boundary then projects a hair past both ends of its half of the +/// tube, and its NURBS form once took the quarter past each end too, going round the whole tube, +/// which SMLib does not take for a torus: the part came in as a mesh of its faces. +#[test] +fn half_tube_a_hair_off_its_torus_imports_as_a_solid() { + use solidcraft_geom::Seg2; + use std::f64::consts::PI; + let (major, minor) = (10.75, 1.25); + let d = Loop2 { + segs: vec![ + Seg2::Arc { center: Vec2::new(major, 0.0), radius: minor, start: 0.0, sweep: PI }, + Seg2::Line { a: Vec2::new(major - minor, 0.0), b: Vec2::new(major + minor, 0.0) }, + ], + }; + let tube = revolve(&Plane::XZ, &[Region2 { outer: d, holes: vec![] }], Vec2::ZERO, Vec2::Y, PI).unwrap().pop().unwrap(); + let text = step_export(&[&tube], "test").unwrap(); + // The torus's placement moved to a point of its own, 5 nm along the axis, off the face's side. + let torus = text.lines().find_map(|l| l.split_once("=TOROIDAL_SURFACE('',#")).unwrap().1.split(',').next().unwrap().to_string(); + let place = text.lines().find(|l| l.starts_with(&format!("#{torus}=AXIS2_PLACEMENT_3D('',#"))).unwrap(); + let (_, axes) = place.split_once("('',#").unwrap().1.split_once(',').unwrap(); + let mut low = text.replace(place, &format!("#{torus}=AXIS2_PLACEMENT_3D('',#900000,{axes}")); + let data_end = low.rfind("ENDSEC;").unwrap(); + low.insert_str(data_end, "#900000=CARTESIAN_POINT('',(0.0,0.0,-5.E-6));\n"); + let imp = step_import(&low).unwrap(); + assert_eq!(imp.bodies.len(), 1, "{:?}", imp.warnings); + let b = &imp.bodies[0]; + assert!(b.refused.is_none() && b.closed && !b.body.is_mesh() && !b.body.is_surface(), "{:?} {:?}", b.refused, imp.warnings); + assert!(rel(measure(&b.body).unwrap().volume, measure(&tube).unwrap().volume) < 1e-3); +} + #[test] fn several_bodies_and_names() { let a = box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap(); diff --git a/crates/step/src/topology.rs b/crates/step/src/topology.rs index 5ca4b5d35..327fb3885 100644 --- a/crates/step/src/topology.rs +++ b/crates/step/src/topology.rs @@ -1226,7 +1226,7 @@ impl<'b, 'a> Builder<'b, 'a> { 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"))?) + Some(brep::form::surface_within(&label, extent, tol).ok_or_else(|| unsupported("a face of more than one turn"))?) } None => None, };