SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 251/509: kernel: fillet_setback, constant-radius rounds with corners set back (and 3 more)
jyviko6fcd6713f5c4
diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex d45806f4ad..f31400cc82 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -683,6 +683,10 @@ pub enum FeatureKind {/// (default) or a G2 patch repeating each blend up to the second order.#[serde(default, skip_serializing_if = "FilletCorner::is_rolling")]corner: FilletCorner,+ /// Corners set back: each corner's patch starts its distance along every edge there+ /// from the vertex instead of where the rounds meet (a constant-radius fillet only).+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ setbacks: Vec<CornerSetback>,/// Round each picked edge's tangent chain with it (the default: edges continuing it/// smoothly at its ends, as far as they go), or only the picked edges.#[serde(default = "yes", skip_serializing_if = "is_yes")]@@ -1841,6 +1845,16 @@ pub enum FeatureKind {},}+/// A fillet corner set back: the vertex at `vertex`, where every edge is rounded, has its corner+/// patch start `distance` along each of its edges from the vertex, the rounds running whole up to+/// their sections there. One distance for all of a corner's edges.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]+pub struct CornerSetback {+ pub vertex: Position,+ #[walk(length = "Setback")]+ pub distance: Expr,+}+/// What fills the corner where three blended edges meet.#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "snake_case")]diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex b91b638300..0c648c85fe 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -3498,6 +3498,13 @@ fn blend_body(// The blended body, and the lineage of what the last blend started from.let (nb, from) = match &f.kind {FeatureKind::Fillet { corner: crate::FilletCorner::G2, .. } => (kernel::fillet_g2_corners(&mb.body, edges, r)?, input),+ FeatureKind::Fillet { setbacks, .. } if !setbacks.is_empty() => {+ let mut corners = Vec::with_capacity(setbacks.len());+ for c in setbacks {+ corners.push((c.vertex.0, val(vals, &c.distance, Kind::Length)?));+ }+ (kernel::fillet_setback(&mb.body, edges, r, &corners)?, input)+ }FeatureKind::Fillet { style: crate::FilletStyle::Curvature, .. } => (kernel::fillet_g2(&mb.body, edges, r)?, input),FeatureKind::Fillet { style: crate::FilletStyle::Chord, .. } => (kernel::fillet_chord(&mb.body, edges, r)?, input),FeatureKind::Fillet { style: crate::FilletStyle::Variable { radius2, start, mid, smooth }, .. } => {@@ -6732,6 +6739,15 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:}// Each edge is found on its own body (picked over several bodies, the edges of each// are blended on it), all against the bodies as they were before this feature.+ // Corner setbacks likewise: SMLib sets back the corners of constant-radius rounds.+ if let FeatureKind::Fillet { setbacks, corner, style, fit, .. } = &f.kind+ && !setbacks.is_empty()+ && (!corner.is_rolling() || !matches!(style, crate::FilletStyle::Constant) || !matches!(fit, crate::FilletFit::Exact))+ {+ return Err(DocError::Invalid(+ "corner setbacks are built for a constant-radius fillet (type: constant, fit: exact, corner: rolling) only".into(),+ ));+ }let on = blend_bodies(st, f, body, &crate::plain(edges))?;let mut groups: Vec<(usize, Vec<usize>)> = Vec::new();for (i, ti) in on.iter().enumerate() {@@ -7770,6 +7786,7 @@ mod chain_tests {style: crate::FilletStyle::Constant,fit: Default::default(),corner: Default::default(),+ setbacks: Vec::new(),tangent_chain: true,},None,diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rsindex 9d96ba557a..339e78ac7d 100644--- a/crates/doc/src/tests.rs+++ b/crates/doc/src/tests.rs@@ -262,6 +262,7 @@ fn box_fillet_cut_timeline() {style: Default::default(),fit: Default::default(),corner: Default::default(),+ setbacks: Vec::new(),tangent_chain: true,},None,@@ -335,6 +336,7 @@ fn errors_are_reported_not_fatal() {style: Default::default(),fit: Default::default(),corner: Default::default(),+ setbacks: Vec::new(),tangent_chain: true,},None,@@ -747,3 +749,26 @@ fn a_join_splits_off_only_what_touches_along_an_edge() {assert!(rel(other.1, arm) < 1e-6 && other.2 == 1, "the arm: {bodies:?}");assert_eq!(kept, Some(KeptSeparate::AlongEdge));}++/// A fillet saved before corner setbacks reads with none and writes no `setbacks`; one with a+/// setback keeps it through a save, its distance an expression.+#[test]+fn fillet_setbacks_default_to_none_and_round_trip() {+ let old = serde_json::json!({"type": "fillet", "edges": [[30.0, 40.0, 20.0]], "radius": "5"});+ let kind: FeatureKind = serde_json::from_value(old).unwrap();+ let FeatureKind::Fillet { setbacks, .. } = &kind else { panic!("{kind:?}") };+ assert!(setbacks.is_empty());+ assert!(serde_json::to_value(&kind).unwrap().get("setbacks").is_none());+ let set = FeatureKind::Fillet {+ edges: vec![Position(Vec3::new(30.0, 40.0, 20.0))],+ radius: "5".into(),+ body: None,+ style: Default::default(),+ fit: Default::default(),+ corner: Default::default(),+ setbacks: vec![CornerSetback { vertex: Position(Vec3::new(60.0, 40.0, 20.0)), distance: "8 mm".into() }],+ tangent_chain: true,+ };+ let back: FeatureKind = serde_json::from_value(serde_json::to_value(&set).unwrap()).unwrap();+ assert_eq!(back, set);+}diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rsindex 280b63d8f2..74fbd99a70 100644--- a/crates/engine/src/cmd/features.rs+++ b/crates/engine/src/cmd/features.rs@@ -49,7 +49,7 @@ pub static COMMANDS: &[CommandSpec] = &[.at("SOLID", "MODIFY").icon("fillet").key("F")- .params("edges: [[x,y,z] point on edge | {body, index}] ; radius: expr; tangent_chain?: bool (default true: each picked edge's tangent chain is rounded with it; false: exactly the picked edges); body?; type?: constant|curvature (alias g2: curvature-continuous quintic between planar faces along straight edges, one planar end face at each end (including sloped ends); radius sets the equivalent circular setback, not constant curvature; exact fit only)|chord (radius is the width across)|variable (radius at the end nearest start, radius2 at the other; one end may be 0, where the round closes to the corner)|spline (the radius along the edge is a clamped B-spline from the end nearest start: radius is its first control radius, radii the rest, knots its knot vector from 0 to 1; one end may be 0); radius2?; start?: [x,y,z]; radii?: [expr, …]; knots?: [number, …]; mid?: [[position 0…1 from start, radius expr], …] (variable radii between the ends); smooth?: bool (smooth instead of straight between the radii); corner?: rolling|g2 (rolling, the default: the corners where three blended edges meet are pieces of the rolling ball's sphere, tangent to each blend; g2: a patch repeating each blend's surface up to the second order, constant-radius exact fillets only, refused where it cannot be built); fit?: exact|reduce|taper (exact, the default: a radius too large for the geometry around the edges is refused; reduce: where it doesn't fit it is reduced to the largest that does, one radius for edges sharing a face; the smallest used is returned as `radius_applied`, each edge's as `radii_applied: [{edge: [x,y,z], radius}]`, and noted in the feature's warning; taper: along each straight edge between planar faces where it doesn't fit, the radius follows the room there as a smooth spline, down to 0 where a face closes to a point, noted in the feature's warning)"),+ .params("edges: [[x,y,z] point on edge | {body, index}] ; radius: expr; tangent_chain?: bool (default true: each picked edge's tangent chain is rounded with it; false: exactly the picked edges); body?; type?: constant|curvature (alias g2: curvature-continuous quintic between planar faces along straight edges, one planar end face at each end (including sloped ends); radius sets the equivalent circular setback, not constant curvature; exact fit only)|chord (radius is the width across)|variable (radius at the end nearest start, radius2 at the other; one end may be 0, where the round closes to the corner)|spline (the radius along the edge is a clamped B-spline from the end nearest start: radius is its first control radius, radii the rest, knots its knot vector from 0 to 1; one end may be 0); radius2?; start?: [x,y,z]; radii?: [expr, …]; knots?: [number, …]; mid?: [[position 0…1 from start, radius expr], …] (variable radii between the ends); smooth?: bool (smooth instead of straight between the radii); corner?: rolling|g2 (rolling, the default: the corners where three blended edges meet are pieces of the rolling ball's sphere, tangent to each blend; g2: a patch repeating each blend's surface up to the second order, constant-radius exact fillets only, refused where it cannot be built); setbacks?: [{vertex: [x,y,z], distance: expr}, …] (corner setbacks: the corner at the vertex nearest `vertex`, where every edge meeting it is rounded, starts its patch `distance` along each of those edges from the vertex, past where the rounds would meet (past the radius at a square corner), so the rounds blend through a larger patch; one distance for all of a corner's edges; constant-radius exact fillets with rolling corners only); fit?: exact|reduce|taper (exact, the default: a radius too large for the geometry around the edges is refused; reduce: where it doesn't fit it is reduced to the largest that does, one radius for edges sharing a face; the smallest used is returned as `radius_applied`, each edge's as `radii_applied: [{edge: [x,y,z], radius}]`, and noted in the feature's warning; taper: along each straight edge between planar faces where it doesn't fit, the radius follows the room there as a smooth spline, down to 0 where a face closes to a point, noted in the feature's warning)"),CommandSpec::new("solid.chamfer", "Chamfer", chamfer).at("SOLID", "MODIFY").icon("chamfer").params("edges: [[x,y,z] | {body, index}] ; distance: expr; tangent_chain?: bool (default true: each picked edge's tangent chain is cut with it; false: exactly the picked edges); distance2?: expr (along the second face) | angle?: expr (from the first face); flip?: bool (which face is first: by default the one facing up most); body?"),CommandSpec::new("solid.combine", "Combine", combine).at("SOLID", "MODIFY").icon("combine").params("target: body; tools: [body]; operation?: join|cut|intersect; touching?: separate|one_body (what a join makes of pieces that share no face: separate, the default, makes each piece that touches another only along an edge or at a point a body of its own and keeps pieces that touch nothing in one body; one_body keeps every piece in one body); keep_tools?: bool; new_component?: bool (the result goes into a new component; component_name?)"),CommandSpec::new("solid.pattern.rectangular", "Rectangular Pattern", pattern_rect)@@ -1654,6 +1654,20 @@ fn fillet(s: &mut Session, p: &Value) -> Result<Value> {if !corner.is_rolling() && (!style.is_constant() || !fit.is_exact()) {return Err(bad(cmd, "`corner: g2` is built for a constant-radius fillet (`type: constant`, `fit: exact`) only"));}+ // Corner setbacks: each a vertex and the distance its patch starts along the edges there.+ let mut setbacks = Vec::new();+ if let Some(list) = p.get("setbacks") {+ let list = list.as_array().ok_or_else(|| bad(cmd, "`setbacks` is a list of {vertex: [x,y,z], distance: expr}"))?;+ for item in list {+ let vertex = item.get("vertex").and_then(vec3).ok_or_else(|| bad(cmd, "each setback needs `vertex`: [x,y,z] at the corner"))?;+ let distance = expr(item, "distance").ok_or_else(|| bad(cmd, "each setback needs `distance`: a length"))?;+ check_expr(s, &distance, Kind::Length, cmd, "setback distance")?;+ setbacks.push(solidcraft_doc::CornerSetback { vertex: Position(vertex), distance });+ }+ if !setbacks.is_empty() && (!style.is_constant() || !fit.is_exact() || !corner.is_rolling()) {+ return Err(bad(cmd, "`setbacks` are built for a constant-radius fillet (`type: constant`, `fit: exact`, `corner: rolling`) only"));+ }+ }let mut out = add_feature(s,p,@@ -1664,6 +1678,7 @@ fn fillet(s: &mut Session, p: &Value) -> Result<Value> {style,fit,corner,+ setbacks,tangent_chain: bool_(p, "tangent_chain").unwrap_or(true),},)?;diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rsindex ab9aadc8f7..f4fafebaed 100644--- a/crates/io/src/lib.rs+++ b/crates/io/src/lib.rs@@ -1048,6 +1048,7 @@ mod tests {style: Default::default(),fit: Default::default(),corner: Default::default(),+ setbacks: Vec::new(),tangent_chain: true,},None,@@ -1134,6 +1135,7 @@ mod tests {style: Default::default(),fit: Default::default(),corner: Default::default(),+ setbacks: Vec::new(),tangent_chain: true,},None,diff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rsindex 67ff61f998..862695176a 100644--- a/crates/kernel/src/blend.rs+++ b/crates/kernel/src/blend.rs@@ -212,6 +212,19 @@ pub fn fillet(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {crate::blend_smlib::fillet(body, edges, radius).and_then(|b| closed(body, b))}+/// [`fillet`] with corner setbacks: each `(at, distance)` sets back the corner at the vertex+/// nearest `at`, a vertex where every edge is rounded, so its patch starts `distance` along+/// each of its edges from the vertex (one distance for all of a corner's edges: SMLib keeps one+/// per corner). The rounds run whole up to their sections there, and the patch between them+/// meets each face in a curve from one round's contact line to the next. The distance must reach+/// past where the rounds would meet without it (past the radius at a square corner); a corner+/// where some edge is not rounded is refused as not supported, a setback as long as an edge at+/// its corner as too large.+pub fn fillet_setback(body: &Body, edges: &[Vec3], radius: f64, setbacks: &[(Vec3, f64)]) -> Result<Body> {+ body.require_brep("fillet")?;+ crate::blend_smlib::fillet_setback(body, edges, radius, setbacks).and_then(|b| closed(body, b))+}+/// [`fillet`] whose corners where three blended edges meet are G2 patches. SMLib's fillet/// corners are a sphere or a Coons patch that meets the rounds tangentially, so this is refused/// rather than quietly given those corners; [`fillet`] (the default) is unchanged.diff --git a/crates/kernel/src/blend_smlib.rs b/crates/kernel/src/blend_smlib.rsindex aac1c49784..64096cfb79 100644--- a/crates/kernel/src/blend_smlib.rs+++ b/crates/kernel/src/blend_smlib.rs@@ -37,6 +37,12 @@ pub(crate) fn fillet_each(body: &Body, edges: &[Vec3], radii: &[f64]) -> Result<imp::blend(body, "fillet", Kind::Round, edges, radii)}+/// A constant-radius round whose corners at `setbacks` (a point at each corner's vertex, and the+/// distance its patch starts along each edge there) are set back ([`crate::fillet_setback`]).+pub(crate) fn fillet_setback(body: &Body, edges: &[Vec3], radius: f64, setbacks: &[(Vec3, f64)]) -> Result<Body> {+ imp::blend_setback(body, edges, &vec![radius; edges.len()], setbacks)+}+/// Curvature-continuous rounds with the setback of a round of `radius` ([`crate::fillet_g2`]).pub(crate) fn fillet_g2(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {imp::blend(body, "G2 fillet", Kind::Curvature, edges, &vec![radius; edges.len()])@@ -179,6 +185,42 @@ mod imp {run(body, what, &picked.edges, |b| b.blend(kind, &picked.points, sizes, tol))}+ /// Rounds with corner setbacks: each corner point picks the body's nearest vertex (within+ /// the pick tolerance), handed to SMLib at that vertex's own position.+ pub(super) fn blend_setback(body: &Body, edges: &[Vec3], sizes: &[f64], setbacks: &[(Vec3, f64)]) -> Result<Body> {+ let what = "fillet with corner setbacks";+ body.require_brep(what)?;+ sizes_ok(what, sizes)?;+ if setbacks.is_empty() || setbacks.len() > solidcraft_smlib::MAX_POINTS {+ return Err(KernelError::Invalid(format!("{what}: give 1…{} corners", solidcraft_smlib::MAX_POINTS)));+ }+ if setbacks.iter().any(|(p, d)| !p.is_finite() || !(d.is_finite() && *d > 1e-6 && *d < 1e6)) {+ return Err(KernelError::Invalid(format!("{what}: each corner is a finite point with a positive, finite setback")));+ }+ let picked = resolve(body, edges)?;+ let corners = corner_vertices(body, setbacks.iter().map(|(p, _)| *p))?;+ let distances: Vec<f64> = setbacks.iter().map(|(_, d)| *d).collect();+ let tol = pick_tolerance(body);+ run(body, what, &picked.edges, |b| b.blend_setback(Blend::Round, &picked.points, sizes, &corners, &distances, tol))+ }++ /// The body's vertex nearest each point, within the pick tolerance: the ends of its edges.+ fn corner_vertices(body: &Body, picks: impl Iterator<Item = Vec3>) -> Result<Vec<[f64; 3]>> {+ let mesh = body.mesh(&crate::MeshTolerance::chord((body.size() * 2e-3).max(1e-3)))?;+ let ends: Vec<Vec3> = mesh.edges.iter().flat_map(|l| l.first().into_iter().chain(l.last())).copied().collect();+ let reach = pick_tolerance(body);+ picks+ .map(|p| {+ ends.iter()+ .map(|v| (v.dist(p), *v))+ .filter(|(d, _)| *d <= reach)+ .min_by(|a, b| a.0.total_cmp(&b.0))+ .map(|(_, v)| [v.x, v.y, v.z])+ .ok_or_else(|| KernelError::Invalid(format!("no corner near the setback point ({:.3}, {:.3}, {:.3})", p.x, p.y, p.z)))+ })+ .collect()+ }+pub(super) fn sides(body: &Body, edges: &[Vec3], d1: f64, side: crate::ChamferSide, flip: bool) -> Result<Body> {body.require_brep("chamfer")?;sizes_ok("chamfer", &vec![d1; edges.len()])?;diff --git a/crates/kernel/src/fillet_setback_tests.rs b/crates/kernel/src/fillet_setback_tests.rsnew file mode 100644index 0000000000..d1e0a886c4--- /dev/null+++ b/crates/kernel/src/fillet_setback_tests.rs@@ -0,0 +1,44 @@+use solidcraft_geom::Vec3;++use crate::*;++/// The 60 x 40 x 20 box with r5 rounds on the three edges at (60, 40, 20).+fn corner_case(setback: Option<f64>) -> Result<Body> {+ let b = box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(60.0, 40.0, 20.0)).unwrap();+ let edges = [Vec3::new(30.0, 40.0, 20.0), Vec3::new(60.0, 20.0, 20.0), Vec3::new(60.0, 40.0, 10.0)];+ match setback {+ Some(s) => fillet_setback(&b, &edges, 5.0, &[(Vec3::new(60.0, 40.0, 20.0), s)]),+ None => fillet(&b, &edges, 5.0),+ }+}++/// Set back 8 along each edge: outside the corner cube [52, 60] x [32, 40] x [12, 20] the body+/// is the sphere corner's, and inside it the convex body holds the hull of its points on the+/// cube's faces (299.0201) and lies within the three rounds' prisms (512 - 225 (1 - pi/4) -+/// 125 (sqrt 2 - 1)); see capi/tests/ops_kernel.cpp, corner_setback. The patch is SMLib's two+/// quadrilaterals per side: 15 faces, 36 edges, 23 vertices; the box stays the box.+#[test]+fn a_corner_set_back_8_blends_through_a_larger_patch() {+ let pi = std::f64::consts::PI;+ let sphere = measure(&corner_case(None).unwrap()).unwrap().volume;+ let out = corner_case(Some(8.0)).unwrap();+ assert!(out.validity().is_empty(), "{:?}", out.validity());+ let m = measure(&out).unwrap();+ let in_c_sphere = 512.0 - 225.0 * (1.0 - pi / 4.0) - 125.0 * (1.0 - pi / 6.0);+ let prisms = 512.0 - 225.0 * (1.0 - pi / 4.0) - 125.0 * (2f64.sqrt() - 1.0);+ let outside = sphere - in_c_sphere;+ assert!(m.volume > outside + 299.0201 && m.volume < outside + prisms, "{} not in [{}, {}]", m.volume, outside + 299.0201, outside + prisms);+ assert_eq!((m.faces, m.edges, m.vertices), (15, 36, 23));+ assert!((m.bbox.min - Vec3::new(0.0, 0.0, 0.0)).len() < 1e-6 && (m.bbox.max - Vec3::new(60.0, 40.0, 20.0)).len() < 1e-6, "{:?}", m.bbox);+}++/// A setback point at no vertex, at a corner where no edge is rounded, or as long as an edge+/// there, is refused.+#[test]+fn a_setback_off_the_rounded_corner_is_refused() {+ let b = box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(60.0, 40.0, 20.0)).unwrap();+ let edges = [Vec3::new(30.0, 40.0, 20.0), Vec3::new(60.0, 20.0, 20.0), Vec3::new(60.0, 40.0, 10.0)];+ assert!(fillet_setback(&b, &edges, 5.0, &[(Vec3::new(30.0, 20.0, 10.0), 8.0)]).is_err());+ assert!(fillet_setback(&b, &edges, 5.0, &[(Vec3::new(0.0, 0.0, 0.0), 8.0)]).is_err());+ assert!(matches!(corner_case(Some(20.0)), Err(KernelError::TooLarge(_))));+}diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex 65e1bcea8a..ba77210cda 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -39,6 +39,8 @@ mod emboss;mod face_source_tests;mod fair;mod fill;+#[cfg(test)]+mod fillet_setback_tests;mod freeform;pub mod fuzz;mod heal;@@ -150,7 +152,7 @@ mod validity;pub mod watch;mod whole_face;-pub use blend::{ChamferSide, chamfer, chamfer_sides, fillet, fillet_each, fillet_g2, fillet_g2_corners, fillet_max, fillet_max_each, tangent_chain};+pub use blend::{ChamferSide, chamfer, chamfer_sides, fillet, fillet_each, fillet_g2, fillet_g2_corners, fillet_max, fillet_max_each, fillet_setback, tangent_chain};pub use blend_corner::fillet_radii;pub use blend_variable::{RadiusSpline, Taper, fillet_chord, fillet_tapered, fillet_variable, fillet_variable_points, fillet_variable_spline, taper};pub use body::{Body, CapSignature, DISPLAY_ANGLE, DisplayShare, EdgeInfo, FaceInfo, FacePaint, FaceSource, MeshTolerance, Paint};diff --git a/crates/smlib/src/ffi/ops.rs b/crates/smlib/src/ffi/ops.rsindex 1e09aabe83..6913190975 100644--- a/crates/smlib/src/ffi/ops.rs+++ b/crates/smlib/src/ffi/ops.rs@@ -1,5 +1,5 @@//! The operations block of `capi/include/smlib.h` (`smlib_boolean`, `smlib_boolean_union_all`, `smlib_boolean2d`, `smlib_fillet`,-//! `smlib_chamfer`, `smlib_blend`, `smlib_fillet_variable`, `smlib_chamfer_sides`, `smlib_shell`, `smlib_offset_faces`,+//! `smlib_chamfer`, `smlib_blend`, `smlib_blend_setback`, `smlib_fillet_variable`, `smlib_chamfer_sides`, `smlib_shell`, `smlib_offset_faces`,//! `smlib_thicken`, `smlib_draft`, `smlib_merge_faces`, `smlib_brep_solid_count`, `smlib_imprint`; the fork's `capi/src/smlib_ops.cpp`), declared by//! hand. Part of the FFI boundary, like its parent: called only through//! [`crate::ops`].@@ -81,6 +81,20 @@ unsafe extern "C" {out: *mut *mut RawBrep,out_failed_point: *mut i64,) -> i32;+ fn smlib_blend_setback(+ brep: *const RawBrep,+ kind: i32,+ points: *const f64,+ sizes: *const f64,+ n_points: i64,+ corners: *const f64,+ setbacks: *const f64,+ n_corners: i64,+ tolerance: f64,+ out: *mut *mut RawBrep,+ out_failed_point: *mut i64,+ out_failed_corner: *mut i64,+ ) -> i32;fn smlib_fillet_variable(brep: *const RawBrep,point: *const f64,@@ -265,6 +279,54 @@ pub fn blend(kind: i32, b: &Handle, points: &[[f64; 3]], sizes: &[f64], toleranc})}+/// `smlib_blend_setback`: `sizes` holds one size per point and `setbacks` one distance per+/// corner (the caller checks the lengths match). A failed pick names its point; a corner that+/// picks no vertex or several comes back with no index.+#[cfg(feature = "native")]+pub fn blend_setback(+ kind: i32,+ b: &Handle,+ points: &[[f64; 3]],+ sizes: &[f64],+ corners: &[[f64; 3]],+ setbacks: &[f64],+ tolerance: f64,+) -> Result<Handle, PickError> {+ let n = i64::try_from(points.len()).map_err(|_| (ERR_ARG, None))?;+ let nc = i64::try_from(corners.len()).map_err(|_| (ERR_ARG, None))?;+ if sizes.len() != points.len() || setbacks.len() != corners.len() {+ return Err((ERR_ARG, None));+ }+ let flat = points.as_ptr().cast::<f64>();+ let flat_corners = corners.as_ptr().cast::<f64>();+ let (mut failed, mut failed_corner) = (-1i64, -1i64);+ new_brep(|out| unsafe {+ smlib_blend_setback(+ b.raw(),+ kind,+ flat,+ sizes.as_ptr(),+ n,+ flat_corners,+ setbacks.as_ptr(),+ nc,+ tolerance,+ out,+ &mut failed,+ &mut failed_corner,+ )+ })+ .map_err(|s| {+ let at = (s == ERR_PICK_NONE || s == ERR_PICK_AMBIGUOUS).then(|| usize::try_from(failed).ok()).flatten();+ (s, at)+ })+}++#[cfg(not(feature = "native"))]+pub fn blend_setback(_: i32, _: &Handle, _: &[[f64; 3]], _: &[f64], _: &[[f64; 3]], _: &[f64], _: f64) -> Result<Handle, PickError> {+ Err((NOT_BUILT, None))+}+/// `smlib_fillet_variable`.#[cfg(feature = "native")]pub fn fillet_variable(diff --git a/crates/smlib/src/ops.rs b/crates/smlib/src/ops.rsindex f273409ac1..dbe331c9a4 100644--- a/crates/smlib/src/ops.rs+++ b/crates/smlib/src/ops.rs@@ -150,6 +150,31 @@ impl Brep {ffi::ops::blend(kind, &self.0, edges, sizes, tolerance).map(Brep).map_err(pick_error)}+ /// [`Brep::blend`] with corner setbacks: each of `corners` picks the vertex nearest it+ /// (within `tolerance`), a corner where every edge is blended, and that corner's patch starts+ /// `setbacks[j]` along each of its edges from the vertex (one distance per corner, as SMLib+ /// keeps it). A corner SMLib builds no setback on (some edge there not blended, a chamfer) is+ /// [`Error::Unsupported`]; a setback as long as an edge there, [`Error::NoRoom`].+ pub fn blend_setback(&self, kind: Blend, edges: &[[f64; 3]], sizes: &[f64], corners: &[[f64; 3]], setbacks: &[f64], tolerance: f64) -> Result<Brep> {+ init()?;+ if edges.len() > MAX_POINTS+ || edges.is_empty()+ || sizes.len() != edges.len()+ || corners.is_empty()+ || corners.len() > MAX_POINTS+ || setbacks.len() != corners.len()+ {+ return Err(Error::Argument);+ }+ let kind = match kind {+ Blend::Round => ffi::ops::BLEND_ROUND,+ Blend::Curvature => ffi::ops::BLEND_CURVATURE,+ Blend::Chord => ffi::ops::BLEND_CHORD,+ Blend::Chamfer => ffi::ops::BLEND_CHAMFER,+ };+ ffi::ops::blend_setback(kind, &self.0, edges, sizes, corners, setbacks, tolerance).map(Brep).map_err(pick_error)+ }+/// The one edge nearest to `edge` (within `tolerance`) rounded with a radius/// that varies along it: a clamped B-spline of `degree` (1 to 3) with `knots` and control/// `radii` over the position along the edge, 0 at its end nearest `start` and 1 at the otherdiff --git a/tests/kernel-cases/ladder/07-fillets/013-corner-setback/expected.json b/tests/kernel-cases/ladder/07-fillets/013-corner-setback/expected.jsonindex 5b6f1ab579..d62cece2e1 100644--- a/tests/kernel-cases/ladder/07-fillets/013-corner-setback/expected.json+++ b/tests/kernel-cases/ladder/07-fillets/013-corner-setback/expected.json@@ -1,7 +1,26 @@{"sources": [],- "what": "three r5 rounds at a corner with setbacks of 8 mm along each edge",+ "what": "three r5 rounds at the corner (60,40,20) with setbacks of 8 mm along each edge","source": "invariants",- "method": "the setback corner patch would be graded by invariants",- "missing": "solid.fillet has no corner setback distances"+ "method": "outside the corner cube C = [52,60]x[32,40]x[12,20] the body is the sphere corner's (009: V0 = 47377.120025868, of which 512 - 225 (1-pi/4) - 125 (1-pi/6) lies in C); the body is convex, so in C it holds the hull of its points on C's faces (the rounds' sections at the setback planes x=52, y=32, z=12 and the cube's corners outside the patch: 299.0201 by a hull of the sections sampled, below the true hull) and lies within the planes tangent to it along those sections, the three rounds' prisms (512 - 225 (1-pi/4) - 125 (sqrt2-1): the corner cube of r keeps the cylinders' common octant (2-sqrt2) r^3). The volume is the middle of [47271.9757, 47384.8935] with that half width as its tolerance. The box is unchanged. SMLib's setback patch is two quadrilaterals per side meeting at its centre: 6 box faces, 3 rounds, 6 patch pieces; vertices: 4 untouched box corners, 2 at each round's far end, the 6 section ends (where the patch starts, 8 from the vertex along each edge), the 6 side middles and the centre (23); edges by Euler, 23 + 15 - 2",+ "body_count": 1,+ "volume_mm3": 47328.434587888,+ "faces": 15,+ "edges": 36,+ "vertices": 23,+ "bbox": {+ "min": [+ 0,+ 0,+ 0+ ],+ "max": [+ 60,+ 40,+ 20+ ]+ },+ "tolerance": {+ "rel": 0.001192+ }}diff --git a/tests/kernel-cases/ladder/07-fillets/013-corner-setback/recipe.json b/tests/kernel-cases/ladder/07-fillets/013-corner-setback/recipe.jsonindex fe7861aa13..221a5361eb 100644--- a/tests/kernel-cases/ladder/07-fillets/013-corner-setback/recipe.json+++ b/tests/kernel-cases/ladder/07-fillets/013-corner-setback/recipe.json@@ -1,3 +1,38 @@{- "commands": []+ "base": "../../01-primitives/001-box",+ "commands": [+ {+ "command": "solid.fillet",+ "params": {+ "edges": [+ [+ 30,+ 40,+ 20+ ],+ [+ 60,+ 20,+ 20+ ],+ [+ 60,+ 40,+ 10+ ]+ ],+ "radius": 5,+ "setbacks": [+ {+ "vertex": [+ 60,+ 40,+ 20+ ],+ "distance": 8+ }+ ]+ }+ }+ ]}