From 525d8e1e61cdb7d23a0da39cc87822b401eb38c6 Mon Sep 17 00:00:00 2001 From: Brett Lawson Date: Wed, 28 Oct 2026 23:55:16 +0100 Subject: [PATCH] Kernel: fillets and chamfers on solidcore core/blend.rs ports the capi's composition round the fillet executive (smlib_ops.cpp blend_call, round_edges, chamfer_offsets/chamfer_edges, chamfer_radius, blend_failure, setbacks_fit, law_ok/law_pinches/law_along, finish; smlib_pick.h): picking edges and corners by point with the NoMatch/Ambiguous rule, per-edge kinds and sizes, bevelled chamfer corners, N x N convex corner setbacks (CornerRefused otherwise), the B-spline variable law, and the capi's errors (Argument, NoRoom, NoEffect, Empty, NotSolid, SMLib statuses). ops.rs routes fillet, chamfer, blend, blend_setback, blend_setback_open, fillet_variable and chamfer_sides on Op::Blend as the boolean family is routed. What the capi asks of fork-only SMLib that solidcore lacks is "not supported yet", refused where the capi first reaches it: curvature blends (fd3b6a7), two-distance and angle chamfers (f653ac9), open corners (60af574), laws with a corner (6eecf04), and rails leaving their face, which the fork may build over the cliff (8ba4667). core/blend_tests.rs checks closed forms (one edge, all twelve edges, a chamfer, Pappus on a cylinder rim, a setback corner, a linear variable round, the errors) and, with native, C++ parity on volume, counts and faces by kind, or the same error. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01SdcgExNEwfR9CX2RAzp2Pt --- crates/smlib/src/core.rs | 3 + crates/smlib/src/core/blend.rs | 707 +++++++++++++++++++++++++++ crates/smlib/src/core/blend_tests.rs | 434 ++++++++++++++++ crates/smlib/src/core/boolean.rs | 2 +- crates/smlib/src/ops.rs | 51 +- 5 files changed, 1190 insertions(+), 7 deletions(-) create mode 100644 crates/smlib/src/core/blend.rs create mode 100644 crates/smlib/src/core/blend_tests.rs diff --git a/crates/smlib/src/core.rs b/crates/smlib/src/core.rs index 67debffa7..07ee4ceab 100644 --- a/crates/smlib/src/core.rs +++ b/crates/smlib/src/core.rs @@ -16,6 +16,9 @@ use solidcore::primitive::api_primitives as primitives; use crate::{Error, Result}; +pub(crate) mod blend; +#[cfg(test)] +mod blend_tests; pub(crate) mod boolean; #[cfg(test)] mod boolean_tests; diff --git a/crates/smlib/src/core/blend.rs b/crates/smlib/src/core/blend.rs new file mode 100644 index 000000000..dff63e02e --- /dev/null +++ b/crates/smlib/src/core/blend.rs @@ -0,0 +1,707 @@ +//! Fillets and chamfers on solidcore: the C API's composition round SMLib's fillet executive, +//! ported from the fork's `capi/src/smlib_ops.cpp` (`blend_call`, `round_edges`, +//! `chamfer_offsets`, `chamfer_edges`, `chamfer_radius`, `blend_failure`, `setbacks_fit`, +//! `size_ok`, `points_ok`, `tolerance_ok`, `law_ok`, `law_pinches`, `law_along`, `finish`, +//! `smlib_fillet`, `smlib_chamfer`, `smlib_blend`, `smlib_blend_setback`, +//! `smlib_blend_setback_open`, `smlib_fillet_variable`, `smlib_chamfer_sides`) and +//! `capi/src/smlib_pick.h` (`pick`, `pick_edges`, `pick_vertices`). +//! +//! As there, every operation works on a copy of its body (`SmApiBrepCopy`), picks edges and +//! corners by point, and drives the executive step by step (`SetFilletParameters`, +//! `CreateFilletCorners`, the corners' bevels and setbacks, `DoFilleting`, `StitchAndOrient`). +//! +//! What the capi asks of fork-only SMLib code that solidcore does not have is +//! [`Error::Unsupported`], refused where the capi would first reach it, so every error before +//! it is the C++ path's: +//! - a curvature-continuous blend (`SetBlendCurveAtThirds`, fork fd3b6a7); +//! - a two-distance or distance-and-angle chamfer (`SetFilletParameters`' per-edge second +//! offsets, fork f653ac9); +//! - a corner left open (`SetMarkCornerPatches`, fork 60af574); +//! - a variable radius whose law has a corner (`SplitFilletFacesAtRadiusCorners`, fork 6eecf04). +//! +//! - a blend whose rail leaves its face, which the fork may build over the cliff +//! (`SmFilletCliffOverflow.cpp`, fork 8ba4667) and solidcore always refuses ([`blend_failure`]). +//! +//! solidcore's own refusals of code it has not ported (`SolidError::Unported`) are +//! [`Error::Unsupported`] too. + +use std::collections::HashSet; +use std::sync::PoisonError; + +use solidcore::SolidError; +use solidcore::blend::fillet_executive::p1::{FilletLaw, FilletLawKind}; +use solidcore::blend::fillet_executive::session::FilletSession; +use solidcore::blend::fillet_geom::p1::{FilletCornerType, FilletErrorType}; +use solidcore::blend::fillet_solver::p1::FilletSurfaceGeneratorType; +use solidcore::geom::vector3d::{Point3, Vec3}; +use solidcore::kernel::Kernel; +use solidcore::mass::integrator::properties::edge_length; +use solidcore::nurbs::b_spline_curve::p1::{BSplineCurve, BSplineCurveForm, CanonicalData, KnotType}; +use solidcore::query::api_queries::edge_closest_point; +use solidcore::topology::brep::p1 as brep_p1; +use solidcore::topology::brep::p2 as brep_p2; +use solidcore::topology::brep::p5::{StitchAndOrientOptions, stitch_and_orient}; +use solidcore::topology::edgeuse::p1 as eu_p1; +use solidcore::topology::edgeuse::p3::{BinormalOptions, evaluate_binormal}; +use solidcore::topology::{Brep, EdgeId, FaceId, VertexId, edge, vertex}; + +use super::boolean::copy_of; +use super::{Body, run}; +use crate::{Blend, ChamferSecond, Error, MAX_POINTS, Result}; + +/// The capi's statuses as SolidCraft errors: an operation's own result. +type Out = std::result::Result; + +/// `SM_ERR_INVALID_INPUT`. +const INVALID_INPUT: i32 = 1007; + +/// An SMLib status as the capi passes it on (`status`, smlib_shim.h): solidcore's upstream +/// status codes as they are; its refusals of code it has not ported as not supported. +fn status(e: SolidError) -> Error { + match e { + SolidError::Upstream { code, .. } => Error::Status(code), + SolidError::InvalidInput { .. } => Error::Status(INVALID_INPUT), + e if e.is_unported() => Error::Unsupported, + e => Error::Solidcore(e.to_string()), + } +} + +/// `size_ok`. +fn size_ok(x: f64) -> bool { + x.is_finite() && x > 0.0 && x <= 1e6 +} + +/// `tolerance_ok`. +fn tolerance_ok(t: f64) -> bool { + t.is_finite() && t > 0.0 && t < 1e6 +} + +/// `points_ok`. +fn points_ok(points: &[[f64; 3]], allow_none: bool) -> bool { + points.len() <= MAX_POINTS && (allow_none || !points.is_empty()) && points.iter().flatten().all(|x| x.is_finite()) +} + +fn p3(p: [f64; 3]) -> Point3 { + Vec3::new(p[0], p[1], p[2]) +} + +/// Why a pick failed: `SMLIB_ERR_PICK_NONE` or `SMLIB_ERR_PICK_AMBIGUOUS`, and the point. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Miss { + None(usize), + Ambiguous(usize), +} + +/// `smlib_pick::pick`: the entity nearest each point, each once, with the index of the point that +/// first picked it. A point picks none when the nearest is farther than `tol`, and is ambiguous +/// when the second nearest is within `tol` too and nearer than the first by at most `model_tol`. +/// An entity whose distance cannot be measured is skipped, as the capi skips a failed query +/// (solidcore's refusal of unported code is not skipped: it fails the pick). +fn pick( + all: &[T], + points: &[[f64; 3]], + tol: f64, + model_tol: f64, + mut dist: impl FnMut(T, Point3) -> solidcore::Result>, +) -> solidcore::Result, Vec), Miss>> { + let (mut picked, mut first) = (Vec::new(), Vec::new()); + for (i, p) in points.iter().enumerate() { + let p = p3(*p); + let (mut best, mut d0, mut d1) = (None, f64::INFINITY, f64::INFINITY); + for &x in all { + let Some(d) = dist(x, p)? else { continue }; + if !d.is_finite() { + continue; + } + if d < d0 { + d1 = d0; + d0 = d; + best = Some(x); + } else if d < d1 { + d1 = d; + } + } + let Some(best) = best.filter(|_| d0 <= tol) else { + return Ok(Err(Miss::None(i))); + }; + if d1 <= tol && d1 - d0 <= model_tol { + return Ok(Err(Miss::Ambiguous(i))); + } + if !picked.contains(&best) { + picked.push(best); + first.push(i); + } + } + Ok(Ok((picked, first))) +} + +/// A query's failure the capi treats as no answer; solidcore's unported code still fails. +fn answer(r: solidcore::Result) -> solidcore::Result> { + match r { + Ok(v) => Ok(Some(v)), + Err(e) if e.is_unported() => Err(e), + Err(_) => Ok(None), + } +} + +/// `pick_edges` (`edge_distance`: `SmApiEdgeClosestPoint`). +fn pick_edges(k: &Kernel, b: &Brep, points: &[[f64; 3]], tol: f64) -> solidcore::Result, Vec), Miss>> { + let all = brep_p1::edges(b, None)?; + pick(&all, points, tol, b.tolerance(), |e, p| Ok(answer(edge_closest_point(k, b, e, p))?.map(|c| c.closest.distance))) +} + +/// `pick_vertices` (`vertex_distance`). +fn pick_vertices(b: &Brep, points: &[[f64; 3]], tol: f64) -> solidcore::Result, Vec), Miss>> { + let all = brep_p1::vertices(b, None)?; + pick(&all, points, tol, b.tolerance(), |v, p| Ok(Some((b.vertex(v)?.point - p).length()))) +} + +/// An edge pick's failure as `pick_error` (ops.rs) reads it. +fn edge_miss(m: Miss) -> Error { + match m { + Miss::None(point) => Error::NoMatch { point }, + Miss::Ambiguous(point) => Error::Ambiguous { point }, + } +} + +/// A corner pick's failure as `setback_error` (ops.rs) reads it: the capi writes the corner +/// point's index to `out_failed_corner` only, so the status comes back bare. +fn corner_miss(m: Miss) -> Error { + match m { + Miss::None(_) => Error::Status(crate::ffi::ops::ERR_PICK_NONE), + Miss::Ambiguous(_) => Error::Status(crate::ffi::ops::ERR_PICK_AMBIGUOUS), + } +} + +/// A corner set back: its vertex and the setback along each of its edges (the capi's +/// `SetBack`; the routed entry points take no ease, which is 0). +struct SetBack { + vertex: VertexId, + distance: f64, +} + +/// `setbacks_fit`: each setback shorter than every edge at its corner, and where an edge's +/// other end is a setback corner too, the two together shorter than the edge. +fn setbacks_fit(k: &Kernel, b: &Brep, setbacks: &[SetBack]) -> solidcore::Result { + for sb in setbacks { + for e in vertex::edges(b, sb.vertex, None)? { + let Some(length) = answer(edge_length(k, b, e, 1e-6))? else { + return Ok(false); + }; + let far = edge::other_vertex(b, e, Some(sb.vertex))?; + let mut other = 0.0; + for o in setbacks { + if Some(o.vertex) == far && far != Some(sb.vertex) { + other = o.distance; + } + } + if sb.distance + other >= length { + return Ok(false); + } + } + } + Ok(true) +} + +/// The midpoint parameter of `e` (`GetInterval().Evaluate(0.5)`). +fn mid(b: &Brep, e: EdgeId) -> solidcore::Result { + Ok(b.edge(e)?.interval.evaluate(0.5)) +} + +/// `chamfer_radius`: the radius of the ball whose tangent points on the two faces of `e` lie +/// `distance` back from the edge at its midpoint, `distance * tan(a / 2)` with `a` the angle +/// between the directions into the faces. `None` where the capi's returns false. +fn chamfer_radius(k: &Kernel, b: &mut Brep, e: EdgeId, distance: f64) -> solidcore::Result> { + let Some(u0) = edge::blend_edgeuse(k, b, e)? else { return Ok(None) }; + let Some(u1) = eu_p1::radial(b, u0)? else { return Ok(None) }; + let t = mid(b, e)?; + let options = BinormalOptions::default(); + let Some(e0) = answer(evaluate_binormal(k, b, u0, t, false, &options))? else { return Ok(None) }; + let Some(e1) = answer(evaluate_binormal(k, b, u1, t, false, &options))? else { return Ok(None) }; + let c = e0.binormal.dot(e1.binormal).clamp(-1.0, 1.0); + let radius = distance * ((1.0 - c) / (1.0 + c)).sqrt(); + Ok((radius.is_finite() && radius > 0.0).then_some(radius)) +} + +/// What `round_edges` makes: the capi's kinds less the chamfer, which `chamfer_offsets` makes. +#[derive(Clone, Copy, PartialEq, Eq)] +enum Section { + Round, + Chord, + Chamfer, +} + +/// The faces of `b`, for `made_faces`: a face whose id is new after the operation was made by +/// it. (The capi marks faces with an attribute SMLib copies through every split; here a face +/// split by the operation counts as made, which only matters to a blend that made no blend +/// face but split one, never seen.) +fn face_set(b: &Brep) -> solidcore::Result> { + Ok(brep_p1::faces(b, None)?.into_iter().collect()) +} + +/// solidcore's refusal of a blend whose rail leaves the face it rolls on (its port of fork +/// fc43974, `refuse_blends_larger_than_faces`). +const RAIL_LEAVES_FACE: &str = "Fillet Error: a rail leaves the face it rolls on (the blend is larger than the faces allow)"; + +/// `blend_failure`: a blend the executive found larger than its faces allow +/// (`SM_FILERR_NO_ROOM`) is [`Error::NoRoom`]; any other failure its status. +/// +/// Except a blend whose rail leaves its face: there the fork decides between building the +/// blend over the cliff (`SmFilletCliffOverflow.cpp`, fork 8ba4667) and refusing it, which +/// solidcore does not port, refusing every such blend. Its answer is the fork's only by chance, +/// so it is [`Error::Unsupported`]. +fn blend_failure(s: &FilletSession<'_>, e: SolidError) -> Error { + let info = s.error_info(); + if info.code != FilletErrorType::NoRoom as i32 || e.is_unported() { + status(e) + } else if info.comment == RAIL_LEAVES_FACE { + Error::Unsupported + } else { + Error::NoRoom + } +} + +/// `round_edges` and `chamfer_offsets` (with equal offsets): `edges` of `b` blended in place, +/// edge i at `sizes[i]`, the executive driven as `SmApiFilletEdgesPerEdge` drives it with the +/// corners' setbacks (`SmFilletCorner::SetSetBackDist`) set between making the corners and +/// filleting, or (a chamfer) every corner bevelled; then `StitchAndOrient`. A blend that made +/// no face is [`Error::NoEffect`]. A setback corner that is not SMLib's same-convexity N x N +/// corner is refused with its index in `setbacks` (`Err(Ok(j))`). +fn blend_edges( + k: &mut Kernel, + b: &mut Brep, + edges: &[EdgeId], + sizes: &[f64], + section: Section, + law: Option, + setbacks: &[SetBack], +) -> solidcore::Result>> { + let before = face_set(b)?; + let done = { + let mut s = FilletSession::new(k, b)?; + // `SetFilletParameters(b, es, sections, solvers, values, laws, -1, -1, -1, -1, + // continuity 1, thumbweight 1)`: the session sets the executive's global merge first, as + // `SmApiFilletEdges` does, and `SetFilletParameters` resets it, as in the capi. + let prepared = match (section, law) { + (Section::Round, None) => s.prepare_per_edge_constant_radius(k, edges, sizes, &[FilletSurfaceGeneratorType::Circular], 1, 1.0), + // The size is the start radius (`smlib_fillet_variable`). + (Section::Round, Some(law)) => match sizes.first() { + Some(&size) => s.prepare_variable_radius_edges(k, edges, size, law, 1, 1), + None => return Ok(Err(Err(Error::Argument))), + }, + (Section::Chord, _) => s.prepare_per_edge_constant_distance(k, edges, sizes, &[FilletSurfaceGeneratorType::Circular], 1, 1.0), + (Section::Chamfer, _) => s.prepare_per_edge_constant_radius(k, edges, sizes, &[FilletSurfaceGeneratorType::Linear], 1, 1.0), + }; + let mut step = prepared.and_then(|()| s.create_corners(k, None)).map(|()| Ok(())); + if let Ok(Ok(())) = step { + step = corners(&mut s, section, setbacks); + } + match step { + Ok(Ok(())) => match s.do_filleting(k, None) { + Ok(()) => Ok(Ok(())), + Err(e) => Ok(Err(Err(blend_failure(&s, e)))), + }, + Ok(Err(refusal)) => Ok(Err(refusal)), + Err(e) => Ok(Err(Err(blend_failure(&s, e)))), + } + }; + let done: solidcore::Result>> = done; + let stitched = match done? { + Ok(()) => stitch_and_orient(k, b, &StitchAndOrientOptions::default()).map_err(status), + Err(refusal) => { + b.refresh_cached_topology(); + return Ok(Err(refusal)); + } + }; + // The port's cached topology, true again for what reads the body next (as solidcore's own + // fillet entry points do). + b.refresh_cached_topology(); + if let Err(e) = stitched { + return Ok(Err(Err(e))); + } + let made = face_set(b)?.difference(&before).count(); + Ok(if made > 0 { Ok(()) } else { Err(Err(Error::NoEffect)) }) +} + +/// The corners' part of `round_edges` / `chamfer_offsets`: a chamfer's corners bevelled; each +/// setback set on its vertex's corner (`GetFilletCornerOfVertex`), which must be an +/// `SM_FCR_N_x_N_CONVEX` corner. +fn corners( + s: &mut FilletSession<'_>, + section: Section, + setbacks: &[SetBack], +) -> solidcore::Result>> { + let ids = s.fillet_corners()?; + if section == Section::Chamfer { + for id in ids { + s.set_corner_bevel(id, true)?; + } + return Ok(Ok(())); + } + for (j, sb) in setbacks.iter().enumerate() { + let mut found = None; + for &id in &ids { + if s.corner(id)?.vertex == Some(sb.vertex) { + found = Some(id); + break; + } + } + let Some(id) = found else { + return Ok(Err(Err(Error::Argument))); + }; + if s.corner(id)?.corner_type() != FilletCornerType::NByNConvex { + return Ok(Err(Ok(j))); + } + s.set_corner_setback(id, sb.distance)?; + } + Ok(Ok(())) +} + +/// `finish`: the result must have faces, and a solid input must give a closed manifold solid. +fn finish(b: Brep, solid_in: bool) -> solidcore::Result> { + if b.face_list().is_empty() { + return Ok(Err(Error::Empty)); + } + if solid_in && !brep_p2::is_manifold_solid(&b)? { + return Ok(Err(Error::NotSolid)); + } + Ok(Ok(b)) +} + +/// Runs `f` on a copy of `body` (`copy_of`) under the kernel's lock. +fn on_copy(call: &'static str, body: &Body, f: impl FnOnce(&mut Kernel, Brep) -> solidcore::Result>) -> Result { + if body.0.is_poisoned() { + return Err(Error::Internal(format!("{call}: the body was left unfinished by an earlier panic"))); + } + run(call, |k| { + let g = body.0.lock().unwrap_or_else(PoisonError::into_inner); + let c = copy_of(k, &g, 1)?; + drop(g); + f(k, c) + })? + .map(Body::new) +} + +/// What [`blend`] does with the picked corners' patches. +#[derive(Clone, Copy, PartialEq, Eq)] +pub(crate) enum Corners { + /// Filled, as SMLib builds them (`smlib_blend`, `smlib_blend_setback`). + Filled, + /// Removed, the holes listed (`smlib_blend_setback_open`): not supported on solidcore. + Open, +} + +/// `blend_call` (as `smlib_fillet`, `smlib_chamfer`, `smlib_blend`, `smlib_blend_setback` and +/// `smlib_blend_setback_open` call it): `sizes` one per point, or one for all; `corners` and +/// `setbacks` the corner setbacks. +#[allow(clippy::too_many_arguments)] // the capi's blend_call +pub(crate) fn blend( + body: &Body, + kind: Blend, + points: &[[f64; 3]], + sizes: &[f64], + tolerance: f64, + corners: &[[f64; 3]], + setbacks: &[f64], + open: Corners, +) -> Result { + let one_size = sizes.len() == 1; + if !points_ok(points, false) + || !tolerance_ok(tolerance) + || !(one_size || sizes.len() == points.len()) + || !points_ok(corners, true) + || setbacks.len() != corners.len() + { + return Err(Error::Argument); + } + if !sizes.iter().all(|&s| size_ok(s)) || !setbacks.iter().all(|&s| size_ok(s)) { + return Err(Error::Argument); + } + // A chamfer's corners are bevelled, which builds no setback. + if !corners.is_empty() && kind == Blend::Chamfer { + return Err(Error::Unsupported); + } + on_copy("blend_call", body, |k, mut w| { + let (picked, first) = match pick_edges(k, &w, points, tolerance)? { + Ok(p) => p, + Err(m) => return Ok(Err(edge_miss(m))), + }; + let each: Vec = first.iter().map(|&i| sizes.get(if one_size { 0 } else { i }).copied().unwrap_or(0.0)).collect(); + // Each corner point picks a vertex; a vertex picked twice takes the first point's setback. + let (at, first_corner) = match pick_vertices(&w, corners, tolerance)? { + Ok(p) => p, + Err(m) => return Ok(Err(corner_miss(m))), + }; + let back: Vec = + at.iter().zip(&first_corner).map(|(&vertex, &j)| SetBack { vertex, distance: setbacks.get(j).copied().unwrap_or(0.0) }).collect(); + if !setbacks_fit(k, &w, &back)? { + return Ok(Err(Error::NoRoom)); + } + let solid_in = brep_p2::is_manifold_solid(&w)?; + let section = match kind { + Blend::Round => Section::Round, + Blend::Chord => Section::Chord, + // `chamfer_edges`: each edge's offsets from its setback at its midpoint. + Blend::Chamfer => { + let mut radii = Vec::with_capacity(picked.len()); + for (&e, &d) in picked.iter().zip(&each) { + match chamfer_radius(k, &mut w, e, d)? { + Some(r) => radii.push(r), + None => return Ok(Err(Error::Status(INVALID_INPUT))), + } + } + return Ok(match blend_edges(k, &mut w, &picked, &radii, Section::Chamfer, None, &[])? { + Ok(()) => finish(w, solid_in)?, + Err(Ok(_)) => Err(Error::Unsupported), + Err(Err(e)) => Err(e), + }); + } + // The curvature-continuous section sits at thirds (`SetBlendCurveAtThirds`, fork + // fd3b6a7), which solidcore does not have. + Blend::Curvature => return Ok(Err(Error::Unsupported)), + }; + // The corners' patches marked to be opened (`SetMarkCornerPatches`, fork 60af574), + // which solidcore does not have. + if open == Corners::Open { + return Ok(Err(Error::Unsupported)); + } + Ok(match blend_edges(k, &mut w, &picked, &each, section, None, &back)? { + Ok(()) => finish(w, solid_in)?, + // A corner SMLib does not set back: the first of the caller's points that picked it. + Err(Ok(j)) => Err(first_corner.get(j).map_or(Error::Unsupported, |&corner| Error::CornerRefused { corner })), + Err(Err(e)) => Err(e), + }) + }) +} + +/// `smlib_chamfer_sides`: its checks and the pick, then not supported: the chamfer's two +/// offsets per edge (`SetFilletParameters`' `pOptSecondRadii`, fork f653ac9) are not in +/// solidcore's executive. +pub(crate) fn chamfer_sides(body: &Body, points: &[[f64; 3]], tolerance: f64, distance: f64, second: ChamferSecond, first: [f64; 3]) -> Result { + let second_ok = match second { + ChamferSecond::Angle(a) => a.is_finite() && a > 1e-6 && a < std::f64::consts::PI - 1e-6, + ChamferSecond::Distance(d) => size_ok(d), + }; + if !points_ok(points, false) || !tolerance_ok(tolerance) || !size_ok(distance) || !second_ok || !first.iter().all(|x| x.is_finite()) { + return Err(Error::Argument); + } + if !(p3(first).length() > 0.0) { + return Err(Error::Argument); + } + on_copy("smlib_chamfer_sides", body, |k, w| { + if let Err(m) = pick_edges(k, &w, points, tolerance)? { + return Ok(Err(edge_miss(m))); + } + Ok(Err(Error::Unsupported)) + }) +} + +/// `law_ok`: a clamped B-spline of `degree` 1 to 3 from 0 to 1, 2 to 100 control radii, each +/// finite, at least 0 and at most 1e6. +fn law_ok(degree: usize, knots: &[f64], radii: &[f64]) -> bool { + let n = radii.len(); + if !(1..=3).contains(°ree) || !(2..=100).contains(&n) || n <= degree || knots.len() != n + degree + 1 { + return false; + } + if !knots.iter().chain(radii).all(|x| x.is_finite()) { + return false; + } + for (i, &k) in knots.iter().enumerate() { + let (low_end, high_end) = (i <= degree, i >= n); + if (low_end && k != 0.0) || (high_end && k != 1.0) || (i > 0 && knots.get(i - 1).is_some_and(|&p| k < p)) { + return false; + } + } + radii.iter().all(|&r| (0.0..=1e6).contains(&r)) +} + +/// `law_pinches`: whether the law's radius is zero somewhere inside (0, 1). +fn law_pinches(degree: usize, knots: &[f64], radii: &[f64]) -> bool { + let n = radii.len() as i64; + let p = degree as i64; + let all_zero = |from: i64, to: i64| -> bool { + let lo = from.max(0); + let mut j = lo; + while j <= to && j < n { + if radii.get(j as usize).is_some_and(|&r| r != 0.0) { + return false; + } + j += 1; + } + from <= to + }; + let kn = |i: i64| knots.get(i as usize).copied().unwrap_or(f64::NAN); + let n_knots = n + p + 1; + let mut i = p; + while i + 1 < n_knots && i < n { + if kn(i) < kn(i + 1) && all_zero(i - p, i) { + return true; + } + i += 1; + } + let mut s = p + 1; + while s < n { + let mut m = 1; + while s + m < n && kn(s + m) == kn(s) { + m += 1; + } + if all_zero(s + m - 1 - p, s - 1) { + return true; + } + s += m; + } + false +} + +/// Whether the law has a corner inside (0, 1) (`SmBSplineFilletLaw::GetCornerParameters`, fork +/// 6eecf04): an interior knot where the radius' slope from the left and from the right differ by +/// more than `SM_EFF_ZERO * (1 + |left| + |right|)`. The slope is the derivative B-spline's, +/// `Q_i = p (r_{i+1} - r_i) / (u_{i+p+1} - u_{i+1})`; it jumps only at a knot repeated `m >= p` +/// times, from `Q_{s-2}` to `Q_{s+m-1-p}` (`s` the knot's first index). +fn law_has_corner(degree: usize, knots: &[f64], radii: &[f64]) -> bool { + const EFF_ZERO: f64 = 1e-12; + let p = degree; + let q = |i: usize| -> Option { + let (r0, r1) = (radii.get(i)?, radii.get(i + 1)?); + let span = knots.get(i + p + 1)? - knots.get(i + 1)?; + Some(p as f64 * (r1 - r0) / span) + }; + let n = radii.len(); + let mut s = p + 1; + while s < n { + let Some(&u) = knots.get(s) else { break }; + let mut m = 1; + while knots.get(s + m) == Some(&u) { + m += 1; + } + if m >= p && u > 0.0 && u < 1.0 { + let (Some(left), Some(right)) = (s.checked_sub(2).and_then(q), q(s + m - 1 - p)) else { + return true; + }; + if (left - right).abs() > EFF_ZERO * (1.0 + left.abs() + right.abs()) { + return true; + } + } + s += m; + } + false +} + +/// `law_along`: the radius law along `e`, the B-spline with the radius as its x and its own +/// parameter as its y (control points at the Greville abscissae), reversed when `start` is +/// nearer the end of the edge's interval than its start. `None` where the capi's is null. +fn law_along(k: &Kernel, b: &Brep, e: EdgeId, start: [f64; 3], degree: usize, knots: &[f64], radii: &[f64]) -> solidcore::Result> { + let edge = b.edge(e)?; + let Some(curve) = edge.curve.as_ref() else { return Ok(None) }; + let ivl = edge.interval; + let (Some(lo), Some(hi)) = (answer(curve.evaluate_point(k, ivl.min()))?, answer(curve.evaluate_point(k, ivl.max()))?) else { + return Ok(None); + }; + let at = p3(start); + let reverse = (hi - at).length() < (lo - at).length(); + let (nk, nr) = (knots.len(), radii.len()); + let kv: Vec = (0..nk).map(|i| if reverse { 1.0 - knots[nk - 1 - i] } else { knots[i] }).collect(); + let mut cps = Vec::with_capacity(nr); + for i in 0..nr { + let g: f64 = (1..=degree).filter_map(|j| kv.get(i + j)).sum(); + let r = if reverse { radii[nr - 1 - i] } else { radii[i] }; + cps.push(Vec3::new(r, g / degree as f64, 0.0)); + } + let (mut unique, mut mults): (Vec, Vec) = (Vec::new(), Vec::new()); + for &x in &kv { + match (unique.last(), mults.last_mut()) { + (Some(&u), Some(m)) if u == x => *m += 1, + _ => { + unique.push(x); + mults.push(1); + } + } + } + let data = CanonicalData { + dim: 3, + degree, + control_points: &cps, + form: BSplineCurveForm::Unspecified, + knot_multiplicities: &mults, + knots: &unique, + knot_type: KnotType::Unspecified, + weights: None, + trim: None, + }; + let Some(c) = answer(BSplineCurve::create_canonical(&data))? else { return Ok(None) }; + // The law's map is the whole curve, 0 to 1 (`FilletLaw::new`'s). + Ok(Some(FilletLaw::new(FilletLawKind::BSpline { law_curve: c, extended_law: None }))) +} + +/// `smlib_fillet_variable`: the one edge nearest `point` rounded with the radius law of +/// `degree`, `knots` and `radii`, 0 at the end nearest `start`. +pub(crate) fn fillet_variable( + body: &Body, + point: [f64; 3], + tolerance: f64, + start: [f64; 3], + degree: usize, + knots: &[f64], + radii: &[f64], +) -> Result { + if !points_ok(&[point], false) || !start.iter().all(|x| x.is_finite()) || !tolerance_ok(tolerance) || !law_ok(degree, knots, radii) { + return Err(Error::Argument); + } + if law_pinches(degree, knots, radii) { + return Err(Error::Unsupported); + } + on_copy("smlib_fillet_variable", body, |k, mut w| { + let picked = match pick_edges(k, &w, &[point], tolerance)? { + Ok((p, _)) => p, + Err(m) => return Ok(Err(edge_miss(m))), + }; + let [e] = picked[..] else { return Ok(Err(Error::NoMatch { point: 0 })) }; + let Some(law) = law_along(k, &w, e, start, degree, knots, radii)? else { + return Ok(Err(Error::Status(INVALID_INPUT))); + }; + // A law with a corner splits the round's face there (`SplitFilletFacesAtRadiusCorners`, + // fork 6eecf04), which solidcore does not have. + if law_has_corner(degree, knots, radii) { + return Ok(Err(Error::Unsupported)); + } + let solid_in = brep_p2::is_manifold_solid(&w)?; + let (r0, r1) = (radii.first().copied().unwrap_or(0.0), radii.last().copied().unwrap_or(0.0)); + Ok(match blend_edges(k, &mut w, &[e], &[r0.max(r1)], Section::Round, Some(law), &[])? { + Ok(()) => finish(w, solid_in)?, + Err(Ok(_)) => Err(Error::Unsupported), + Err(Err(e)) => Err(e), + }) + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn laws_are_checked_as_the_capi_checks_them() { + assert!(law_ok(1, &[0.0, 0.0, 1.0, 1.0], &[1.0, 2.0])); + assert!(!law_ok(1, &[0.0, 0.0, 1.0], &[1.0, 2.0])); + assert!(!law_ok(1, &[0.0, 0.5, 1.0, 1.0], &[1.0, 2.0])); + assert!(!law_ok(1, &[0.0, 0.0, 1.0, 1.0], &[-1.0, 2.0])); + assert!(!law_ok(4, &[0.0; 7], &[1.0, 2.0])); + assert!(law_pinches(1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 0.0, 1.0])); + assert!(!law_pinches(1, &[0.0, 0.0, 1.0, 1.0], &[0.0, 1.0])); + // A straight law has no corner; a bent one does at its inner knot; a cubic none. + assert!(!law_has_corner(1, &[0.0, 0.0, 1.0, 1.0], &[1.0, 2.0])); + assert!(!law_has_corner(1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 1.5, 2.0])); + assert!(law_has_corner(1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 2.0, 1.0])); + assert!(!law_has_corner(3, &[0.0, 0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0, 1.0], &[1.0, 2.0, 1.0, 2.0, 1.0])); + } + + #[test] + fn picks_follow_the_capis_rule() { + let all = [0.0f64, 1.0, 3.0]; + let d = |x: f64, p: Point3| Ok(Some((x - p.x).abs())); + assert_eq!(pick(&all, &[[0.9, 0.0, 0.0]], 0.5, 1e-6, d).unwrap(), Ok((vec![1.0], vec![0]))); + assert_eq!(pick(&all, &[[2.0, 0.0, 0.0]], 0.5, 1e-6, d).unwrap(), Err(Miss::None(0))); + assert_eq!(pick(&all, &[[1.0, 0.0, 0.0], [0.5, 0.0, 0.0]], 1.0, 1e-6, d).unwrap(), Err(Miss::Ambiguous(1))); + // The same entity twice is picked once, by its first point. + assert_eq!(pick(&all, &[[3.1, 0.0, 0.0], [2.9, 0.0, 0.0]], 0.5, 1e-6, d).unwrap(), Ok((vec![3.0], vec![0]))); + } +} diff --git a/crates/smlib/src/core/blend_tests.rs b/crates/smlib/src/core/blend_tests.rs new file mode 100644 index 000000000..b464046ba --- /dev/null +++ b/crates/smlib/src/core/blend_tests.rs @@ -0,0 +1,434 @@ +//! Fillets and chamfers on solidcore, against closed forms: every result exports to a record that +//! validates. With SMLib built, the same case on the C++ kernel gives the same volume, counts and +//! faces by surface kind, or the same error (parity only: the expected values are the analytic +//! ones). +//! +//! The bodies are solidcore's own boxes and cylinders: a record's curved surfaces do not come +//! into solidcore yet (solidcore#1432, #1433). + +use std::collections::BTreeMap; +use std::f64::consts::PI; +use std::sync::mpsc; +use std::time::Duration; + +use super::blend::{Corners, blend, chamfer_sides, fillet_variable}; +use super::{Body, counts, make_box, make_cylinder, to_arrays, volume}; +use crate::export::native; +use crate::{Blend, ChamferSecond, Error}; + +/// A case longer than this is a hang. +const TIMEOUT: Duration = Duration::from_secs(300); + +/// How near a pick point must be. +const TOL: f64 = 0.01; + +#[derive(Clone, Copy, Debug)] +enum Shape { + Box([f64; 3], [f64; 3]), + Cylinder([f64; 3], f64, f64), +} + +impl Shape { + fn core(self) -> Body { + match self { + Shape::Box(o, s) => make_box(o, s), + Shape::Cylinder(o, r, h) => make_cylinder(o, r, h), + } + .unwrap() + } +} + +#[derive(Clone, Debug)] +enum Op { + /// `Brep::blend` of one kind, one size for every edge. + Blend(Shape, Blend, Vec<[f64; 3]>, f64), + /// `Brep::chamfer_sides`. + Sides(Shape, Vec<[f64; 3]>, f64, ChamferSecond, [f64; 3]), + /// `Brep::blend_setback` of rounds: edges, radius, corners, setbacks. + Setback(Shape, Vec<[f64; 3]>, f64, Vec<[f64; 3]>, Vec), + /// `Brep::fillet_variable`: edge point, start, degree, knots, radii. + Variable(Shape, [f64; 3], [f64; 3], usize, Vec, Vec), +} + +/// What a case must give. +#[derive(Clone, Debug)] +enum Expect { + /// A body of this volume (relative 1e-9). + Volume(f64), + /// A body of this volume to this relative accuracy. + Near(f64, f64), + /// A body whose volume lies strictly between these. + Between(f64, f64), + /// This error. + Fails(Error), +} + +struct Case { + op: Op, + expect: Expect, +} + +/// A 30 x 20 x 10 block from the origin. +const BLOCK: Shape = Shape::Box([0.0; 3], [30.0, 20.0, 10.0]); +const ABC: f64 = 6000.0; +/// Its top front edge, along x at y = 0, z = 10, 30 long. +const TOP_FRONT: [f64; 3] = [15.0, 0.0, 10.0]; + +/// The cross-section a round of radius r takes from a right-angled edge: (1 - π/4) r². +fn spandrel(r: f64) -> f64 { + (1.0 - PI / 4.0) * r * r +} + +fn case(name: &str) -> Case { + let c = |op, expect| Case { op, expect }; + let r = 2.0; + match name { + // abc - (1 - π/4) r² L. + "fillet_one_edge" => c(Op::Blend(BLOCK, Blend::Round, vec![TOP_FRONT], r), Expect::Volume(ABC - spandrel(r) * 30.0)), + // Every edge rounded at r, the corners spheres: (a-2r)(b-2r)(c-2r) + 2r Σ(faces less + // 2r) + πr² Σ(edges less 2r) + 4/3 πr³. + "fillet_all_edges" => { + let (a, b, h) = (30.0 - 2.0 * r, 20.0 - 2.0 * r, 10.0 - 2.0 * r); + let v = a * b * h + 2.0 * r * (a * b + b * h + h * a) + PI * r * r * (a + b + h) + 4.0 / 3.0 * PI * r * r * r; + let mut edges = Vec::new(); + for (y, z) in [(0.0, 0.0), (20.0, 0.0), (0.0, 10.0), (20.0, 10.0)] { + edges.push([15.0, y, z]); + } + for (x, z) in [(0.0, 0.0), (30.0, 0.0), (0.0, 10.0), (30.0, 10.0)] { + edges.push([x, 10.0, z]); + } + for (x, y) in [(0.0, 0.0), (30.0, 0.0), (0.0, 20.0), (30.0, 20.0)] { + edges.push([x, y, 5.0]); + } + c(Op::Blend(BLOCK, Blend::Round, edges, r), Expect::Volume(v)) + } + // abc - d² L / 2. + "chamfer_one_edge" => c(Op::Blend(BLOCK, Blend::Chamfer, vec![TOP_FRONT], r), Expect::Volume(ABC - r * r * 30.0 / 2.0)), + // abc - d1 d2 L / 2: 2 back along the top (the face leaning most along +z), 3 down the + // front. + "chamfer_two_distances" => { + c(Op::Sides(BLOCK, vec![TOP_FRONT], 2.0, ChamferSecond::Distance(3.0), [0.0, 0.0, 1.0]), Expect::Volume(ABC - 2.0 * 3.0 * 30.0 / 2.0)) + } + // 2 back along the top, at 30° to it: d tan 30° down the front. + "chamfer_distance_angle" => c( + Op::Sides(BLOCK, vec![TOP_FRONT], 2.0, ChamferSecond::Angle(PI / 6.0), [0.0, 0.0, 1.0]), + Expect::Volume(ABC - 2.0 * 2.0 * (PI / 6.0).tan() * 30.0 / 2.0), + ), + // A 5 mm cylinder 10 high, its top rim rounded at 1. Pappus: the spandrel (1 - π/4) r², + // its centroid (10 - 3π)/(12 - 3π) r in from the rim, swept round the axis. + "fillet_cylinder_rim" => { + let (big, h, r) = (5.0, 10.0, 1.0); + let inset = (10.0 - 3.0 * PI) / (12.0 - 3.0 * PI) * r; + c( + Op::Blend(Shape::Cylinder([0.0; 3], big, h), Blend::Round, vec![[0.0, big, h]], r), + Expect::Volume(PI * big * big * h - 2.0 * PI * (big - inset) * spandrel(r)), + ) + } + // The three edges at the corner (30, 20, 10) rounded at r, the corner set back 4 along + // each. Without a setback the corner is a sphere's octant, and the block keeps + // abc - (1 - π/4) r² Σ(L - r) - (1 - π/6) r³; the setback changes only what lies within + // s + r of the corner, a cube of side s + r. + "setback_corner" => { + let s = 4.0; + let plain = ABC - spandrel(r) * (30.0 + 20.0 + 10.0 - 3.0 * r) - (1.0 - PI / 6.0) * r * r * r; + let near = (s + r) * (s + r) * (s + r); + c( + Op::Setback(BLOCK, vec![[15.0, 20.0, 10.0], [30.0, 10.0, 10.0], [30.0, 20.0, 5.0]], r, vec![[30.0, 20.0, 10.0]], vec![s]), + Expect::Between(plain - near, plain + near), + ) + } + // The top front edge rounded from 1 at x = 0 to 3 at x = 30, linearly, each section + // square to the edge a quarter circle: abc - (1 - π/4) ∫ r(x)² dx + // = abc - (1 - π/4) L (r0² + r0 r1 + r1²) / 3. The round is a B-spline surface fitted to + // those sections, which both kernels build 2.5e-7 short of it (and within 1e-9 of each + // other), within the solver's fitting tolerance. + "fillet_variable_linear" => { + let (r0, r1, l) = (1.0, 3.0, 30.0); + c( + Op::Variable(BLOCK, TOP_FRONT, [0.0, 0.0, 10.0], 1, vec![0.0, 0.0, 1.0, 1.0], vec![r0, r1]), + Expect::Near(ABC - (1.0 - PI / 4.0) * l * (r0 * r0 + r0 * r1 + r1 * r1) / 3.0, 1e-6), + ) + } + // A round of 12 on a 10 mm cube's top front edge is larger than either face beside it: + // the fork builds it over the cliffs, on the faces' continuations, and cuts away all of + // the cube outside the round's cylinder (axis y = 12, z = -2, radius 12). What stays is + // 10 times the square's part inside that circle, ∫ (√(144 - u²) - 2) du over + // u = y - 12 from -√140 to -2: 72 (asin(√140/12) - asin(1/6)) - 2 (√140 - 2). + "fillet_over_a_cliff" => { + let w = 140f64.sqrt(); + let area = 72.0 * ((w / 12.0).asin() - (1.0f64 / 6.0).asin()) - 2.0 * (w - 2.0); + c(Op::Blend(Shape::Box([0.0; 3], [10.0; 3]), Blend::Round, vec![[5.0, 0.0, 10.0]], 12.0), Expect::Volume(10.0 * area)) + } + // A round of 6 on the top rim of a cylinder of radius 5 is wider than the cylinder. + "fillet_too_large" => { + c(Op::Blend(Shape::Cylinder([0.0; 3], 5.0, 10.0), Blend::Round, vec![[0.0, 5.0, 10.0]], 6.0), Expect::Fails(Error::NoRoom)) + } + "pick_near_nothing" => { + c(Op::Blend(BLOCK, Blend::Round, vec![TOP_FRONT, [100.0, 100.0, 100.0]], r), Expect::Fails(Error::NoMatch { point: 1 })) + } + // √3 from all three edges at the corner (0, 0, 10). + "pick_ambiguous" => c(Op::Blend(BLOCK, Blend::Round, vec![[-1.0, -1.0, 11.0]], r), Expect::Fails(Error::Ambiguous { point: 0 })), + _ => panic!("{name}"), + } +} + +/// The tolerance a case picks with: the ambiguous point lies √3 from its edges. +fn tolerance(name: &str) -> f64 { + if name == "pick_ambiguous" { 5.0 } else { TOL } +} + +fn rel(a: f64, b: f64) -> f64 { + (a - b).abs() / b.abs() +} + +#[derive(Debug, PartialEq)] +struct Measured { + volume: f64, + counts: [usize; 3], + kinds: BTreeMap, +} + +fn kinds(rec: &solidcraft_geom::brep::Brep) -> BTreeMap { + let mut out = BTreeMap::new(); + for f in &rec.faces { + let v = serde_json::to_value(&f.surface).unwrap(); + *out.entry(v["kind"].as_str().unwrap_or("?").to_owned()).or_default() += 1; + } + out +} + +fn on_core(name: &str, c: &Case) -> crate::Result { + let tol = tolerance(name); + match &c.op { + Op::Blend(s, kind, points, size) => blend(&s.core(), *kind, points, &[*size], tol, &[], &[], Corners::Filled), + Op::Sides(s, points, d, second, first) => chamfer_sides(&s.core(), points, tol, *d, *second, *first), + Op::Setback(s, points, size, corners, setbacks) => { + blend(&s.core(), Blend::Round, points, &vec![*size; points.len()], tol, corners, setbacks, Corners::Filled) + } + Op::Variable(s, point, start, degree, knots, radii) => fillet_variable(&s.core(), *point, tol, *start, *degree, knots, radii), + } +} + +/// Runs `f` on its own thread: a hang fails the test instead of stopping the run. +fn timed(name: &str, f: impl FnOnce() -> T + Send + 'static) -> T { + let (tx, rx) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _ = tx.send(f()); + }); + match rx.recv_timeout(TIMEOUT) { + Ok(v) => v, + Err(mpsc::RecvTimeoutError::Disconnected) => match worker.join() { + Err(p) => std::panic::resume_unwind(p), + Ok(()) => panic!("{name}: no result"), + }, + Err(mpsc::RecvTimeoutError::Timeout) => panic!("{name}: solidcore hung (no result after {TIMEOUT:?})"), + } +} + +type Got = std::result::Result; + +/// Checks a kernel's result against the case's closed form; what it measured, or its error. +fn judge(name: &str, who: &str, expect: &Expect, got: Got) -> Got { + match (expect, &got) { + (Expect::Fails(e), Err(g)) => assert_eq!(g, e, "{name}: {who} failed otherwise"), + (Expect::Fails(e), Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {e:?}"), + (_, Err(g)) => panic!("{name}: {who} failed: {g}"), + (Expect::Volume(v), Ok(m)) => assert!(rel(m.volume, *v) < 1e-9, "{name}: {who} volume {} vs analytic {v}", m.volume), + (Expect::Near(v, within), Ok(m)) => assert!(rel(m.volume, *v) < *within, "{name}: {who} volume {} vs analytic {v}", m.volume), + (Expect::Between(lo, hi), Ok(m)) => assert!(*lo < m.volume && m.volume < *hi, "{name}: {who} volume {} not in ({lo}, {hi})", m.volume), + } + got +} + +fn solidcore_case(name: &'static str) -> Got { + timed(name, move || { + let c = case(name); + let got = on_core(name, &c).map(|body| { + let v = volume(&body, 1e-8).unwrap_or_else(|e| panic!("{name}: volume: {e}")); + let n = counts(&body).unwrap(); + let (rec, _) = native(&to_arrays(&body).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}")); + rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}")); + Measured { volume: v, counts: n, kinds: kinds(&rec) } + }); + judge(name, "solidcore", &c.expect, got) + }) +} + +/// The case on the C++ kernel, called directly (whatever the routing). +#[cfg(feature = "native")] +fn cpp_case(name: &str) -> Got { + use crate::ops::{pick_error, setback_error}; + use crate::{Brep, ffi}; + crate::init().unwrap(); + let make = |s: Shape| -> Brep { + match s { + Shape::Box(o, z) => ffi::make_box(&o, &z), + Shape::Cylinder(o, r, h) => ffi::make_cylinder(&o, r, h), + } + .map(Brep::made) + .unwrap() + }; + let kind = |k| match k { + Blend::Round => ffi::ops::BLEND_ROUND, + Blend::Curvature => ffi::ops::BLEND_CURVATURE, + Blend::Chord => ffi::ops::BLEND_CHORD, + Blend::Chamfer => ffi::ops::BLEND_CHAMFER, + }; + let c = case(name); + let tol = tolerance(name); + let r = match &c.op { + Op::Blend(s, k, points, size) => { + ffi::ops::blend(kind(*k), make(*s).cpp().unwrap(), points, &vec![*size; points.len()], tol).map_err(pick_error) + } + Op::Sides(s, points, d, second, first) => { + let (value, angle) = match second { + ChamferSecond::Distance(d) => (*d, false), + ChamferSecond::Angle(a) => (*a, true), + }; + ffi::ops::chamfer_sides(make(*s).cpp().unwrap(), points, tol, *d, value, angle, first).map_err(pick_error) + } + Op::Setback(s, points, size, corners, setbacks) => { + ffi::ops::blend_setback(ffi::ops::BLEND_ROUND, make(*s).cpp().unwrap(), points, &vec![*size; points.len()], corners, setbacks, tol) + .map_err(setback_error) + } + Op::Variable(s, point, start, degree, knots, radii) => { + ffi::ops::fillet_variable(make(*s).cpp().unwrap(), point, tol, start, i32::try_from(*degree).unwrap(), knots, radii).map_err( + |s| match s { + ffi::ops::ERR_PICK_NONE => Error::NoMatch { point: 0 }, + ffi::ops::ERR_PICK_AMBIGUOUS => Error::Ambiguous { point: 0 }, + s => crate::error(s), + }, + ) + } + }; + let got = r.map(|h| { + let v = ffi::volume(&h, 1e-8).unwrap(); + let n = ffi::counts(&h).unwrap().map(|x| usize::try_from(x).unwrap()); + let b = Brep::made(h); + let (rec, _) = native(&b.cpp_arrays().unwrap()).unwrap(); + rec.validate().unwrap(); + Measured { volume: v, counts: n, kinds: kinds(&rec) } + }); + judge(name, "C++", &c.expect, got) +} + +/// solidcore and C++ agree: volume within 1e-9, the same counts and faces by kind, or the same +/// error. +#[cfg(feature = "native")] +fn parity(name: &'static str) { + let cpp = cpp_case(name); + let ours = solidcore_case(name); + match (ours, cpp) { + (Ok(a), Ok(b)) => { + assert!(rel(a.volume, b.volume) < 1e-9, "{name}: solidcore {} vs C++ {}", a.volume, b.volume); + assert_eq!(a.counts, b.counts, "{name}: face, edge, vertex counts (solidcore vs C++)"); + assert_eq!(a.kinds, b.kinds, "{name}: faces by surface kind (solidcore vs C++)"); + } + (a, b) => assert_eq!(a.err(), b.err(), "{name}: errors (solidcore vs C++)"), + } +} + +macro_rules! cases { + ($($m:ident $(: $ign:meta)?),* $(,)?) => {$( + mod $m { + #[test] + $(#[$ign])? + fn solidcore_matches_the_closed_form() { + let _ = super::solidcore_case(stringify!($m)); + } + #[cfg(feature = "native")] + #[test] + $(#[$ign])? + fn solidcore_matches_the_cpp_kernel() { + super::parity(stringify!($m)); + } + #[cfg(feature = "native")] + #[test] + fn the_cpp_kernel_matches_the_closed_form() { + let _ = super::cpp_case(stringify!($m)); + } + } + )*}; +} + +cases!( + fillet_one_edge, + fillet_all_edges, + chamfer_one_edge, + chamfer_two_distances: ignore = "solidcore: no per-edge second offset in SetFilletParameters (fork f653ac9)", + chamfer_distance_angle: ignore = "solidcore: no per-edge second offset in SetFilletParameters (fork f653ac9)", + fillet_cylinder_rim, + setback_corner, + fillet_variable_linear, + fillet_over_a_cliff: ignore = "solidcore: no cliff overflow (fork 8ba4667)", + fillet_too_large, + pick_near_nothing, + pick_ambiguous, +); + +/// What solidcore does not have yet is refused as not supported, after the capi's own checks. +#[test] +fn fork_only_blends_are_not_supported_yet() { + let r = timed("unsupported", || { + let b = BLOCK.core(); + let sides = chamfer_sides(&b, &[TOP_FRONT], TOL, 2.0, ChamferSecond::Distance(3.0), [0.0, 0.0, 1.0]).err(); + let curvature = blend(&b, Blend::Curvature, &[TOP_FRONT], &[2.0], TOL, &[], &[], Corners::Filled).err(); + let corner = [[15.0, 20.0, 10.0], [30.0, 10.0, 10.0], [30.0, 20.0, 5.0]]; + let open = blend(&b, Blend::Round, &corner, &[2.0; 3], TOL, &[[30.0, 20.0, 10.0]], &[4.0], Corners::Open).err(); + // 1 to 2 and back to 1: a corner at the middle. + let bent = fillet_variable(&b, TOP_FRONT, TOL, [0.0, 0.0, 10.0], 1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 2.0, 1.0]).err(); + // A round over a cliff (fork 8ba4667): solidcore refuses every rail leaving its face. + let cliff = blend(&Shape::Box([0.0; 3], [10.0; 3]).core(), Blend::Round, &[[5.0, 0.0, 10.0]], &[12.0], TOL, &[], &[], Corners::Filled).err(); + assert_eq!(cliff, Some(Error::Unsupported)); + // A pick that fails still says so first. + let far = chamfer_sides(&b, &[[100.0; 3]], TOL, 2.0, ChamferSecond::Distance(3.0), [0.0, 0.0, 1.0]).err(); + (sides, curvature, open, bent, far) + }); + assert_eq!(r.0, Some(Error::Unsupported)); + assert_eq!(r.1, Some(Error::Unsupported)); + assert_eq!(r.2, Some(Error::Unsupported)); + assert_eq!(r.3, Some(Error::Unsupported)); + assert_eq!(r.4, Some(Error::NoMatch { point: 0 })); +} + +/// The capi's argument checks, before any kernel call. +#[test] +fn hostile_arguments_are_refused() { + let b = BLOCK.core(); + let none = Corners::Filled; + assert_eq!(blend(&b, Blend::Round, &[], &[1.0], TOL, &[], &[], none).err(), Some(Error::Argument)); + assert_eq!(blend(&b, Blend::Round, &[[f64::NAN; 3]], &[1.0], TOL, &[], &[], none).err(), Some(Error::Argument)); + assert_eq!(blend(&b, Blend::Round, &[TOP_FRONT], &[-1.0], TOL, &[], &[], none).err(), Some(Error::Argument)); + assert_eq!(blend(&b, Blend::Round, &[TOP_FRONT], &[1.0], 0.0, &[], &[], none).err(), Some(Error::Argument)); + assert_eq!(blend(&b, Blend::Round, &[TOP_FRONT], &[f64::INFINITY], TOL, &[], &[], none).err(), Some(Error::Argument)); + // A chamfer's corners are bevelled, which builds no setback. + assert_eq!(blend(&b, Blend::Chamfer, &[TOP_FRONT], &[1.0], TOL, &[[0.0, 0.0, 10.0]], &[1.0], none).err(), Some(Error::Unsupported)); + assert_eq!(fillet_variable(&b, TOP_FRONT, TOL, [0.0; 3], 1, &[0.0, 1.0], &[1.0, 2.0]).err(), Some(Error::Argument)); + // A radius that pinches to nothing inside the edge. + assert_eq!(fillet_variable(&b, TOP_FRONT, TOL, [0.0; 3], 1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 0.0, 1.0]).err(), Some(Error::Unsupported)); + assert_eq!(chamfer_sides(&b, &[TOP_FRONT], TOL, 1.0, ChamferSecond::Angle(4.0), [0.0, 0.0, 1.0]).err(), Some(Error::Argument)); + assert_eq!(chamfer_sides(&b, &[TOP_FRONT], TOL, 1.0, ChamferSecond::Distance(1.0), [0.0; 3]).err(), Some(Error::Argument)); +} + +/// A setback longer than an edge at its corner leaves no room, before any blend is made. +#[test] +fn a_setback_past_an_edge_has_no_room() { + let r = timed("setback_long", || { + let b = BLOCK.core(); + let corner = [[15.0, 20.0, 10.0], [30.0, 10.0, 10.0], [30.0, 20.0, 5.0]]; + blend(&b, Blend::Round, &corner, &[2.0; 3], TOL, &[[30.0, 20.0, 10.0]], &[10.0], Corners::Filled).err() + }); + assert_eq!(r, Some(Error::NoRoom)); +} + +/// The body blended is never changed. +#[test] +fn the_body_stays_as_it_was() { + let r = timed("operand", || { + let b = BLOCK.core(); + let _ = blend(&b, Blend::Round, &[TOP_FRONT], &[2.0], TOL, &[], &[], Corners::Filled); + (counts(&b).unwrap(), volume(&b, 1e-8).unwrap()) + }); + assert_eq!(r.0, [6, 12, 8]); + assert!(rel(r.1, ABC) < 1e-12, "{}", r.1); +} diff --git a/crates/smlib/src/core/boolean.rs b/crates/smlib/src/core/boolean.rs index b7a11e530..021b9d48a 100644 --- a/crates/smlib/src/core/boolean.rs +++ b/crates/smlib/src/core/boolean.rs @@ -47,7 +47,7 @@ fn named(entity: EntityRef, domain: u64) -> ObjectRef { /// `copy_of` (smlib_ops.cpp, smlib_imprint.cpp): `SmApiBrepCopy`, a copy that owns its geometry. /// A plain `Clone` is not one: its geometry keeps the source's owners. Copy `n` (from 1) names /// its objects in key domain `n`. -fn copy_of(k: &mut Kernel, b: &Brep, n: u64) -> SolidResult { +pub(super) fn copy_of(k: &mut Kernel, b: &Brep, n: u64) -> SolidResult { let target = move |e| named(e, n.saturating_mul(100_000_000)); let mut state = p2::ArenaNotifyState::new(&Brep::new()); let mut env = state.env(None); diff --git a/crates/smlib/src/ops.rs b/crates/smlib/src/ops.rs index feaedfc08..829895999 100644 --- a/crates/smlib/src/ops.rs +++ b/crates/smlib/src/ops.rs @@ -47,7 +47,7 @@ pub const MAX_UNION_BREPS: usize = 100_000; /// Most points one selection may hold (the C API's limit). pub const MAX_POINTS: usize = 4096; -fn pick_error((s, at): ffi::ops::PickError) -> Error { +pub(crate) fn pick_error((s, at): ffi::ops::PickError) -> Error { match (s, at) { (ffi::ops::ERR_PICK_NONE, Some(point)) => Error::NoMatch { point }, (ffi::ops::ERR_PICK_AMBIGUOUS, Some(point)) => Error::Ambiguous { point }, @@ -55,7 +55,7 @@ fn pick_error((s, at): ffi::ops::PickError) -> Error { } } -fn setback_error((s, at, corner): ffi::ops::SetbackError) -> Error { +pub(crate) fn setback_error((s, at, corner): ffi::ops::SetbackError) -> Error { match corner { Some(corner) => Error::CornerRefused { corner }, None => pick_error((s, at)), @@ -184,6 +184,9 @@ impl Brep { /// The edges nearest to `edges` (each within `tolerance`), exactly those, rounded /// at `radius`. pub fn fillet(&self, edges: &[[f64; 3]], tolerance: f64, radius: f64) -> Result { + if route::Op::Blend.backend() == route::Backend::Solidcore { + return self.core_blend(Blend::Round, edges, &[radius], tolerance, &[], &[], core::blend::Corners::Filled); + } self.pick_op(ffi::ops::Pick::Fillet, edges, tolerance, radius, false) } @@ -191,16 +194,22 @@ impl Brep { /// an equal-distance chamfer `distance` back along each face (measured at each edge's /// midpoint), with bevelled corners. pub fn chamfer(&self, edges: &[[f64; 3]], tolerance: f64, distance: f64) -> Result { + if route::Op::Blend.backend() == route::Backend::Solidcore { + return self.core_blend(Blend::Chamfer, edges, &[distance], tolerance, &[], &[], core::blend::Corners::Filled); + } self.pick_op(ffi::ops::Pick::Chamfer, edges, tolerance, distance, false) } /// The edges nearest to `edges` (each within `tolerance`), exactly those, blended /// as `kind`, edge i at `sizes[i]`. pub fn blend(&self, kind: Blend, edges: &[[f64; 3]], sizes: &[f64], tolerance: f64) -> Result { - init()?; if edges.len() > MAX_POINTS || edges.is_empty() || sizes.len() != edges.len() { return Err(Error::Argument); } + if route::Op::Blend.backend() == route::Backend::Solidcore { + return self.core_blend(kind, edges, sizes, tolerance, &[], &[], core::blend::Corners::Filled); + } + init()?; let kind = match kind { Blend::Round => ffi::ops::BLEND_ROUND, Blend::Curvature => ffi::ops::BLEND_CURVATURE, @@ -224,7 +233,6 @@ impl Brep { setbacks: &[f64], tolerance: f64, ) -> Result { - init()?; if edges.len() > MAX_POINTS || edges.is_empty() || sizes.len() != edges.len() @@ -234,6 +242,10 @@ impl Brep { { return Err(Error::Argument); } + if route::Op::Blend.backend() == route::Backend::Solidcore { + return self.core_blend(kind, edges, sizes, tolerance, corners, setbacks, core::blend::Corners::Filled); + } + init()?; let kind = match kind { Blend::Round => ffi::ops::BLEND_ROUND, Blend::Curvature => ffi::ops::BLEND_CURVATURE, @@ -257,7 +269,6 @@ impl Brep { setbacks: &[f64], tolerance: f64, ) -> Result<(Brep, Vec)> { - init()?; if edges.len() > MAX_POINTS || edges.is_empty() || sizes.len() != edges.len() @@ -267,6 +278,10 @@ impl Brep { { return Err(Error::Argument); } + if route::Op::Blend.backend() == route::Backend::Solidcore { + return self.core_blend(kind, edges, sizes, tolerance, corners, setbacks, core::blend::Corners::Open).map(|b| (b, Vec::new())); + } + init()?; let kind = match kind { Blend::Round => ffi::ops::BLEND_ROUND, Blend::Curvature => ffi::ops::BLEND_CURVATURE, @@ -284,6 +299,9 @@ impl Brep { /// `radii` over the position along the edge, 0 at its end nearest `start` and 1 at the other /// (the edge curve's parameter scaled to 0..1). pub fn fillet_variable(&self, edge: [f64; 3], tolerance: f64, start: [f64; 3], degree: usize, knots: &[f64], radii: &[f64]) -> Result { + if route::Op::Blend.backend() == route::Backend::Solidcore { + return core::blend::fillet_variable(self.core()?, edge, tolerance, start, degree, knots, radii).map(Brep::made_core); + } init()?; let degree = i32::try_from(degree).map_err(|_| Error::Argument)?; ffi::ops::fillet_variable(self.cpp()?, &edge, tolerance, &start, degree, knots, radii).map(Brep::made).map_err(|s| match s { @@ -298,10 +316,13 @@ impl Brep { /// and by `second` on the other, with bevelled corners (setbacks measured at each edge's /// midpoint). pub fn chamfer_sides(&self, edges: &[[f64; 3]], tolerance: f64, distance: f64, second: ChamferSecond, first: [f64; 3]) -> Result { - init()?; if edges.is_empty() || edges.len() > MAX_POINTS { return Err(Error::Argument); } + if route::Op::Blend.backend() == route::Backend::Solidcore { + return core::blend::chamfer_sides(self.core()?, edges, tolerance, distance, second, first).map(Brep::made_core); + } + init()?; let (value, angle) = match second { ChamferSecond::Distance(d) => (d, false), ChamferSecond::Angle(a) => (a, true), @@ -368,6 +389,24 @@ impl Brep { ffi::ops::draft(self.cpp()?, faces, tolerance, &neutral_origin, &neutral_normal, &pull, angle).map(Brep::made).map_err(pick_error) } + /// [`Brep::blend`] and its kin on solidcore (`core::blend::blend`). + #[allow(clippy::too_many_arguments)] + fn core_blend( + &self, + kind: Blend, + edges: &[[f64; 3]], + sizes: &[f64], + tolerance: f64, + corners: &[[f64; 3]], + setbacks: &[f64], + open: core::blend::Corners, + ) -> Result { + if edges.len() > MAX_POINTS || edges.is_empty() { + return Err(Error::Argument); + } + core::blend::blend(self.core()?, kind, edges, sizes, tolerance, corners, setbacks, open).map(Brep::made_core) + } + fn pick_op(&self, kind: ffi::ops::Pick, points: &[[f64; 3]], tolerance: f64, size: f64, allow_none: bool) -> Result { init()?; if points.len() > MAX_POINTS || (points.is_empty() && !allow_none) {