SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 270/509: kernel-cases: a continuity check, and ladder 07/015 graded by it (and 3 more)
jyviko34c5bc74a5d4
diff --git a/apps/solidcraft-cli/src/kernel_cases.rs b/apps/solidcraft-cli/src/kernel_cases.rsindex d75f83ae06..272c3c99b1 100644--- a/apps/solidcraft-cli/src/kernel_cases.rs+++ b/apps/solidcraft-cli/src/kernel_cases.rs@@ -114,6 +114,60 @@ fn open_edges(positions: &[solidcraft_engine::geom::Vec3], triangles: &[[u32; 3]}/// An error that means "this kernel can't do it yet", not a wrong answer.+/// Stations along each seam the `continuity` check samples.+const SEAM_SAMPLES: usize = 65;+/// A seam is tangent (G1), and two seams meeting at a vertex turn there, past this angle (°).+const SEAM_ANGLE_DEG: f64 = 1.0;++/// The `continuity` check's measure of `body`: over the tangent seams lying wholly within+/// `within` of `near`, the worst curvature jump (1/mm) at every station and at the stations at+/// least `clear` (mm, along the seam) from each vertex where two of those seams turn (a corner of+/// the patch's boundary, where its neighbours' own G1 seams end and no surface is G2 to both),+/// with how many seams and stations clear there were. An error where the seams can't be measured.+fn curvature_jumps(body: &solidcraft_engine::kernel::Body, near: [f64; 3], within: f64, clear: f64) -> Result<Value, String> {+ use solidcraft_engine::geom::Vec3;+ let tol = solidcraft_engine::kernel::ContinuityTolerances { gap_mm: 1e-3, angle_deg: SEAM_ANGLE_DEG, curvature_per_mm: 0.0 };+ let report = solidcraft_engine::kernel::seam_diagnostics(body, &[], SEAM_SAMPLES, tol).map_err(|e| e.to_string())?;+ let at = Vec3::new(near[0], near[1], near[2]);+ let seams: Vec<_> = report+ .seams+ .iter()+ .filter(|s| s.normal_angle_deg.value <= SEAM_ANGLE_DEG && s.points.len() >= 2 && s.points.iter().all(|p| p.dist(at) <= within))+ .collect();+ // Each seam's end directions, pointing into it.+ let ends = |s: &solidcraft_engine::kernel::SeamReport| -> Option<[(Vec3, Vec3); 2]> {+ let (p0, p1) = (*s.points.first()?, *s.points.last()?);+ let (q0, q1) = (*s.points.get(1)?, *s.points.get(s.points.len() - 2)?);+ Some([(p0, (q0 - p0).normalized()?), (p1, (q1 - p1).normalized()?)])+ };+ let all_ends: Vec<(Vec3, Vec3)> = seams.iter().filter_map(|s| ends(s)).flatten().collect();+ let weld = 1e-6 * within.max(1.0);+ let cos = SEAM_ANGLE_DEG.to_radians().cos();+ // A vertex turns where another seam leaves it other than straight on.+ let turns = |p: Vec3, d: Vec3| all_ends.iter().any(|(q, e)| q.dist(p) <= weld && (*e - d).len() > 1e-9 && -e.dot(d) < cos);+ let (mut worst, mut worst_clear, mut stations) = (0.0f64, 0.0f64, 0usize);+ for s in &seams {+ let Some(e) = ends(s) else { continue };+ let turning: Vec<Vec3> = e.iter().filter(|(p, d)| turns(*p, *d)).map(|(p, _)| *p).collect();+ // Arc length along the seam to each station, from its start.+ let mut along = vec![0.0f64; s.points.len()];+ for k in 1..s.points.len() {+ along[k] = along[k - 1] + s.points[k].dist(s.points[k - 1]);+ }+ let length = along.last().copied().unwrap_or(0.0);+ for (k, st) in s.stations.iter().enumerate() {+ worst = worst.max(st.curvature_jump_per_mm);+ let a = along.get(k).copied().unwrap_or(0.0);+ let from_turn = turning.iter().map(|p| if p.dist(s.points[0]) <= weld { a } else { length - a }).fold(f64::INFINITY, f64::min);+ if from_turn >= clear {+ worst_clear = worst_clear.max(st.curvature_jump_per_mm);+ stations += 1;+ }+ }+ }+ Ok(json!({"seams": seams.len(), "stations_clear": stations, "worst_per_mm": worst, "worst_clear_per_mm": worst_clear}))+}+fn unsupported(e: &str) -> bool {e.contains("not supported yet")}@@ -256,6 +310,24 @@ fn check_case(dir: &str, dumps: Option<&std::path::Path>) -> Value {open == 0 && over == 0,);}+ // Curvature continuity across the seams round a point: the worst jump clear of the+ // seams' turns must be within the case's bound.+ if let Some(cont) = want.get("continuity").filter(|c| !c.is_null()) {+ let (near, within, clear, bound) =+ (v3(&cont["near"]), cont["within_mm"].as_f64(), cont["clear_mm"].as_f64(), cont["curvature_jump_per_mm"].as_f64());+ match (near, within, clear, bound) {+ (Some(near), Some(within), Some(clear), Some(bound)) => match curvature_jumps(&b.body, near, within, clear) {+ Ok(got) => {+ let ok = got["seams"].as_u64().unwrap_or(0) > 0+ && got["stations_clear"].as_u64().unwrap_or(0) > 0+ && got["worst_clear_per_mm"].as_f64().is_some_and(|w| w <= bound);+ c.push("curvature_jump", got, json!({"worst_clear_per_mm": format!("<= {bound}")}), ok);+ }+ Err(e) => c.push("curvature_jump", json!(format!("{}: {e}", b.name)), json!("measurable"), false),+ },+ _ => c.push("curvature_jump", json!("continuity needs near, within_mm, clear_mm and curvature_jump_per_mm"), json!("a bound"), false),+ }+ }if want_valid {// Closed shells, and every validity check this build has.if want_shells.is_none() {diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex da54060a23..ce847c4585 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -1845,7 +1845,9 @@ pub enum FilletCorner {/// A piece of the rolling ball's sphere: tangent (G1) to each blend.#[default]Rolling,- /// A G2 patch repeating each blend's surface up to the second order (see `corner_g2`).+ /// The corner set back (its distance from the fillet's `setbacks`, else 1.5 × the radius)+ /// and filled with a patch meeting the rounds and the faces round it to the second order+ /// (`solidcraft_kernel::fillet_g2_corners`).G2,}diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 29caa08e7a..47267b8f7b 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -3494,13 +3494,16 @@ fn blend_body(let (mut used, mut tapered) = (None, Vec::new());// 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() => {+ FeatureKind::Fillet { corner, setbacks, .. } if matches!(corner, crate::FilletCorner::G2) || !setbacks.is_empty() => {+ // Each setback: its corner's vertex and its distance.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)+ match corner {+ crate::FilletCorner::G2 => (kernel::fillet_g2_corners(&mb.body, edges, r, &corners)?, input),+ crate::FilletCorner::Rolling => (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),@@ -6656,13 +6659,11 @@ 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+ if let FeatureKind::Fillet { setbacks, style, fit, .. } = &f.kind&& !setbacks.is_empty()- && (!corner.is_rolling() || !matches!(style, crate::FilletStyle::Constant) || !matches!(fit, crate::FilletFit::Exact))+ && (!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(),- ));+ return Err(DocError::Invalid("corner setbacks are built for a constant-radius fillet (type: constant, fit: exact) only".into()));}let on = blend_bodies(st, f, body, &crate::plain(edges))?;let mut groups: Vec<(usize, Vec<usize>)> = Vec::new();diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rsindex c4de9df762..61179189f4 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); 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)"),+ .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: each corner where three or more rounded edges meet, and every edge there is rounded, is set back (1.5 × the radius along each edge unless `setbacks` names it) and filled with a patch meeting the rounds and the faces round it to the second order (curvature-continuous seams, clear of the points where a round's section ends on a face), 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 only; with `corner: g2`, the G2 patch's corners); 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)@@ -1676,8 +1676,8 @@ fn fillet(s: &mut Session, p: &Value) -> Result<Value> {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"));+ if !setbacks.is_empty() && (!style.is_constant() || !fit.is_exact()) {+ return Err(bad(cmd, "`setbacks` are built for a constant-radius fillet (`type: constant`, `fit: exact`) only"));}}let mut out = add_feature(@@ -3192,8 +3192,8 @@ mod thin_extrude_tests;#[path = "extrude_convention_tests.rs"]mod extrude_convention_tests;/// `solid.fillet corner?: rolling|g2`: the default keeps the rolling ball's sphere corner, `g2`-/// is accepted and refuses (item 10's patch is built but not sewn in yet, see `corner_g2`), and an-/// unknown word is refused.+/// sets the corner back and fills it with the G2 patch (`solidcraft_kernel::fillet_g2_corners`),+/// with `setbacks` naming its distance, and an unknown word is refused.#[cfg(test)]#[allow(clippy::unwrap_used)]mod corner_tests {@@ -3218,7 +3218,7 @@ mod corner_tests {}#[test]- fn the_default_corner_is_the_rolling_ball_and_g2_refuses_clearly() {+ fn the_default_corner_is_the_rolling_ball_and_g2_sets_it_back_for_its_patch() {let (default, reply) = cornered(None);assert_eq!(reply["warning"], json!(null), "{reply}");let (rolling, _) = cornered(Some("rolling"));@@ -3227,13 +3227,23 @@ mod corner_tests {// `corner: rolling` is the default: the same body, to the last bit of its area.assert_eq!(solidcraft_kernel::measure(&ball).unwrap().area, solidcraft_kernel::measure(&same).unwrap().area);assert!(solidcraft_kernel::measure(&ball).unwrap().volume > 7000.0);- // `corner: g2`: accepted, and refused with a clear message until the patch sews in.+ // `corner: g2`: the corner set back (1.5 r by default, or as `setbacks` says) and filled+ // with the G2 patch: one closed solid of the box's faces, the rounds and the patch, a+ // little fuller than the ball's corner (its patch spans the setback, not the ball).+ let ball_volume = solidcraft_kernel::measure(&ball).unwrap().volume;+ for setbacks in [json!([]), json!([{"vertex": [0, 0, 0], "distance": 7}])] {+ let mut s = Session::default();+ run(&mut s, "solid.box", &json!({"length": 20, "width": 20, "height": 20, "body_name": "B"}));+ run(&mut s, "solid.fillet", &json!({"edges": [[10, 0, 0], [0, 10, 0], [0, 0, 10]], "radius": 4, "corner": "g2", "setbacks": setbacks}));+ let body = s.world_state().unwrap().body("B").unwrap().body.clone();+ assert!(body.validity().is_empty(), "{:?}", body.validity());+ let m = solidcraft_kernel::measure(&body).unwrap();+ eprintln!("corner g2, setbacks {setbacks}: {} faces, volume {:.4} (ball {:.4})", m.faces, m.volume, ball_volume);+ assert_eq!(m.faces, 10);+ assert!((m.volume - ball_volume).abs() < 1e-3 * ball_volume, "{} vs {}", m.volume, ball_volume);+ }let mut s = Session::default();run(&mut s, "solid.box", &json!({"length": 20, "width": 20, "height": 20, "body_name": "B"}));- let err =- s.execute("solid.fillet", &json!({"edges": [[10, 0, 0], [0, 10, 0], [0, 0, 10]], "radius": 4, "corner": "g2"})).unwrap_err().to_string();- eprintln!("corner g2: {err}");- assert!(err.contains("not supported yet:") && err.contains("G2 corner"), "{err}");// An unknown word, and a style the G2 corner has no patch for, are refused as parameters.assert!(s.execute("solid.fillet", &json!({"edges": [[10, 0, 0]], "radius": 4, "corner": "round"})).is_err());assert!(s.execute("solid.fillet", &json!({"edges": [[10, 0, 0]], "radius": 4, "corner": "g2", "type": "chord"})).is_err());diff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rsindex f1cc3c4528..bfbde93e94 100644--- a/crates/kernel/src/blend.rs+++ b/crates/kernel/src/blend.rs@@ -233,8 +233,9 @@ pub fn fillet_setback(body: &Body, edges: &[Vec3], radius: f64, setbacks: &[(Vec/// its vertex and the distance its patch starts along each edge there (the others take/// [`crate::DEFAULT_SETBACK_FACTOR`] times the radius), SMLib leaves it open, and a patch that/// meets the rounds and the faces round it to the second order fills it. The faces are sewn-/// into one solid. Without such a corner this is [`fillet`]. Refused: a corner where an edge is-/// not rounded (SMLib sets back only corners where all are), a setback that does not reach past+/// into one solid, convex corners and concave ones alike. Without such a corner this is+/// [`fillet`]. Refused: a corner where an edge is not rounded, or whose edges are not all of one+/// convexity (SMLib sets back only corners where all are rounded, alike), a setback that does not reach past/// where the rounds would meet, a hole that is no height field over its plane or a patch that/// does not meet its neighbours within the tolerances.pub fn fillet_g2_corners(body: &Body, edges: &[Vec3], radius: f64, setbacks: &[(Vec3, f64)]) -> Result<Body> {diff --git a/crates/kernel/src/corner_g2_tests.rs b/crates/kernel/src/corner_g2_tests.rsindex 9fd4dcf960..9306c0bf3b 100644--- a/crates/kernel/src/corner_g2_tests.rs+++ b/crates/kernel/src/corner_g2_tests.rs@@ -164,3 +164,44 @@ fn what_the_g2_corner_cannot_build_is_refused() {let plain = fillet(&body, &edges[..2], 5.0).unwrap();assert_eq!(measure(&two).unwrap().faces, measure(&plain).unwrap().faces);}++/// The 60 x 40 x 20 box with a 20 x 20 x 10 notch cut from its top corner (60, 40, 20): its+/// inner corner (40, 20, 10) where three concave edges meet, and the notch's outer corner+/// (60, 20, 10) where the concave edge along x meets two convex ones.+fn notched() -> Body {+ let a = box_solid(Vec3::ZERO, Vec3::new(60.0, 40.0, 20.0)).unwrap();+ let b = box_solid(Vec3::new(40.0, 20.0, 10.0), Vec3::new(70.0, 50.0, 30.0)).unwrap();+ boolean(&a, &b, BoolOp::Cut).unwrap().unwrap()+}++/// The notch's inner corner, three concave r5 rounds (ladder 07/019): set back 7.5 and filled,+/// one closed valid solid with the faces the ball corner has, the patch's seams G2 clear of the+/// hole's corners where the ball's jump 1/r.+#[test]+fn a_concave_corner_takes_the_g2_patch_too() {+ let body = notched();+ let edges = [Vec3::new(50.0, 20.0, 10.0), Vec3::new(40.0, 30.0, 10.0), Vec3::new(40.0, 20.0, 15.0)];+ let ball = fillet(&body, &edges, 5.0).unwrap();+ let g2 = fillet_g2_corners(&body, &edges, 5.0, &[]).unwrap();+ assert!(g2.validity().is_empty(), "{:?}", g2.validity());+ let v = crate::validity::validity(&g2);+ assert!(v.ok(), "{v:?}");+ let (m, mb) = (measure(&g2).unwrap(), measure(&ball).unwrap());+ let (_, clear, n) = corner_seams(&g2, 0.15);+ let (_, ball_clear, _) = corner_seams(&ball, 0.15);+ eprintln!("concave G2 corner: {} faces (ball {}), volume {:.4} (ball {:.4}), jump clear of the corners {clear:.3e} ({n} stations), ball's {ball_clear:.3e}", m.faces, mb.faces, m.volume, mb.volume);+ assert_eq!(m.faces, mb.faces);+ assert!(clear <= CURVATURE_SHARE / 5.0 && ball_clear > 0.19, "{clear} {ball_clear}");+}++/// The notch's outer corner, two convex rounds and a concave one: SMLib sets back only a corner+/// of one convexity, so the G2 corner is refused as not supported (the rolling ball builds).+#[test]+fn a_mixed_convexity_corner_is_refused() {+ let body = notched();+ let edges = [Vec3::new(50.0, 20.0, 10.0), Vec3::new(60.0, 30.0, 10.0), Vec3::new(60.0, 20.0, 15.0)];+ assert!(fillet(&body, &edges, 5.0).is_ok());+ let err = fillet_g2_corners(&body, &edges, 5.0, &[]).unwrap_err().to_string();+ eprintln!("mixed corner: {err}");+ assert!(err.contains("not supported yet"), "{err}");+}diff --git a/tests/kernel-cases/README.md b/tests/kernel-cases/README.mdindex 04b6cee873..5de1011e42 100644--- a/tests/kernel-cases/README.md+++ b/tests/kernel-cases/README.md@@ -88,6 +88,7 @@ the frozen truck-geometry PRs, a `kernel-paused` PR), for the report's coverage| `body_count`, `faces`, `edges`, `vertices` | Exact counts, where the geometry fixes them. Faces and edges count whole analytic surfaces and curves once (a full cylinder side is one face). || `volume_mm3`, `area_mm2`, `center_of_mass`, `bbox` | As in `tests/oracle`: totals over every body, relative tolerance 1e-3 for volume and area, 1e-3 of the box diagonal for positions. || `faces`, `edges`, `vertices`, `shells`, `body_count` as `[min, max]` | An inclusive range, where the geometry only bounds a count (a modelled thread's faces). |+| `continuity` | `{near, within_mm, clear_mm, curvature_jump_per_mm}`: over every tangent seam lying wholly within `within_mm` of `near` (a corner's patch and its neighbours), the curvature jump across it (the faces' normal curvatures square to the seam, from their exact surfaces, at 65 stations a seam) is at most `curvature_jump_per_mm` at every station at least `clear_mm` along the seam from a vertex where two of those seams turn (where a neighbour's own G1 seam ends, which no surface is G2 to both sides of). A rolling ball's corner jumps 1 / r everywhere. || `watertight` | `true`: each body's display mesh (chord tolerance `tolerance.mesh_mm`, default 0.01 mm) has no open and no over-shared edges, with vertices closer than `tolerance.weld_mm` (default 1e-4 mm) taken as one. || `timeout_s` | A longer timeout for this case than the run's (at most 1800 s), for cases that are slow by nature. A case that only needs it on a loaded machine shouldn't set it. || `tolerance` | Optional overrides: `rel`, `abs_mm`, `mesh_mm`, `weld_mm`. |diff --git a/tests/kernel-cases/ladder/07-fillets/015-corner-g2-patch/expected.json b/tests/kernel-cases/ladder/07-fillets/015-corner-g2-patch/expected.jsonindex a5246f6977..da5c27f960 100644--- a/tests/kernel-cases/ladder/07-fillets/015-corner-g2-patch/expected.json+++ b/tests/kernel-cases/ladder/07-fillets/015-corner-g2-patch/expected.json@@ -2,7 +2,29 @@"sources": [],"what": "three r5 rounds at a corner with the g2 corner patch","source": "invariants",- "method": "the g2 patch replaces the sphere octant; no closed-form volume; one valid body, the same faces as 009",+ "method": "the corner set back 1.5 r = 7.5 and filled with one patch G2 to the three rounds and the three faces; no closed-form volume; one valid body, the same faces as 009, within the box; across the patch's seams the curvature jump is at most 1e-3 per mm (the ball's corner, 009, jumps 1/r = 0.2) clear of the six points where a round's section ends on a face, where the round's own G1 seam with the face ends (the patch passes from one curvature to the other within 15% of each side: 1.2 mm covers it)","body_count": 1,- "faces": 10+ "faces": 10,+ "bbox": {+ "min": [+ 0,+ 0,+ 0+ ],+ "max": [+ 60,+ 40,+ 20+ ]+ },+ "continuity": {+ "near": [+ 60,+ 40,+ 20+ ],+ "within_mm": 15,+ "clear_mm": 1.2,+ "curvature_jump_per_mm": 0.001+ }}diff --git a/tests/kernel-cases/ladder/07-fillets/019-concave-corner-g2-patch/expected.json b/tests/kernel-cases/ladder/07-fillets/019-concave-corner-g2-patch/expected.jsonnew file mode 100644index 0000000000..0ede2bac07--- /dev/null+++ b/tests/kernel-cases/ladder/07-fillets/019-concave-corner-g2-patch/expected.json@@ -0,0 +1,30 @@+{+ "sources": [],+ "what": "three concave r5 rounds at the inner corner of a 20x20x10 notch, with the g2 corner patch",+ "source": "invariants",+ "method": "the notch's inner corner (40,20,10), three concave edges, set back 1.5 r = 7.5 and filled with one patch G2 to the three rounds and the three faces; one valid body with the faces of the ball corner (13); across the patch's seams the curvature jump is at most 1e-3 per mm (the ball's corner jumps 1/r = 0.2) clear of the six points where a round's section ends on a face (within 11 mm of the corner: the hole reaches 7.5 sqrt 2; the vertical round, 2.5 mm long past its setback, meets its faces 11.2 mm out, with the G1 jump every round has)",+ "body_count": 1,+ "faces": 13,+ "bbox": {+ "min": [+ 0,+ 0,+ 0+ ],+ "max": [+ 60,+ 40,+ 20+ ]+ },+ "continuity": {+ "near": [+ 40,+ 20,+ 10+ ],+ "within_mm": 11,+ "clear_mm": 1.2,+ "curvature_jump_per_mm": 0.001+ }+}diff --git a/tests/kernel-cases/ladder/07-fillets/019-concave-corner-g2-patch/recipe.json b/tests/kernel-cases/ladder/07-fillets/019-concave-corner-g2-patch/recipe.jsonnew file mode 100644index 0000000000..0a98532720--- /dev/null+++ b/tests/kernel-cases/ladder/07-fillets/019-concave-corner-g2-patch/recipe.json@@ -0,0 +1,53 @@+{+ "base": "../../01-primitives/001-box",+ "commands": [+ {+ "command": "solid.box",+ "params": {+ "corner": [+ 40,+ 20,+ 10+ ],+ "length": 30,+ "width": 30,+ "height": 20,+ "body_name": "Notch"+ }+ },+ {+ "command": "solid.combine",+ "params": {+ "target": "Part",+ "tools": [+ "Notch"+ ],+ "operation": "cut"+ }+ },+ {+ "command": "solid.fillet",+ "params": {+ "edges": [+ [+ 50,+ 20,+ 10+ ],+ [+ 40,+ 30,+ 10+ ],+ [+ 40,+ 20,+ 15+ ]+ ],+ "radius": 5,+ "corner": "g2"+ }+ }+ ]+}diff --git a/tests/kernel-cases/ladder/golden.json b/tests/kernel-cases/ladder/golden.jsonindex 7f35e0b010..53aa862d7d 100644--- a/tests/kernel-cases/ladder/golden.json+++ b/tests/kernel-cases/ladder/golden.json@@ -1189,8 +1189,28 @@"status": "pass"},"ladder/07-fillets/015-corner-g2-patch": {- "seconds": 0.00302384,- "status": "unsupported"+ "measured": {+ "area_mm2": 8520.38925544218,+ "body_count": 1,+ "edges": 24,+ "faces": 10,+ "vertices": 16,+ "volume_mm3": 47370.10741440046+ },+ "seconds": 2.184099933,+ "status": "pass"+ },+ "ladder/07-fillets/019-concave-corner-g2-patch": {+ "measured": {+ "area_mm2": 8702.800595617835,+ "body_count": 1,+ "edges": 33,+ "faces": 13,+ "vertices": 22,+ "volume_mm3": 44254.3419135911+ },+ "seconds": 2.217877403,+ "status": "pass"},"ladder/07-fillets/016-corner-three-sequential-r5-r3-r7": {"seconds": 0.045599545,diff --git a/tests/kernel-cases/ladder/ladder.json b/tests/kernel-cases/ladder/ladder.jsonindex 22df15ac63..ae3c21f85c 100644--- a/tests/kernel-cases/ladder/ladder.json+++ b/tests/kernel-cases/ladder/ladder.json@@ -124,6 +124,7 @@{"cases": ["ladder/07-fillets/015-corner-g2-patch",+ "ladder/07-fillets/019-concave-corner-g2-patch","ladder/07-fillets/006-variable-r5-to-zero","ladder/07-fillets/001-single-edge-r5","ladder/07-fillets/007-variable-r5-to-1e-3",diff --git a/tools/kernel-ladder/cases.py b/tools/kernel-ladder/cases.pyindex 5150837020..562a4e09aa 100644--- a/tools/kernel-ladder/cases.py+++ b/tools/kernel-ladder/cases.py@@ -863,8 +863,25 @@ case(T7, "014-curved-edge-r2", "an r2 round on the top edge of a cylinder r10 h2{"body_count": 1, "volume_mm3": PI * 100 * 20 - SPANDREL * 4 * 2 * PI * (10 - XBAR * 2), "faces": 4},"a torus round: Pappus on the removed section (1-pi/4) r^2 at radius 10 - r(10-3pi)/(12-3pi)")case(T7, "015-corner-g2-patch", "three r5 rounds at a corner with the g2 corner patch",- [F(corner, 5, corner="g2")], {"body_count": 1, "faces": 10},- "the g2 patch replaces the sphere octant; no closed-form volume; one valid body, the same faces as 009", base=B1, source="invariants")+ [F(corner, 5, corner="g2")],+ {"body_count": 1, "faces": 10, "bbox": {"min": [0, 0, 0], "max": [60, 40, 20]},+ "continuity": {"near": [60, 40, 20], "within_mm": 15, "clear_mm": 1.2, "curvature_jump_per_mm": 0.001}},+ "the corner set back 1.5 r = 7.5 and filled with one patch G2 to the three rounds and the three faces; no closed-form volume; "+ "one valid body, the same faces as 009, within the box; across the patch's seams the curvature jump is at most 1e-3 per mm "+ "(the ball's corner, 009, jumps 1/r = 0.2) clear of the six points where a round's section ends on a face, where the round's "+ "own G1 seam with the face ends (the patch passes from one curvature to the other within 15% of each side: 1.2 mm covers it)",+ base=B1, source="invariants")+notch = [[50, 20, 10], [40, 30, 10], [40, 20, 15]]+case(T7, "019-concave-corner-g2-patch", "three concave r5 rounds at the inner corner of a 20x20x10 notch, with the g2 corner patch",+ [box([40, 20, 10], 30, 30, 20, body_name="Notch"), C("solid.combine", target="Part", tools=["Notch"], operation="cut"),+ F(notch, 5, corner="g2")],+ {"body_count": 1, "faces": 13, "bbox": {"min": [0, 0, 0], "max": [60, 40, 20]},+ "continuity": {"near": [40, 20, 10], "within_mm": 11, "clear_mm": 1.2, "curvature_jump_per_mm": 0.001}},+ "the notch's inner corner (40,20,10), three concave edges, set back 1.5 r = 7.5 and filled with one patch G2 to the three "+ "rounds and the three faces; one valid body with the faces of the ball corner (13); across the patch's seams the curvature "+ "jump is at most 1e-3 per mm (the ball's corner jumps 1/r = 0.2) clear of the six points where a round's section ends on a face (within 11 mm of the corner: the hole reaches 7.5 sqrt 2; "+ "the vertical round, 2.5 mm long past its setback, meets its faces 11.2 mm out, with the G1 jump every round has)",+ base=B1, source="invariants")V7 = V5 - 2 * SPANDREL * 25 * 20 - SPANDREL * 9 * 60 + SPANDREL * 1 * 2 * PI * (8 + XBAR * 1)case(T7, "017-part-rounds", "the running part: r5 on the front vertical edges, r3 on the back wall's top front edge, r1 where the boss meets the top",[F([[0, 0, 10], [60, 0, 10]], 5), F([[30, 30, 35]], 3), F([[23, 15, 20]], 1)],