From 5a2e050f71c773dde8d2e39e8e2748c23de03e55 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Tue, 27 Oct 2026 22:02:31 -0400 Subject: [PATCH] Wave 290/509: STEP and SMLib: no edge or vertex tolerance past the 1 mm SMLib takes (and 3 more) 4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 0bee8c2ed jyviko: solidcraft-smlib: Brep::edge_face_distance, SMLib's own edge/face gap - 5d6810128 jyviko: STEP and SMLib: no edge or vertex tolerance past the 1 mm SMLib takes - 005b1e6ea jyviko: SMLib pcurves: an edge past its face's patch gets a tolerance that covers it - f327cdb3d jyviko: solidcraft-smlib test: an edge 2.5 um past its patch keeps its interval Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ --- crates/geom/src/brep/pcurve.rs | 4 +++ crates/smlib/src/ffi/measure.rs | 18 +++++++++++++- crates/smlib/src/flat.rs | 2 ++ crates/smlib/src/import.rs | 14 ++++++++--- crates/smlib/src/measure.rs | 13 +++++++++- crates/smlib/src/pcurves.rs | 44 ++++++++++++++++++++++++++++++--- crates/smlib/src/tests.rs | 44 +++++++++++++++++++++++++++++++++ crates/step/src/topology.rs | 27 +++++++++----------- 8 files changed, 143 insertions(+), 23 deletions(-) diff --git a/crates/geom/src/brep/pcurve.rs b/crates/geom/src/brep/pcurve.rs index 3a86d2466..cb1e3e08e 100644 --- a/crates/geom/src/brep/pcurve.rs +++ b/crates/geom/src/brep/pcurve.rs @@ -64,6 +64,10 @@ const CHECKS: usize = 16; /// How close, against the geometry's size, a closed-form pcurve must lift onto its edge to be /// taken as exact (rounding, well inside any tolerance). const EXACT: f64 = 1e-9; +/// An edge's tolerance over its largest distance from a face's surface: a pcurve is accepted +/// within half its edge's tolerance ([`pcurves_within`]), as SMLib's zone tolerance is half the +/// record's, so a tolerance that covers a gap goes past twice it. +pub const SURFACE_GAP_MARGIN: f64 = 3.0; /// For each loop of a face on `surface`, the pcurve of each of its edge uses, in order, within /// `tolerance` mm (or the use's own edge tolerance where larger) of the edge when lifted onto diff --git a/crates/smlib/src/ffi/measure.rs b/crates/smlib/src/ffi/measure.rs index 2761b2458..7c90fd2d9 100644 --- a/crates/smlib/src/ffi/measure.rs +++ b/crates/smlib/src/ffi/measure.rs @@ -1,4 +1,5 @@ -//! `smlib_brep_mass_properties`, `smlib_brep_area` and `smlib_brep_bounds` (the fork's `capi/src/smlib_measure.cpp`), declared by +//! `smlib_brep_mass_properties`, `smlib_brep_area`, `smlib_brep_bounds` and +//! `smlib_brep_edge_face_distance` (the fork's `capi/src/smlib_measure.cpp`), declared by //! hand. Part of the FFI boundary, like its parent: called only through [`crate::measure`]. #![allow(unsafe_code)] @@ -14,6 +15,7 @@ unsafe extern "C" { pub fn smlib_brep_mass_properties(brep: *const RawBrep, relative_accuracy: f64, out: *mut f64) -> i32; pub fn smlib_brep_area(brep: *const RawBrep, relative_accuracy: f64, out: *mut f64) -> i32; pub fn smlib_brep_bounds(brep: *const RawBrep, lo: *mut f64, hi: *mut f64) -> i32; + pub fn smlib_brep_edge_face_distance(brep: *const RawBrep, edge: i64, face: i64, out: *mut f64) -> i32; } #[cfg(feature = "native")] @@ -43,6 +45,20 @@ pub fn bounds(b: &Handle) -> Result<([f64; 3], [f64; 3]), i32> { } } +#[cfg(feature = "native")] +pub fn edge_face_distance(b: &Handle, edge: i64, face: i64) -> Result { + let mut d = 0.0; + match unsafe { smlib_brep_edge_face_distance(b.raw(), edge, face, &mut d) } { + OK => Ok(d), + s => Err(s), + } +} + +#[cfg(not(feature = "native"))] +pub fn edge_face_distance(_: &Handle, _: i64, _: i64) -> Result { + Err(NOT_BUILT) +} + #[cfg(not(feature = "native"))] pub fn bounds(_: &Handle) -> Result<([f64; 3], [f64; 3]), i32> { Err(NOT_BUILT) diff --git a/crates/smlib/src/flat.rs b/crates/smlib/src/flat.rs index 62c2eb6b6..1d28635a0 100644 --- a/crates/smlib/src/flat.rs +++ b/crates/smlib/src/flat.rs @@ -104,6 +104,8 @@ pub const FACE_TORUS_MAJOR_RADIUS: i32 = 162; pub const FACE_TORUS_MINOR_RADIUS: i32 = 163; pub const EDGE_TOLERANCE: i32 = 164; pub const VERTEX_TOLERANCE: i32 = 165; +/// The largest EDGE_TOLERANCE or VERTEX_TOLERANCE import takes (smlib.h: "at most 1"). +pub const MAX_TOLERANCE: f64 = 1.0; /// `SMLIB_FLAT_MAX_LEN`: no array is longer. pub const MAX_LEN: usize = 1 << 27; pub const SURFACE_NURBS: u8 = 0; diff --git a/crates/smlib/src/import.rs b/crates/smlib/src/import.rs index bdd9b8630..516963da3 100644 --- a/crates/smlib/src/import.rs +++ b/crates/smlib/src/import.rs @@ -254,15 +254,23 @@ fn laid_out(brep: &b::Brep, trusted: bool, analytic: bool, bare: &HashSet<(u32, } a.i(flat::EDGE_VERTICES).extend([i64::from(e.vertices[0]), i64::from(e.vertices[1])]); a.r(flat::EDGE_RANGE).extend(*interval); - // Each edge's own tolerance, never below the body's. - a.r(flat::EDGE_TOLERANCE).push(e.tolerance.max(brep.tolerance)); + // Each edge's own tolerance, never below the body's, and never past what SMLib takes. + let tolerance = e.tolerance.max(brep.tolerance); + if !(tolerance <= flat::MAX_TOLERANCE) { + return Err(Unsupported::NotYet("an edge tolerance over 1 mm")); + } + a.r(flat::EDGE_TOLERANCE).push(tolerance); } let (mut lo, mut hi) = ([f64::INFINITY; 3], [f64::NEG_INFINITY; 3]); for v in &brep.vertices { a.i(flat::VERTEX_POINT_TYPE).push(1); a.r3(flat::VERTEX_POSITION, v.point); - a.r(flat::VERTEX_TOLERANCE).push(v.tolerance.max(brep.tolerance)); + let tolerance = v.tolerance.max(brep.tolerance); + if !(tolerance <= flat::MAX_TOLERANCE) { + return Err(Unsupported::NotYet("a vertex tolerance over 1 mm")); + } + a.r(flat::VERTEX_TOLERANCE).push(tolerance); for k in 0..3 { lo[k] = lo[k].min(v.point[k]); hi[k] = hi[k].max(v.point[k]); diff --git a/crates/smlib/src/measure.rs b/crates/smlib/src/measure.rs index f44d4c655..ec470c967 100644 --- a/crates/smlib/src/measure.rs +++ b/crates/smlib/src/measure.rs @@ -1,5 +1,5 @@ //! Exact mass properties from SMLib: area, volume, centroid and inertia, integrated on the exact -//! surfaces rather than a tessellation, and the exact box. +//! surfaces rather than a tessellation; the exact box; how far an edge lies from a face's surface. use crate::{Brep, Result, error, ffi}; @@ -48,6 +48,17 @@ impl Brep { ffi::measure::bounds(&self.0).map_err(error) } + /// How far edge `edge` (its curve over its interval) lies from the surface of face `face`, + /// over that surface's own domain and not beyond it, in mm: SMLib's own edge/face gap, the + /// one it sizes an edge's tolerance by. Indices are in the body's edge and face order (as + /// it was imported and is exported). An edge run past its face's patch measures how far it + /// goes; SMLib keeps such an edge whole when making its UV trim only when its zone tolerance + /// (half the flat arrays' `EDGE_TOLERANCE`) covers this. + pub fn edge_face_distance(&self, edge: usize, face: usize) -> Result { + let (Ok(e), Ok(f)) = (i64::try_from(edge), i64::try_from(face)) else { return Err(error(ffi::ERR_ARG)) }; + ffi::measure::edge_face_distance(&self.0, e, f).map_err(error) + } + /// Total area of every face, each counted once, so sheets and open shells too. pub fn area(&self, relative_accuracy: f64) -> Result { ffi::measure::area(&self.0, relative_accuracy).map_err(error) diff --git a/crates/smlib/src/pcurves.rs b/crates/smlib/src/pcurves.rs index ca37050ff..720d36f6b 100644 --- a/crates/smlib/src/pcurves.rs +++ b/crates/smlib/src/pcurves.rs @@ -6,7 +6,7 @@ use std::collections::HashSet; -use solidcraft_geom::brep::pcurve::{TrimFace, Trims}; +use solidcraft_geom::brep::pcurve::{SURFACE_GAP_MARGIN, TrimFace, Trims}; use solidcraft_geom::brep::{self as b, Curve2, EdgeUseRef, Loop, OrientedEdge, OrientedFace, Region, Shell, Vertex}; /// [`Trims`] by SMLib. @@ -21,8 +21,12 @@ impl Trims for SmlibTrims { fn trims(face: &TrimFace<'_>) -> Result>, String> { let (record, bare) = sheet(face)?; - let arrays = crate::import::arrays_with_bare_uses(&record, &bare).map_err(|e| e.to_string())?; - let body = crate::flat::Flat::from_arrays(&arrays).and_then(|f| f.import()).map_err(|e| e.to_string())?; + let mut arrays = crate::import::arrays_with_bare_uses(&record, &bare).map_err(|e| e.to_string())?; + let import = |a: &crate::import::Arrays| crate::flat::Flat::from_arrays(a).and_then(|f| f.import()).map_err(|e| e.to_string()); + let mut body = import(&arrays)?; + if cover_gaps(&body, face, &bare, &mut arrays)? { + body = import(&arrays)?; + } let (out, order) = body.to_native_ordered().map_err(|e| e.to_string())?; let [made] = out.faces.as_slice() else { return Err(format!("SMLib made {} faces of one", out.faces.len())) }; let made_uses: Vec<&OrientedEdge> = made @@ -58,6 +62,40 @@ fn trims(face: &TrimFace<'_>) -> Result>, String> { Ok(result) } +/// Each bare use's edge measured against the face's surface as SMLib measures it (over the +/// surface's own domain: an edge run a few um past its patch measures how far), and its +/// `EDGE_TOLERANCE` in `arrays` raised to cover that gap with [`SURFACE_GAP_MARGIN`]: SMLib keeps +/// an edge whole when making its trim only when its zone tolerance (half that) covers the gap, and +/// otherwise trims the edge back to the patch. Whether any was raised; an edge farther off than +/// SMLib's tolerances reach is refused with how far. +fn cover_gaps(body: &crate::Brep, face: &TrimFace<'_>, bare: &HashSet<(u32, u32, u32)>, arrays: &mut crate::import::Arrays) -> Result { + let mut edges: Vec = Vec::new(); + for (li, l) in face.loops.iter().enumerate() { + for (p, u) in l.iter().enumerate() { + let (Ok(li), Ok(p)) = (u32::try_from(li), u32::try_from(p)) else { return Err("too many uses".into()) }; + if bare.contains(&(0, li, p)) && !edges.contains(&(u.edge as usize)) { + edges.push(u.edge as usize); + } + } + } + let mut raised = false; + for e in edges { + let gap = body.edge_face_distance(e, 0).map_err(|e| e.to_string())?; + let need = SURFACE_GAP_MARGIN * gap; + let tolerances = arrays.reals.get_mut(&crate::flat::EDGE_TOLERANCE).ok_or("edge tolerances")?; + let given = tolerances.get_mut(e).ok_or("edge reference")?; + if need <= *given { + continue; + } + if !(need <= crate::flat::MAX_TOLERANCE) { + return Err(format!("an edge lies {gap} mm off the face's surface")); + } + *given = need; + raised = true; + } + Ok(raised) +} + /// A pcurve SMLib made on its edge's interval `theirs`, on ours. SMLib may set an edge's end to /// a parameter of its own (a knot its vertex lies at, the end of the part on the face): where /// each end it chose is within the edge's tolerance of ours on the edge's curve, the pcurve is diff --git a/crates/smlib/src/tests.rs b/crates/smlib/src/tests.rs index 7054be25b..c3251961b 100644 --- a/crates/smlib/src/tests.rs +++ b/crates/smlib/src/tests.rs @@ -109,3 +109,47 @@ fn a_pcurve_smlib_ends_within_the_edges_tolerance_is_mapped_onto_our_interval() let err = crate::pcurves::on_our_interval(pc, &edge, [0.0, 0.99]).unwrap_err(); assert!(err.contains("SMLib moved an edge's interval") && err.contains("tolerance"), "{err}"); } + +/// An edge whose curve runs 2.5 um past its vertex and its face's patch (as Poppy Humanoid's +/// Congé19 has them), with a tolerance of 0.5 um: SMLib trims such an edge back to the patch +/// when it makes its trim, unless the edge's tolerance covers its gap. The gap is measured +/// (SMLib's own, over the patch) and covered, so the face's pcurves come back on the edge's +/// own interval, ending at the patch's corner. +#[cfg(feature = "native")] +#[test] +fn an_edge_a_few_um_past_its_patch_keeps_its_interval() { + use solidcraft_geom::brep::pcurve::{TrimEdge, TrimFace, TrimUse, Trims}; + use solidcraft_geom::brep::{Curve, Surface}; + // S(u, v) = (10u, 10v, 2v^2), bicubic + let g = [0.0, 1.0 / 3.0, 2.0 / 3.0, 1.0]; + let z = [0.0, 0.0, 2.0 / 3.0, 2.0]; + let bezier = vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0]; + let points: Vec> = (0..4).map(|i| (0..4).map(|j| [10.0 * g[i], 10.0 * g[j], z[j]]).collect()).collect(); + let surface = Surface::Spline { u_knots: bezier.clone(), v_knots: bezier.clone(), points: points.clone() }; + let past = 2.5e-3; + let spline = |p: Vec<[f64; 3]>| Curve::Spline { knots: bezier.clone(), points: p }; + let curves = [ + spline((0..4).map(|i| [(10.0 + past) * g[i], 0.0, 0.0]).collect()), + spline((0..4).map(|j| points[3][j]).collect()), + spline((0..4).map(|i| points[3 - i][3]).collect()), + spline((0..4).map(|j| points[0][3 - j]).collect()), + ]; + let ends = [[0, 1], [1, 2], [2, 3], [3, 0]]; + let edges = (0..4) + .map(|k| TrimEdge { curve: &curves[k], nurbs: None, interval: [0.0, 1.0], vertices: ends[k], tolerance: if k == 0 { 1e-3 } else { 1e-5 } }) + .collect(); + let face = TrimFace { + surface: &surface, + nurbs: None, + domain: [[0.0, 1.0], [0.0, 1.0]], + edges, + vertices: vec![[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 10.0, 2.0], [0.0, 10.0, 2.0]], + loops: vec![(0..4).map(|k| TrimUse { edge: k, forward: true, pcurve: None }).collect()], + tolerance: 1e-5, + }; + let pcs = crate::pcurves::SmlibTrims.trims(&face).unwrap(); + let pc = &pcs[0][0]; + assert_eq!(pc.interval(), Some([0.0, 1.0])); + let [u, v] = pc.eval(1.0).unwrap(); + assert!((u - 1.0).abs() < 1e-9 && v.abs() < 1e-9, "{u} {v}"); +} diff --git a/crates/step/src/topology.rs b/crates/step/src/topology.rs index bcf6eb465..719aac904 100644 --- a/crates/step/src/topology.rs +++ b/crates/step/src/topology.rs @@ -77,20 +77,17 @@ const MAX_SPLINE_POINTS: usize = 4096; const MAX_SPLINE_DEGREE: usize = 16; /// Samples along a curve when projecting a vertex onto it. const MAX_SAMPLES: usize = 4096; -/// How far (mm) a vertex may lie from its curve before the edge is refused. -const MAX_VERTEX_GAP: f64 = 1.0; -/// How far (mm) an edge's curve may lie from a face's surface before the face is refused. -const MAX_EDGE_GAP: f64 = 1.0; +/// The largest tolerance (mm) an edge or vertex is given: SMLib takes none larger (smlib.h's +/// EDGE_TOLERANCE and VERTEX_TOLERANCE, `solidcraft_smlib::flat::MAX_TOLERANCE`). Geometry that +/// would need more is refused, with how far off it lies. +const MAX_TOLERANCE: f64 = 1.0; +/// A vertex's tolerance over its largest gap from its curves and surfaces. +const VERTEX_GAP_MARGIN: f64 = 1.5; /// Intervals an edge's curve is measured over against each face's surface it bounds. const EDGE_GAP_SAMPLES: usize = 16; /// An edge's tolerance over the largest gap measured between its pcurves and its curve, as the /// record check measures it: with margin, as a vertex's. const EDGE_GAP_MARGIN: f64 = 1.5; -/// An edge's tolerance over its largest distance from a face's surface, measured before its -/// pcurve is made: a closed-form pcurve is accepted within half its edge's tolerance -/// (`pcurve::pcurves_within`), so the tolerance goes past twice the distance. -const EDGE_SURFACE_MARGIN: f64 = 3.0; - /// A solid (or sheet) read from the file. #[derive(Clone, Debug)] pub struct Solid { @@ -441,11 +438,11 @@ impl<'b, 'a> Builder<'b, 'a> { /// A vertex `gap` mm from where its edge's curve puts it: refused if far off, else its /// tolerance covers the gap. fn raise_vertex(&mut self, v: u32, gap: f64, edge: u64) -> R<()> { - if !(gap <= MAX_VERTEX_GAP) { + if !(VERTEX_GAP_MARGIN * gap <= MAX_TOLERANCE) { return Err(format!("edge #{edge}: a vertex lies {gap} mm off its curve")); } if let Some(x) = self.vertices.get_mut(v as usize) { - x.tolerance = x.tolerance.max(1.5 * gap); + x.tolerance = x.tolerance.max(VERTEX_GAP_MARGIN * gap); } Ok(()) } @@ -492,7 +489,7 @@ impl<'b, 'a> Builder<'b, 'a> { let Some(s) = on.project_with(&starts, p, None, f64::INFINITY).and_then(|q| on.point(q)) else { continue }; gap = gap.max(s.dist(p)); } - self.cover_edge(e, gap, EDGE_SURFACE_MARGIN)?; + self.cover_edge(e, gap, pcurve::SURFACE_GAP_MARGIN)?; } } Ok(()) @@ -504,7 +501,7 @@ impl<'b, 'a> Builder<'b, 'a> { if margin * gap <= x.tolerance { return Ok(()); } - if !(gap <= MAX_EDGE_GAP) { + if !(margin * gap <= MAX_TOLERANCE) { return Err(format!("an edge lies {gap} mm off the face's surface")); } x.tolerance = margin * gap; @@ -1002,10 +999,10 @@ impl<'b, 'a> Builder<'b, 'a> { { let p = v3(x.point); let gap = surface.project(p, None, f64::INFINITY).and_then(|q| surface.point(q)).map_or(f64::INFINITY, |s| s.dist(p)); - if !(gap <= MAX_VERTEX_GAP) { + if !(VERTEX_GAP_MARGIN * gap <= MAX_TOLERANCE) { return Err(format!("face #{}: a vertex loop's vertex lies {gap} mm off its surface", face.step)); } - x.tolerance = x.tolerance.max(1.5 * gap); + x.tolerance = x.tolerance.max(VERTEX_GAP_MARGIN * gap); } } }