diff --git a/crates/smlib/SMLIB_REV b/crates/smlib/SMLIB_REV index d5a51ab3a..091b71394 100644 --- a/crates/smlib/SMLIB_REV +++ b/crates/smlib/SMLIB_REV @@ -1 +1 @@ -4a81dd9ca9a7bbd41c5125e4cc7b026f6abae5e5 +f6d2c5e00e63b0923351566714f161decf64373d diff --git a/crates/smlib/src/ffi.rs b/crates/smlib/src/ffi.rs index 2d69a594a..90b261312 100644 --- a/crates/smlib/src/ffi.rs +++ b/crates/smlib/src/ffi.rs @@ -7,7 +7,7 @@ use std::ffi::{c_char, c_void}; /// `SMLIB_ABI_VERSION` this crate was written against. -pub const ABI_VERSION: i32 = 3; +pub const ABI_VERSION: i32 = 4; pub const OK: i32 = 0; pub const ERR_EXCEPTION: i32 = -1000; diff --git a/crates/smlib/src/ffi/ssi.rs b/crates/smlib/src/ffi/ssi.rs index fb9b57629..b62f10803 100644 --- a/crates/smlib/src/ffi/ssi.rs +++ b/crates/smlib/src/ffi/ssi.rs @@ -70,27 +70,22 @@ unsafe extern "C" { fn smlib_surface_free(s: *mut RawSurface); fn smlib_surface_domain(s: *const RawSurface, out: *mut f64) -> i32; fn smlib_surface_evaluate(s: *const RawSurface, u: f64, v: f64, out: *mut f64) -> i32; - fn smlib_ssi(a: *const RawSurface, b: *const RawSurface, method: i32, approx_tol: f64, samples_per_curve: i32, out: *mut *mut RawResult) -> i32; + fn smlib_ssi(a: *const RawSurface, b: *const RawSurface, method: i32, approx_tol: f64, out: *mut *mut RawResult) -> i32; fn smlib_ssi_result_free(r: *mut RawResult); fn smlib_ssi_curve_count(r: *const RawResult, out: *mut i32) -> i32; - fn smlib_ssi_curve_info( + fn smlib_ssi_curve_info(r: *const RawResult, i: i32, ty: *mut i32, flags: *mut i32, deviation: *mut f64, interval: *mut f64) -> i32; + fn smlib_ssi_curve_nurbs( r: *const RawResult, i: i32, - ty: *mut i32, - flags: *mut i32, - samples: *mut i32, - deviation: *mut f64, - interval: *mut f64, - ) -> i32; - fn smlib_ssi_curve_samples( - r: *const RawResult, - i: i32, - cap: i64, - xyz: *mut f64, - uv_a: *mut f64, - uv_b: *mut f64, - a_at_uv: *mut f64, - b_at_uv: *mut f64, + which: i32, + degree: *mut i32, + n_points: *mut i64, + n_knots: *mut i64, + cap_points: i64, + points: *mut f64, + weights: *mut f64, + cap_knots: i64, + knots: *mut f64, ) -> i32; fn smlib_ssi_point_count(r: *const RawResult, out: *mut i32) -> i32; fn smlib_ssi_point(r: *const RawResult, i: i32, xyz: *mut f64, uv_a: *mut f64, uv_b: *mut f64) -> i32; @@ -139,20 +134,22 @@ impl Drop for ResultHandle { #[derive(Clone, Copy, Debug)] pub struct CurveInfo { pub ty: i32, - pub flags: i32, - pub samples: i32, pub deviation: f64, pub interval: [f64; 2], } -/// One curve's samples, flat: 3 (xyz, a_at_uv, b_at_uv) or 2 (uv_a, uv_b) values per sample. +/// `smlib_ssi_curve_nurbs` `which`: the 3D curve, the UV curve on a, on b. +pub const CURVE_3D: i32 = 0; +pub const CURVE_UV_A: i32 = 1; +pub const CURVE_UV_B: i32 = 2; + +/// One B-spline as `smlib_ssi_curve_nurbs` gives it: cartesian control points, `dim` values each, +/// one weight each, and every knot (as many as points + degree + 1). #[derive(Clone, Debug, Default)] -pub struct Samples { - pub xyz: Vec, - pub uv_a: Vec, - pub uv_b: Vec, - pub a_at_uv: Vec, - pub b_at_uv: Vec, +pub struct Nurbs { + pub points: Vec, + pub weights: Vec, + pub knots: Vec, } #[cfg(feature = "native")] @@ -258,9 +255,9 @@ mod calls { st => Err(st), } } - pub fn ssi(a: &SurfaceHandle, b: &SurfaceHandle, method: i32, approx_tol: f64, samples: i32) -> Result { + pub fn ssi(a: &SurfaceHandle, b: &SurfaceHandle, method: i32, approx_tol: f64) -> Result { let mut out: *mut RawResult = std::ptr::null_mut(); - match (unsafe { smlib_ssi(a.0.as_ptr(), b.0.as_ptr(), method, approx_tol, samples, &mut out) }, std::ptr::NonNull::new(out)) { + match (unsafe { smlib_ssi(a.0.as_ptr(), b.0.as_ptr(), method, approx_tol, &mut out) }, std::ptr::NonNull::new(out)) { (OK, Some(p)) => Ok(ResultHandle(p)), (OK, None) => Err(ERR_EMPTY), (s, _) => Err(s), @@ -274,30 +271,43 @@ mod calls { } } pub fn curve_info(r: &ResultHandle, i: i32) -> Result { - let mut c = CurveInfo { ty: 0, flags: 0, samples: 0, deviation: 0.0, interval: [0.0; 2] }; - match unsafe { smlib_ssi_curve_info(r.0.as_ptr(), i, &mut c.ty, &mut c.flags, &mut c.samples, &mut c.deviation, c.interval.as_mut_ptr()) } { + let mut c = CurveInfo { ty: 0, deviation: 0.0, interval: [0.0; 2] }; + match unsafe { smlib_ssi_curve_info(r.0.as_ptr(), i, &mut c.ty, std::ptr::null_mut(), &mut c.deviation, c.interval.as_mut_ptr()) } { OK => Ok(c), s => Err(s), } } - pub fn curve_samples(r: &ResultHandle, i: i32, n: usize) -> Result { - let cap = i64::try_from(n).map_err(|_| ERR_ARG)?; - let three = n.checked_mul(3).ok_or(ERR_ARG)?; - let mut s = - Samples { xyz: vec![0.0; three], uv_a: vec![0.0; 2 * n], uv_b: vec![0.0; 2 * n], a_at_uv: vec![0.0; three], b_at_uv: vec![0.0; three] }; + /// Curve `i`'s `which` B-spline, `dim` coordinates per control point: the counts first, then + /// the arrays. + pub fn curve_nurbs(r: &ResultHandle, i: i32, which: i32, dim: usize) -> Result { + let (mut degree, mut np, mut nk) = (0i32, 0i64, 0i64); + let null = std::ptr::null_mut(); + let st = unsafe { smlib_ssi_curve_nurbs(r.0.as_ptr(), i, which, &mut degree, &mut np, &mut nk, 0, null, null, 0, null) }; + if st != OK { + return Err(st); + } + let (n, k) = (usize::try_from(np).map_err(|_| ERR_ARG)?, usize::try_from(nk).map_err(|_| ERR_ARG)?); + let degree = usize::try_from(degree).map_err(|_| ERR_ARG)?; + if !(n > degree && k == n + degree + 1) { + return Err(ERR_ARG); + } + let mut c = Nurbs { points: vec![0.0; n.checked_mul(dim).ok_or(ERR_ARG)?], weights: vec![0.0; n], knots: vec![0.0; k] }; let st = unsafe { - smlib_ssi_curve_samples( + smlib_ssi_curve_nurbs( r.0.as_ptr(), i, - cap, - s.xyz.as_mut_ptr(), - s.uv_a.as_mut_ptr(), - s.uv_b.as_mut_ptr(), - s.a_at_uv.as_mut_ptr(), - s.b_at_uv.as_mut_ptr(), + which, + std::ptr::null_mut(), + std::ptr::null_mut(), + std::ptr::null_mut(), + np, + c.points.as_mut_ptr(), + c.weights.as_mut_ptr(), + nk, + c.knots.as_mut_ptr(), ) }; - if st == OK { Ok(s) } else { Err(st) } + if st == OK { Ok(c) } else { Err(st) } } pub fn point_count(r: &ResultHandle) -> Result { let mut n = 0; @@ -345,7 +355,7 @@ mod calls { pub fn evaluate(_: &SurfaceHandle, _: f64, _: f64) -> Result<[f64; 3], i32> { Err(NOT_BUILT) } - pub fn ssi(_: &SurfaceHandle, _: &SurfaceHandle, _: i32, _: f64, _: i32) -> Result { + pub fn ssi(_: &SurfaceHandle, _: &SurfaceHandle, _: i32, _: f64) -> Result { Err(NOT_BUILT) } pub fn curve_count(_: &ResultHandle) -> Result { @@ -354,7 +364,7 @@ mod calls { pub fn curve_info(_: &ResultHandle, _: i32) -> Result { Err(NOT_BUILT) } - pub fn curve_samples(_: &ResultHandle, _: i32, _: usize) -> Result { + pub fn curve_nurbs(_: &ResultHandle, _: i32, _: i32, _: usize) -> Result { Err(NOT_BUILT) } pub fn point_count(_: &ResultHandle) -> Result { diff --git a/crates/smlib/src/ssi.rs b/crates/smlib/src/ssi.rs index cd31c95e1..135ab5923 100644 --- a/crates/smlib/src/ssi.rs +++ b/crates/smlib/src/ssi.rs @@ -1,15 +1,14 @@ //! Surface/surface intersection (`capi/include/smlib.h`, "Surface/surface intersection"): two //! surfaces described in plain numbers, intersected by one of SMLib's SSI entry points, each -//! intersection curve sampled uniformly in its parameters. +//! intersection curve exactly as SMLib holds it: schema 4 B-splines (`solidcraft_geom::brep`). //! //! The constructors take exactly the fields of an SSI corpus case (`tests/ssi-corpus`), angles in //! degrees. Each surface's UV domain is SMLib's natural one ([`Surface::domain`]): (u, v) itself //! for planes, the parameterisation of SMLib's internal NURBS form for the other analytic kinds. -use crate::{Error, Result, error, ffi, init}; +use solidcraft_geom::brep as b; -/// `SMLIB_SSI_MAX_SAMPLES`: most samples per curve. -pub const MAX_SAMPLES: usize = 100_000; +use crate::{Error, Result, error, ffi, init}; /// A surface with its UV domain, owned on the C side. pub struct Surface(ffi::ssi::SurfaceHandle); @@ -209,27 +208,25 @@ impl CurveType { } } -/// One intersection curve, sampled at the same count of parameters on the 3D curve and on each -/// UV curve. A value SMLib could not evaluate is NaN, and so is every UV value (with the surface -/// at it) of a UV curve the method did not return ([`SsiCurve::has_uv_a`]). +/// One intersection curve as SMLib returned it: its 3D curve and, where the method returned +/// them, its curves in each surface's UV, each the (rational) B-spline SMLib holds (its lines, +/// circles and ellipses are B-splines too; an intersection curve one SMLib fitted within the +/// approximation tolerance). #[derive(Clone, Debug)] pub struct SsiCurve { pub curve_type: CurveType, - pub has_uv_a: bool, - pub has_uv_b: bool, /// SMLib's deviation estimate (NaN: none). pub deviation: f64, - /// The 3D curve's natural parameter interval, which `xyz` samples uniformly. + /// The 3D curve's natural parameter interval. pub interval: [f64; 2], - pub xyz: Vec<[f64; 3]>, - pub uv_a: Vec<[f64; 2]>, - pub uv_b: Vec<[f64; 2]>, - /// Surface a at `uv_a`, b at `uv_b`. - pub a_at_uv: Vec<[f64; 3]>, - pub b_at_uv: Vec<[f64; 3]>, + pub curve: b::Curve, + /// On surface a, in a's UV. + pub uv_a: Option, + /// On surface b, in b's UV. + pub uv_b: Option, } -/// An isolated point: a [`CurveType::Touching`] curve's first sample. +/// An isolated point: where a [`CurveType::Touching`] curve starts. #[derive(Clone, Copy, Debug)] pub struct SsiPoint { pub xyz: [f64; 3], @@ -244,39 +241,54 @@ pub struct SsiResult { pub points: Vec, } -fn triples(v: &[f64]) -> Vec<[f64; 3]> { - v.as_chunks::<3>().0.to_vec() +/// The 3D B-spline: polynomial where every weight is 1. +fn curve3(c: ffi::ssi::Nurbs) -> b::Curve { + let points = c.points.as_chunks::<3>().0; + if c.weights.iter().all(|w| *w == 1.0) { + b::Curve::Spline { knots: c.knots, points: points.to_vec() } + } else { + b::Curve::RationalSpline { + knots: c.knots, + homogeneous: points.iter().zip(&c.weights).map(|(p, w)| [p[0] * w, p[1] * w, p[2] * w, *w]).collect(), + } + } } -fn pairs(v: &[f64]) -> Vec<[f64; 2]> { - v.as_chunks::<2>().0.to_vec() +/// A UV B-spline, as [`curve3`]. +fn curve2(c: ffi::ssi::Nurbs) -> b::Curve2 { + let points = c.points.as_chunks::<2>().0; + if c.weights.iter().all(|w| *w == 1.0) { + b::Curve2::Spline { knots: c.knots, points: points.to_vec() } + } else { + b::Curve2::RationalSpline { knots: c.knots, homogeneous: points.iter().zip(&c.weights).map(|(p, w)| [p[0] * w, p[1] * w, *w]).collect() } + } +} + +/// A UV curve the method may not have returned (`SMLIB_ERR_EMPTY`). +fn uv(r: &ffi::ssi::ResultHandle, i: i32, which: i32) -> Result> { + match ffi::ssi::curve_nurbs(r, i, which, 2) { + Ok(c) => Ok(Some(curve2(c))), + Err(ffi::ERR_EMPTY) => Ok(None), + Err(s) => Err(error(s)), + } } /// Intersects `a` and `b` within their domains with `method` at approximation tolerance -/// `approx_tol` (<= 0: SMLib's default, 1/1000 of the surfaces' size), sampling each curve at -/// `samples` parameters (2..=[`MAX_SAMPLES`]). An intersector failure is SMLib's status. -pub fn intersect(a: &Surface, b: &Surface, method: Method, approx_tol: f64, samples: usize) -> Result { - if !(2..=MAX_SAMPLES).contains(&samples) { - return Err(Error::Argument); - } - let r = ffi::ssi::ssi(&a.0, &b.0, method.code(), approx_tol, int(samples)?).map_err(error)?; +/// `approx_tol` (<= 0: SMLib's default, 1/1000 of the surfaces' size). An intersector failure is +/// SMLib's status; a curve SMLib does not hold as a B-spline is [`Error::Unsupported`]. +pub fn intersect(a: &Surface, b: &Surface, method: Method, approx_tol: f64) -> Result { + let r = ffi::ssi::ssi(&a.0, &b.0, method.code(), approx_tol).map_err(error)?; let n = ffi::ssi::curve_count(&r).map_err(error)?; let mut curves = Vec::new(); for i in 0..n { let info = ffi::ssi::curve_info(&r, i).map_err(error)?; - let count = usize::try_from(info.samples).map_err(|_| Error::Argument)?; - let s = ffi::ssi::curve_samples(&r, i, count).map_err(error)?; curves.push(SsiCurve { curve_type: CurveType::from_code(info.ty), - has_uv_a: info.flags & 1 != 0, - has_uv_b: info.flags & 2 != 0, deviation: info.deviation, interval: info.interval, - xyz: triples(&s.xyz), - uv_a: pairs(&s.uv_a), - uv_b: pairs(&s.uv_b), - a_at_uv: triples(&s.a_at_uv), - b_at_uv: triples(&s.b_at_uv), + curve: curve3(ffi::ssi::curve_nurbs(&r, i, ffi::ssi::CURVE_3D, 3).map_err(error)?), + uv_a: uv(&r, i, ffi::ssi::CURVE_UV_A)?, + uv_b: uv(&r, i, ffi::ssi::CURVE_UV_B)?, }); } let n = ffi::ssi::point_count(&r).map_err(error)?; @@ -304,15 +316,16 @@ mod tests { (Ok(p), Ok(s)) => (p, s), (p, s) => panic!("{p:?} {s:?}"), }; - let r = intersect(&plane, &sphere, Method::Global, 1e-6, 101).expect("intersect"); + let r = intersect(&plane, &sphere, Method::Global, 1e-6).expect("intersect"); assert!(!r.curves.is_empty()); for c in &r.curves { - assert_eq!(c.xyz.len(), 101); - for p in &c.xyz { - assert!((p[0].hypot(p[1]) - 1.0).abs() < 1e-5 && p[2].abs() < 1e-5, "{p:?}"); + let eval = b::eval::CurveEval::new(&c.curve).expect("a curve"); + let [t0, t1] = c.interval; + for k in 0..=100 { + let p = eval.point(t0 + (t1 - t0) * f64::from(k) / 100.0).expect("evaluates"); + assert!((p.x.hypot(p.y) - 1.0).abs() < 1e-5 && p.z.abs() < 1e-5, "{p:?}"); } } - assert_eq!(intersect(&plane, &sphere, Method::Global, 1e-6, 1).err(), Some(Error::Argument)); } #[test] diff --git a/crates/smlib/tests/ssi_corpus.rs b/crates/smlib/tests/ssi_corpus.rs index 6e3346915..d75ce76ae 100644 --- a/crates/smlib/tests/ssi_corpus.rs +++ b/crates/smlib/tests/ssi_corpus.rs @@ -530,12 +530,20 @@ fn surface(s: &Value) -> Result { r.map_err(|e| e.to_string()) } -/// SMLib's answer as the corpus runner writes it for `gsi`: samples SMLib could not evaluate -/// dropped, empty UV arrays for a UV curve the method did not return, the runner's type names, -/// and no isolated points (the runner only reports those in face mode). +/// SMLib's answer as the corpus runner writes it for `gsi`: each exact curve sampled where the +/// runner samples it ([`RUNNER_SAMPLES`] parameters spread evenly over the 3D curve's natural +/// interval, each UV curve over its own, the surfaces at the UV samples), samples that cannot be +/// evaluated dropped, empty UV arrays for a UV curve the method did not return, the runner's type +/// names, and no isolated points (the runner only reports those in face mode). #[cfg(feature = "native")] -fn runner_output(r: solidcraft_smlib::Result, ms: f64) -> Outcome { - use solidcraft_smlib::ssi::CurveType; +fn runner_output( + r: solidcraft_smlib::Result, + a: &solidcraft_smlib::ssi::Surface, + b: &solidcraft_smlib::ssi::Surface, + ms: f64, +) -> Outcome { + use solidcraft_geom::brep::{Curve2, eval::CurveEval}; + use solidcraft_smlib::ssi::{CurveType, Surface}; let r = match r { Ok(r) => r, Err(solidcraft_smlib::Error::Status(s)) => { @@ -543,33 +551,33 @@ fn runner_output(r: solidcraft_smlib::Result, } Err(e) => return Outcome::Crashed(e.to_string()), }; - let curves = r - .curves - .into_iter() - .map(|c| { - let curve_type = match c.curve_type { - CurveType::None => "n/a", - CurveType::Unknown => "UNKNOWN", - CurveType::Touching => "TOUCHING", - CurveType::Crossing => "CROSSING", - CurveType::Tangent => "TANGENT", - CurveType::Coincident => "COINCIDENT", - CurveType::NearTangent => "NEAR_TANGENT", - CurveType::RegionBoundary => "REGION_BOUNDARY", - CurveType::Other(_) => "?", - }; - let evaluated = |p: &[f64]| p.iter().any(|x| !x.is_nan()); - let on = |has: bool, uv: Vec<[f64; 2]>, at: Vec| -> (Vec<[f64; 2]>, Vec) { - if !has { - return (Vec::new(), Vec::new()); - } - uv.into_iter().zip(at).filter(|(q, _)| evaluated(q)).unzip() - }; - let (uv1, s1_at_uv) = on(c.has_uv_a, c.uv_a, c.a_at_uv); - let (uv2, s2_at_uv) = on(c.has_uv_b, c.uv_b, c.b_at_uv); - EngineCurve { curve_type: curve_type.into(), xyz: c.xyz.into_iter().filter(|p| evaluated(p)).collect(), uv1, uv2, s1_at_uv, s2_at_uv } - }) - .collect(); + let params = |[t0, t1]: [f64; 2]| (0..RUNNER_SAMPLES).map(move |i| t0 + (t1 - t0) * (i as f64 / (RUNNER_SAMPLES - 1) as f64)); + let on = |c: &Option, s: &Surface| -> (Vec<[f64; 2]>, Vec) { + let Some(c) = c else { return (Vec::new(), Vec::new()) }; + let Some(ivl) = c.interval() else { return (Vec::new(), Vec::new()) }; + params(ivl).filter_map(|t| c.eval(t)).filter_map(|q| s.evaluate(q[0], q[1]).ok().map(|p| (q, p))).unzip() + }; + let mut curves = Vec::new(); + for c in r.curves { + let curve_type = match c.curve_type { + CurveType::None => "n/a", + CurveType::Unknown => "UNKNOWN", + CurveType::Touching => "TOUCHING", + CurveType::Crossing => "CROSSING", + CurveType::Tangent => "TANGENT", + CurveType::Coincident => "COINCIDENT", + CurveType::NearTangent => "NEAR_TANGENT", + CurveType::RegionBoundary => "REGION_BOUNDARY", + CurveType::Other(_) => "?", + }; + let xyz = match CurveEval::new(&c.curve) { + Ok(e) => params(c.interval).filter_map(|t| e.point(t)).map(|p| [p.x, p.y, p.z]).collect(), + Err(e) => return Outcome::Crashed(format!("an intersection curve: {e}")), + }; + let (uv1, s1_at_uv) = on(&c.uv_a, a); + let (uv2, s2_at_uv) = on(&c.uv_b, b); + curves.push(EngineCurve { curve_type: curve_type.into(), xyz, uv1, uv2, s1_at_uv, s2_at_uv }); + } Outcome::Ran(EngineResult { status: ssi_score::SM_SUCCESS, status_name: None, time_ms: ms, curves, points: Vec::new() }) } @@ -588,8 +596,8 @@ fn smlib_global_intersect_at_1e_6() { let a = surface(&case.surfaces[0]).unwrap_or_else(|e| panic!("{} surface 1: {e}", case.id)); let b = surface(&case.surfaces[1]).unwrap_or_else(|e| panic!("{} surface 2: {e}", case.id)); let t = std::time::Instant::now(); - let r = intersect(&a, &b, Method::Global, 1e-6, RUNNER_SAMPLES); - runner_output(r, t.elapsed().as_secs_f64() * 1e3) + let r = intersect(&a, &b, Method::Global, 1e-6); + runner_output(r, &a, &b, t.elapsed().as_secs_f64() * 1e3) }) .collect(); let ran = t0.elapsed();