SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 455/509: kernel: one smooth angle, and a round too small to change the part is refused (and 3 more)
jyviko0b206f2ed54e
diff --git a/crates/engine/src/cmd/surface.rs b/crates/engine/src/cmd/surface.rsindex 85fbab8f00..e1c054a71a 100644--- a/crates/engine/src/cmd/surface.rs+++ b/crates/engine/src/cmd/surface.rs@@ -1294,8 +1294,9 @@ mod tests {/// Extend a cylinder strip: naturally 5 along its axis (10 · π/2 · 25, one face, still a/// cylinder), up to the plane z = 30 (10 · π/2 · 30), and by tangent and curvature run-offs/// along a straight edge, 20 long: each SMLib's G1 or G2 extension of the surface, so the- /// strip stays one face (the tangent one a flat 5 × 20, the curvature one the parabola- /// s ↦ s·R + ½κs²·n with the cylinder's κ = 1/10, its section ∫₀⁵ √(1 + κ²s²) ds long).+ /// strip stays one face. The distance is measured across the surface (the run-off's section+ /// is 5 long, whatever its curvature) and the strip is its section swept 20 along z, so each+ /// run-off adds 5 × 20: 10 · π/2 · 20 + 100./// Undo, redo and reopening; the default saves nothing new.#[test]fn extend_a_cylinder_strip_every_way() {@@ -1322,11 +1323,9 @@ mod tests {run(&mut s, "edit.undo", json!({}));let side = [0.0, 10.0, 10.0];- let k: f64 = 0.1;- let parabola = 2.5 * (1.0 + 25.0 * k * k).sqrt() + (5.0 * k).asinh() / (2.0 * k);- for (mode, run_off) in [("tangent", 5.0), ("curvature", parabola)] {+ for mode in ["tangent", "curvature"] {run(&mut s, "surface.extend", json!({"body": "Strip", "edges": [side], "distance": 5, "mode": mode}));- let want = 10.0 * pi / 2.0 * 20.0 + run_off * 20.0;+ let want = 10.0 * pi / 2.0 * 20.0 + 5.0 * 20.0;assert!((area(&s, "Strip") - want).abs() < want * 1e-3, "{mode}: {} vs {want}", area(&s, "Strip")); // (measured on meshes)let cold = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());assert!((area(&cold, "Strip") - area(&s, "Strip")).abs() < 1e-9, "{mode}");diff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rsindex ac134b452f..d947e6bc25 100644--- a/crates/kernel/src/blend.rs+++ b/crates/kernel/src/blend.rs@@ -684,9 +684,11 @@ pub fn tangent_chain(body: &Body, picks: &[Vec3]) -> Result<Vec<Vec3>> {Ok(out)}-/// Edges meeting at an angle below this continue one another; faces meeting at an angle below-/// it meet tangentially.-const TANGENT_DEGREES: f64 = 0.5;+/// Edges meeting at an angle (radians) below this continue one another; faces meeting at an+/// angle below it meet tangentially, a smooth edge with nothing to round. One value for smooth+/// everywhere: the shaded view's ([`crate::smooth_edges::ANGLE`], half a degree), so an edge+/// the view draws can be rounded and one it hides is smooth.+const TANGENT: f64 = crate::smooth_edges::ANGLE;/// The point halfway along edge `e`.fn edge_middle(rec: &Faces, e: usize) -> Option<Vec3> {@@ -699,7 +701,7 @@ fn normal_reach(rec: &Faces) -> f64 {rec.rec.tolerance.max(1e-7) * 10.0}-/// Whether edge `e`'s two uses meet tangentially (within [`TANGENT_DEGREES`]) all along it: a+/// Whether edge `e`'s two uses meet tangentially (within [`TANGENT`]) all along it: a/// smooth edge, with no corner to blend (a seam a face meets itself across is one). An edge/// whose faces are tangent at one end only (a round running into a wall it is tangent to where/// the wall meets its face) is a crease everywhere else, which is not smooth; nor is a cusp, its@@ -707,7 +709,7 @@ fn normal_reach(rec: &Faces) -> f64 {/// edge. Decided exactly from the faces' surfaces and the uses' pcurves/// ([`crate::tangent_edge`]).fn smooth_join(rec: &Faces, e: usize) -> Result<bool> {- crate::tangent_edge::tangent_all_along(&rec.rec, |f| rec.side(f), e, TANGENT_DEGREES.to_radians())+ crate::tangent_edge::tangent_all_along(&rec.rec, |f| rec.side(f), e, TANGENT)}/// `seeds` (edges in the record's order, each once), then every other edge that continues one@@ -735,7 +737,7 @@ fn chain_of(rec: &Faces, seeds: &[usize], hidden: &[bool]) -> Result<Vec<usize>>}if a == v { rec.tangent(e, false) } else { rec.tangent(e, true).map(|t| t * -1.0) }};- let cos = TANGENT_DEGREES.to_radians().cos();+ let cos = TANGENT.cos();let accept = normal_reach(rec);// Whether edge `e` is convex at its end `v` (its faces meet at less than 180° inside the// body): the direction into its second face, square to it, points against its first face's@@ -798,6 +800,33 @@ pub(crate) fn unfinished_chain(body: &Body, picks: &[Vec3], edges: &[usize], hidOk(chain_of(&rec, &seeds, hidden)?.get(seeds.len()).and_then(|&next| edge_middle(&rec, next)))}+/// Before rounding exactly `edges` (the record's edges `picks` took, in order), edge i at radius+/// `radii[i]`: refuses a round too small to change the part. Across a crease whose faces' normals+/// turn by δ, a round of radius r lies r·(sec(δ/2) − 1) (≈ r·δ²/8) inside the sharp edge at its+/// middle, the farthest it moves the part; below the edge's tolerance the round is the edge+/// itself to the model's accuracy (SMLib refuses to build it). δ is the least turn along the edge+/// ([`crate::tangent_edge::least_angle_along`]); the message names the smallest radius that+/// rounds it, tolerance / (sec(δ/2) − 1), rounded up to the micrometre.+pub(crate) fn rounds_too_small(body: &Body, picks: &[Vec3], edges: &[usize], radii: &[f64]) -> Result<()> {+ let rec = Faces::of(body)?;+ for (i, (&e, &r)) in edges.iter().zip(radii).enumerate() {+ let Some(edge) = rec.rec.edges.get(e) else { continue };+ let tolerance = edge.tolerance.max(rec.rec.tolerance);+ let Some(turn) = crate::tangent_edge::least_angle_along(&rec.rec, |f| rec.side(f), e)? else { continue };+ let reach = 1.0 / (0.5 * turn).cos() - 1.0;+ if !(turn > TANGENT && reach.is_finite() && reach > 0.0) || r * reach >= tolerance {+ continue;+ }+ let at = picks.get(i).map(|p| format!("({:.3}, {:.3}, {:.3})", p.x, p.y, p.z)).unwrap_or_default();+ let smallest = (tolerance / reach * 1e3).ceil() / 1e3;+ return Err(KernelError::Invalid(format!(+ "a round of radius {r} mm on the edge at {at} is too small: its faces turn only {:.2}° across the edge, so the round stays within the model's tolerance ({tolerance} mm) of it and changes nothing; the smallest radius that rounds this edge is {smallest:.3} mm",+ turn.to_degrees()+ )));+ }+ Ok(())+}+/// A blend's failure where a picked edge continues tangentially into `next`, an edge left out/// ([`unfinished_chain`]): SMLib rounds a tangent chain as one sequence and could not end the/// blend there, so the reason and the way out are named.@@ -1216,6 +1245,66 @@ mod tests {}}+ /// A block 40 wide and 20 deep (z 0…20) whose top rises from y = 20 at its sides to a+ /// crease along z at x = 20, each half sloping `slope` degrees, so the faces turn by twice+ /// that across the crease; and a point on the crease.+ fn roof(slope: f64) -> (Body, Vec3) {+ let h = 20.0 * slope.to_radians().tan();+ let outline = [Vec2::new(0.0, 0.0), Vec2::new(40.0, 0.0), Vec2::new(40.0, 20.0), Vec2::new(20.0, 20.0 + h), Vec2::new(0.0, 20.0)];+ let region = Region2 { outer: Loop2::polygon(&outline), holes: vec![] };+ let body = crate::build::extrude(&Plane::XY, &[region], 0.0, 20.0).unwrap().remove(0);+ (body, Vec3::new(20.0, 20.0 + h, 10.0))+ }++ /// A round lies r·(sec(δ/2) − 1) inside the crease it replaces (δ the faces' turn): below the+ /// edge's tolerance it changes nothing and is refused as too small, naming the smallest+ /// radius that rounds. The block's edges are held to 2e-5 mm (SMLib's intersection tolerance+ /// for a part this size, twice its zone tolerance of 1e-5). At 1° an R0.4 round would lie+ /// 0.4 · (sec 0.5° − 1) = 0.015 µm in, under it: the smallest is 2e-5 / (sec 0.5° − 1) =+ /// 0.52523 mm, named rounded up. At 3° the R2 round is 0.685 µm in and builds: one face more,+ /// the top that much lower, removing 20 · r²(tan(δ/2) − δ/2) = 4.786e-4 mm³.+ #[test]+ fn a_round_too_small_to_change_the_part_is_refused_naming_the_smallest_that_rounds() {+ let (gentle, crease) = roof(0.5);+ let rec = Faces::of(&gentle).unwrap().rec;+ assert!(rec.tolerance == 2e-5 && rec.edges.iter().all(|e| e.tolerance == 2e-5), "{}", rec.tolerance);+ let turn = 1f64.to_radians();+ let smallest = 2e-5 / (1.0 / (0.5 * turn).cos() - 1.0);+ assert!((smallest - 0.52523).abs() < 1e-5, "{smallest}");+ let e = fillet(&gentle, &[crease], 0.4).unwrap_err().to_string();+ assert!(+ e.contains("is too small") && e.contains("turn only 1.00°") && e.contains("the smallest radius that rounds this edge is 0.526 mm"),+ "{e}"+ );++ let (steeper, crease) = roof(1.5);+ let (r, turn) = (2.0, 3f64.to_radians());+ let rounded = fillet(&steeper, &[crease], r).unwrap();+ assert!(rounded.validity().is_empty(), "{:?}", rounded.validity());+ assert_eq!(rounded.face_count(), steeper.face_count() + 1);+ let (before, after) = (crate::measure(&steeper).unwrap(), crate::measure(&rounded).unwrap());+ let sag = r * (1.0 / (0.5 * turn).cos() - 1.0);+ assert!(((before.bbox.max.y - after.bbox.max.y) - sag).abs() < 1e-9, "{} vs {sag}", before.bbox.max.y - after.bbox.max.y);+ let removed = 20.0 * r * r * ((0.5 * turn).tan() - 0.5 * turn);+ assert!(((before.volume - after.volume) - removed).abs() < 1e-6, "{} vs {removed}", before.volume - after.volume);+ }++ /// At 1° the crease rounds from 0.526 mm: R2 lies 0.076 µm in and R20 0.76 µm, and each+ /// builds, removing 20 · r²(tan(δ/2) − δ/2).+ #[test]+ #[ignore = "fails until SMLib rounds creases from 0.5° (SmEdge::GetBlendEdgeuse calls an edge within 2° of tangent smooth: SM_ERR_INVALID_INPUT)"]+ fn a_one_degree_crease_rounds_from_the_smallest_radius_named() {+ let (gentle, crease) = roof(0.5);+ let turn = 1f64.to_radians();+ for r in [2.0, 20.0] {+ let rounded = fillet(&gentle, &[crease], r).unwrap();+ assert!(rounded.validity().is_empty(), "r={r}: {:?}", rounded.validity());+ let removed = 20.0 * r * r * ((0.5 * turn).tan() - 0.5 * turn);+ let (before, after) = (crate::measure(&gentle).unwrap().volume, crate::measure(&rounded).unwrap().volume);+ assert!(((before - after) - removed).abs() < 1e-6, "r={r}: {} vs {removed}", before - after);+ }+ }+/// A pin standing in a socket, 3.5 mm from two of its walls, in a large block. The cutters/// for its tip reach several times the chamfer's size past each edge (more on a larger part),/// into the walls, and their union took bites out of them: 7.2 mm³ instead of the tip's.diff --git a/crates/kernel/src/blend_smlib.rs b/crates/kernel/src/blend_smlib.rsindex 04e8438817..c49afdb9ab 100644--- a/crates/kernel/src/blend_smlib.rs+++ b/crates/kernel/src/blend_smlib.rs@@ -204,6 +204,9 @@ mod imp {sizes_ok(what, sizes)?;let picked = resolve(body, edges)?;let next = crate::blend::unfinished_chain(body, edges, &picked.edges, &picked.hidden)?;+ if matches!(kind, Kind::Round) {+ crate::blend::rounds_too_small(body, edges, &picked.edges, sizes)?;+ }let tol = pick_tolerance(body);let Kind::Round = kind else {let kind = blend_kind(kind);@@ -257,6 +260,7 @@ mod imp {}let picked = resolve(body, edges)?;let next = crate::blend::unfinished_chain(body, edges, &picked.edges, &picked.hidden)?;+ crate::blend::rounds_too_small(body, edges, &picked.edges, sizes)?;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);diff --git a/crates/kernel/src/smooth_edges.rs b/crates/kernel/src/smooth_edges.rsindex 4dc4d84669..b5ab06441c 100644--- a/crates/kernel/src/smooth_edges.rs+++ b/crates/kernel/src/smooth_edges.rs@@ -33,7 +33,8 @@ const STATIONS: usize = 8;/// 1–2% step the eye tells apart on a smooth gradient. So a join this close to tangent shows no/// line in the shading. Exact tangency (fillets, analytic seams) reads 1e-12 or so, far inside/// it; real creases a model means are degrees. Tangency alone does not hide an edge ([`BEND`]).-const ANGLE: f64 = 0.5 * std::f64::consts::PI / 180.0;+/// It is SolidCraft's one angle for smooth: a blend finds nothing to round below it too.+pub(crate) const ANGLE: f64 = 0.5 * std::f64::consts::PI / 180.0;/// Largest difference of the two faces' normal curvatures across an edge, relative to the/// larger one (or to 1 / the edge's length where both are flatter), that still counts as one/// smooth surface (G2): [`ANGLE`], the same visibility criterion as for the normals. Continueddiff --git a/crates/kernel/src/tangent_edge.rs b/crates/kernel/src/tangent_edge.rsindex 1d943ab396..4ca6afe67f 100644--- a/crates/kernel/src/tangent_edge.rs+++ b/crates/kernel/src/tangent_edge.rs@@ -265,12 +265,15 @@ fn bernstein_roots(c: &[f64], lo: f64, hi: f64, depth: u32, work: &mut usize, oubernstein_roots(&r, mid, hi, depth - 1, work, out);}-/// Whether edge `e`'s two uses' faces meet with outward normals within `max_angle` (radians) of-/// each other all along it, `sign(f)` turning face `f`'s natural normal outward. An edge with-/// other than two uses has no such pair: false. See the module documentation.-pub(crate) fn tangent_all_along(rec: &Brep, sign: impl Fn(usize) -> Option<f64>, e: usize, max_angle: f64) -> Result<bool> {+/// Calls `visit` with the outward unit normals of edge `e`'s two uses' faces at one point of the+/// edge after another, `sign(f)` turning face `f`'s natural normal outward: on each piece of the+/// edge where both normals are polynomials, at the `D + 1` Chebyshev points the module+/// documentation describes, skipping a point where either is undefined (a pole). `visit` returns+/// whether to go on. `Ok(None)` for an edge with other than two uses; else whether some point had+/// both normals.+fn normal_pairs(rec: &Brep, sign: impl Fn(usize) -> Option<f64>, e: usize, mut visit: impl FnMut(Vec3, Vec3) -> bool) -> Result<Option<bool>> {let edge = rec.edges.get(e).ok_or_else(|| failed(format!("edge {e}")))?;- let [ua, ub] = edge.uses.as_slice() else { return Ok(false) };+ let [ua, ub] = edge.uses.as_slice() else { return Ok(None) };let use_of = |u: &solidcraft_geom::brep::EdgeUseRef| -> Result<Use<'_>> {let face = rec.faces.get(u.face as usize).ok_or_else(|| failed(format!("face {}", u.face)))?;let oriented = match face.loops.get(u.r#loop as usize) {@@ -297,7 +300,6 @@ pub(crate) fn tangent_all_along(rec: &Brep, sign: impl Fn(usize) -> Option<f64>,if breaks.len().saturating_mul(nodes) > MAX_POINTS {return Err(failed(format!("deciding tangency along edge {e}: {} pieces of degree {degree}", breaks.len())));}- let cos = max_angle.cos();let mut defined = false;for w in breaks.windows(2) {let &[t0, t1] = w else { continue };@@ -308,17 +310,47 @@ pub(crate) fn tangent_all_along(rec: &Brep, sign: impl Fn(usize) -> Option<f64>,for j in 0..nodes {let t = m + h * ((2 * j + 1) as f64 * std::f64::consts::PI / (2 * nodes) as f64).cos();if let (Some(na), Some(nb)) = (a.normal(t)?, b.normal(t)?) {- if !(na.dot(nb) >= cos) {- return Ok(false);- }defined = true;+ if !visit(na, nb) {+ return Ok(Some(true));+ }}}}+ Ok(Some(defined))+}++/// Whether edge `e`'s two uses' faces meet with outward normals within `max_angle` (radians) of+/// each other all along it, `sign(f)` turning face `f`'s natural normal outward. An edge with+/// other than two uses has no such pair: false. See the module documentation.+pub(crate) fn tangent_all_along(rec: &Brep, sign: impl Fn(usize) -> Option<f64>, e: usize, max_angle: f64) -> Result<bool> {+ let cos = max_angle.cos();+ let mut tangent = true;+ let Some(defined) = normal_pairs(rec, sign, e, |na, nb| {+ tangent = na.dot(nb) >= cos;+ tangent+ })?+ else {+ return Ok(false);+ };if !defined {return Err(failed(format!("edge {e}: its faces' normals are undefined all along it")));}- Ok(true)+ Ok(tangent)+}++/// The least angle (radians, 0 to π) between the outward normals of edge `e`'s two uses' faces+/// at the points [`normal_pairs`] visits: the edge's least angle where it is the same all along+/// the edge (two planes, a plane and a cylinder along a generator), at most a little above it+/// elsewhere. `None` for an edge with other than two uses, or whose normals are undefined+/// everywhere.+pub(crate) fn least_angle_along(rec: &Brep, sign: impl Fn(usize) -> Option<f64>, e: usize) -> Result<Option<f64>> {+ let mut least = f64::INFINITY;+ let defined = normal_pairs(rec, sign, e, |na, nb| {+ least = least.min(na.cross(nb).len().atan2(na.dot(nb)));+ true+ })?;+ Ok(defined.filter(|d| *d).map(|_| least))}#[cfg(test)]diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsindex b0a1cf739a..bfd6b2a9ac 100644--- a/crates/kernel/src/tests.rs+++ b/crates/kernel/src/tests.rs@@ -373,17 +373,43 @@ fn fillet_max_each_reduces_only_where_the_radius_does_not_fit() {assert_eq!(fillet_max_each(&post, &mids, 3.5).unwrap().map(|x| x.0), Some(vec![3.0; 4]));}-/// A corner's rounds with a radius per edge, one wider than its faces, are refused as too large,-/// so a fit can reduce them. (The same corner at one radius as wide as the faces, and its fit,-/// are the rig's fillets/477-fillet-cube-corner-rounds-as-wide-as-faces-* cases; no command-/// takes a radius per edge.)+/// R21 on an edge of a 20 mm cube overflows on its tangent sides, which a round may, taking all+/// of both faces beside the edge: its circle about (y, z) = (21, 21) meets them only at 21, past+/// the cube. What is left is the square [0, 20]² inside that circle, with u = 21 − y,+/// ∫₁^√440 (√(441 − u²) − 1) du, along 20: 6107.529370.+fn round_wider_than_its_faces() -> f64 {+ let f = |u: f64| 0.5 * (u * (441.0 - u * u).sqrt() + 441.0 * (u / 21.0).asin());+ let w = 440f64.sqrt();+ 20.0 * (f(w) - f(1.0) - (w - 1.0))+}++#[test]+fn a_round_wider_than_its_faces_overflows_onto_its_tangent_sides() {+ let want = round_wider_than_its_faces();+ assert!((want - 6107.529370).abs() < 1e-6, "{want}");+ let b = box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();+ let out = fillet(&b, &[Vec3::new(10.0, 0.0, 0.0)], 21.0).unwrap();+ assert!(out.validity().is_empty(), "{:?}", out.validity());+ assert!(rel(measure(&out).unwrap().volume, want) < 1e-9, "{} vs {want}", measure(&out).unwrap().volume);+}++/// A corner's rounds with a radius per edge, one wider than its faces: R21 with R5 on the other+/// two edges at the corner. The R21 takes both faces beside its edge, and with them the R5+/// edges, which lie on them: the body is R21's alone+/// ([`a_round_wider_than_its_faces_overflows_onto_its_tangent_sides`]). (The same corner at one+/// radius as wide as the faces, and its fit, are the rig's+/// fillets/477-fillet-cube-corner-rounds-as-wide-as-faces-* cases; no command takes a radius per+/// edge.)#[test]-fn corner_rounds_larger_than_their_faces_are_too_large() {+#[ignore = "fails until SMLib blends the corner whole: status 1001, fillet error 4 (edge type 14), Unable to Trim Rail Curve"]+fn a_corner_round_wider_than_its_faces_overflows_and_takes_the_corners_other_edges() {let b = box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();let corner = [Vec3::new(10.0, 0.0, 0.0), Vec3::new(0.0, 10.0, 0.0), Vec3::new(0.0, 0.0, 10.0)];let sel: Vec<(Vec3, f64)> = corner.iter().copied().zip([21.0, 5.0, 5.0]).collect();- let e = crate::blend_corner::fillet_radii(&b, &sel).unwrap_err();- assert!(matches!(e, KernelError::TooLarge(_)), "{e}");+ let out = crate::blend_corner::fillet_radii(&b, &sel).unwrap();+ assert!(out.validity().is_empty(), "{:?}", out.validity());+ let want = round_wider_than_its_faces();+ assert!(rel(measure(&out).unwrap().volume, want) < 1e-9, "{} vs {want}", measure(&out).unwrap().volume);}#[test]diff --git a/skills/solidcraft-tests/SKILL.md b/skills/solidcraft-tests/SKILL.mdindex 7c2ec4abd4..761e80141b 100644--- a/skills/solidcraft-tests/SKILL.md+++ b/skills/solidcraft-tests/SKILL.md@@ -15,7 +15,7 @@ The long form is `docs/book/src/dev/testing.md`.- Crash fixes: a regression test from the report's `design.solidcraft` and `replay.json` (`skills/solidcraft-crash-safety/SKILL.md`).## Unit test or rig case-- Unit tests assert the code's logic: which edges a chain picks, name resolution, history labels, refusal wording, hostile input, parsing and saving (`corner_rounds_larger_than_their_faces_are_too_large`: per-edge radii, which no command takes, refused as `TooLarge`).+- Unit tests assert the code's logic: which edges a chain picks, name resolution, history labels, refusal wording, hostile input, parsing and saving (`a_corner_round_wider_than_its_faces_overflows_and_takes_the_corners_other_edges`: per-edge radii, which no command takes, so no rig case can).- The rig (`tests/kernel-cases/`) asserts geometry: exact volumes, shapes, seam continuity, geometric refusals, through commands with a hand-derived answer, so it survives a kernel swap (`fillets/190-fillet-disc-rim-past-its-2mm-wall`). A test doing both keeps only its logic.## A failing test needs its fixdiff --git a/tests/kernel-cases/fillets/KNOWN_FAILING b/tests/kernel-cases/fillets/KNOWN_FAILINGindex ed55721c46..1946a83b34 100644--- a/tests/kernel-cases/fillets/KNOWN_FAILING+++ b/tests/kernel-cases/fillets/KNOWN_FAILING@@ -28,11 +28,11 @@5835-chamfer-sloped-basin-1-mm-rim-2-two-edges SMLib status 1001: SmFilletNx2Corner, CalcFilletIntSideFace cannot intersect a chamfer with the side face at the rim's corner, where the front chamfer past the rim should build cut by the front face5835-chamfer-sloped-basin-4-mm-rim-2-2-edges SMLib status 1001 on the chamfers meeting at the rim's re-entrant corner5835-chamfer-sloped-basin-4-mm-rim-2-4-edges SMLib status 1001 on the chamfers meeting at the rim's re-entrant corners-851-chamfer-knife-edge-tip-0-5 SMLib SM_ERR_INVALID_INPUT on the knife edge (opposite normals on its two faces)-851-chamfer-knife-edge-tip-2 SMLib SM_ERR_INVALID_INPUT on the knife edge (opposite normals on its two faces)-851-chamfer-knife-edge-tip-2-box-less-cylinder SMLib SM_ERR_INVALID_INPUT on the knife edge (opposite normals on its two faces)-851-chamfer-knife-edge-tip-2-sketched SMLib SM_ERR_INVALID_INPUT on the knife edge (opposite normals on its two faces)-851-chamfer-knife-edge-tip-5 SMLib SM_ERR_INVALID_INPUT on the knife edge (opposite normals on its two faces)+851-chamfer-knife-edge-tip-0-5 SMLib SM_ERR_INVALID_INPUT: smlib_chamfer takes the ball radius d·√((1−c)/(1+c)), c the faces' binormals' dot (capi chamfer_radius), which is 0 at a cusp, where they agree; the case wants the ball of radius d+851-chamfer-knife-edge-tip-2 SMLib SM_ERR_INVALID_INPUT: smlib_chamfer takes the ball radius d·√((1−c)/(1+c)), c the faces' binormals' dot (capi chamfer_radius), which is 0 at a cusp, where they agree; the case wants the ball of radius d+851-chamfer-knife-edge-tip-2-box-less-cylinder SMLib SM_ERR_INVALID_INPUT: smlib_chamfer takes the ball radius d·√((1−c)/(1+c)), c the faces' binormals' dot (capi chamfer_radius), which is 0 at a cusp, where they agree; the case wants the ball of radius d+851-chamfer-knife-edge-tip-2-sketched SMLib SM_ERR_INVALID_INPUT: smlib_chamfer takes the ball radius d·√((1−c)/(1+c)), c the faces' binormals' dot (capi chamfer_radius), which is 0 at a cusp, where they agree; the case wants the ball of radius d+851-chamfer-knife-edge-tip-5 SMLib SM_ERR_INVALID_INPUT: smlib_chamfer takes the ball radius d·√((1−c)/(1+c)), c the faces' binormals' dot (capi chamfer_radius), which is 0 at a cusp, where they agree; the case wants the ball of radius d9-fillet-corner-curvature-with-reduce-fit not supported yet: solid.fillet builds corner g2 with the exact fit only9-fillet-corner-curvature-with-taper-fit not supported yet: solid.fillet builds corner g2 with the exact fit only926-chamfer-top-edge-ending-on-boss-wall-above-it not supported yet: the chamfer is refused as larger than its faces where it ends on the boss's wall