Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Fillets and chamfers meeting at corners on curved faces: what #935 leaves (#854)

Tobias Breckle32d3cf6877af
diff --git a/crates/engine/src/cmd/features_more_tests.rs b/crates/engine/src/cmd/features_more_tests.rs
index 510e90dedc..3b0e688a52 100644
--- a/crates/engine/src/cmd/features_more_tests.rs
+++ b/crates/engine/src/cmd/features_more_tests.rs
@@ -729,3 +729,197 @@ fn cutting_a_text_removes_each_letter_whether_its_letters_stand_apart_or_touch()
assert_eq!(s.world_state().bodies.len(), 1);
}
}
+
+/// A rounded part as drawn in the app: a rectangle and a quarter circle tangent to its top
+/// line, extruded together. The arc (about (62.17, -21), radius 21) ends square at the front
+/// face and in a knife-edge tip where it runs into the back face.
+fn knife_edge_part() -> Session {
+ let mut s = Session::default();
+ run(&mut s, "sketch.create", json!({"plane": "XY"}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0.0, 0.0], "p1": [41.5, -21.0]}));
+ run(&mut s, "sketch.dimension", json!({"entities": ["l2"], "text_at": [36.5, -8.5], "value": "21 mm"}));
+ run(&mut s, "sketch.line", json!({"infer": true, "points": ["p2", [61.5, -21.0]]}));
+ run(&mut s, "sketch.dimension", json!({"entities": ["l5"], "text_at": [54.5, -26.5], "value": "21"}));
+ run(&mut s, "sketch.circle.center", json!({"center": "l5.end", "radius": 21.0}));
+ run(&mut s, "sketch.line", json!({"infer": true, "points": ["p3", [62.166666666666664, 0.0]]}));
+ run(&mut s, "sketch.constraint.tangent", json!({"a": "c1", "b": "l6"}));
+ run(&mut s, "sketch.finish", json!({}));
+ run(&mut s, "solid.extrude", json!({"direction": "positive", "distance": "10 mm", "operation": "new", "profiles": [0, 1], "sketch": 1}));
+ s
+}
+
+/// The volume of the session's bodies through the display plan (the measure's mesh cuts across
+/// the concave arc). It holds to about 1e-3 of what a blend removes here; the bounds below are
+/// about twice what each test reads.
+fn planned(s: &Session) -> f64 {
+ s.model.state().bodies.iter().map(|b| b.body.display_plan(2e-4).unwrap().evaluate().measure().volume).sum()
+}
+
+/// The middle of the part's arc.
+const KNIFE_ARC_MID: [f64; 2] = [62.166666666666664 - 21.0 * std::f64::consts::FRAC_1_SQRT_2, -21.0 + 21.0 * std::f64::consts::FRAC_1_SQRT_2];
+
+/// Simpson's rule over the round's corner (2 × 2 less a quarter disc) at distance ρ = 21 + x
+/// from the arc's axis, times `length(ρ)`.
+fn round_along(length: impl Fn(f64) -> f64) -> f64 {
+ let (r, n) = (2.0f64, 2000);
+ let h = r / n as f64;
+ (0..=n)
+ .map(|i| {
+ let x = i as f64 * h;
+ let w = if i == 0 || i == n { 1.0 } else { [2.0, 4.0][i % 2] };
+ w * (r - (r * r - (r - x) * (r - x)).max(0.0).sqrt()) * length(21.0 + x)
+ })
+ .sum::<f64>()
+ * h
+ / 3.0
+}
+
+/// Its edges are stored the other way round from their curves, which once chained the arc
+/// with the front edge across their corner. Rounding the arc at the bottom and the top removes
+/// the round's section along it, cut off at the tip by the back face's plane: ρ asin(21 / ρ).
+#[test]
+fn fillet_an_arc_that_runs_into_a_knife_edge_tip() {
+ let mut s = knife_edge_part();
+ let before = planned(&s);
+ let [x, y] = KNIFE_ARC_MID;
+ run(&mut s, "solid.fillet", json!({"edges": [[x, y, 0.0]], "radius": 2}));
+ run(&mut s, "solid.fillet", json!({"edges": [[x, y, 10.0]], "radius": 2}));
+ let removed = round_along(|rho| rho * (21.0 / rho).asin());
+ let after = planned(&s);
+ assert!(rel(before - after, 2.0 * removed) < 2e-3, "removed {} vs {}", before - after, 2.0 * removed);
+}
+
+/// The part's front corner (the front face into the arc) rounded with 2 first, then the bottom
+/// run (front edge, the corner round's arc, the arc) with 2 as well: a round on a round of the
+/// same radius. Along the front edge a straight round; at the corner the ball turns about one
+/// point, a piece of sphere (θ r³ / 6 over the corner's θ); along the arc the torus section from
+/// the corner round to the tip.
+#[test]
+fn fillet_a_run_over_a_corner_rounded_with_the_same_radius() {
+ let mut s = knife_edge_part();
+ run(&mut s, "solid.fillet", json!({"edges": [[41.1667, -21.0, 5.0]], "radius": 2}));
+ let before = planned(&s);
+ let [x, y] = KNIFE_ARC_MID;
+ // The corner round: about (62.17 - √(23² - 2²), -19), its arc's middle 2 from there.
+ let cx = 62.166666666666664 - (23.0f64 * 23.0 - 4.0).sqrt();
+ let joint = 2.0f64.atan2((23.0f64 * 23.0 - 4.0).sqrt());
+ let theta = std::f64::consts::FRAC_PI_2 - joint;
+ let corner_mid = [cx + 2.0 * (theta / 2.0).sin(), -19.0 - 2.0 * (theta / 2.0).cos()];
+ run(&mut s, "solid.fillet", json!({"edges": [[x, y, 0.0], [corner_mid[0], corner_mid[1], 0.0], [20.0, -21.0, 0.0]], "radius": 2}));
+ let removed = (1.0 - std::f64::consts::FRAC_PI_4) * 4.0 * cx + theta * 8.0 / 6.0 + round_along(|rho| rho * ((21.0 / rho).asin() - joint));
+ let after = planned(&s);
+ assert!(rel(before - after, removed) < 1e-3, "removed {} vs {removed}", before - after);
+}
+
+/// Straight edges of the part ending at its arc wall: the long front edge at the top (the wall
+/// cuts the round off at x = 62.17 − √(21² − d²), d from the front face) and the back edge at
+/// the top, which runs into the knife-edge tip (x = 62.17 − √(21² − (21 − d)²), d from the back
+/// face).
+#[test]
+fn fillet_straight_edges_that_end_at_the_arc_wall() {
+ let cx = 62.166666666666664;
+ for (edge, cut) in [([20.0, -21.0, 10.0], 0.0), ([30.0, 0.0, 10.0], 21.0)] {
+ let mut s = knife_edge_part();
+ let before = planned(&s);
+ run(&mut s, "solid.fillet", json!({"edges": [edge], "radius": 2}));
+ let removed = round_along(|rho| {
+ let d = rho - 21.0;
+ cx - (441.0 - (cut - d) * (cut - d)).sqrt()
+ });
+ let after = planned(&s);
+ assert!(rel(before - after, removed) < 3e-3, "{edge:?}: removed {} vs {removed}", before - after);
+ }
+}
+
+/// The vertical knife edge at the tip (the arc and the back face meeting at no angle) rounds to
+/// the ball 2 from both, about 13 back from the tip: the cusp beyond the ball, on the tip's side
+/// of its contacts, all the way up.
+#[test]
+fn fillet_the_knife_edge_at_the_tip() {
+ let cx = 62.166666666666664;
+ let (kx, ky) = (cx - (23.0f64 * 23.0 - 19.0 * 19.0).sqrt(), -2.0);
+ let (hx, hy) = (0.002, 0.0005);
+ let mut area = 0.0;
+ let mut x = kx + hx / 2.0;
+ while x < cx {
+ let lo = -21.0 + (441.0 - (x - cx) * (x - cx)).max(0.0).sqrt();
+ for j in 0..((0.0 - lo) / hy).ceil() as usize {
+ let (y0, y1) = (lo + j as f64 * hy, (lo + (j + 1) as f64 * hy).min(0.0));
+ let y = (y0 + y1) * 0.5;
+ let a = (y - ky).atan2(x - kx);
+ if (x - kx).hypot(y - ky) > 2.0 && a >= (-21.0 - ky).atan2(cx - kx) {
+ area += (y1 - y0) * hx;
+ }
+ }
+ x += hx;
+ }
+ let mut s = knife_edge_part();
+ let before = planned(&s);
+ run(&mut s, "solid.fillet", json!({"edges": [[cx, 0.0, 5.0]], "radius": 2}));
+ let after = planned(&s);
+ assert!(rel(before - after, area * 10.0) < 5e-4, "removed {} vs {}", before - after, area * 10.0);
+ let mut s = knife_edge_part();
+ run(&mut s, "solid.chamfer", json!({"edges": [[cx, 0.0, 5.0]], "distance": 2}));
+ assert!(before - planned(&s) > before - after, "the chamfer takes the ball's bulge off too");
+}
+
+/// Rounds of the edges at the arc's top front corner, two or all three together (r 2): they meet
+/// in creases (with all three, a piece of sphere fills the corner). Each set takes off its rounds
+/// alone, less what each alone takes in a box about the corner, plus what they take there
+/// together: the CSG grid of the kernel's `rounds_meeting_at_a_corner_of_an_arc_wall`
+/// (curvecorner_tests.rs, 0.02 mm cells), within its accuracy.
+#[test]
+fn fillet_edges_meeting_at_the_front_corner_of_the_arc() {
+ // In the box about the corner: what the long edge's, the arc's and the upright's rounds take
+ // alone, and what two or all three take together.
+ let corner = [2.719176, 3.015864, 1.863];
+ let together = [(vec![0, 2], 3.886936), (vec![0, 1], 4.971256), (vec![1, 2], 4.19864), (vec![0, 1, 2], 6.3332)];
+ let [x, y] = KNIFE_ARC_MID;
+ let (long, arc, upright) = ([20.0, -21.0, 10.0], [x, y, 10.0], [41.1667, -21.0, 5.0]);
+ let off = |edges: Vec<[f64; 3]>| {
+ let mut s = knife_edge_part();
+ let before = planned(&s);
+ run(&mut s, "solid.fillet", json!({"edges": edges, "radius": 2}));
+ before - planned(&s)
+ };
+ let edges = [long, arc, upright];
+ let alone = edges.map(|e| off(vec![e]));
+ for (which, both) in together {
+ let want = which.iter().map(|i| alone[*i] - corner[*i]).sum::<f64>() + both;
+ let got = off(which.iter().map(|i| edges[*i]).collect());
+ assert!((got - want).abs() < 0.03, "{which:?}: removed {got} vs {want}");
+ }
+}
+
+/// The long top front edge rounded, then the small front-left upright as a fillet of its own
+/// (as in the app): the new round ends in the earlier one, taking off what both take together.
+#[test]
+fn fillet_the_long_edge_then_the_small_left_edge() {
+ let mut s = knife_edge_part();
+ let before = planned(&s);
+ run(&mut s, "solid.fillet", json!({"edges": [[20.0, -21.0, 10.0]], "radius": 2}));
+ run(&mut s, "solid.fillet", json!({"edges": [[0.0, -21.0, 5.0]], "radius": 2}));
+ let one_by_one = before - planned(&s);
+ let mut s = knife_edge_part();
+ run(&mut s, "solid.fillet", json!({"edges": [[20.0, -21.0, 10.0], [0.0, -21.0, 5.0]], "radius": 2}));
+ let together = before - planned(&s);
+ // Within the display meshes' accuracy (the two are built of different faces).
+ assert!(rel(one_by_one, together) < 2e-4, "one by one {one_by_one} vs together {together}");
+}
+
+/// The long top front edge and the front-left vertical edge rounded together (r 2): the long
+/// round ends at the arc wall, the two meet at the top-left corner (the top-left edge sharp).
+/// Each removes its own round (the long one cut off by the wall), less what both would take at
+/// the corner: in its 2 mm cube, what lies outside both quarter circles, ∫ (2 − √(4 − t²))² dt
+/// over 0..2 = 16 − 8/3 − 4π.
+#[test]
+fn fillet_two_edges_meeting_at_a_corner_one_running_into_the_arc_wall() {
+ let mut s = knife_edge_part();
+ let before = planned(&s);
+ run(&mut s, "solid.fillet", json!({"edges": [[20.0, -21.0, 10.0], [0.0, -21.0, 5.0]], "radius": 2}));
+ let long = round_along(|rho| 62.166666666666664 - (441.0 - (rho - 21.0) * (rho - 21.0)).sqrt());
+ let upright = (1.0 - std::f64::consts::FRAC_PI_4) * 4.0 * 10.0;
+ let removed = long + upright - (16.0 - 8.0 / 3.0 - 4.0 * std::f64::consts::PI);
+ let after = planned(&s);
+ assert!(rel(before - after, removed) < 1e-3, "removed {} vs {removed}", before - after);
+}
diff --git a/crates/engine/src/tests/robustness.rs b/crates/engine/src/tests/robustness.rs
index 1faf6af877..48a06a6bb3 100644
--- a/crates/engine/src/tests/robustness.rs
+++ b/crates/engine/src/tests/robustness.rs
@@ -559,3 +559,18 @@ fn a_boundary_found_across_a_seam_is_not_used() {
let r = fuzz::run(20, 8);
assert_eq!(r.outcome.kind, "ok", "seed 20: {:?}\n{}", r.outcome, r.script());
}
+
+/// Seed 33 ends in a fillet on its second body (#854's corner blends build it differently from
+/// before). Its display plan and its measured volume agree for every body (on main before #854,
+/// that body read 4439.42 through the display plan and 4443.51 measured).
+#[test]
+fn seed_33_display_plan_and_measure_agree() {
+ let r = fuzz::run(33, 8);
+ assert_eq!(r.outcome.kind, "ok", "seed 33: {:?}\n{}", r.outcome, r.script());
+ let s = script(r.script());
+ for b in &s.model.state().bodies {
+ let planned = b.body.display_plan(2e-4).unwrap().evaluate().measure().volume;
+ let measured = solidcraft_kernel::measure(&b.body).unwrap().volume;
+ assert!((planned - measured).abs() < 2e-5 * measured, "{}: planned {planned}, measured {measured}", b.name);
+ }
+}
diff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rs
index c7dd9de657..51cfc95085 100644
--- a/crates/kernel/src/blend.rs
+++ b/crates/kernel/src/blend.rs
@@ -495,6 +495,18 @@ fn blend_geometry(
return Err(unsupported("G2 fillets require straight edges around each planar end face"));
}
let g = faces.get(ga).ok_or_else(|| KernelError::Failed("face".into()))?;
+ // An end face running on smoothly from a side, an earlier round of this radius (its
+ // end an arc of it): the blend ends in that round, which takes a corner of its own
+ // (`curveblend::corner_blend`), the same as rounding both together.
+ let normal = |f: &mt::Face| crate::curveblend::project(f, p, None).map(|x| x.1);
+ let of_radius = |e: &mt::Edge| crate::curveblend::circle_of(e, r * 1e-4).is_some_and(|c| (c.1 - r).abs() <= r * 1e-4);
+ if let Some(ng) = normal(g)
+ && [i1, i2].iter().filter_map(|i| faces.get(*i)).filter_map(|f| normal(f)).any(|ns| ns.dot(ng) > 1.0 - 1e-6)
+ && shape == Shape::Round
+ && (of_radius(&e1) || of_radius(&e2))
+ {
+ return Err(unsupported("a blend ending in an earlier round"));
+ }
let surf = g.surface();
let surf_b = faces.get(gb).ok_or_else(|| KernelError::Failed("face".into()))?.surface();
let on_tol = (size * 1e-5).max(1e-6);
@@ -1134,8 +1146,14 @@ fn orders<T: Clone>(items: &[T]) -> Vec<Vec<T>> {
/// boundary leaves its surface (a blend that ran on past the end of a round's surface, which a
/// round of a curved edge does not have) another order that has none is preferred.
fn blend(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str) -> Result<Body> {
+ blend_with(body, edges, r, shape, what, false)
+}
+
+/// [`blend`]; `curved_ends`: also roll a ball along a straight edge between planes that ends at
+/// a curved face (the last resort, after the corner build for an earlier round there).
+fn blend_with(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str, curved_ends: bool) -> Result<Body> {
let sound = |b: &Body| crate::tess::boundaries_on_surfaces(&b.solid, (b.size() * 1e-4).max(1e-6));
- let first = blend_in_order(body, edges, r, shape, what);
+ let first = blend_in_order(body, edges, r, shape, what, curved_ends);
let reorder = (2..=MAX_REORDERED).contains(&edges.len())
&& match &first {
Ok(b) => !sound(b),
@@ -1147,7 +1165,7 @@ fn blend(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str) -> Resul
}
let mut fallback: Option<Body> = None;
for order in orders(edges).into_iter().skip(1) {
- if let Ok(done) = blend_in_order(body, &order, r, shape, what) {
+ if let Ok(done) = blend_in_order(body, &order, r, shape, what, curved_ends) {
if sound(&done) {
return Ok(done);
}
@@ -1164,7 +1182,7 @@ fn blend(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str) -> Resul
}
}
-fn blend_in_order(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str) -> Result<Body> {
+fn blend_in_order(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str, curved_ends: bool) -> Result<Body> {
if !(r.is_finite() && r > 1e-6 && r < 1e6) {
return Err(KernelError::Invalid(format!("{what} size must be positive")));
}
@@ -1178,6 +1196,16 @@ fn blend_in_order(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str)
let counts = record::counts(&[body]);
// Coplanar neighbours as one face (as after a join), so corners look as they should.
let mut cur = crate::boolean_record::healed(body)?;
+ // The last resort only for edges it treats otherwise: else it repeats the refusal.
+ if curved_ends {
+ let solid = cur.deep_copy();
+ let ids = edge_ids(&cur, &solid, edges)?;
+ let other =
+ Body::unique_edges(&solid).iter().any(|e| ids.contains(&e.id()) && !curved_case(&solid, e, false) && curved_case(&solid, e, true));
+ if !other {
+ return Err(unsupported("no edge ending at a curved face"));
+ }
+ }
// Every edge of a convex planar body: rounded as a whole (sphere corners).
if shape == Shape::Round && edges.len() >= 6 {
let solid = cur.deep_copy();
@@ -1207,8 +1235,8 @@ fn blend_in_order(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str)
{
let _ = groups;
let loop_pts: Vec<Vec3> = edges.iter().filter(|p| !rest.iter().any(|q| q.dist(**p) < 1e-12)).copied().collect();
- cur = record::after(blend_in_order(&cur, &rest, r, shape, what)?, &cur, &counts);
- return Ok(record::after(blend_in_order(&cur, &loop_pts, r, shape, what)?, &cur, &counts));
+ cur = record::after(blend_in_order(&cur, &rest, r, shape, what, curved_ends)?, &cur, &counts);
+ return Ok(record::after(blend_in_order(&cur, &loop_pts, r, shape, what, curved_ends)?, &cur, &counts));
}
// A loop the loop blend refuses for its shape (seams that aren't straight, walls it can't
// trim) is blended edge by edge below instead: a ball rolls along its smooth chain.
@@ -1236,11 +1264,11 @@ fn blend_in_order(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str)
Err(_) => {}
}
}
- blend_each(cur, edges, r, shape, what, &counts)
+ blend_each(cur, edges, r, shape, what, &counts, curved_ends)
}
/// The edges blended one at a time (see [`blend`]), `cur` being the healed body.
-fn blend_each(mut cur: Body, edges: &[Vec3], r: f64, shape: Shape, what: &str, counts: &[(usize, usize)]) -> Result<Body> {
+fn blend_each(mut cur: Body, edges: &[Vec3], r: f64, shape: Shape, what: &str, counts: &[(usize, usize)], curved_ends: bool) -> Result<Body> {
let counts = counts.to_vec();
// One at a time, in whatever order works: a run along a planar face's loop (bridging arcs
// that earlier blends left between selected edges, so corners round off), a single edge,
@@ -1251,6 +1279,30 @@ fn blend_each(mut cur: Body, edges: &[Vec3], r: f64, shape: Shape, what: &str, c
// refused away from every later blend would be refused the same way again: it is not tried
// again (a refusal costs a rolling-ball attempt, seconds each on a long curved edge).
let mut refused: Vec<(Vec3, (Vec3, Vec3), KernelError)> = Vec::new();
+ // A chain runs on along the edges smooth with a selected one in the body as given, not along
+ // a round this blend has made meanwhile (which would take in edges nobody selected, or not,
+ // by the order the edges come in).
+ let along: Vec<mt::Edge> = {
+ let solid = cur.deep_copy();
+ let all = Body::unique_edges(&solid);
+ let tol = (cur.size() * 2e-3).max(1e-3);
+ let mut list: Vec<mt::Edge> = Vec::new();
+ for p in edges {
+ if let Some((idx, _)) = cur.nearest_edge(*p, tol)?
+ && let Some(e) = all.get(idx)
+ {
+ let ids = smooth_chain(&solid, e).unwrap_or_else(|| vec![e.id()]);
+ for x in all.iter().filter(|x| ids.contains(&x.id())) {
+ if !list.iter().any(|y| y.id() == x.id()) {
+ list.push(x.clone());
+ }
+ }
+ }
+ }
+ list
+ };
+ let near_chain = (cur.size() * 1e-6).max(1e-7);
+ let on_chains = |e: &mt::Edge| lies_on(e, &along, near_chain);
for _ in 0..(2 * edges.len() + 4) {
if todo.is_empty() {
return Ok(cur);
@@ -1315,11 +1367,23 @@ fn blend_each(mut cur: Body, edges: &[Vec3], r: f64, shape: Shape, what: &str, c
};
// A straight edge running on smoothly into curved ones (a flange into its bend, a
// side into a rounded corner): the blend follows the whole smooth chain, as the
- // rolling ball would.
- let chain = smooth_chain(&solid, &edge);
- let runs_on = !curved_case(&solid, &edge)
+ // rolling ball would. A fillet doesn't run on into an earlier round's arc of its
+ // radius: it ends in that round (as if both were rounded together).
+ let chain = smooth_chain_within(&solid, &edge, &on_chains);
+ let into_round = |ids: &[mt::EdgeID]| {
+ Body::unique_edges(&solid).iter().any(|x| {
+ ids.contains(&x.id())
+ && x.id() != edge.id()
+ && [edge.front(), edge.back()].iter().any(|v| x.front() == *v || x.back() == *v)
+ && crate::curveblend::circle_of(x, size * 1e-6).is_some_and(|c| (c.1 - r).abs() <= r * 1e-4)
+ })
+ };
+ let own = edge.id();
+ let runs_on = !curved_case(&solid, &edge, false)
&& chain.as_ref().is_some_and(|ids| {
- ids.len() > 1 && Body::unique_edges(&solid).iter().any(|x| ids.contains(&x.id()) && !matches!(x.curve(), mt::Curve::Line(_)))
+ ids.len() > 1
+ && Body::unique_edges(&solid).iter().any(|x| ids.contains(&x.id()) && !matches!(x.curve(), mt::Curve::Line(_)))
+ && !(shape == Shape::Round && into_round(ids))
});
let local = || guard(what, || blend_one(&solid, &edge, size, r, shape));
let attempt = match chain.as_deref().filter(|_| runs_on).map(roll) {
@@ -1333,16 +1397,24 @@ fn blend_each(mut cur: Body, edges: &[Vec3], r: f64, shape: Shape, what: &str, c
None => match local() {
Ok(o) => Ok((o, vec![j])),
// A curved edge, or one between curved faces: roll a ball along its smooth chain.
- Err(e) if !curved_case(&solid, &edge) => Err(e),
+ Err(e) if !curved_case(&solid, &edge, curved_ends) => Err(e),
Err(e) => match chain.as_deref() {
// The chain that cannot be rolled (it runs on into the edge an earlier round
- // left where it met another face): the edge alone, ending on that round.
- Some(ids) => roll(ids)
- .or_else(|first| if ids.len() > 1 { roll(&[edge.id()]).map_err(|_| first) } else { Err(first) })
- .map_err(|e2| match e2 {
- KernelError::TooLarge(m) => KernelError::TooLarge(format!("{m} ({e})")),
- e2 => KernelError::Failed(format!("{e2} ({e})")),
- }),
+ // left where it met another face): the edge alone, ending on that round. A
+ // straight edge into an earlier round of this radius: on its own.
+ Some(ids) => {
+ let ids = if shape == Shape::Round && !curved_case(&solid, &edge, false) && into_round(ids) {
+ std::slice::from_ref(&own)
+ } else {
+ ids
+ };
+ roll(ids).or_else(|first| if ids.len() > 1 { roll(&[edge.id()]).map_err(|_| first) } else { Err(first) }).map_err(|e2| {
+ match e2 {
+ KernelError::TooLarge(m) => KernelError::TooLarge(format!("{m} ({e})")),
+ e2 => KernelError::Failed(format!("{e2} ({e})")),
+ }
+ })
+ }
None => Err(e),
},
},
@@ -1500,12 +1572,16 @@ fn run_on_loop(cur: &Body, solid: &Solid, pts: &[Vec3]) -> Result<Option<(Vec<mt
Ok(best)
}
-/// Is the edge curved, or does it lie between faces that aren't both planar?
-fn curved_case(solid: &Solid, edge: &mt::Edge) -> bool {
+/// Is the edge curved, or does it lie between faces that aren't both planar (or, with
+/// `curved_ends`, end at one)?
+fn curved_case(solid: &Solid, edge: &mt::Edge, curved_ends: bool) -> bool {
if !matches!(edge.curve(), mt::Curve::Line(_)) {
return true;
}
- solid.face_iter().filter(|f| f.edge_iter().any(|e| e.id() == edge.id())).any(|f| !matches!(f.oriented_surface(), mt::Surface::Plane(_)))
+ // Between curved faces, or (when asked) ending at one: a straight edge running into a wall.
+ let curved = |f: &mt::Face| !matches!(f.oriented_surface(), mt::Surface::Plane(_));
+ solid.face_iter().filter(|f| f.edge_iter().any(|e| e.id() == edge.id())).any(curved)
+ || (curved_ends && solid.face_iter().filter(|f| f.vertex_iter().any(|v| v == *edge.front() || v == *edge.back())).any(curved))
}
/// Whether the two faces of `edge` meet tangentially along it (sampled at a quarter, the
@@ -1531,6 +1607,32 @@ fn tangent_faces(solid: &Solid, edge: &mt::Edge) -> bool {
/// The chain of edges continuing `edge` smoothly at its ends (its ids): closed, or open where
/// the next edge turns sharply.
fn smooth_chain(solid: &Solid, edge: &mt::Edge) -> Option<Vec<mt::EdgeID>> {
+ smooth_chain_within(solid, edge, &|_| true)
+}
+
+/// Whether edge `e` runs along one of `along` (is a piece of it): points through it lie on one.
+fn lies_on(e: &mt::Edge, along: &[mt::Edge], tol: f64) -> bool {
+ use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};
+ if along.iter().any(|a| a.id() == e.id()) {
+ return true;
+ }
+ let c = e.curve();
+ let (t0, t1) = c.range_tuple();
+ [0.25, 0.5, 0.75].iter().all(|f| {
+ let p = c.subs(t0 + (t1 - t0) * f);
+ along.iter().any(|a| {
+ let ac = a.curve();
+ let (a0, a1) = ac.range_tuple();
+ let d = |t: f64| crate::body::from_p3(ac.subs(t)).dist(crate::body::from_p3(p));
+ let Some(hint) = (0..=16).map(|i| a0 + (a1 - a0) * i as f64 / 16.0).min_by(|x, y| d(*x).total_cmp(&d(*y))) else { return false };
+ let t = ac.search_nearest_parameter(p, hint, 50).unwrap_or(hint).clamp(a0, a1);
+ d(t).min(d(hint)) <= tol
+ })
+ })
+}
+
+/// [`smooth_chain`], walking on only over edges `keep` allows.
+fn smooth_chain_within(solid: &Solid, edge: &mt::Edge, keep: &dyn Fn(&mt::Edge) -> bool) -> Option<Vec<mt::EdgeID>> {
use mt::{BoundedCurve, ParametricCurve};
let all = Body::unique_edges(solid);
// Along the edge as it runs from its front to its back (an edge may run against its curve).
@@ -1550,7 +1652,7 @@ fn smooth_chain(solid: &Solid, edge: &mt::Edge) -> Option<Vec<mt::EdgeID>> {
let next = all.iter().filter(|e| !ids.contains(&e.id()) && (*e.front() == v || *e.back() == v)).find_map(|e| {
let fwd = *e.front() == v;
let t = if fwd { dir(e, false)? } else { -dir(e, true)? };
- (t.dot(d) > 1.0 - 1e-4 && !smooth_seam(solid, e)).then(|| (e.clone(), fwd))
+ (t.dot(d) > 1.0 - 1e-4 && !smooth_seam(solid, e) && keep(e)).then(|| (e.clone(), fwd))
});
let Some((e, fwd)) = next else { return Some(false) };
ids.push(e.id());
@@ -1713,21 +1815,52 @@ fn closed(b: Body) -> Result<Body> {
pub fn fillet(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {
body.require_brep("fillet")?;
// Corners the local blends refuse (an earlier round at an edge's end): radius per edge.
- blend(body, edges, radius, Shape::Round, "fillet").and_then(closed).or_else(|e| {
- let sel: Vec<(Vec3, f64)> = edges.iter().map(|p| (*p, radius)).collect();
- // The local blend's refusal, unless only the corner build found the radius too large.
- crate::blend_corner::fillet_radii(body, &sel)
- .and_then(closed)
- .map_err(|e2| match (&e, e2) {
- (KernelError::TooLarge(_), _) => e,
- (_, e2 @ KernelError::TooLarge(_)) => e2,
- _ => e,
- })
- // Three edges at a vertex of any faces end in a sphere.
- .or_else(|e| {
- if edges.len() >= 3 { crate::blend_vertex::fillet_ball_vertices(body, edges, radius).and_then(closed).map_err(|_| e) } else { Err(e) }
- })
- })
+ blend(body, edges, radius, Shape::Round, "fillet")
+ .and_then(closed)
+ .or_else(|e| {
+ let sel: Vec<(Vec3, f64)> = edges.iter().map(|p| (*p, radius)).collect();
+ // The local blend's refusal, unless only the corner build found the radius too large.
+ crate::blend_corner::fillet_radii(body, &sel)
+ .and_then(closed)
+ .map_err(|e2| keep_size(e, e2))
+ // Three edges at a vertex of any faces end in a sphere.
+ .or_else(|e| {
+ if edges.len() >= 3 {
+ crate::blend_vertex::fillet_ball_vertices(body, edges, radius).and_then(closed).map_err(|_| e)
+ } else {
+ Err(e)
+ }
+ })
+ })
+ // Straight edges ending at a curved face that isn't an earlier round's: a rolling ball
+ // trimmed by the face. Refused, the refusal above stands.
+ .or_else(|e| blend_with(body, edges, radius, Shape::Round, "fillet", true).and_then(closed).map_err(|_| e))
+ // Blends meeting at corners on curved faces: all at once.
+ .or_else(|e| corners(body, edges, radius, Shape::Round, "fillet").and_then(closed).map_err(|e2| keep_size(e, e2)))
+}
+
+/// The first refusal, unless only the second found the blend too large (a smaller one may fit).
+fn keep_size(e: KernelError, e2: KernelError) -> KernelError {
+ match (&e, e2) {
+ (KernelError::TooLarge(_), _) => e,
+ (_, e2 @ KernelError::TooLarge(_)) => e2,
+ _ => e,
+ }
+}
+
+/// Blend the edges together, rebuilding the corners where they meet on faces of any surface
+/// (see [`crate::curveblend::corner_blend`]).
+fn corners(body: &Body, edges: &[Vec3], r: f64, shape: Shape, what: &str) -> Result<Body> {
+ let counts = record::counts(&[body]);
+ let cur = crate::boolean_record::healed(body)?;
+ let size = cur.size();
+ let solid = cur.deep_copy();
+ let ids = edge_ids(&cur, &solid, edges)?;
+ if ids.len() != edges.len() {
+ return Err(KernelError::Invalid("no edge near a selected point".into()));
+ }
+ let (made, rec) = guard(what, || crate::curveblend::corner_blend(&solid, &ids, size, r, shape == Shape::Round))?;
+ Ok(record::after(record::rebuilt(made, &[&solid], &rec)?, &cur, &counts))
}
/// The step of the radius search: three significant digits of the requested radius.
@@ -1925,7 +2058,7 @@ pub fn chamfer(body: &Body, edges: &[Vec3], distance: f64) -> Result<Body> {
return Ok(result);
}
// Coplanar neighbours as one face (as after a join), so corners look as they should.
- let mut cur = crate::boolean_record::healed(body)?;
+ let cur = crate::boolean_record::healed(body)?;
if let Some(groups) = loop_groups(&cur, edges)? {
let whole = || -> Result<Body> {
let mut lc = cur.clone();
@@ -1951,14 +2084,22 @@ pub fn chamfer(body: &Body, edges: &[Vec3], distance: f64) -> Result<Body> {
Err(_) => {}
}
}
- for p in edges {
- let step = match chamfer_tool(&cur, *p, distance, 0).and_then(|t| cut_one(&cur, &t)) {
- Ok(Some(b)) => b,
- _ => blend(&cur, std::slice::from_ref(p), distance, Shape::Flat, "chamfer")?,
- };
- cur = record::after(step, &cur, &counts);
- }
- Ok(cur)
+ let start = cur.clone();
+ let one_by_one = || -> Result<Body> {
+ let mut cur = start.clone();
+ for p in edges {
+ let step = match chamfer_tool(&cur, *p, distance, 0).and_then(|t| cut_one(&cur, &t)) {
+ Ok(Some(b)) => b,
+ // A chain running on into curved faces, or an edge ending at one: as for fillets.
+ _ => blend(&cur, std::slice::from_ref(p), distance, Shape::Flat, "chamfer")
+ .or_else(|e| blend_with(&cur, std::slice::from_ref(p), distance, Shape::Flat, "chamfer", true).map_err(|_| e))?,
+ };
+ cur = record::after(step, &cur, &counts);
+ }
+ Ok(cur)
+ };
+ // Chamfers meeting at corners on curved faces: all at once.
+ one_by_one().or_else(|e| corners(body, edges, distance, Shape::Flat, "chamfer").map_err(|e2| keep_size(e, e2)))
}
/// `cur` cut by one cutter, with its history over `[cur]` (`None`: nothing left).
diff --git a/crates/kernel/src/blend_corner.rs b/crates/kernel/src/blend_corner.rs
index 6a5945b59b..ea3cd7de3d 100644
--- a/crates/kernel/src/blend_corner.rs
+++ b/crates/kernel/src/blend_corner.rs
@@ -128,6 +128,150 @@ fn hit(v: Vec3, u: Vec3, t: Vec3, s: f64) -> Result<Vec3> {
Ok(v + u * (s / k))
}
+/// Unit direction in which a (curved) edge leaves its end vertex `v`.
+fn leaving(e: &mt::Edge, v: &mt::Vertex) -> Option<Vec3> {
+ use mt::{BoundedCurve, ParametricCurve};
+ let c = e.curve();
+ let (t0, t1) = c.range_tuple();
+ let at_front = e.absolute_front() == v;
+ let d = c.der(if at_front { t0 } else { t1 });
+ let d = Vec3::new(d.x, d.y, d.z);
+ (if at_front { d } else { d * -1.0 }).normalized()
+}
+
+/// Point where the contact line at setback `s` (in-face direction `t`) crosses a curved edge
+/// leaving `v`: the first along it from `v`.
+fn crossing(e: &mt::Edge, v: Vec3, t: Vec3, s: f64) -> Result<Vec3> {
+ use mt::{BoundedCurve, ParametricCurve};
+ let c = e.curve();
+ let (t0, t1) = c.range_tuple();
+ let from_front = crate::body::from_p3(e.absolute_front().point()).dist(v) <= crate::body::from_p3(e.absolute_back().point()).dist(v);
+ let at = |f: f64| crate::body::from_p3(c.subs(if from_front { t0 + (t1 - t0) * f } else { t1 - (t1 - t0) * f }));
+ let g = |f: f64| (at(f) - v).dot(t) - s;
+ let steps = 256;
+ let mut lo = 0.0;
+ for i in 1..=steps {
+ let hi = i as f64 / steps as f64;
+ if g(hi) >= 0.0 {
+ let (mut a, mut b) = (lo, hi);
+ for _ in 0..60 {
+ let m = (a + b) * 0.5;
+ if g(m) >= 0.0 {
+ b = m;
+ } else {
+ a = m;
+ }
+ }
+ return Ok(at((a + b) * 0.5));
+ }
+ lo = hi;
+ }
+ Err(too_large("a fillet larger than the faces next to it"))
+}
+
+/// The cylinder's (a chamfer's plane's) section by a curved end face `g`, from `a` (on the
+/// contact line with in-face direction `ta`) to `b` (`tb`) round the edge's end `v` (its other
+/// end `far`): points of the blend's cross-sections on the face, interpolated; within tolerance
+/// of both.
+#[allow(clippy::too_many_arguments)]
+fn curved_section(
+ sel: &Sel,
+ g: &mt::Face,
+ (a, ta): (Vec3, Vec3),
+ (b, tb): (Vec3, Vec3),
+ v: Vec3,
+ far: Vec3,
+ round: bool,
+ size: f64,
+) -> Result<mt::Curve> {
+ use mt::ParametricCurve;
+ let tolerance = (size * 1e-5).clamp(1e-5, 0.001);
+ let fail = || too_large("a fillet larger than the faces next to it");
+ // Position along the edge, and the cross-section there (fraction 0 on `ta`'s side).
+ let along = |x: Vec3| (x - sel.p0).dot(sel.d);
+ let point = |f: f64, l: f64| -> Vec3 {
+ let apex = sel.p0 + sel.d * l;
+ let (pa, pb) = (apex + ta * sel.s, apex + tb * sel.s);
+ if round { crate::body::from_p3(conic(pa, apex, pb, sel.w).subs(f)) } else { pa + (pb - pa) * f }
+ };
+ // The face's surface, each search started from the last one's answer (the points come in
+ // small steps).
+ let surface = g.oriented_surface();
+ let last = std::cell::Cell::new(None::<(f64, f64)>);
+ let side = |x: Vec3| -> f64 {
+ use mt::{ParametricSurface, ParametricSurface3D, SearchNearestParameter};
+ let found = last
+ .get()
+ .and_then(|hint| surface.search_nearest_parameter(p3(x), Some(hint), 20))
+ .or_else(|| surface.search_nearest_parameter(p3(x), None, 100));
+ found.map_or(f64::NAN, |(u, w)| {
+ last.set(Some((u, w)));
+ let n = surface.normal(u, w);
+ (x - crate::body::from_p3(surface.subs(u, w))).dot(Vec3::new(n.x, n.y, n.z))
+ })
+ };
+ let (la, lb) = (along(a), along(b));
+ // Out of the material: toward the edge's end.
+ let outward = if along(v) >= along(far) { 1.0 } else { -1.0 };
+ let step = ((lb - la).abs().max(sel.s * 0.05)) / 16.0;
+ let root = |f: f64| -> Option<f64> {
+ let guess = la + (lb - la) * f;
+ let gv = side(point(f, guess));
+ if !gv.is_finite() {
+ return None;
+ }
+ let dir = if gv < 0.0 { outward } else { -outward };
+ let mut prev = (guess, gv);
+ for i in 1..=4096 {
+ let l = guess + dir * step * i as f64;
+ let cur = (l, side(point(f, l)));
+ if !cur.1.is_finite() {
+ return None;
+ }
+ if (prev.1 < 0.0) != (cur.1 < 0.0) {
+ let (mut x, mut y) = (prev, cur);
+ for _ in 0..60 {
+ let m = (x.0 + y.0) * 0.5;
+ let gm = side(point(f, m));
+ if (gm < 0.0) == (x.1 < 0.0) {
+ x = (m, gm);
+ } else {
+ y = (m, gm);
+ }
+ }
+ return Some((x.0 + y.0) * 0.5);
+ }
+ prev = cur;
+ }
+ None
+ };
+ // Closer together toward the ends, where the face may only touch the blend.
+ let across = |t: f64| (1.0 - (std::f64::consts::PI * t).cos()) * 0.5;
+ let mut m = 8;
+ loop {
+ let mut pts = vec![a];
+ for i in 1..m {
+ let f = across(i as f64 / m as f64);
+ pts.push(point(f, root(f).ok_or_else(fail)?));
+ }
+ pts.push(b);
+ let curve = crate::build::interpolate_cubic(&pts).ok_or_else(|| KernelError::Failed("fillet: end curve".into()))?;
+ let accurate = (0..m).all(|i| {
+ let t = (i as f64 + 0.5) / m as f64;
+ let f = across(t);
+ let x = crate::body::from_p3(curve.subs(t));
+ root(f).is_some_and(|l| point(f, l).dist(x) <= tolerance) && side(x).abs() <= tolerance
+ });
+ if accurate {
+ return Ok(mt::Curve::BSplineCurve(curve));
+ }
+ if m >= 128 {
+ return Err(KernelError::Failed("fillet: could not fit the blend's end in a curved face".into()));
+ }
+ m *= 2;
+ }
+}
+
/// Point in a face where the contact lines of two edges from `v` (directions `u1`, `u2`, in-face
/// directions `t1`, `t2`, setbacks `s1`, `s2`) cross.
fn meet(v: Vec3, (u1, t1, s1): (Vec3, Vec3, f64), (u2, t2, s2): (Vec3, Vec3, f64)) -> Result<Vec3> {
@@ -292,18 +436,26 @@ fn build(cur: &Body, sel_pts: &[(Vec3, f64)], round: bool) -> Result<Body> {
if eids.len() != 3 || fids.len() != 3 {
return Err(unsupported("fillets ending where more than three edges meet"));
}
- if fids.iter().any(|f| normal(*f).is_none()) {
+ // Where one fillet ends, the face it ends on may be curved (and the edges it shares
+ // with the others): the blend ends in that face's section of the cylinder.
+ let chosen = eids.iter().filter(|id| sels.contains_key(id)).count();
+ let sides: Vec<usize> = eids.iter().filter_map(|id| sels.get(id)).flat_map(|s| [s.fa, s.fb]).collect();
+ if fids.iter().any(|f| normal(*f).is_none() && (chosen != 1 || sides.contains(f))) {
return Err(unsupported("fillets ending on curved faces"));
}
let pv = vtx(v);
let mut list = Vec::new();
for id in eids {
let e = edges.get(id).ok_or_else(|| KernelError::Failed("edge".into()))?;
- if !matches!(e.curve(), mt::Curve::Line(_)) {
+ let u = if matches!(e.curve(), mt::Curve::Line(_)) {
+ let other = if e.absolute_front() == v { e.absolute_back() } else { e.absolute_front() };
+ (vtx(other) - pv).normalized()
+ } else if chosen == 1 && !sels.contains_key(id) {
+ leaving(e, v)
+ } else {
return Err(unsupported("fillets ending next to curved edges"));
}
- let other = if e.absolute_front() == v { e.absolute_back() } else { e.absolute_front() };
- let u = (vtx(other) - pv).normalized().ok_or_else(|| KernelError::Failed("zero-length edge".into()))?;
+ .ok_or_else(|| KernelError::Failed("zero-length edge".into()))?;
list.push((*id, u));
}
around.insert(*vid, Around { edges: list });
@@ -345,14 +497,29 @@ fn build(cur: &Body, sel_pts: &[(Vec3, f64)], round: bool) -> Result<Body> {
let s1 = sel(*e1)?;
let (f12, f31) = (face_with(*e1, *e2)?, face_with(*e1, *e3)?);
let f23 = face_with(*e2, *e3)?;
- let p2 = hit(*u2, s1.t(f12), s1.s, f12)?;
- let p3_ = hit(*u3, s1.t(f31), s1.s, f31)?;
+ // Along a curved neighbouring edge: where it crosses the contact line.
+ let reach = |e: mt::EdgeID, u: Vec3, f: usize| -> Result<Vec3> {
+ match edges.get(&e) {
+ Some(x) if !matches!(x.curve(), mt::Curve::Line(_)) => crossing(x, v, s1.t(f), s1.s),
+ _ => hit(u, s1.t(f), s1.s, f),
+ }
+ };
+ let p2 = reach(*e2, *u2, f12)?;
+ let p3_ = reach(*e3, *u3, f31)?;
let (a, b) = (builder::vertex(p3(p2)), builder::vertex(p3(p3_)));
endpt.insert((*e2, *vid, None), a.clone());
endpt.insert((*e1, *vid, Some(f12)), a.clone());
endpt.insert((*e3, *vid, None), b.clone());
endpt.insert((*e1, *vid, Some(f31)), b.clone());
- let c = if round { edge(&a, &b, mt::Curve::NurbsCurve(conic(p2, v, p3_, s1.w)))? } else { builder::line(&a, &b) };
+ let c = match faces.get(f23) {
+ Some(g) if normal(f23).is_none() => {
+ let e1v = edges.get(e1).ok_or_else(|| KernelError::Failed("edge".into()))?;
+ let far = if e1v.absolute_front().id() == *vid { vtx(e1v.absolute_back()) } else { vtx(e1v.absolute_front()) };
+ edge(&a, &b, curved_section(s1, g, (p2, s1.t(f12)), (p3_, s1.t(f31)), v, far, round, size)?)?
+ }
+ _ if round => edge(&a, &b, mt::Curve::NurbsCurve(conic(p2, v, p3_, s1.w)))?,
+ _ => builder::line(&a, &b),
+ };
list.push((c, vec![Owner::Face(f23), Owner::Cyl(*e1)]));
}
([(ea, ua), (eb, ub)], [(e3, u3)]) => {
@@ -467,7 +634,13 @@ fn build(cur: &Body, sel_pts: &[(Vec3, f64)], round: bool) -> Result<Body> {
if (pb - pa).dot(orig) <= size * 1e-9 * orig.len() {
return Err(too_large("a fillet larger than the faces next to it"));
}
- let x = builder::line(&a, &b);
+ let x = if matches!(e.curve(), mt::Curve::Line(_)) {
+ builder::line(&a, &b)
+ } else {
+ // A curved edge next to a fillet's end, shortened along its own curve.
+ let moved = |n: &mt::Vertex, o: &mt::Vertex| (n != o).then(|| n.clone());
+ crate::curveblend::trim_curved_seam(&e.absolute_clone(), moved(&a, e.absolute_front()), moved(&b, e.absolute_back()), size)?
+ };
lines.insert((e.id(), f), x.clone());
Ok(x)
};
diff --git a/crates/kernel/src/build.rs b/crates/kernel/src/build.rs
index 77d6a85929..acb2175ea3 100644
--- a/crates/kernel/src/build.rs
+++ b/crates/kernel/src/build.rs
@@ -1332,10 +1332,34 @@ fn cubic_basis(knots: &[f64], n_ctrl: usize, u: f64) -> Vec<f64> {
/// Cubic B-spline through points at uniform parameters (clamped, knots by averaging).
pub(crate) fn interpolate_cubic(pts: &[Vec3]) -> Option<mt::BSplineCurve<mt::Point3>> {
let m = pts.len();
- if m < 4 {
+ let u: Vec<f64> = (0..m).map(|i| i as f64 / (m.max(2) - 1) as f64).collect();
+ interpolate_cubic_at(pts, &u)
+}
+
+/// [`interpolate_cubic`] by chord length: the parameters (0 to 1) in proportion to the distance
+/// along the points. Points closer together toward an end (where a curve leaves another
+/// tangentially) then don't slow the curve to a stop there, where a uniform parameter lets it
+/// double back on itself.
+pub(crate) fn interpolate_cubic_chordal(pts: &[Vec3]) -> Option<(mt::BSplineCurve<mt::Point3>, Vec<f64>)> {
+ let mut u = vec![0.0];
+ for w in pts.windows(2) {
+ let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return None };
+ u.push(u.last().copied().unwrap_or(0.0) + a.dist(*b));
+ }
+ let total = u.last().copied().filter(|t| t.is_finite() && *t > 0.0)?;
+ let u: Vec<f64> = u.iter().map(|x| x / total).collect();
+ if u.windows(2).any(|w| w.first() >= w.get(1)) {
+ return None;
+ }
+ interpolate_cubic_at(pts, &u).map(|c| (c, u))
+}
+
+/// The cubic B-spline through `pts` at parameters `u` (rising from 0 to 1), its knots averaged.
+fn interpolate_cubic_at(pts: &[Vec3], u: &[f64]) -> Option<mt::BSplineCurve<mt::Point3>> {
+ let m = pts.len();
+ if m < 4 || u.len() != m {
return None;
}
- let u: Vec<f64> = (0..m).map(|i| i as f64 / (m - 1) as f64).collect();
let mut knots = vec![0.0; 4];
for j in 1..(m - 3) {
knots.push((j..j + 3).filter_map(|i| u.get(i)).sum::<f64>() / 3.0);
diff --git a/crates/kernel/src/curveblend.rs b/crates/kernel/src/curveblend.rs
index 7d7bd27e3e..0ede742de4 100644
--- a/crates/kernel/src/curveblend.rs
+++ b/crates/kernel/src/curveblend.rs
@@ -459,6 +459,24 @@ fn solve(
cusp: f64,
extra: Option<(usize, Vec3, Vec3)>,
tol: f64,
+) -> Option<Section> {
+ solve_from(f1, f2, p, t, r, sigma, cusp, extra, tol, None)
+}
+
+/// [`solve`], started from the centre `start` when given (the corner builder's balls at a knife
+/// edge start beside the last one).
+#[allow(clippy::too_many_arguments)]
+fn solve_from(
+ f1: &[&mt::Face],
+ f2: &[&mt::Face],
+ p: Vec3,
+ t: Vec3,
+ r: f64,
+ sigma: f64,
+ cusp: f64,
+ extra: Option<(usize, Vec3, Vec3)>,
+ tol: f64,
+ start: Option<Vec3>,
) -> Option<Section> {
// The nearest face of a side (several faces on one smooth surface group). Each face's
// search starts from its last answer: the centre moves little between iterations. An
@@ -484,7 +502,9 @@ fn solve(
let (q2, n2) = near(f2, p)?;
let _ = (q1, q2);
let den = 1.0 + n1.dot(n2);
- let mut c = if cusp != 0.0 && den.abs() < KNIFE {
+ let mut c = if let Some(c) = start {
+ c
+ } else if cusp != 0.0 && den.abs() < KNIFE {
// The normals are (nearly) opposite: `(n1 + n2) / den` has no direction. The centre is r
// inside face 1 and slides along it, away from the edge, until it is r from face 2 too.
let w = n1.cross(t).normalized()? * cusp;
@@ -552,6 +572,21 @@ fn solve(
None
}
+/// Whether the strip's curvature jumps where two runs of sections meet (each three sections from
+/// the joint outward, the joint's first): for the centres or either contact, the difference of
+/// the circles through them would move the middle section by more than a tenth of `tolerance`.
+fn bends(a: [&Section; 3], b: [&Section; 3], tolerance: f64) -> bool {
+ let curvature = |p: [Vec3; 3]| {
+ let (x, y, z) = (p[1] - p[0], p[2] - p[1], p[2] - p[0]);
+ let d = x.len() * y.len() * z.len();
+ if d > 1e-300 { 2.0 * x.cross(y).len() / d } else { 0.0 }
+ };
+ let h = a[0].c.dist(a[1].c);
+ [|s: &Section| s.c, |s: &Section| s.q1, |s: &Section| s.q2]
+ .iter()
+ .any(|f| (curvature(a.map(f)) - curvature(b.map(f))).abs() * h * h > tolerance * 0.1)
+}
+
/// Homogeneous control points of the circular (or straight) cross-section from q1 to q2.
fn section_controls(s: &Section, round: bool) -> Option<[mt::Vector4; 3]> {
let h = |p: Vec3, w: f64| mt::Vector4::new(p.x * w, p.y * w, p.z * w, w);
@@ -570,10 +605,168 @@ fn section_controls(s: &Section, round: bool) -> Option<[mt::Vector4; 3]> {
Some([h(s.q1, 1.0), h(m, half), h(s.q2, 1.0)])
}
+/// Where to start the ball at a knife edge through `p` (direction `t`, the sides running on from
+/// it along `into`): the first point along them, from the edge, where they are a diameter
+/// apart, midway.
+fn knife_start(o1: &[&mt::Face], o2: &[&mt::Face], p: Vec3, t: Vec3, into: Vec3, r: f64) -> Option<Vec3> {
+ let w = (into - t * into.dot(t)).normalized()?;
+ (1..=256).find_map(|k| {
+ let x = p + w * (r * k as f64 / 8.0);
+ let a = o1.iter().filter_map(|f| project(f, x, None)).min_by(|a, b| a.0.dist(x).total_cmp(&b.0.dist(x)))?;
+ let b = o2.iter().filter_map(|f| project(f, x, None)).min_by(|a, b| a.0.dist(x).total_cmp(&b.0.dist(x)))?;
+ let c = (a.0 + b.0) * 0.5;
+ (a.0.dist(b.0) >= 2.0 * r).then(|| c - t * (c - p).dot(t))
+ })
+}
+
+/// Whether two faces meeting at no angle at `pm` (the first's outward normal `n1`, running on
+/// from the edge along `into`) hold the material between them: a little way in, the second is
+/// behind the first.
+fn knife_convex(f1: &mt::Face, f2: &mt::Face, pm: Vec3, into: Vec3, r: f64) -> Option<bool> {
+ let x = pm + into * r;
+ let (a, b) = (project(f1, x, None)?, project(f2, x, None)?);
+ Some((b.0 - a.0).dot(a.1) < 0.0)
+}
+
+/// The nearest point of a face's (oriented) surface to `x`, its outward normal and parameters;
+/// `last`: where the last search on it ended (the points asked about come in small steps).
+fn nearest_on(surface: &mt::Surface, last: &std::cell::Cell<Option<(f64, f64)>>, x: Vec3) -> Option<(Vec3, Vec3, (f64, f64))> {
+ use mt::{ParametricSurface, ParametricSurface3D, SearchNearestParameter};
+ // The nearest of the search from the last answer, a fresh one (the first time, also from
+ // a grid over the surface's parameters: a fresh search on a conic can settle on its far
+ // side) and either kept within the parameters (past them a conic runs on round).
+ let (ru, rv) = surface.try_range_tuple();
+ let ((u0, u1), (v0, v1)) = (ru.unwrap_or((f64::NEG_INFINITY, f64::INFINITY)), rv.unwrap_or((f64::NEG_INFINITY, f64::INFINITY)));
+ let inside = |uv: (f64, f64)| uv.0 >= u0 - 1e-9 && uv.0 <= u1 + 1e-9 && uv.1 >= v0 - 1e-9 && uv.1 <= v1 + 1e-9;
+ let warm = last.get().and_then(|hint| surface.search_nearest_parameter(p3(x), Some(hint), 20));
+ let mut found: Vec<(f64, f64)> = warm.into_iter().collect();
+ if !warm.is_some_and(inside) {
+ found.extend(surface.search_nearest_parameter(p3(x), None, 100));
+ }
+ if last.get().is_none() && [u0, u1, v0, v1].iter().all(|x| x.is_finite()) {
+ for i in 0..5 {
+ for j in 0..5 {
+ let hint = (u0 + (u1 - u0) * (i as f64 + 0.5) / 5.0, v0 + (v1 - v0) * (j as f64 + 0.5) / 5.0);
+ found.extend(surface.search_nearest_parameter(p3(x), Some(hint), 50));
+ }
+ }
+ }
+ let clamped: Vec<(f64, f64)> = found.iter().map(|(u, v)| (u.clamp(u0, u1), v.clamp(v0, v1))).collect();
+ found.extend(clamped);
+ let d = |uv: &(f64, f64)| from_p3(surface.subs(uv.0, uv.1)).dist(x);
+ let uv = found.into_iter().filter(|uv| d(uv).is_finite()).min_by(|a, b| d(a).total_cmp(&d(b)))?;
+ last.set(Some(uv));
+ let n = surface.normal(uv.0, uv.1);
+ Some((from_p3(surface.subs(uv.0, uv.1)), Vec3::new(n.x, n.y, n.z).normalized()?, uv))
+}
+
+/// The strip with parameters in proportion to its lengths across and along (the same surface).
+/// The mesher triangulates a face in its parameters: on a unit square for a strip a few
+/// millimetres wide and tens long, the points of a slanted end fan out into triangles so long
+/// along the curve that they turn over.
+fn in_proportion(surface: &mt::Surface) -> Result<mt::Surface> {
+ use mt::ParametricSurface;
+ let fail = || KernelError::Failed("curve blend: strip parameters".into());
+ let mt::Surface::NurbsSurface(ns) = surface else { return Err(fail()) };
+ let length = |at: &dyn Fn(f64) -> Vec3| (0..32).map(|i| at(i as f64 / 32.0).dist(at((i + 1) as f64 / 32.0))).sum::<f64>();
+ let across = length(&|u| from_p3(surface.subs(u, 0.5)));
+ let along = length(&|v| from_p3(surface.subs(0.5, v)));
+ if !(across.is_finite() && along.is_finite() && across > 1e-9 && along > 1e-9) {
+ return Err(fail());
+ }
+ let bs = ns.non_rationalized();
+ let (mut uk, mut vk) = bs.knot_vecs().clone();
+ uk.transform(across, 0.0);
+ vk.transform(along, 0.0);
+ let bs = mt::BSplineSurface::try_new((uk, vk), bs.control_points().clone()).map_err(|_| fail())?;
+ Ok(mt::Surface::NurbsSurface(mt::NurbsSurface::new(bs)))
+}
+
+/// A chain edge the ball turns about instead of rolling along: an arc of the blend's radius on a
+/// planar side (`side`), curving round the ball (a rounded corner rounded again). The ball's
+/// centre stays at `c`, it touches the planar side only at the arc's centre `o`, and the blend
+/// there is a piece of sphere (of cone, for a chamfer) about the axis through `c` along `axis`.
+#[derive(Clone, Copy, Debug)]
+struct Pivot {
+ c: Vec3,
+ o: Vec3,
+ axis: Vec3,
+ side: usize,
+}
+
+/// The circle an edge lies on (centre, radius, axis), if it is an arc of one within `tol`.
+pub(crate) fn circle_of(e: &mt::Edge, tol: f64) -> Option<(Vec3, f64, Vec3)> {
+ use mt::{BoundedCurve, ParametricCurve};
+ let curve = e.oriented_curve();
+ let (t0, t1) = curve.range_tuple();
+ let at = |f: f64| from_p3(curve.subs(t0 + (t1 - t0) * f));
+ let (a, u, v) = (at(0.0), at(0.5) - at(0.0), at(1.0) - at(0.0));
+ let w = u.cross(v);
+ if w.len2() < 1e-24 {
+ return None;
+ }
+ let o = a + (v * u.len2() - u * v.len2()).cross(w) * (1.0 / (2.0 * w.len2()));
+ let (rho, axis) = (o.dist(a), w.normalized()?);
+ (0..=8).map(|i| at(i as f64 / 8.0)).all(|p| (p.dist(o) - rho).abs() <= tol && (p - o).dot(axis).abs() <= tol).then_some((o, rho, axis))
+}
+
+/// The surface the section (homogeneous controls from contact 1 to contact 2) sweeps turning by
+/// `angle` about the axis through `c` along the unit `axis`: rational quadratic arcs in v, a
+/// quarter turn at most each, so it is exact.
+fn revolve(ctrl: [mt::Vector4; 3], c: Vec3, axis: Vec3, angle: f64) -> Option<mt::Surface> {
+ let pieces = ((angle.abs() / std::f64::consts::FRAC_PI_2).ceil() as usize).clamp(1, 8);
+ let step = angle / pieces as f64;
+ let half = (step / 2.0).cos();
+ if !(half.is_finite() && half > 1e-6) {
+ return None;
+ }
+ let rot = |x: Vec3, phi: f64| {
+ let (s, co) = phi.sin_cos();
+ x * co + axis.cross(x) * s + axis * (axis.dot(x) * (1.0 - co))
+ };
+ let h = |p: Vec3, w: f64| mt::Vector4::new(p.x * w, p.y * w, p.z * w, w);
+ let mut rows = Vec::with_capacity(3);
+ for q in ctrl {
+ if !(q.w.is_finite() && q.w > 1e-12) {
+ return None;
+ }
+ let x = Vec3::new(q.x / q.w, q.y / q.w, q.z / q.w) - c;
+ let along = axis * axis.dot(x);
+ let mut row = vec![h(c + x, q.w)];
+ for i in 0..pieces {
+ let a0 = step * i as f64;
+ row.push(h(c + along + rot(x - along, a0 + step / 2.0) * (1.0 / half), q.w * half));
+ row.push(h(c + rot(x, a0 + step), q.w));
+ }
+ rows.push(row);
+ }
+ let mut knots = vec![0.0; 3];
+ for i in 1..pieces {
+ let k = i as f64 / pieces as f64;
+ knots.extend([k, k]);
+ }
+ knots.extend([1.0; 3]);
+ let bs = mt::BSplineSurface::try_new((mt::KnotVec::bezier_knot(2), mt::KnotVec::from(knots)), rows).ok()?;
+ Some(mt::Surface::NurbsSurface(mt::NurbsSurface::new(bs)))
+}
+
+/// Whether the edge is straight: a line, or a curve on the segment between its ends within
+/// `tol` (an earlier blend's contact along a straight edge is a fitted curve).
+fn straight(e: &mt::Edge, tol: f64) -> bool {
+ use mt::{BoundedCurve, ParametricCurve};
+ let c = e.curve();
+ if matches!(c, mt::Curve::Line(_)) {
+ return true;
+ }
+ let (a, b) = (from_p3(e.front().point()), from_p3(e.back().point()));
+ let (t0, t1) = c.range_tuple();
+ a.dist(b) > tol && (0..=16).all(|i| from_p3(c.subs(t0 + (t1 - t0) * i as f64 / 16.0)).dist_to_segment(a, b) <= tol)
+}
+
/// A curved seam (an arc of an end face) shortened to the blend's contacts: the part of its
/// curve between the new ends `a` and `b` (`None` keeps that end), which must lie on it, in
/// order, short of each other.
-fn trim_curved_seam(seam: &mt::Edge, a: Option<mt::Vertex>, b: Option<mt::Vertex>, size: f64) -> Result<mt::Edge> {
+pub(crate) fn trim_curved_seam(seam: &mt::Edge, a: Option<mt::Vertex>, b: Option<mt::Vertex>, size: f64) -> Result<mt::Edge> {
// A closed seam (a full circle starting and ending at one vertex) has no "between": which
// end a contact replaces, and which way round the kept piece runs, are both ambiguous.
if seam.front() == seam.back() {
@@ -771,6 +964,52 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
if n1.dot(n2) > 1.0 - 1e-6 {
return Err(unsupported("blending a smooth edge"));
}
+ // Arcs on a planar side that curve round the ball: its centre runs round them at their
+ // radius less the blend's. Less than nothing is too large; nothing is a pivot.
+ let mut pivots: Vec<Option<Pivot>> = vec![None; n];
+ for (k, e) in chain.iter().enumerate() {
+ let Some((o, rho, _)) = circle_of(e, tol * 1e3) else { continue };
+ for side in [1, 2] {
+ let Some(f) = (if side == 1 { side1.get(k) } else { side2.get(k) }).and_then(|i| faces.get(*i)) else { continue };
+ let mt::Surface::Plane(pl) = f.oriented_surface() else { continue };
+ let Some(np) = Vec3::new(pl.normal().x, pl.normal().y, pl.normal().z).normalized() else { continue };
+ // Into the face (left of the edge as the face runs it, about its outward normal).
+ let Some(used) = f.boundary_iters().into_iter().flatten().find(|x| x.id() == e.id()) else { continue };
+ let Some((pm, tm)) = ({
+ use mt::{BoundedCurve, ParametricCurve};
+ let c = used.oriented_curve();
+ let (a, b) = c.range_tuple();
+ let d = c.der((a + b) * 0.5);
+ Vec3::new(d.x, d.y, d.z).normalized().map(|t| (from_p3(c.subs((a + b) * 0.5)), t))
+ }) else {
+ continue;
+ };
+ if (o - pm).dot(np.cross(tm)) <= 0.0 {
+ continue;
+ }
+ if rho < r - tol * 1e3 {
+ return Err(too_large("the blend is larger than a corner radius"));
+ }
+ if (rho - r).abs() > tol * 1e3 {
+ continue;
+ }
+ // The ball sits on the planar side at the arc's centre; the other side must be a round
+ // about the same axis, the ball touching it all along.
+ let c = o + np * (sigma * r);
+ let (a1, a2) = edge_sides(&[k]);
+ let other = if side == 1 { a2 } else { a1 };
+ let reach = other.iter().filter_map(|f| project(f, c, None)).map(|x| x.0.dist(c)).fold(f64::INFINITY, f64::min);
+ if (reach - r).abs() <= size * 1e-4 {
+ if let Some(slot) = pivots.get_mut(k) {
+ *slot = Some(Pivot { c, o, axis: np, side });
+ }
+ break;
+ }
+ }
+ }
+ if pivots.iter().all(Option::is_some) {
+ return Err(unsupported("rounding again only rounded corners of the blend's radius"));
+ }
// Seams at the chain's vertices: edges there that aren't in the chain, and their side.
let chain_ids: Vec<mt::EdgeID> = chain.iter().map(|e| e.id()).collect();
let mut seams: Vec<Vec<(usize, mt::Edge)>> = Vec::with_capacity(nv);
@@ -834,6 +1073,21 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
.ok_or_else(|| KernelError::Failed("tangent".into()))?;
let here = seams.get(k).cloned().unwrap_or_default();
let at_end = end_faces.iter().any(|(kk, _)| *kk == k);
+ // Next to a pivot the ball is at its centre, touching the other side square above the
+ // vertex.
+ let pivoting: Vec<Pivot> = [(k < n).then_some(k), if k > 0 { Some(k - 1) } else { closed.then_some(n - 1) }]
+ .into_iter()
+ .flatten()
+ .filter_map(|i| pivots.get(i).copied().flatten())
+ .collect();
+ if let Some(pv) = pivoting.first().copied() {
+ if at_end || pivoting.iter().any(|x| x.c.dist(pv.c) > tol * 1e3) {
+ return Err(unsupported("a rounded corner of the blend's radius where the edge chain ends or turns"));
+ }
+ let q = pv.c + (p - pv.o);
+ vsec.push(if pv.side == 1 { Section { c: pv.c, q1: pv.o, q2: q } } else { Section { c: pv.c, q1: q, q2: pv.o } });
+ continue;
+ }
if at_end {
// A plane square to the edge holds the blend's end section. Any other end face: the
// blend runs on past the end and is cut back where it meets that face.
@@ -856,7 +1110,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
// The plane through the seam square to that side's surface.
let o = from_p3(seam.front().point());
let d = (from_p3(seam.back().point()) - o).normalized().ok_or_else(|| KernelError::Failed("seam".into()))?;
- if !matches!(seam.curve(), mt::Curve::Line(_)) {
+ if !straight(&seam, tol * 10.0) {
return Err(unsupported("a curved seam where the edge chain turns"));
}
let fs = if side == 1 { &s1 } else { &s2 };
@@ -871,13 +1125,17 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
Some((side, o, d.cross(nn).normalized().ok_or_else(|| KernelError::Failed("seam plane".into()))?))
}
};
- let (a1, a2) = edge_sides(&vertex_edges(k));
+ // On the faces of the edge from this vertex alone (the last edge's at an open chain's
+ // end): the other edge's faces are untrimmed here and can run on near the ball where it no
+ // longer is (a wall past the round at a corner, which a ball rolling round it pokes
+ // through).
+ let (a1, a2) = edge_sides(&[k.min(n - 1)]);
let s = solve(&a1, &a2, p, t, r, sigma, cusp, extra, tol * 100.0).ok_or_else(|| unsupported("the ball doesn't fit along the edge"))?;
// A seam on the other side too must pass through that side's contact.
if let Some((side, seam)) = here.get(1).filter(|_| !at_end) {
let q = if *side == 1 { s.q1 } else { s.q2 };
let (a, b) = (from_p3(seam.front().point()), from_p3(seam.back().point()));
- if !matches!(seam.curve(), mt::Curve::Line(_)) || q.dist_to_segment(a, b) > tol * 1e3 {
+ if !straight(seam, tol * 10.0) || q.dist_to_segment(a, b) > tol * 1e3 {
return Err(unsupported("seams on both sides of a corner of the edge chain"));
}
}
@@ -962,8 +1220,13 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
if n.checked_mul(samples).is_none_or(|count| count > MAX_CHAIN_SAMPLES) {
return Err(unsupported("curve blend exceeds the section fitting limit"));
}
- let mut guides = Vec::with_capacity(n);
+ // No guide along a pivot: its sections are the two at its ends.
+ let mut guides: Vec<Option<Guide>> = Vec::with_capacity(n);
for (k, e) in chain.iter().enumerate() {
+ if pivots.get(k).copied().flatten().is_some() {
+ guides.push(None);
+ continue;
+ }
let mut list = vec![*vsec.get(k).ok_or_else(|| KernelError::Failed("section".into()))?];
for j in 1..samples - 1 {
list.push(section_at(k, e, j as f64 / (samples - 1) as f64)?);
@@ -976,14 +1239,14 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
list.extend(ext.iter().copied());
}
}
- guides.push(Guide::new(list)?);
+ guides.push(Some(Guide::new(list)?));
}
// Intersection curves inherit their leader's piecewise parameter speed. Fitting
// those parameters creates oscillations even on a geometrically smooth spine.
// Resample by distance along the rolling centres, projecting each interpolated
// centre back onto the exact two offset surfaces before it becomes a section.
let uniform_section = |k: usize, along: f64| -> Result<Section> {
- let guide = guides.get(k).ok_or_else(|| KernelError::Failed("spine guide".into()))?;
+ let guide = guides.get(k).and_then(Option::as_ref).ok_or_else(|| KernelError::Failed("spine guide".into()))?;
if along == 0.0 {
return guide.sections.first().copied().ok_or_else(|| KernelError::Failed("section".into()));
}
@@ -996,13 +1259,26 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
.ok_or_else(|| unsupported("the ball doesn't fit along the resampled spine"))
};
let esec: Vec<Vec<Section>> = (0..n)
- .map(|k| (0..samples).map(|j| uniform_section(k, j as f64 / (samples - 1) as f64)).collect::<Result<Vec<_>>>())
+ .map(|k| match guides.get(k) {
+ Some(Some(_)) => (0..samples).map(|j| uniform_section(k, j as f64 / (samples - 1) as f64)).collect::<Result<Vec<_>>>(),
+ _ => Ok(vec![
+ *vsec.get(k).ok_or_else(|| KernelError::Failed("section".into()))?,
+ *vsec.get((k + 1) % nv).ok_or_else(|| KernelError::Failed("section".into()))?,
+ ]),
+ })
.collect::<Result<_>>()?;
// Each strip's neighbouring sections at its own spacing (edges of different lengths
// have differently spaced samples, which makes a uniform interpolation overshoot).
- let length = |k: usize| guides.get(k).and_then(|g| g.lengths.last().copied()).unwrap_or(0.0);
- let mut fits = Vec::with_capacity(n);
+ let length = |k: usize| guides.get(k).and_then(Option::as_ref).and_then(|g| g.lengths.last().copied()).unwrap_or(0.0);
+ let rolls = |k: usize| guides.get(k).is_some_and(Option::is_some);
+ let mut fits: Vec<Option<Fit>> = Vec::with_capacity(n);
for k in 0..n {
+ // A pivot's surface is made whole (`revolve`); a strip next to one ends on the joint's
+ // section on its own.
+ if !rolls(k) {
+ fits.push(None);
+ continue;
+ }
let h = length(k) / (samples - 1) as f64;
let spaced = |nb: usize, from_end: bool| -> Result<Option<Vec<Section>>> {
let l = length(nb);
@@ -1018,18 +1294,38 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
}
Ok(Some(out))
};
- let before = if closed || k > 0 { spaced((k + n - 1) % n, true)? } else { Some(Vec::new()) };
- let after = if closed || k + 1 < n { spaced((k + 1) % n, false)? } else { Some(Vec::new()) };
+ let (prev, next) = ((k + n - 1) % n, (k + 1) % n);
let list = esec.get(k).ok_or_else(|| KernelError::Failed("section".into()))?;
+ // Not across a joint where the strip's curvature jumps (a line or a wide arc into a
+ // small round): a spline smooth through it spreads the jump over the sections beside
+ // it, and the error falls only with the square of their spacing. The strip then ends
+ // on the joint's section on its own, which the next one shares.
+ let smooth = |near: [Option<&Section>; 3], beyond: [Option<&Section>; 3]| match (near, beyond) {
+ ([Some(a), Some(b), Some(c)], [Some(x), Some(y), Some(z)]) => !bends([a, b, c], [x, y, z], fit_tolerance),
+ _ => false,
+ };
+ let before = match (closed || k > 0) && rolls(prev) {
+ true => spaced(prev, true)?
+ .map(|b| if smooth([list.first(), list.get(1), list.get(2)], [list.first(), b.get(1), b.first()]) { b } else { Vec::new() }),
+ false => Some(Vec::new()),
+ };
+ let after = match (closed || k + 1 < n) && rolls(next) {
+ true => spaced(next, false)?.map(|a| {
+ let m = list.len();
+ let tail = [list.last(), m.checked_sub(2).and_then(|i| list.get(i)), m.checked_sub(3).and_then(|i| list.get(i))];
+ if smooth(tail, [list.last(), a.first(), a.get(1)]) { a } else { Vec::new() }
+ }),
+ false => Some(Vec::new()),
+ };
let fit = match (before, after) {
(Some(b), Some(a)) => crate::guard("fit curve blend", || fit_strip(list, &b, &a, round))?,
_ => crate::guard("fit curve blend", || fit_sections(&esec, k, closed, round))?,
};
- fits.push(fit);
+ fits.push(Some(fit));
}
let mut accurate = true;
'edges: for k in 0..n {
- let fit = fits.get(k).ok_or_else(|| KernelError::Failed("curve blend fit".into()))?;
+ let Some(Some(fit)) = fits.get(k) else { continue };
for j in 0..samples - 1 {
for fraction in [0.25, 0.5, 0.75] {
let along = (j as f64 + fraction) / (samples - 1) as f64;
@@ -1054,7 +1350,7 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
let mut caps: Vec<(usize, usize, f64, f64, mt::Curve)> = Vec::new();
for (k, fi, _, _, tangent) in &slanted {
let ke = if *k == 0 { 0 } else { n - 1 };
- let fit = fits.get(ke).ok_or_else(|| KernelError::Failed("curve blend fit".into()))?;
+ let fit = fits.get(ke).and_then(Option::as_ref).ok_or_else(|| KernelError::Failed("curve blend fit".into()))?;
let g = faces.get(*fi).ok_or_else(|| KernelError::Failed("end face".into()))?;
let at = vsec.get(*k).copied().ok_or_else(|| KernelError::Failed("section".into()))?;
let seam = |s: u8| seams.get(*k).and_then(|l| l.iter().find(|(x, _)| *x as u8 == s)).map(|(_, e)| e);
@@ -1085,6 +1381,16 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
*b = builder::vertex(curve.subs(hi));
}
}
+ // Along a pivot the planar side's contact is one point: one vertex at both its ends.
+ for (k, pv) in pivots.iter().enumerate() {
+ let Some(pv) = pv else { continue };
+ let vs = if pv.side == 1 { &mut v1 } else { &mut v2 };
+ if let Some(v) = vs.get(k).cloned()
+ && let Some(slot) = vs.get_mut((k + 1) % nv)
+ {
+ *slot = v;
+ }
+ }
// A chain end (a cap, or the section at a square end) on the far end of its seam uses that
// seam up: that vertex is the end.
let mut consumed: HashMap<mt::EdgeID, mt::Vertex> = HashMap::new();
@@ -1117,15 +1423,48 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
};
arcs.push(e);
}
+ // Outward: toward the ball centre on a concave edge, away on a convex one.
+ let oriented = |mut surface: mt::Surface, list: &[Section]| -> Result<mt::Surface> {
+ use mt::{ParametricSurface3D, SearchNearestParameter};
+ let s = list.get(list.len() / 2).ok_or_else(|| fail("section"))?;
+ let mid = s.c + ((s.q1 - s.c) + (s.q2 - s.c)).normalized().ok_or_else(|| fail("mid"))? * r;
+ if let Some((u, v)) = surface.search_nearest_parameter(p3(mid), None, 100) {
+ let nn = surface.normal(u, v);
+ let want = (s.c - mid) * sigma;
+ if Vec3::new(nn.x, nn.y, nn.z).dot(want) < 0.0 {
+ surface = mt::Invertible::inverse(&surface);
+ }
+ }
+ Ok(surface)
+ };
// Contact curves and blend faces per edge.
- let mut c1: Vec<mt::Edge> = Vec::with_capacity(n);
- let mut c2: Vec<mt::Edge> = Vec::with_capacity(n);
+ // (None: the planar side's contact along a pivot, a point.)
+ let mut c1: Vec<Option<mt::Edge>> = Vec::with_capacity(n);
+ let mut c2: Vec<Option<mt::Edge>> = Vec::with_capacity(n);
let mut blends: Vec<mt::Surface> = Vec::with_capacity(n);
for (k, list) in esec.iter().enumerate() {
let k1 = (k + 1) % nv;
let (a1, b1, a2, b2) = (v1.get(k), v1.get(k1), v2.get(k), v2.get(k1));
let (Some(a1), Some(b1), Some(a2), Some(b2)) = (a1, b1, a2, b2) else { return Err(fail("vertex")) };
- let fit = fits.get(k).ok_or_else(|| fail("fit"))?;
+ if let Some(pv) = pivots.get(k).copied().flatten() {
+ // The section at the start turned about the axis to the one at the end; the other
+ // side's contact is the circle its end runs on.
+ let (s0, s1e) = (list.first().ok_or_else(|| fail("section"))?, list.last().ok_or_else(|| fail("section"))?);
+ let (qa, qb) = if pv.side == 1 { (s0.q2, s1e.q2) } else { (s0.q1, s1e.q1) };
+ let (a, b) = (qa - pv.c, qb - pv.c);
+ let angle = pv.axis.dot(a.cross(b)).atan2(a.dot(b));
+ let (sn, cs) = (angle / 2.0).sin_cos();
+ let mid = pv.c + a * cs + pv.axis.cross(a) * sn + pv.axis * (pv.axis.dot(a) * (1.0 - cs));
+ let surface = section_controls(s0, round).and_then(|ctrl| revolve(ctrl, pv.c, pv.axis, angle)).ok_or_else(|| fail("pivot"))?;
+ let (from, to) = if pv.side == 1 { (a2, b2) } else { (a1, b1) };
+ let arc = builder::circle_arc(from, to, p3(mid));
+ let (e1, e2) = if pv.side == 1 { (None, Some(arc)) } else { (Some(arc), None) };
+ c1.push(e1);
+ c2.push(e2);
+ blends.push(oriented(surface, list)?);
+ continue;
+ }
+ let fit = fits.get(k).and_then(Option::as_ref).ok_or_else(|| fail("fit"))?;
let [cv1, cv2] = &fit.contacts;
// Contacts past a slanted end stop at the end curve.
let (mut cv1, mut cv2) = (cv1.clone(), cv2.clone());
@@ -1143,28 +1482,12 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
cv2 = cv2.cut(*t2);
}
}
- let e1 = mt::Edge::new(a1, b1, cv1);
- let e2 = mt::Edge::new(a2, b2, cv2);
- let mut surface = fit.surface.clone();
- // Outward: toward the ball centre on a concave edge, away on a convex one.
- {
- use mt::{ParametricSurface3D, SearchNearestParameter};
- let s = list.get(list.len() / 2).ok_or_else(|| fail("section"))?;
- let mid = s.c + ((s.q1 - s.c) + (s.q2 - s.c)).normalized().ok_or_else(|| fail("mid"))? * r;
- if let Some((u, v)) = surface.search_nearest_parameter(p3(mid), None, 100) {
- let nn = surface.normal(u, v);
- let want = (s.c - mid) * sigma;
- if Vec3::new(nn.x, nn.y, nn.z).dot(want) < 0.0 {
- surface = mt::Invertible::inverse(&surface);
- }
- }
- }
- c1.push(e1);
- c2.push(e2);
- blends.push(surface);
+ c1.push(Some(mt::Edge::new(a1, b1, cv1)));
+ c2.push(Some(mt::Edge::new(a2, b2, cv2)));
+ blends.push(oriented(fit.surface.clone(), list)?);
}
// Rebuild the side faces: chain edges become contact curves, seams start at contacts.
- let mut subst: HashMap<mt::EdgeID, (mt::Edge, mt::Edge)> = HashMap::new();
+ let mut subst: HashMap<mt::EdgeID, (Option<mt::Edge>, Option<mt::Edge>)> = HashMap::new();
for (k, e) in chain.iter().enumerate() {
let (Some(x), Some(y)) = (c1.get(k), c2.get(k)) else { return Err(fail("contact")) };
subst.insert(e.id(), (x.clone(), y.clone()));
@@ -1293,7 +1616,8 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
let mut es = Vec::new();
for e in w.edge_iter() {
let ne = if let Some((x, y)) = subst.get(&e.id()) {
- let base = if on1 { x } else { y };
+ // A point along a pivot: the contacts beside it meet there.
+ let Some(base) = (if on1 { x } else { y }) else { continue };
// Same direction as the chain edge, or reversed.
let chain_e = chain.iter().find(|c| c.id() == e.id()).ok_or_else(|| fail("edge"))?;
if e.front() == chain_e.front() { base.clone() } else { base.inverse() }
@@ -1328,11 +1652,15 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
.map(|e| e.front() == chain_e.front())
.ok_or_else(|| fail("edge use"))?;
// Side 1 runs the contact forward (as the chain) when it ran the edge forward.
+ // A pivot's planar contact is a point: three sides.
let wire: mt::Wire = if used_fwd {
- vec![e1.inverse(), ak.clone(), e2.clone(), ak1.inverse()].into()
+ [e1.as_ref().map(|e| e.inverse()), Some(ak.clone()), e2.clone(), Some(ak1.inverse())]
} else {
- vec![e1.clone(), ak1.clone(), e2.inverse(), ak.inverse()].into()
- };
+ [e1.clone(), Some(ak1.clone()), e2.as_ref().map(|e| e.inverse()), Some(ak.inverse())]
+ }
+ .into_iter()
+ .flatten()
+ .collect();
let face = mt::Face::try_new(vec![wire], bf.clone()).map_err(|e| fail(&e.to_string()))?;
rec.blend(&face, [chain_e.id()]);
out.push(face);
@@ -1345,6 +1673,10 @@ fn curve_blend_with_limit(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64,
})
}
+#[path = "curvecorner.rs"]
+mod corner;
+pub(crate) use corner::corner_blend;
+
#[cfg(test)]
#[path = "curveblend_tests.rs"]
mod tests;
diff --git a/crates/kernel/src/curveblend_tests.rs b/crates/kernel/src/curveblend_tests.rs
index 522f94dffe..bf16062470 100644
--- a/crates/kernel/src/curveblend_tests.rs
+++ b/crates/kernel/src/curveblend_tests.rs
@@ -5,6 +5,7 @@ use mt::{BoundedCurve, ParametricCurve, ParametricSurface, ParametricSurface3D,
use super::*;
use crate::blend::plane_normal;
+use crate::issue_851_tests::planned_volume;
use crate::{Body, BoolOp, boolean, cylinder, fillet};
fn tee(scale: f64, origin: Vec3) -> Body {
@@ -408,3 +409,239 @@ fn a_smooth_seam_is_refused_as_having_no_corner() {
assert!(fillet(&one, &[Vec3::new(20.0, 0.0, 20.0)], 1.0).is_ok());
assert!(matches!(fillet(&one, &[Vec3::new(35.0, 30.0, 10.0)], 1.0), Err(KernelError::Invalid(_))));
}
+
+/// A 40 × 40 × 20 box whose front wall is an arc of radius 40 about a Z axis: `concave` cuts a
+/// cylinder away from the front (the wall curves into the part), otherwise the part is the box
+/// within the cylinder (the wall curves out). The arc meets the planar side walls x = 0 and
+/// x = 40 at an angle, not square. With the bottom arc's midpoint, the axis's base point and the
+/// side of the wall the material is on (+1 away from the axis, −1 toward it).
+fn arc_walled_box(concave: bool) -> (Body, Vec3, Vec3, f64) {
+ let block = crate::box_solid(Vec3::ZERO, Vec3::new(40.0, 40.0, 20.0)).unwrap();
+ let (axis, op, side) =
+ if concave { (Vec3::new(20.0, -30.0, 0.0), BoolOp::Cut, 1.0) } else { (Vec3::new(20.0, 70.0, 0.0), BoolOp::Intersect, -1.0) };
+ let tool = cylinder(axis, Vec3::Z, 40.0, 20.0).unwrap();
+ let body = boolean(&block, &tool, op).unwrap().unwrap();
+ (body, axis + Vec3::new(0.0, side * 40.0, 0.0), axis, side)
+}
+
+/// Volume the blend removes along the bottom arc: the corner's cross-section at each distance
+/// ρ from the axis (`depth(x)`, x ∈ [0, size] from the wall into the material), times the arc
+/// of radius ρ between the side walls.
+fn removed_volume(side: f64, size: f64, depth: impl Fn(f64) -> f64) -> f64 {
+ let steps = 4000;
+ let h = size / steps as f64;
+ (0..=steps)
+ .map(|i| {
+ let x = i as f64 * h;
+ let rho = 40.0 + side * x;
+ let w = if i == 0 || i == steps {
+ 1.0
+ } else if i % 2 == 1 {
+ 4.0
+ } else {
+ 2.0
+ };
+ w * depth(x) * 2.0 * rho * (20.0 / rho).asin()
+ })
+ .sum::<f64>()
+ * h
+ / 3.0
+}
+
+#[test]
+fn rolling_ball_along_an_arc_ends_in_side_walls_at_an_angle() {
+ // The bottom edge of an arc wall ends in the side walls at an angle (#556). The round is the
+ // torus about the cylinder's axis (centre circle of radius 40 ± r at height r), trimmed by
+ // the side walls; the chamfer is the cone between the two contacts.
+ let r = 2.0;
+ for concave in [true, false] {
+ let (body, mid, axis, side) = arc_walled_box(concave);
+ let v0 = planned_volume(&body);
+ for round in [true, false] {
+ let what = format!("{} {}", if concave { "concave" } else { "convex" }, if round { "fillet" } else { "chamfer" });
+ let blend = if round { fillet(&body, &[mid], r) } else { crate::chamfer(&body, &[mid], r) }.unwrap_or_else(|e| panic!("{what}: {e}"));
+ assert!(blend.validity().is_empty(), "{what}: {:?}", blend.validity());
+ let volume = planned_volume(&blend);
+ let removed =
+ if round { removed_volume(side, r, |x| r - (r * r - (r - x) * (r - x)).max(0.0).sqrt()) } else { removed_volume(side, r, |x| r - x) };
+ assert!((v0 - volume - removed).abs() < removed * 3e-3, "{what}: removed {} vs {removed}", v0 - volume);
+ // The blend face stays between the side walls and, for the round, on the torus.
+ let surfaces: Vec<_> =
+ blend.solid.face_iter().map(|f| f.oriented_surface()).filter(|s| matches!(s, mt::Surface::NurbsSurface(_))).collect();
+ assert!(!surfaces.is_empty(), "{what}: no blend face");
+ let mesh = blend.tessellate_with(0.0005, true).unwrap();
+ let (lo, hi) = mesh.positions.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), p| (lo.min(p.x), hi.max(p.x)));
+ assert!(lo > -1e-3 && hi < 40.0 + 1e-3, "{what}: the blend runs past the side walls: x {lo}..{hi}");
+ if round {
+ // Sections of the round across the arc: the quarter circle about the centre
+ // ring (radius 40 ± r about the axis, at height r) from contact to contact.
+ let ring = 40.0 + side * r;
+ let mut worst: f64 = 0.0;
+ for i in 0..=40 {
+ let x = 40.0 * i as f64 / 40.0;
+ for a in 1..8 {
+ let t = std::f64::consts::FRAC_PI_2 * a as f64 / 8.0;
+ let (rho, z) = (ring - side * r * t.cos(), r - r * t.sin());
+ let dx = x - axis.x;
+ let dy = (rho * rho - dx * dx).sqrt() * if concave { 1.0 } else { -1.0 };
+ let p = Vec3::new(x, axis.y + dy, z);
+ worst = worst.max(nearest_blend(&surfaces, p).0);
+ }
+ }
+ assert!(worst < 1e-3, "{what}: blend surface is {worst} mm off the torus");
+ }
+ }
+ }
+}
+
+#[test]
+fn rolling_ball_past_a_slanted_end_face_is_too_large_and_reduces() {
+ // On the outward-curving wall a round of 4 would run its bottom contact into the back face
+ // before it reaches the side wall (the contact circle of radius 36 meets x = 0 at y ≈ 40.07):
+ // too large, and the largest that fits rounds the edge.
+ let (body, mid, _, _) = arc_walled_box(false);
+ let e = fillet(&body, &[mid], 4.0).unwrap_err();
+ assert!(matches!(e, KernelError::TooLarge(_)), "{e}");
+ let (r, blend) = crate::fillet_max(&body, &[mid], 4.0).unwrap();
+ assert!(r > 3.0 && r < 4.0, "{r}");
+ assert!(blend.validity().is_empty(), "{:?}", blend.validity());
+}
+
+#[test]
+fn rolling_ball_runs_into_a_knife_edge_tip() {
+ // The corner of a block outside a cylinder of radius 21 about (21, −21): its wall meets the
+ // back face y = 0 tangentially at (21, 0) and the left face x = 0 at (0, −21), knife-edge
+ // tips at both ends of the arc. The round of the bottom arc runs into both, cut off by the
+ // end faces' planes, which touch the wall contact at the tips without crossing it: at
+ // distance ρ from the axis it runs from x = 0 to y = 0, ρ (asin(21 / ρ) − acos(21 / ρ)).
+ let block = crate::box_solid(Vec3::new(0.0, -21.0, 0.0), Vec3::new(21.0, 0.0, 10.0)).unwrap();
+ let body = boolean(&block, &cylinder(Vec3::new(21.0, -21.0, -1.0), Vec3::Z, 21.0, 12.0).unwrap(), BoolOp::Cut).unwrap().unwrap();
+ let mid = Vec3::new(21.0 - 21.0 * std::f64::consts::FRAC_1_SQRT_2, -21.0 + 21.0 * std::f64::consts::FRAC_1_SQRT_2, 0.0);
+ let r = 2.0;
+ let blend = fillet(&body, &[mid], r).unwrap();
+ assert!(blend.validity().is_empty(), "{:?}", blend.validity());
+ let (n, h) = (4000, r / 4000.0);
+ let removed = (0..=n)
+ .map(|i| {
+ let x = i as f64 * h;
+ let rho = 21.0 + x;
+ let w = if i == 0 || i == n {
+ 1.0
+ } else if i % 2 == 1 {
+ 4.0
+ } else {
+ 2.0
+ };
+ w * (r - (r * r - (r - x) * (r - x)).max(0.0).sqrt()) * rho * ((21.0 / rho).asin() - (21.0 / rho).acos())
+ })
+ .sum::<f64>()
+ * h
+ / 3.0;
+ let got = planned_volume(&body) - planned_volume(&blend);
+ assert!((got - removed).abs() < removed * 5e-3, "removed {got} vs {removed}");
+}
+
+#[test]
+fn rolling_ball_turns_about_a_rounded_corner_of_its_radius() {
+ // The box with the inward-curving wall, its 60° corner at x = 0 rounded (r 2) first. The
+ // bottom edges then run: the side wall's, the corner round's (an arc of radius 2) and the
+ // arc wall's into the slanted side wall at x = 40. Rounded again with r 2 the ball can't
+ // roll round the corner: it turns about one point there, and the blend is a piece of sphere.
+ // It is what the rolling round tends to as its radius tends to the corner's, too large past
+ // it, and its mesh is closed.
+ let (body, _, _, _) = arc_walled_box(true);
+ let body = fillet(&body, &[Vec3::new(0.0, 4.641016151377546, 10.0)], 2.0).unwrap();
+ // The corner round's centre is 4 from the corner along its bisector, (2, 8.105): its arc's
+ // middle is 2 back toward the corner.
+ let ends = [Vec3::new(0.0, 25.0, 0.0), Vec3::new(1.0, 6.373, 0.0), Vec3::new(20.0, 10.0, 0.0)];
+ let v0 = planned_volume(&body);
+ let removed = |r: f64| {
+ let b = fillet(&body, &ends, r).unwrap_or_else(|e| panic!("r {r}: {e}"));
+ assert!(b.validity().is_empty(), "r {r}: {:?}", b.validity());
+ v0 - planned_volume(&b)
+ };
+ let (a, b, at) = (removed(1.96), removed(1.98), removed(2.0));
+ let expected = 2.0 * b - a;
+ assert!((at - expected).abs() < expected * 2e-3, "removed {at} at r 2, {a} and {b} before it");
+ let e = fillet(&body, &ends, 2.5).unwrap_err();
+ assert!(matches!(e, KernelError::TooLarge(_)), "{e}");
+ let (r, _) = crate::fillet_max(&body, &ends, 2.5).unwrap();
+ assert!(r > 1.5 && r <= 2.0 + 1e-9, "{r}");
+}
+
+#[test]
+fn rolling_ball_along_a_straight_edge_ends_in_a_curved_face() {
+ // The box with the inward-curving wall: the bottom edge of the side wall x = 0 runs from the
+ // back to the curved wall (#556). The round of radius 2 along it is cut off by that wall:
+ // at d from the side wall it runs from y = −30 + √(40² − (d − 20)²) to the back at y = 40.
+ let (body, _, _, _) = arc_walled_box(true);
+ let r = 2.0;
+ for round in [true, false] {
+ let blend =
+ if round { fillet(&body, &[Vec3::new(0.0, 25.0, 0.0)], r) } else { crate::chamfer(&body, &[Vec3::new(0.0, 25.0, 0.0)], r) }.unwrap();
+ assert!(blend.validity().is_empty(), "{:?}", blend.validity());
+ let (n, h) = (4000, r / 4000.0);
+ let removed = (0..=n)
+ .map(|i| {
+ let d = i as f64 * h;
+ let w = if i == 0 || i == n {
+ 1.0
+ } else if i % 2 == 1 {
+ 4.0
+ } else {
+ 2.0
+ };
+ let depth = if round { r - (r * r - (r - d) * (r - d)).max(0.0).sqrt() } else { r - d };
+ w * depth * (40.0 - (-30.0 + (1600.0 - (d - 20.0) * (d - 20.0)).sqrt()))
+ })
+ .sum::<f64>()
+ * h
+ / 3.0;
+ let (m0, m1) = (body.tessellate_with(0.0005, true).unwrap(), blend.tessellate_with(0.0005, true).unwrap());
+ let got = m0.measure().volume - m1.measure().volume;
+ assert!((got - removed).abs() < removed * 3e-3, "round {round}: removed {got} vs {removed}");
+ let volume_about = |o: Vec3| {
+ let at = |i: u32| m1.positions[i as usize] - o;
+ m1.triangles.iter().map(|t| at(t[0]).dot(at(t[1]).cross(at(t[2]))) / 6.0).sum::<f64>()
+ };
+ let shift = volume_about(Vec3::ZERO) - volume_about(Vec3::new(-100.0, 50.0, 30.0));
+ assert!(shift.abs() < 1e-2, "round {round}: the mesh is not closed (volume moves {shift} with the origin)");
+ }
+}
+
+#[test]
+fn chamfer_a_chain_of_a_line_and_an_arc_into_a_slanted_end() {
+ // A 40 × 40 block, 20 high, whose front runs straight for 20 and then along an arc of
+ // radius 29 about (20, 29), tangent to it, up to (40, 8): the right face meets the arc at an
+ // angle. The top front chain chamfered by 2 (the planes' and the cone's sections are 2 × 2
+ // corners, 2 − w high at w in from the edge): 2 a millimetre along the line, and along the
+ // arc out to the right face, at each distance ρ from its axis, the height times the arc of
+ // radius ρ inside x ≤ 40.
+ use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2};
+ let start = -std::f64::consts::FRAC_PI_2;
+ let end = (-21.0f64).atan2(20.0);
+ let segs = vec![
+ Seg2::Line { a: Vec2::new(0.0, 0.0), b: Vec2::new(20.0, 0.0) },
+ Seg2::Arc { center: Vec2::new(20.0, 29.0), radius: 29.0, start, sweep: end - start },
+ Seg2::Line { a: Vec2::new(40.0, 8.0), b: Vec2::new(40.0, 40.0) },
+ Seg2::Line { a: Vec2::new(40.0, 40.0), b: Vec2::new(0.0, 40.0) },
+ Seg2::Line { a: Vec2::new(0.0, 40.0), b: Vec2::new(0.0, 0.0) },
+ ];
+ let body = crate::extrude(&Plane::XY, &[Region2 { outer: Loop2 { segs }, holes: vec![] }], 0.0, 20.0).unwrap().pop().unwrap();
+ let volume = |b: &Body| b.tessellate_with(0.0005, true).unwrap().measure().volume;
+ let made = crate::chamfer(&body, &[Vec3::new(10.0, 0.0, 20.0)], 2.0).unwrap();
+ let n = 2000;
+ let h = 2.0 / n as f64;
+ let arc = (0..=n)
+ .map(|i| {
+ let rho = 27.0 + i as f64 * h;
+ let w = if i == 0 || i == n { 1.0 } else { [2.0, 4.0][i % 2] };
+ w * (rho - 27.0) * rho * (20.0 / rho).asin()
+ })
+ .sum::<f64>()
+ * h
+ / 3.0;
+ let want = 40.0 + arc;
+ let got = volume(&body) - volume(&made);
+ assert!((got - want).abs() < want * 1e-3, "removed {got} vs {want}");
+}
diff --git a/crates/kernel/src/curvecorner.rs b/crates/kernel/src/curvecorner.rs
new file mode 100644
index 0000000000..46b943d080
--- /dev/null
+++ b/crates/kernel/src/curvecorner.rs
@@ -0,0 +1,1160 @@
+//! Corners where rolling-ball blends meet on faces of any surface (the arc wall of an extruded
+//! profile and the edges round it): what [`crate::blend_corner`] does for straight edges between
+//! planes, with each blend fitted as in the parent module.
+//!
+//! Each blended edge's strip (its rolling-ball sections, fitted) runs a little past both ends.
+//! Every end vertex has three faces and three edges. There:
+//! - one blended edge: the strip ends where the third face cuts it, between where its contacts
+//! cross the other two edges;
+//! - two: the strips cut each other along a crease, from where their contacts cross on the face
+//! they share to the third edge. When one strip's contact
+//! reaches further along the third edge, the other's ends on the crease alone and the first
+//! runs on beyond it to end on the other's third face;
+//! - three (one radius): each strip ends at its section through the ball touching all three
+//! faces, and a piece of that ball's sphere fills the corner.
+
+use std::cell::Cell;
+use std::collections::{HashMap, HashSet};
+
+use solidcraft_geom::Vec3;
+use truck_modeling::{self as mt, builder};
+
+use super::{
+ Guide, MAX_SAMPLES, SAMPLES, Section, fit_sections, in_proportion, knife_convex, knife_start, nearest_on, project, section_fits, solve_from,
+ unsupported,
+};
+use crate::blend::{too_large, vtx};
+use crate::body::{Solid, from_p3, p3, v3};
+use crate::record::Rebuild;
+use crate::{KernelError, Result};
+
+fn fail(m: &str) -> KernelError {
+ KernelError::Failed(format!("blend corner: {m}"))
+}
+
+/// One blended edge's strip: the fitted rolling-ball surface (u across, from the contact with
+/// side `fa` at 0 to side `fb`'s at 1; v along the edge from its front, running on past both
+/// ends), its contacts (in v) and its sections.
+struct Strip {
+ edge: mt::Edge,
+ fa: usize,
+ fb: usize,
+ surface: mt::Surface,
+ contacts: [mt::Curve; 2],
+ /// v of the sections at the edge's front and back vertex.
+ ends: [f64; 2],
+ /// +1 when the surface's normal points out of the material, −1 when into it.
+ flip: f64,
+ /// −1 for a convex edge (the ball inside the material), +1 for a concave one.
+ sigma: f64,
+ /// Sections with their v.
+ sections: Vec<(f64, Section)>,
+}
+
+impl Strip {
+ fn row(&self, f: usize) -> Result<usize> {
+ if f == self.fa {
+ Ok(0)
+ } else if f == self.fb {
+ Ok(1)
+ } else {
+ Err(fail("a face beside a blend"))
+ }
+ }
+
+ fn contact(&self, f: usize) -> Result<&mt::Curve> {
+ self.contacts.get(self.row(f)?).ok_or_else(|| fail("contact"))
+ }
+
+ /// u of the contact with face `f`.
+ fn u(&self, f: usize) -> Result<f64> {
+ self.row(f).map(|i| i as f64)
+ }
+
+ fn at(&self, u: f64, v: f64) -> Vec3 {
+ use mt::ParametricSurface;
+ from_p3(self.surface.subs(u, v))
+ }
+
+ /// The edge's own stretch of v.
+ fn own(&self) -> (f64, f64) {
+ let [a, b] = self.ends;
+ (a.min(b), a.max(b))
+ }
+
+ /// v of the edge's end at `v`, and +1 when the strip runs on past it toward larger v.
+ fn end_at(&self, v: &mt::Vertex) -> (f64, f64) {
+ let [a, b] = self.ends;
+ if self.edge.front() == v { (a, -1.0) } else { (b, 1.0) }
+ }
+
+ /// The strip's nearest point to `x` (u and v within it): from the section whose ball is
+ /// nearest, by Gauss-Newton steps kept within the strip.
+ fn nearest(&self, x: Vec3) -> Option<(f64, f64)> {
+ use mt::ParametricSurface;
+ let (v0, s0) = self.sections.iter().min_by(|a, b| a.1.c.dist(x).total_cmp(&b.1.c.dist(x)))?;
+ let (a, b, w) = (s0.q1 - s0.c, s0.q2 - s0.c, x - s0.c);
+ let angle = |p: Vec3, q: Vec3| (p.dot(q) / (p.len() * q.len()).max(1e-300)).clamp(-1.0, 1.0).acos();
+ let total = angle(a, b);
+ let mut uv = ((angle(a, w) / total.max(1e-12)).clamp(0.0, 1.0), *v0);
+ let dist = |uv: (f64, f64)| from_p3(self.surface.subs(uv.0, uv.1)).dist(x);
+ let mut d = dist(uv);
+ for _ in 0..50 {
+ let p = from_p3(self.surface.subs(uv.0, uv.1));
+ let (su, sv) = (self.surface.uder(uv.0, uv.1), self.surface.vder(uv.0, uv.1));
+ let (su, sv) = (Vec3::new(su.x, su.y, su.z), Vec3::new(sv.x, sv.y, sv.z));
+ let r = x - p;
+ let (a11, a12, a22) = (su.dot(su), su.dot(sv), sv.dot(sv));
+ let (b1, b2) = (su.dot(r), sv.dot(r));
+ let det = a11 * a22 - a12 * a12;
+ if !(det.abs() > 1e-300) {
+ break;
+ }
+ let (mut du, mut dv) = ((b1 * a22 - b2 * a12) / det, (a11 * b2 - a12 * b1) / det);
+ let mut moved = false;
+ for _ in 0..30 {
+ let next = ((uv.0 + du).clamp(0.0, 1.0), (uv.1 + dv).clamp(0.0, 1.0));
+ let dn = dist(next);
+ if dn <= d {
+ moved = (next.0 - uv.0).abs() + (next.1 - uv.1).abs() > 1e-15;
+ uv = next;
+ d = dn;
+ break;
+ }
+ du *= 0.5;
+ dv *= 0.5;
+ }
+ if !moved {
+ break;
+ }
+ }
+ Some(uv)
+ }
+}
+
+/// Signed distance from a surface, positive out of the material; each search starts where the
+/// last ended (the points asked about come in small steps). A strip's is measured to its
+/// nearest point within it: past a contact, to the contact along the face there.
+enum Away<'a> {
+ Face(Box<(mt::Surface, Cell<Option<(f64, f64)>>)>),
+ Strip(&'a Strip),
+}
+
+impl<'a> Away<'a> {
+ fn face(f: &mt::Face) -> Self {
+ Away::Face(Box::new((f.oriented_surface(), Cell::new(None))))
+ }
+
+ fn strip(s: &'a Strip) -> Self {
+ Away::Strip(s)
+ }
+
+ fn at(&self, x: Vec3) -> Option<f64> {
+ use mt::{ParametricSurface, ParametricSurface3D, SearchNearestParameter};
+ match self {
+ Away::Face(face) if matches!(face.0, mt::Surface::Plane(_)) => nearest_on(&face.0, &face.1, x).map(|(q, n, _)| (x - q).dot(n)),
+ Away::Face(face) => {
+ let (surface, last) = (&face.0, &face.1);
+ // The nearest of the search from the last answer, a fresh one and either kept
+ // within the surface's parameters: past them a conic's patch runs on round to
+ // its far side, where a search can settle.
+ let (ru, rv) = surface.try_range_tuple();
+ let ((u0, u1), (v0, v1)) = (ru.unwrap_or((f64::NEG_INFINITY, f64::INFINITY)), rv.unwrap_or((f64::NEG_INFINITY, f64::INFINITY)));
+ let inside = |uv: (f64, f64)| uv.0 >= u0 - 1e-9 && uv.0 <= u1 + 1e-9 && uv.1 >= v0 - 1e-9 && uv.1 <= v1 + 1e-9;
+ let warm = last.get().and_then(|h| surface.search_nearest_parameter(p3(x), Some(h), 20));
+ let mut found: Vec<(f64, f64)> = warm.into_iter().collect();
+ if !warm.is_some_and(inside) {
+ found.extend(surface.search_nearest_parameter(p3(x), None, 100));
+ }
+ let clamped: Vec<(f64, f64)> = found.iter().map(|(u, v)| (u.clamp(u0, u1), v.clamp(v0, v1))).collect();
+ found.extend(clamped);
+ let d = |uv: &(f64, f64)| from_p3(surface.subs(uv.0, uv.1)).dist(x);
+ let uv = found.into_iter().filter(|uv| d(uv).is_finite()).min_by(|a, b| d(a).total_cmp(&d(b)))?;
+ last.set(Some(uv));
+ let q = from_p3(surface.subs(uv.0, uv.1));
+ let n = surface.normal(uv.0, uv.1);
+ Some((x - q).dot(Vec3::new(n.x, n.y, n.z).normalized()?))
+ }
+ Away::Strip(s) => {
+ let (u, v) = s.nearest(x)?;
+ let q = from_p3(s.surface.subs(u, v));
+ let n = s.surface.normal(u, v);
+ Some((x - q).dot(Vec3::new(n.x, n.y, n.z).normalized()?) * s.flip)
+ }
+ }
+ }
+}
+
+/// Unit direction along a curve at `t`.
+fn tangent(c: &mt::Curve, t: f64) -> Option<Vec3> {
+ use mt::ParametricCurve;
+ let d = c.der(t);
+ Vec3::new(d.x, d.y, d.z).normalized()
+}
+
+/// Nearest parameter on `c` to `x`, started from the nearest of a few samples.
+/// The radius of edge `e` seen along the unit `axis`: its points, moved along the axis into one
+/// plane, all on one circle (within `tol`).
+fn radius_along(e: &mt::Edge, axis: Vec3, tol: f64) -> Option<f64> {
+ use mt::{BoundedCurve, ParametricCurve};
+ let curve = e.curve();
+ let (t0, t1) = curve.range_tuple();
+ let at = |f: f64| {
+ let p = from_p3(curve.subs(t0 + (t1 - t0) * f));
+ p - axis * axis.dot(p)
+ };
+ let (a, u, v) = (at(0.0), at(0.5) - at(0.0), at(1.0) - at(0.0));
+ let w = u.cross(v);
+ if w.len2() < 1e-24 || w.normalized()?.dot(axis).abs() < 1.0 - 1e-6 {
+ return None;
+ }
+ let o = a + (v * u.len2() - u * v.len2()).cross(w) * (1.0 / (2.0 * w.len2()));
+ let rho = o.dist(a);
+ (0..=16).map(|i| at(i as f64 / 16.0)).all(|p| (p.dist(o) - rho).abs() <= tol).then_some(rho)
+}
+
+fn param_on(c: &mt::Curve, x: Vec3) -> Option<f64> {
+ use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};
+ let (lo, hi) = c.range_tuple();
+ let d = |t: f64| from_p3(c.subs(t)).dist(x);
+ let hint = (0..=64).map(|i| lo + (hi - lo) * i as f64 / 64.0).min_by(|a, b| d(*a).total_cmp(&d(*b)))?;
+ let t = c.search_nearest_parameter(p3(x), hint, 100).unwrap_or(hint).clamp(lo, hi);
+ Some(if d(t) <= d(hint) { t } else { hint })
+}
+
+/// Where curve `a` crosses curve `b` on face `f`, both lying in it: its parameter on `a` and
+/// the point. Of several, the one within `own` (a range of `a`'s parameter) nearest `near`.
+fn cross(a: &mt::Curve, b: &mt::Curve, f: &mt::Face, near: Vec3, own: (f64, f64), tol: f64) -> Option<(f64, Vec3)> {
+ use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};
+ let (a0, a1) = a.range_tuple();
+ let (b0, b1) = b.range_tuple();
+ let surface = f.oriented_surface();
+ let last = Cell::new(None);
+ let hint = Cell::new(None::<f64>);
+ // Signed distance across `b` in the face, and how far `b`'s nearest point is.
+ // `b` sampled once (an intersection curve is slow to evaluate).
+ let along_b: Vec<(f64, Vec3)> = (0..=64).map(|i| b0 + (b1 - b0) * i as f64 / 64.0).map(|t| (t, from_p3(b.subs(t)))).collect();
+ let lateral = |s: f64| -> Option<(f64, f64)> {
+ let x = from_p3(a.subs(s));
+ // From the last answer when that is still nearest, else from the nearest sample of `b`
+ // (a search from the far end of a short arc can stay there).
+ let d = |t: f64| from_p3(b.subs(t)).dist(x);
+ let warm = hint.get().map(|h| b.search_nearest_parameter(p3(x), h, 50).unwrap_or(h).clamp(b0, b1));
+ let (start, ds) = along_b.iter().map(|(t, p)| (*t, p.dist(x))).min_by(|p, q| p.1.total_cmp(&q.1))?;
+ let t = match warm {
+ Some(w) if d(w) <= ds => w,
+ _ => {
+ let cold = b.search_nearest_parameter(p3(x), start, 50).unwrap_or(start).clamp(b0, b1);
+ match warm {
+ Some(w) if d(w) <= d(cold).min(ds) => w,
+ _ if d(cold) <= ds => cold,
+ _ => start,
+ }
+ }
+ };
+ hint.set(Some(t));
+ let y = from_p3(b.subs(t));
+ let (_, n, _) = nearest_on(&surface, &last, y)?;
+ let m = n.cross(tangent(b, t)?).normalized()?;
+ Some(((x - y).dot(m), x.dist(y)))
+ };
+ let steps = 256;
+ let samples: Vec<(f64, Option<(f64, f64)>)> = (0..=steps)
+ .map(|i| {
+ let s = a0 + (a1 - a0) * i as f64 / steps as f64;
+ (s, lateral(s))
+ })
+ .collect();
+ // Only where `a` comes within a sample's step of `b` (elsewhere the side flips only round
+ // an end of `b`).
+ let step = samples.windows(2).map(|w| from_p3(a.subs(w[1].0)).dist(from_p3(a.subs(w[0].0)))).fold(0.0, f64::max);
+ let close = |d: f64| d <= 2.0 * step + tol;
+ let mut found: Vec<(f64, Vec3)> = Vec::new();
+ for w in samples.windows(2) {
+ let [(s0, Some((h0, d0))), (s1, Some((h1, d1)))] = w else { continue };
+ if h1.abs() <= tol && *d1 <= tol {
+ found.push((*s1, from_p3(a.subs(*s1))));
+ continue;
+ }
+ if (*h0 < 0.0) == (*h1 < 0.0) || !(close(*d0) || close(*d1)) {
+ continue;
+ }
+ let (mut lo, mut hi, glo) = (*s0, *s1, *h0);
+ hint.set(None);
+ for _ in 0..60 {
+ let m = (lo + hi) * 0.5;
+ let Some((hm, _)) = lateral(m) else { break };
+ if (hm < 0.0) == (glo < 0.0) {
+ lo = m;
+ } else {
+ hi = m;
+ }
+ }
+ let s = (lo + hi) * 0.5;
+ hint.set(None);
+ if lateral(s).is_some_and(|(_, d)| d <= tol) {
+ found.push((s, from_p3(a.subs(s))));
+ }
+ }
+ if let Some((s, Some((h, d)))) = samples.first()
+ && h.abs() <= tol
+ && *d <= tol
+ {
+ found.push((*s, from_p3(a.subs(*s))));
+ }
+ // Touching without crossing: through an end of `b` (an edge the blend uses up to its far
+ // vertex), where the side `b` is measured from turns over. Where the distance comes down
+ // to nothing.
+ for w in samples.windows(3) {
+ let [(s0, Some((_, d0))), (_, Some((_, d1))), (s2, Some((_, d2)))] = w else { continue };
+ if !(d1 <= d0 && d1 <= d2 && close(*d1)) {
+ continue;
+ }
+ let gap = |s: f64| {
+ hint.set(None);
+ lateral(s).map_or(f64::INFINITY, |x| x.1)
+ };
+ let (mut lo, mut hi) = (*s0, *s2);
+ for _ in 0..80 {
+ let (x, y) = (lo + (hi - lo) * 0.381_966, lo + (hi - lo) * 0.618_034);
+ if gap(x) < gap(y) {
+ hi = y;
+ } else {
+ lo = x;
+ }
+ }
+ let s = (lo + hi) * 0.5;
+ if gap(s) <= tol && !found.iter().any(|f| (f.0 - s).abs() <= (a1 - a0) * 1e-6) {
+ found.push((s, from_p3(a.subs(s))));
+ }
+ }
+ let slack = (a1 - a0) * 1e-6;
+ let outside = |s: f64| s < own.0 - slack || s > own.1 + slack;
+ found.into_iter().min_by(|x, y| outside(x.0).cmp(&outside(y.0)).then(x.1.dist(near).total_cmp(&y.1.dist(near))))
+}
+
+/// Where curve `c` crosses `side`'s surface: its parameter and the point; of several, the one
+/// nearest `near`.
+fn reach(c: &mt::Curve, side: &Away, near: Vec3, tol: f64) -> Option<(f64, Vec3)> {
+ use mt::{BoundedCurve, ParametricCurve};
+ let (lo, hi) = c.range_tuple();
+ let g = |s: f64| side.at(from_p3(c.subs(s))).filter(|x| x.is_finite());
+ let steps = 256;
+ let samples: Vec<(f64, Option<f64>)> = (0..=steps)
+ .map(|i| {
+ let s = lo + (hi - lo) * i as f64 / steps as f64;
+ (s, g(s))
+ })
+ .collect();
+ let mut found: Vec<(f64, Vec3)> = Vec::new();
+ for w in samples.windows(2) {
+ let [(s0, Some(g0)), (s1, Some(g1))] = w else { continue };
+ if (*g0 < 0.0) == (*g1 < 0.0) {
+ continue;
+ }
+ let (mut a, mut b, ga) = (*s0, *s1, *g0);
+ for _ in 0..60 {
+ let m = (a + b) * 0.5;
+ let Some(gm) = g(m) else { break };
+ if (gm < 0.0) == (ga < 0.0) {
+ a = m;
+ } else {
+ b = m;
+ }
+ }
+ let s = (a + b) * 0.5;
+ if g(s).is_some_and(|x| x.abs() <= tol) {
+ found.push((s, from_p3(c.subs(s))));
+ }
+ }
+ found.into_iter().min_by(|x, y| x.1.dist(near).total_cmp(&y.1.dist(near)))
+}
+
+/// The curve on strip `s` from `a` to `b` (each u, v and point) where `side` changes sign (it is
+/// negative in the material kept): for each u between, the v where it does nearest a guess
+/// between the ends, stepping toward `out` (+1: larger v) while inside. Interpolated by chord
+/// length through u spaced closer toward the ends; between its points it stays on the strip and
+/// on the surface.
+fn trace(s: &Strip, a: (f64, f64, Vec3), b: (f64, f64, Vec3), side: &Away, out: f64, tolerance: f64) -> Result<mt::Curve> {
+ use mt::ParametricCurve;
+ let beyond = || too_large("the blend is larger than the neighbouring faces");
+ let (ua, va, pa) = a;
+ let (ub, vb, pb) = b;
+ let f = |u: f64, v: f64| side.at(s.at(u, v)).unwrap_or(f64::NAN);
+ let root = |frac: f64| -> Option<(f64, f64)> {
+ let u = ua + (ub - ua) * frac;
+ let guess = (va + (vb - va) * frac).clamp(0.0, 1.0);
+ // Steps in proportion to the distance from the nearer end, where the curve is known: a
+ // face tangent to a contact there (a knife-edge tip) crosses the strip only within a
+ // window that narrows toward it.
+ let step = (vb - va).abs().max(1e-3) * frac.min(1.0 - frac).clamp(1e-6, 0.5) / 8.0;
+ let g = f(u, guess);
+ if !g.is_finite() {
+ return None;
+ }
+ let dir = if g < 0.0 { out } else { -out };
+ let mut prev = (guess, g);
+ for i in 1..=4096 {
+ let v = (guess + dir * step * i as f64).clamp(0.0, 1.0);
+ let cur = (v, f(u, v));
+ if !cur.1.is_finite() {
+ return None;
+ }
+ if (prev.1 < 0.0) != (cur.1 < 0.0) {
+ let (mut x, mut y) = (prev, cur);
+ for _ in 0..60 {
+ let m = (x.0 + y.0) * 0.5;
+ let fm = f(u, m);
+ if (fm < 0.0) == (x.1 < 0.0) {
+ x = (m, fm);
+ } else {
+ y = (m, fm);
+ }
+ }
+ return Some((u, (x.0 + y.0) * 0.5));
+ }
+ if v <= 0.0 || v >= 1.0 {
+ return None;
+ }
+ prev = cur;
+ }
+ None
+ };
+ let across = |t: f64| (1.0 - (std::f64::consts::PI * t).cos()) * 0.5;
+ let mut m = 8;
+ loop {
+ let mut pts = vec![pa];
+ for i in 1..m {
+ let (u, v) = root(across(i as f64 / m as f64)).ok_or_else(beyond)?;
+ pts.push(s.at(u, v));
+ }
+ pts.push(pb);
+ let (curve, params) = crate::build::interpolate_cubic_chordal(&pts).ok_or_else(|| fail("end curve"))?;
+ let mut accurate = true;
+ for (i, w) in params.windows(2).enumerate() {
+ let (Some(t0), Some(t1)) = (w.first(), w.get(1)) else { continue };
+ root(across((i as f64 + 0.5) / m as f64)).ok_or_else(beyond)?;
+ let x = from_p3(curve.subs((t0 + t1) * 0.5));
+ let on = s.nearest(x).map(|(a, b)| s.at(a, b).dist(x));
+ let off = side.at(x).map(f64::abs);
+ if !(on.is_some_and(|d| d <= tolerance) && off.is_some_and(|d| d <= tolerance)) {
+ accurate = false;
+ break;
+ }
+ }
+ if accurate {
+ return Ok(mt::Curve::BSplineCurve(curve));
+ }
+ if m >= 256 {
+ return Err(fail("could not fit where the blends meet"));
+ }
+ m *= 2;
+ }
+}
+
+/// Convex (−1) or concave (+1): from the edge's direction as its first face runs it and the
+/// faces' outward normals at its middle. At a knife edge (normals opposite), also the
+/// direction both faces run on from it.
+fn convexity(faces: &[mt::Face], e: &mt::Edge, fa: usize, fb: usize, r: f64) -> Result<(f64, Option<Vec3>)> {
+ use mt::{BoundedCurve, ParametricCurve};
+ let (Some(f1), Some(f2)) = (faces.get(fa), faces.get(fb)) else { return Err(fail("face")) };
+ let used = f1.boundary_iters().into_iter().flatten().find(|x| x.id() == e.id()).ok_or_else(|| fail("edge use"))?;
+ let c = used.oriented_curve();
+ let (a, b) = c.range_tuple();
+ let pm = from_p3(c.subs((a + b) * 0.5));
+ let t = tangent(&c, (a + b) * 0.5).ok_or_else(|| fail("tangent"))?;
+ let (Some(n1), Some(n2)) = (project(f1, pm, None).map(|x| x.1), project(f2, pm, None).map(|x| x.1)) else { return Err(fail("normals")) };
+ if n1.dot(n2) > 1.0 - 1e-6 {
+ return Err(unsupported("blending a smooth edge"));
+ }
+ if n1.dot(n2) < -1.0 + 1e-6 {
+ let into = n1.cross(t).normalized().ok_or_else(|| fail("normals"))?;
+ return match knife_convex(f1, f2, pm, into, r) {
+ Some(true) => Ok((-1.0, Some(into))),
+ _ => Err(unsupported("blending a knife edge inside the material (a crack)")),
+ };
+ }
+ Ok((if t.dot(n1.cross(n2)) > 0.0 { -1.0 } else { 1.0 }, None))
+}
+
+/// The strip of edge `e` between faces `fa` and `fb`, running on past each end as far as the
+/// ball still fits, up to `reach`.
+#[allow(clippy::too_many_arguments)]
+fn strip(
+ faces: &[mt::Face],
+ e: &mt::Edge,
+ (fa, fb): (usize, usize),
+ r: f64,
+ round: bool,
+ (sigma, knife): (f64, Option<Vec3>),
+ reach: f64,
+ tol: f64,
+ fit_tol: f64,
+) -> Result<Strip> {
+ use mt::{BoundedCurve, ParametricCurve, ParametricSurface3D, SearchNearestParameter};
+ let (Some(f1), Some(f2)) = (faces.get(fa), faces.get(fb)) else { return Err(fail("face")) };
+ let (o1, o2) = ([f1], [f2]);
+ let curve = e.curve();
+ let (t0, t1) = curve.range_tuple();
+ let at = |s: f64| -> Option<(Vec3, Vec3)> {
+ let t = t0 + (t1 - t0) * s;
+ Some((from_p3(curve.subs(t)), tangent(&curve, t)?))
+ };
+ // At a knife edge each ball starts where the last one was, beside it (the first where the
+ // faces are a diameter apart): the edge itself is no start.
+ let offset: Cell<Option<Vec3>> = Cell::new(None);
+ let ball = |p: Vec3, t: Vec3| -> Option<Section> {
+ let start = match (knife, offset.get()) {
+ (None, _) => None,
+ (Some(_), Some(o)) => Some(p + o),
+ (Some(into), None) => Some(knife_start(&o1, &o2, p, t, into, r)?),
+ };
+ let s = solve_from(&o1, &o2, p, t, r, sigma, 0.0, None, tol * 100.0, start)?;
+ if knife.is_some() {
+ offset.set(Some(s.c - p));
+ }
+ Some(s)
+ };
+ // Along the edge, then on along its curve past its ends (a line runs straight on, a conic's
+ // arc round its circle) while the ball fits.
+ let mut raw: Vec<Section> = Vec::new();
+ let (p0, _) = at(0.0).ok_or_else(|| fail("tangent"))?;
+ let n = 32;
+ let mut along = Vec::with_capacity(n + 1);
+ for i in 0..=n {
+ let (p, t) = at(i as f64 / n as f64).ok_or_else(|| fail("tangent"))?;
+ along.push(ball(p, t).ok_or_else(|| unsupported("the ball doesn't fit along the edge"))?);
+ }
+ let length = (0..n).filter_map(|i| Some(at(i as f64 / n as f64)?.0.dist(at((i + 1) as f64 / n as f64)?.0))).sum::<f64>();
+ if !(length.is_finite() && length > tol) {
+ return Err(fail("edge length"));
+ }
+ let past = |sign: f64| -> Vec<Section> {
+ let mut list = Vec::new();
+ for k in 1..=16 {
+ let s = (sign * reach * k as f64 / 16.0) / length;
+ match at(if sign < 0.0 { s } else { 1.0 + s }).filter(|(p, t)| p.is_finite() && t.is_finite()).and_then(|(p, t)| ball(p, t)) {
+ Some(x) => list.push(x),
+ None => break,
+ }
+ }
+ list
+ };
+ let after = past(1.0);
+ offset.set(along.first().map(|s| s.c - p0));
+ let before = past(-1.0);
+ raw.extend(before.iter().rev().copied());
+ let first = raw.len();
+ raw.extend(along);
+ let last = raw.len() - 1;
+ raw.extend(after);
+ let guide = Guide::new(raw)?;
+ let total = guide.lengths.last().copied().ok_or_else(|| fail("spine"))?;
+ let ends = [
+ guide.lengths.get(first).copied().ok_or_else(|| fail("spine"))? / total,
+ guide.lengths.get(last).copied().ok_or_else(|| fail("spine"))? / total,
+ ];
+ let uniform = |along: f64| -> Result<Section> {
+ if along <= 0.0 {
+ return guide.sections.first().copied().ok_or_else(|| fail("section"));
+ }
+ if along >= 1.0 {
+ return guide.sections.last().copied().ok_or_else(|| fail("section"));
+ }
+ let (anchor, t) = guide.anchor(along).ok_or_else(|| unsupported("degenerate rolling-ball spine"))?;
+ solve_from(&o1, &o2, anchor, t, r, sigma, 0.0, None, tol * 100.0, None)
+ .ok_or_else(|| unsupported("the ball doesn't fit along the resampled spine"))
+ };
+ let mut samples = SAMPLES;
+ let (list, fit) = loop {
+ let list: Vec<Section> = (0..samples).map(|j| uniform(j as f64 / (samples - 1) as f64)).collect::<Result<_>>()?;
+ let fit = crate::guard("fit corner blend", || fit_sections(std::slice::from_ref(&list), 0, false, round))?;
+ let mut accurate = true;
+ 'check: for j in 0..samples - 1 {
+ for fraction in [0.25, 0.5, 0.75] {
+ let along = (j as f64 + fraction) / (samples - 1) as f64;
+ if !section_fits(&fit, &uniform(along)?, along, round, sigma, fit_tol) {
+ accurate = false;
+ break 'check;
+ }
+ }
+ }
+ if accurate {
+ break (list, fit);
+ }
+ if samples >= MAX_SAMPLES {
+ return Err(fail("could not fit the rolling-ball surface"));
+ }
+ samples = (2 * samples - 1).min(MAX_SAMPLES);
+ };
+ // Outward: toward the ball centre on a concave edge, away on a convex one.
+ let mid = list.get(list.len() / 2).ok_or_else(|| fail("section"))?;
+ let m = mid.c + ((mid.q1 - mid.c) + (mid.q2 - mid.c)).normalized().ok_or_else(|| fail("section"))? * r;
+ let (u, v) = fit.surface.search_nearest_parameter(p3(m), Some((0.5, 0.5)), 100).ok_or_else(|| fail("orientation"))?;
+ let nn = fit.surface.normal(u, v);
+ let flip = if Vec3::new(nn.x, nn.y, nn.z).dot((mid.c - m) * sigma) < 0.0 { -1.0 } else { 1.0 };
+ let sections = list.iter().enumerate().map(|(j, s)| (j as f64 / (samples - 1) as f64, *s)).collect();
+ let [c1, c2] = fit.contacts;
+ Ok(Strip { edge: e.clone(), fa, fb, surface: fit.surface, contacts: [c1, c2], ends, flip, sigma, sections })
+}
+
+/// The point a radius from all three faces (inside the material for a convex corner), from
+/// `start`, and its contacts with them.
+fn corner_ball(faces: [&mt::Face; 3], start: Vec3, r: f64, sigma: f64, tol: f64) -> Option<(Vec3, [Vec3; 3])> {
+ let mut c = start;
+ for _ in 0..100 {
+ let mut rows = [[0.0; 3]; 3];
+ let mut rhs = [0.0; 3];
+ let mut qs = [Vec3::ZERO; 3];
+ let mut worst: f64 = 0.0;
+ for (((f, row), b), q) in faces.iter().zip(rows.iter_mut()).zip(rhs.iter_mut()).zip(qs.iter_mut()) {
+ let (x, n, _) = project(f, c, None)?;
+ let g = (c - x).dot(n) - sigma * r;
+ *row = [n.x, n.y, n.z];
+ *b = -g;
+ *q = x;
+ worst = worst.max(g.abs());
+ }
+ let d = crate::polyhedron::solve3_pub(rows, rhs)?;
+ let dc = Vec3::new(d[0], d[1], d[2]);
+ if worst < tol && dc.len() < tol {
+ return Some((c, qs));
+ }
+ c += dc;
+ if !c.is_finite() {
+ return None;
+ }
+ }
+ None
+}
+
+/// Flip a surface so that its normal near `at` points along `outward`.
+fn orient(mut surf: mt::Surface, at: Vec3, outward: Vec3) -> mt::Surface {
+ use mt::{ParametricSurface3D, SearchNearestParameter};
+ if let Some((u, v)) = surf.search_nearest_parameter(p3(at), None, 100) {
+ let n = surf.normal(u, v);
+ if Vec3::new(n.x, n.y, n.z).dot(outward) < 0.0 {
+ surf = mt::Invertible::inverse(&surf);
+ }
+ }
+ surf
+}
+
+/// Where a blend's contact ends at a vertex where it ends alone: crossing the edge there (its
+/// parameter and the point), or past that edge's far vertex `w`, crossing the next edge `g` of
+/// its face there (`h`: the third edge at `w`, between the faces `f4` beyond and the vertex's
+/// third face).
+enum Reached {
+ Edge(f64, Vec3),
+ Past { t: f64, p: Vec3, w: mt::Vertex, g: mt::EdgeID, h: mt::EdgeID, f4: usize },
+}
+
+/// A face of the shell being rebuilt, a strip, or a corner's sphere.
+#[derive(Clone, Copy, PartialEq)]
+enum Owner {
+ Face(usize),
+ Strip(mt::EdgeID),
+ Patch,
+}
+
+/// Edges from `from` to `to` through the pool edges of `owner`.
+fn connect(from: &mt::Vertex, to: &mt::Vertex, pool: &[(mt::Edge, Vec<Owner>)], owner: Owner) -> Result<Vec<mt::Edge>> {
+ let mut out = Vec::new();
+ let mut used: HashSet<mt::EdgeID> = HashSet::new();
+ let mut cur = from.clone();
+ for _ in 0..=pool.len() {
+ if &cur == to {
+ return Ok(out);
+ }
+ let next = pool.iter().filter(|(e, o)| o.contains(&owner) && !used.contains(&e.id())).find_map(|(e, _)| {
+ if e.front() == &cur {
+ Some(e.clone())
+ } else if e.back() == &cur {
+ Some(e.inverse())
+ } else {
+ None
+ }
+ });
+ let Some(e) = next else { break };
+ used.insert(e.id());
+ cur = e.back().clone();
+ out.push(e);
+ }
+ Err(fail("a boundary does not close"))
+}
+
+/// Blend the edges `ids` of `solid` with radius `r` (a chamfer's distance), rebuilding the
+/// corners at their ends; with what it built from `solid`.
+pub(crate) fn corner_blend(solid: &Solid, ids: &[mt::EdgeID], size: f64, r: f64, round: bool) -> Result<(Solid, Rebuild)> {
+ if !(size.is_finite() && size > 0.0 && r.is_finite() && r > 0.0) {
+ return Err(KernelError::Invalid("blend size and radius must be finite and positive".into()));
+ }
+ if ids.is_empty() || ids.len() > 64 {
+ return Err(KernelError::Invalid("select 1…64 edges".into()));
+ }
+ let tol = (size * 1e-7).max(1e-9);
+ let fit_tol = (size * 1e-5).clamp(1e-5, 0.001);
+ let shells = solid.boundaries();
+ let si = shells.iter().position(|sh| sh.edge_iter().any(|e| ids.contains(&e.id()))).ok_or_else(|| fail("edge not found"))?;
+ let shell = shells.get(si).ok_or_else(|| fail("shell"))?;
+ if ids.iter().any(|id| !shell.edge_iter().any(|e| e.id() == *id)) {
+ return Err(unsupported("blends on separate lumps in one go"));
+ }
+ let faces: Vec<mt::Face> = shell.face_iter().cloned().collect();
+ let edges: HashMap<mt::EdgeID, mt::Edge> = shell.edge_iter().map(|e| (e.id(), e.absolute_clone())).collect();
+ let mut on_edge: HashMap<mt::EdgeID, Vec<usize>> = HashMap::new();
+ let mut at_vertex: HashMap<mt::VertexID, (HashSet<mt::EdgeID>, Vec<usize>)> = HashMap::new();
+ for (fi, f) in faces.iter().enumerate() {
+ for e in f.edge_iter() {
+ let list = on_edge.entry(e.id()).or_default();
+ if !list.contains(&fi) {
+ list.push(fi);
+ }
+ for v in [e.front(), e.back()] {
+ let a = at_vertex.entry(v.id()).or_default();
+ a.0.insert(e.id());
+ if !a.1.contains(&fi) {
+ a.1.push(fi);
+ }
+ }
+ }
+ }
+ let face_with = |a: mt::EdgeID, b: mt::EdgeID| -> Result<usize> {
+ let fa = on_edge.get(&a).cloned().unwrap_or_default();
+ let fb = on_edge.get(&b).cloned().unwrap_or_default();
+ fa.into_iter().find(|f| fb.contains(f)).ok_or_else(|| fail("faces"))
+ };
+ let face = |fi: usize| faces.get(fi).ok_or_else(|| fail("face"));
+
+ // The vertices at the blended edges' ends: three faces, three edges.
+ let mut touched: HashMap<mt::VertexID, mt::Vertex> = HashMap::new();
+ let mut sides: HashMap<mt::EdgeID, (usize, usize, f64, Option<Vec3>)> = HashMap::new();
+ for id in ids {
+ let e = edges.get(id).ok_or_else(|| fail("edge"))?;
+ if e.front() == e.back() {
+ return Err(unsupported("blending a closed edge at a corner"));
+ }
+ let fs = on_edge.get(id).cloned().unwrap_or_default();
+ let [fa, fb] = fs[..] else { return Err(unsupported("the edge is not between two faces")) };
+ let (sigma, knife) = convexity(&faces, e, fa, fb, r)?;
+ sides.insert(*id, (fa, fb, sigma, knife));
+ touched.insert(e.front().id(), e.front().clone());
+ touched.insert(e.back().id(), e.back().clone());
+ }
+ for vid in touched.keys() {
+ let (eids, fids) = at_vertex.get(vid).ok_or_else(|| fail("vertex"))?;
+ if eids.len() != 3 || fids.len() != 3 {
+ return Err(unsupported("blends ending where more than three edges meet"));
+ }
+ let chosen: Vec<&mt::EdgeID> = eids.iter().filter(|id| sides.contains_key(id)).collect();
+ if chosen.len() >= 2 && chosen.iter().any(|id| sides.get(*id).is_none_or(|s| s.2 > 0.0)) {
+ return Err(unsupported("concave blends meeting at a corner"));
+ }
+ if chosen.len() == 3 && !round {
+ return Err(unsupported("three chamfers at one corner"));
+ }
+ // A blended edge running on smoothly into one that isn't: the blend follows it there
+ // (a chain round the corner, blended elsewhere), unless it is an earlier round's arc of
+ // this radius, which the blend ends in. Round a smaller one the ball can't.
+ let v = touched.get(vid).ok_or_else(|| fail("vertex"))?;
+ let leaves = |e: &mt::Edge| {
+ use mt::BoundedCurve;
+ let c = e.curve();
+ let (t0, t1) = c.range_tuple();
+ tangent(&c, if e.front() == v { t0 } else { t1 }).map(|d| if e.front() == v { d } else { -d })
+ };
+ for id in &chosen {
+ let Some(d) = edges.get(*id).and_then(leaves) else { continue };
+ for g in eids.iter().filter(|g| !sides.contains_key(*g)) {
+ let Some(e) = edges.get(g) else { continue };
+ if !leaves(e).is_some_and(|x| x.dot(d) < -1.0 + 1e-6) {
+ continue;
+ }
+ // The earlier round's end may also be where it meets a curved face: a circle only
+ // seen along the round's axis, which its contact with the third face runs along.
+ let third = eids.iter().find(|x| *x != *id && *x != g).and_then(|x| edges.get(x)).and_then(leaves);
+ let seen = super::circle_of(e, tol * 1e3).map(|c| c.1).or_else(|| third.and_then(|a| radius_along(e, a, tol * 1e3)));
+ match seen {
+ Some(rho) if (rho - r).abs() <= tol * 1e3 => {}
+ Some(rho) if rho < r => return Err(too_large("the blend is larger than a corner radius")),
+ _ => return Err(unsupported("a blend running on smoothly into an edge not blended")),
+ }
+ }
+ }
+ }
+
+ crate::guard("blend corners", || {
+ // The strips.
+ let mut strips: HashMap<mt::EdgeID, Strip> = HashMap::new();
+ for id in ids {
+ let (Some(e), Some((fa, fb, sigma, knife))) = (edges.get(id), sides.get(id).copied()) else { return Err(fail("edge")) };
+ strips.insert(*id, strip(&faces, e, (fa, fb), r, round, (sigma, knife), 8.0 * r, tol, fit_tol)?);
+ }
+ let strip_of = |id: &mt::EdgeID| strips.get(id).ok_or_else(|| fail("strip"));
+ // New end points: (edge, vertex, the face of a blended edge's contact).
+ let mut endpt: HashMap<(mt::EdgeID, mt::VertexID, Option<usize>), mt::Vertex> = HashMap::new();
+ let mut pool: HashMap<mt::VertexID, Vec<(mt::Edge, Vec<Owner>)>> = HashMap::new();
+ let mut patches: Vec<(mt::Face, Vec<mt::EdgeID>)> = Vec::new();
+ // Edges a blend uses up to their far vertex (an earlier round's edge, when the radii
+ // are equal): left out, the blend ends at that vertex.
+ let mut consumed: HashSet<mt::EdgeID> = HashSet::new();
+ // Vertices a blend takes in (an earlier round's corner past the end of its edge).
+ let mut gone: HashMap<mt::VertexID, mt::Vertex> = HashMap::new();
+ // In a fixed order (by position): the work and the result don't depend on hashing.
+ let mut order_v: Vec<(&mt::VertexID, &mt::Vertex)> = touched.iter().collect();
+ order_v.sort_by(|a, b| {
+ let (p, q) = (vtx(a.1), vtx(b.1));
+ p.x.total_cmp(&q.x).then(p.y.total_cmp(&q.y)).then(p.z.total_cmp(&q.z))
+ });
+ for (vid, vert) in order_v {
+ let v = vtx(vert);
+ let (eids, _) = at_vertex.get(vid).ok_or_else(|| fail("vertex"))?;
+ let mut chosen: Vec<mt::EdgeID> = eids.iter().filter(|id| sides.contains_key(id)).copied().collect();
+ let rest: Vec<mt::EdgeID> = eids.iter().filter(|id| !sides.contains_key(id)).copied().collect();
+ chosen.sort_by_key(|id| ids.iter().position(|x| x == id));
+ let curve_of = |id: &mt::EdgeID| edges.get(id).map(|e| e.curve()).ok_or_else(|| fail("edge"));
+ // The new end on edge `id` at `p`: its far vertex when the blend reaches it.
+ // A contact (`along`: the curves arriving there, and where) that runs into that
+ // vertex along another of its edges would leave a face no wider than nothing: refused.
+ let at_end = |id: &mt::EdgeID, p: Vec3, along: &[(&mt::Curve, f64, usize)]| -> Result<(mt::Vertex, bool)> {
+ let far = edges.get(id).map(|e| if e.front().id() == *vid { e.back().clone() } else { e.front().clone() });
+ let Some(w) = far.filter(|w| vtx(w).dist(p) <= fit_tol * 10.0 && !touched.contains_key(&w.id())) else {
+ return Ok((builder::vertex(p3(p)), false));
+ };
+ let others = at_vertex.get(&w.id()).map(|x| x.0.iter().filter(|g| *g != id).copied().collect::<Vec<_>>()).unwrap_or_default();
+ for g in others {
+ use mt::BoundedCurve;
+ let Some(e) = edges.get(&g) else { continue };
+ let c = e.curve();
+ let (t0, t1) = c.range_tuple();
+ let leaves = tangent(&c, if e.front() == &w { t0 } else { t1 });
+ let of = on_edge.get(&g).cloned().unwrap_or_default();
+ if along
+ .iter()
+ .filter(|(_, _, f)| of.contains(f))
+ .filter_map(|(c, t, _)| tangent(c, *t))
+ .any(|d| leaves.is_some_and(|l| l.dot(d).abs() > 1.0 - 1e-6))
+ {
+ return Err(unsupported("a blend that runs along an edge where it ends"));
+ }
+ }
+ Ok((w, true))
+ };
+ let mut ending = |id: &mt::EdgeID, p: Vec3, along: &[(&mt::Curve, f64, usize)]| -> Result<mt::Vertex> {
+ let (w, used) = at_end(id, p, along)?;
+ if used {
+ consumed.insert(*id);
+ }
+ Ok(w)
+ };
+ let list = pool.entry(*vid).or_default();
+ match (&chosen[..], &rest[..]) {
+ ([e1], [e2, e3]) => {
+ let s1 = strip_of(e1)?;
+ let (f12, f31, f23) = (face_with(*e1, *e2)?, face_with(*e1, *e3)?, face_with(*e2, *e3)?);
+ let (_, out) = s1.end_at(vert);
+ let (c12, c31) = (s1.contact(f12)?, s1.contact(f31)?);
+ let none = || too_large("the blend is larger than the neighbouring faces");
+ // Each contact crosses its edge at the vertex, or runs past that edge's far
+ // end (the blend takes in that corner, an earlier round's) to the next edge of
+ // its face there.
+ let side = |ei: &mt::EdgeID, fi: usize| -> Result<Reached> {
+ let c = s1.contact(fi)?;
+ if let Some((t, p)) = cross(c, &curve_of(ei)?, face(fi)?, v, s1.own(), fit_tol) {
+ return Ok(Reached::Edge(t, p));
+ }
+ // Only an earlier round's corner: the third face runs on smoothly from a
+ // side at the vertex (else the blend would wrap round a corner of the part).
+ let normal = |f: usize| face(f).ok().and_then(|g| project(g, v, None)).map(|x| x.1);
+ let smooth = normal(f23).is_some_and(|n| [f12, f31].iter().any(|f| normal(*f).is_some_and(|m| m.dot(n) > 1.0 - 1e-6)));
+ if !smooth {
+ return Err(none());
+ }
+ let e = edges.get(ei).ok_or_else(|| fail("edge"))?;
+ let w = if e.front().id() == *vid { e.back().clone() } else { e.front().clone() };
+ let (ws, wf) = at_vertex.get(&w.id()).ok_or_else(|| fail("vertex"))?;
+ if touched.contains_key(&w.id()) || ws.len() != 3 || wf.len() != 3 || ws.iter().any(|x| sides.contains_key(x)) {
+ return Err(none());
+ }
+ let on = |f: usize| ws.iter().filter(|x| *x != ei).find(|x| on_edge.get(*x).is_some_and(|fs| fs.contains(&f))).copied();
+ let (Some(g), Some(h)) = (on(fi), on(f23)) else { return Err(none()) };
+ let f4 = face_with(g, h)?;
+ let (t, p) = cross(c, &curve_of(&g)?, face(fi)?, v, s1.own(), fit_tol).ok_or_else(none)?;
+ // Through that far vertex itself: the contact reaches the edge's end there
+ // (touching it where it runs in tangent to the contact, as at a knife-edge
+ // tip).
+ if p.dist(vtx(&w)) <= fit_tol * 10.0 {
+ return Ok(Reached::Edge(t, vtx(&w)));
+ }
+ Ok(Reached::Past { t, p, w, g, h, f4 })
+ };
+ match (side(e2, f12)?, side(e3, f31)?) {
+ (Reached::Edge(v2, p2), Reached::Edge(v3, p3_)) => {
+ let (a, b) = (ending(e2, p2, &[(c12, v2, f12)])?, ending(e3, p3_, &[(c31, v3, f31)])?);
+ endpt.insert((*e2, *vid, None), a.clone());
+ endpt.insert((*e1, *vid, Some(f12)), a.clone());
+ endpt.insert((*e3, *vid, None), b.clone());
+ endpt.insert((*e1, *vid, Some(f31)), b.clone());
+ let end = Away::face(face(f23)?);
+ let c = trace(s1, (s1.u(f12)?, v2, p2), (s1.u(f31)?, v3, p3_), &end, out, fit_tol)?;
+ list.push((mt::Edge::new(&a, &b, c), vec![Owner::Face(f23), Owner::Strip(*e1)]));
+ }
+ (r2, r3) => {
+ // The end runs from the edge reached across the third face to where
+ // it crosses the edge `h` from the corner taken in, then across the
+ // face beyond (`f4`) to the next edge `g`.
+ let ((ed, fd, td, pd), (ex, fx, past)) = match (r2, r3) {
+ (Reached::Edge(t, p), past @ Reached::Past { .. }) => ((e2, f12, t, p), (e3, f31, past)),
+ (past @ Reached::Past { .. }, Reached::Edge(t, p)) => ((e3, f31, t, p), (e2, f12, past)),
+ _ => return Err(unsupported("a blend running past both edges where it ends")),
+ };
+ let Reached::Past { t: tx, p: px, w, g, h, f4 } = past else { return Err(fail("corner")) };
+ let a = ending(ed, pd, &[(s1.contact(fd)?, td, fd)])?;
+ let b = builder::vertex(p3(px));
+ let (_, y) = reach(&curve_of(&h)?, &Away::strip(s1), vtx(&w), fit_tol).ok_or_else(none)?;
+ let (u_y, v_y) = s1.nearest(y).ok_or_else(none)?;
+ if s1.at(u_y, v_y).dist(y) > fit_tol * 10.0 {
+ return Err(none());
+ }
+ let yv = builder::vertex(p3(y));
+ consumed.insert(*ex);
+ gone.insert(w.id(), w.clone());
+ endpt.insert((*ed, *vid, None), a.clone());
+ endpt.insert((*e1, *vid, Some(fd)), a.clone());
+ endpt.insert((*e1, *vid, Some(fx)), b.clone());
+ endpt.insert((g, w.id(), None), b.clone());
+ endpt.insert((h, w.id(), None), yv.clone());
+ let first = trace(s1, (s1.u(fd)?, td, pd), (u_y, v_y, y), &Away::face(face(f23)?), out, fit_tol)?;
+ let second = trace(s1, (u_y, v_y, y), (s1.u(fx)?, tx, px), &Away::face(face(f4)?), out, fit_tol)?;
+ list.push((mt::Edge::new(&a, &yv, first), vec![Owner::Face(f23), Owner::Strip(*e1)]));
+ list.push((mt::Edge::new(&yv, &b, second), vec![Owner::Face(f4), Owner::Strip(*e1)]));
+ }
+ }
+ }
+ ([ea, eb], [e3]) => {
+ let (sa, sb) = (strip_of(ea)?, strip_of(eb)?);
+ let fab = face_with(*ea, *eb)?;
+ let (fa3, fb3) = (face_with(*ea, *e3)?, face_with(*eb, *e3)?);
+ let c3 = curve_of(e3)?;
+ let none = || too_large("the blend is larger than the neighbouring faces");
+ // Where the contacts cross on the shared face, and each reaches the third edge.
+ let (va_q, q) = cross(sa.contact(fab)?, sb.contact(fab)?, face(fab)?, v, sa.own(), fit_tol).ok_or_else(none)?;
+ let vb_q = param_on(sb.contact(fab)?, q).ok_or_else(none)?;
+ let (va_x, xa) = cross(sa.contact(fa3)?, &c3, face(fa3)?, v, sa.own(), fit_tol).ok_or_else(none)?;
+ let (vb_x, xb) = cross(sb.contact(fb3)?, &c3, face(fb3)?, v, sb.own(), fit_tol).ok_or_else(none)?;
+ let qv = builder::vertex(p3(q));
+ endpt.insert((*ea, *vid, Some(fab)), qv.clone());
+ endpt.insert((*eb, *vid, Some(fab)), qv.clone());
+ if xa.dist(xb) <= fit_tol * 10.0 {
+ // The crease runs to the third edge.
+ let x = (xa + xb) * 0.5;
+ let xv = ending(e3, x, &[(sa.contact(fa3)?, va_x, fa3), (sb.contact(fb3)?, vb_x, fb3)])?;
+ endpt.insert((*e3, *vid, None), xv.clone());
+ endpt.insert((*ea, *vid, Some(fa3)), xv.clone());
+ endpt.insert((*eb, *vid, Some(fb3)), xv.clone());
+ let (_, out) = sa.end_at(vert);
+ let c = trace(sa, (sa.u(fab)?, va_q, q), (sa.u(fa3)?, va_x, x), &Away::strip(sb), out, fit_tol)?;
+ list.push((mt::Edge::new(&qv, &xv, c), vec![Owner::Strip(*ea), Owner::Strip(*eb)]));
+ } else {
+ // The strip reaching further along the third edge (`big`) runs on past
+ // the crease to end on the other's third face.
+ let (big, small, ebig, esmall, fbig3, fsmall3, x, vbig_x) =
+ if xa.dist(v) > xb.dist(v) { (sa, sb, *ea, *eb, fa3, fb3, xa, va_x) } else { (sb, sa, *eb, *ea, fb3, fa3, xb, vb_x) };
+ let vs_q = if esmall == *ea { va_q } else { vb_q };
+ let (vs_y, y) = reach(small.contact(fsmall3)?, &Away::strip(big), v, fit_tol).ok_or_else(none)?;
+ let (u_y, v_y) = big.nearest(y).ok_or_else(none)?;
+ if big.at(u_y, v_y).dist(y) > fit_tol * 10.0 {
+ return Err(unsupported("blends this different at one corner"));
+ }
+ let xv = ending(e3, x, &[(big.contact(fbig3)?, vbig_x, fbig3)])?;
+ let yv = builder::vertex(p3(y));
+ endpt.insert((*e3, *vid, None), xv.clone());
+ endpt.insert((ebig, *vid, Some(fbig3)), xv.clone());
+ endpt.insert((esmall, *vid, Some(fsmall3)), yv.clone());
+ let (_, out_s) = small.end_at(vert);
+ let (_, out_b) = big.end_at(vert);
+ let crease = trace(small, (small.u(fab)?, vs_q, q), (small.u(fsmall3)?, vs_y, y), &Away::strip(big), out_s, fit_tol)?;
+ let section = trace(big, (u_y, v_y, y), (big.u(fbig3)?, vbig_x, x), &Away::face(face(fsmall3)?), out_b, fit_tol)?;
+ list.push((mt::Edge::new(&qv, &yv, crease), vec![Owner::Strip(*ea), Owner::Strip(*eb)]));
+ list.push((mt::Edge::new(&yv, &xv, section), vec![Owner::Face(fsmall3), Owner::Strip(ebig)]));
+ }
+ }
+ ([e1, e2, e3], []) => {
+ let s1 = strip_of(e1)?;
+ let (f12, f23, f31) = (face_with(*e1, *e2)?, face_with(*e2, *e3)?, face_with(*e3, *e1)?);
+ // The corner ball, from the first strip's section nearest the vertex.
+ let (v1, _) = s1.end_at(vert);
+ let start = s1
+ .sections
+ .iter()
+ .min_by(|a, b| (a.0 - v1).abs().total_cmp(&(b.0 - v1).abs()))
+ .map(|x| x.1.c)
+ .ok_or_else(|| fail("section"))?;
+ let (c, [q12, q23, q31]) = corner_ball([face(f12)?, face(f23)?, face(f31)?], start, r, s1.sigma, tol * 100.0)
+ .ok_or_else(|| unsupported("the ball doesn't fit in the corner"))?;
+ let (v12, v23, v31) = (builder::vertex(p3(q12)), builder::vertex(p3(q23)), builder::vertex(p3(q31)));
+ for (e, f, x) in [(e1, f12, &v12), (e2, f12, &v12), (e2, f23, &v23), (e3, f23, &v23), (e3, f31, &v31), (e1, f31, &v31)] {
+ endpt.insert((*e, *vid, Some(f)), x.clone());
+ }
+ let arc = |a: &mt::Vertex, b: &mt::Vertex| -> Result<mt::Edge> {
+ let m = c + ((vtx(a) - c) + (vtx(b) - c)).normalized().ok_or_else(|| fail("corner arc"))? * r;
+ Ok(builder::circle_arc(a, b, p3(m)))
+ };
+ let (a1, a2, a3) = (arc(&v12, &v31)?, arc(&v12, &v23)?, arc(&v23, &v31)?);
+ // A sphere with its poles and seam away from the patch.
+ let n = |f: usize, q: Vec3| face(f).ok().and_then(|g| project(g, q, None)).map(|x| x.1).unwrap_or(Vec3::Z);
+ let out = (n(f12, q12) + n(f23, q23) + n(f31, q31)).normalized().unwrap_or(Vec3::Z);
+ let side = out.any_perp();
+ let (np, sp, back) = (c + side * r, c - side * r, c - out * r);
+ let meridian = builder::circle_arc(&builder::vertex(p3(np)), &builder::vertex(p3(sp)), p3(back));
+ let surf = mt::Surface::RevolutedCurve(mt::Processor::new(mt::RevolutedCurve::by_revolution(
+ meridian.oriented_curve(),
+ p3(c),
+ v3(side),
+ )));
+ let surf = orient(surf, c + out * r, out * -s1.sigma);
+ let wire: mt::Wire = vec![a2.clone(), a3.clone(), a1.inverse()].into();
+ let patch = mt::Face::try_new(vec![wire], surf).map_err(|e| fail(&format!("corner patch: {e}")))?;
+ patches.push((patch, vec![*e1, *e2, *e3]));
+ list.push((a1, vec![Owner::Strip(*e1), Owner::Patch]));
+ list.push((a2, vec![Owner::Strip(*e2), Owner::Patch]));
+ list.push((a3, vec![Owner::Strip(*e3), Owner::Patch]));
+ }
+ _ => return Err(unsupported("this corner")),
+ }
+ }
+
+ // Rebuilt edges: contacts per (edge, face), shortened edges per edge.
+ let end_of =
+ |id: mt::EdgeID, v: &mt::Vertex, f: Option<usize>| -> mt::Vertex { endpt.get(&(id, v.id(), f)).cloned().unwrap_or_else(|| v.clone()) };
+ let mut lines: HashMap<(mt::EdgeID, Option<usize>), mt::Edge> = HashMap::new();
+ let mut line_of = |e: &mt::Edge, f: Option<usize>| -> Result<mt::Edge> {
+ use mt::Cut;
+ if let Some(x) = lines.get(&(e.id(), f)) {
+ return Ok(x.clone());
+ }
+ let abs = e.absolute_clone();
+ let (a, b) = (end_of(e.id(), abs.front(), f), end_of(e.id(), abs.back(), f));
+ let x = match (f, strips.get(&e.id())) {
+ (Some(fi), Some(s)) => {
+ // The contact between its new ends.
+ let c = s.contact(fi)?;
+ let none = || too_large("the blend is larger than the neighbouring faces");
+ let (ta, tb) = (param_on(c, vtx(&a)).ok_or_else(none)?, param_on(c, vtx(&b)).ok_or_else(none)?);
+ if tb - ta < 1e-9 {
+ return Err(too_large("the blend is larger than the neighbouring faces"));
+ }
+ let mut piece = c.clone();
+ let _ = piece.cut(tb);
+ let piece = piece.cut(ta);
+ mt::Edge::try_new(&a, &b, piece).map_err(|e| fail(&format!("contact: {e}")))?
+ }
+ _ => {
+ let orig = vtx(abs.back()) - vtx(abs.front());
+ if (vtx(&b) - vtx(&a)).dot(orig) <= size * 1e-9 * orig.len() {
+ return Err(too_large("the blend is larger than the neighbouring faces"));
+ }
+ if matches!(abs.curve(), mt::Curve::Line(_)) {
+ builder::line(&a, &b)
+ } else {
+ let moved = |n: &mt::Vertex, o: &mt::Vertex| (n != o).then(|| n.clone());
+ super::trim_curved_seam(&abs, moved(&a, abs.front()), moved(&b, abs.back()), size)?
+ }
+ }
+ };
+ lines.insert((e.id(), f), x.clone());
+ Ok(x)
+ };
+ let changed = |v: &mt::Vertex| touched.contains_key(&v.id()) || gone.contains_key(&v.id());
+ let moved = |e: &mt::Edge| changed(e.front()) || changed(e.back());
+ let everywhere: Vec<(mt::Edge, Vec<Owner>)> = pool.values().flatten().cloned().collect();
+ let mut rec = Rebuild::default();
+ let mut out: Vec<mt::Face> = Vec::with_capacity(faces.len() + strips.len() + patches.len());
+ for (fi, f) in faces.iter().enumerate() {
+ if !f.vertex_iter().any(|v| changed(&v)) {
+ out.push(f.clone());
+ continue;
+ }
+ let mut wires = Vec::new();
+ for w in f.boundaries() {
+ let olds: Vec<mt::Edge> = w.edge_iter().filter(|e| !consumed.contains(&e.id())).cloned().collect();
+ let mut news = Vec::with_capacity(olds.len());
+ for e in &olds {
+ let ne = if strips.contains_key(&e.id()) {
+ line_of(e, Some(fi))?
+ } else if moved(e) {
+ let piece = line_of(e, None)?;
+ rec.piece(&piece, e);
+ piece
+ } else {
+ news.push(e.clone());
+ continue;
+ };
+ news.push(if e.front() == e.absolute_front() { ne } else { ne.inverse() });
+ }
+ let n = news.len();
+ let mut ws = Vec::new();
+ for i in 0..n {
+ let (Some(a), Some(b)) = (news.get(i), news.get((i + 1) % n)) else { continue };
+ ws.push(a.clone());
+ if a.back() != b.front() {
+ ws.extend(connect(a.back(), b.front(), &everywhere, Owner::Face(fi))?);
+ }
+ }
+ wires.push(mt::Wire::from(ws));
+ }
+ let rebuilt = mt::Face::try_new(wires, f.oriented_surface()).map_err(|e| fail(&format!("face: {e}")))?;
+ rec.face(&rebuilt, f);
+ out.push(rebuilt);
+ }
+ // The strips: back along the first face's contact, round the front corner, along the
+ // second's, round the back corner.
+ for id in ids {
+ let (Some(s), Some(e)) = (strips.get(id), edges.get(id)) else { continue };
+ let (va, vb) = (e.front(), e.back());
+ let a_forward = faces.get(s.fa).is_some_and(|f| f.boundaries().iter().any(|w| w.edge_iter().any(|x| x.id() == *id && x.front() == va)));
+ let la = line_of(e, Some(s.fa))?;
+ let lb = line_of(e, Some(s.fb))?;
+ let (first, second) = if a_forward { (la.inverse(), lb) } else { (lb.inverse(), la) };
+ let p1 = pool.get(&va.id()).map(|x| &x[..]).unwrap_or(&[]);
+ let p2 = pool.get(&vb.id()).map(|x| &x[..]).unwrap_or(&[]);
+ let mut w = vec![first.clone()];
+ w.extend(connect(first.back(), second.front(), p1, Owner::Strip(*id))?);
+ w.push(second.clone());
+ w.extend(connect(second.back(), first.front(), p2, Owner::Strip(*id))?);
+ let surface = if s.flip < 0.0 { mt::Invertible::inverse(&s.surface) } else { s.surface.clone() };
+ let surface = in_proportion(&surface)?;
+ let blend = mt::Face::try_new(vec![w.into()], surface).map_err(|e| fail(&format!("blend face: {e}")))?;
+ rec.blend(&blend, [*id]);
+ out.push(blend);
+ }
+ // Corner patches run each section opposite to its strip.
+ for (mut p, corner) in patches {
+ let uses = |f: &mt::Face, id: mt::EdgeID| {
+ f.boundaries().iter().flat_map(|w| w.edge_iter().cloned().collect::<Vec<_>>()).find(|x| x.id() == id).map(|x| x.front().id())
+ };
+ let flip = p
+ .boundaries()
+ .first()
+ .and_then(|w| w.edge_iter().next())
+ .and_then(|pe| out.iter().find_map(|f| uses(f, pe.id())).map(|front| front == pe.front().id()));
+ if flip == Some(true) {
+ let surf = p.oriented_surface();
+ let wires: Vec<mt::Wire> = p.boundaries().iter().map(|w| w.inverse()).collect();
+ p = mt::Face::try_new(wires, surf).map_err(|e| fail(&format!("corner patch: {e}")))?;
+ }
+ rec.blend(&p, corner);
+ out.push(p);
+ }
+ let mut shells = solid.boundaries().clone();
+ if let Some(sh) = shells.get_mut(si) {
+ *sh = out.into();
+ }
+ let res = Solid::try_new(shells).map_err(|e| fail(&format!("invalid solid: {e}")))?;
+ Ok((res, rec))
+ })
+}
+
+#[cfg(test)]
+#[path = "curvecorner_tests.rs"]
+mod tests;
diff --git a/crates/kernel/src/curvecorner_tests.rs b/crates/kernel/src/curvecorner_tests.rs
new file mode 100644
index 0000000000..7773a2b9ff
--- /dev/null
+++ b/crates/kernel/src/curvecorner_tests.rs
@@ -0,0 +1,312 @@
+use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
+
+use crate::Body;
+
+const X0: f64 = 41.0 + 1.0 / 6.0;
+/// The arc's axis.
+const CX: f64 = X0 + 21.0;
+
+/// The arc part: a 41⅙ × 21 rectangle and, beside it, the corner a circle of radius 21 about
+/// (CX, −21) leaves against the top line it touches (its arc square to the front, a knife edge
+/// at the tip), extruded 10.
+fn arc_part() -> Body {
+ scaled_arc_part(1.0)
+}
+
+/// [`arc_part`] scaled by `k` about the origin.
+fn scaled_arc_part(k: f64) -> Body {
+ let p = |x: f64, y: f64| Vec2::new(x * k, y * k);
+ let segs = vec![
+ Seg2::Line { a: p(0.0, 0.0), b: p(0.0, -21.0) },
+ Seg2::Line { a: p(0.0, -21.0), b: p(X0, -21.0) },
+ Seg2::Arc { center: p(CX, -21.0), radius: 21.0 * k, start: std::f64::consts::PI, sweep: -std::f64::consts::FRAC_PI_2 },
+ Seg2::Line { a: p(CX, 0.0), b: p(0.0, 0.0) },
+ ];
+ crate::extrude(&Plane::XY, &[Region2 { outer: Loop2 { segs }, holes: vec![] }], 0.0, 10.0 * k).unwrap().pop().unwrap()
+}
+
+/// Points on the edges at the top: the long front edge, the arc, the back edge; the uprights
+/// between the front and the arc, and at the tip (a knife edge); the left top edge and the
+/// left front upright.
+const LONG: Vec3 = Vec3::new(20.0, -21.0, 10.0);
+fn arc_top() -> Vec3 {
+ let a = std::f64::consts::FRAC_PI_4;
+ Vec3::new(CX - 21.0 * a.cos(), -21.0 + 21.0 * a.sin(), 10.0)
+}
+const BACK: Vec3 = Vec3::new(30.0, 0.0, 10.0);
+const UPRIGHT: Vec3 = Vec3::new(X0, -21.0, 5.0);
+const TIP: Vec3 = Vec3::new(CX, 0.0, 5.0);
+const LEFT: Vec3 = Vec3::new(0.0, -10.0, 10.0);
+const LEFT_FRONT: Vec3 = Vec3::new(0.0, -21.0, 5.0);
+
+/// The volume of the body's display mesh, asserting it is closed (the legacy mesher can misread
+/// a zero-angle face corner such as the tip's).
+fn volume(b: &Body) -> f64 {
+ crate::issue_851_tests::planned_volume(b)
+}
+
+/// What a blend (radius or distance 2) of the edges at `pts` takes off the part.
+fn removed(round: bool, pts: &[Vec3]) -> f64 {
+ let body = arc_part();
+ let b = if round { crate::fillet(&body, pts, 2.0) } else { crate::chamfer(&body, pts, 2.0) }.unwrap();
+ volume(&body) - volume(&b)
+}
+
+/// The part's material at `p`.
+fn in_part(p: Vec3) -> bool {
+ (0.0..=CX).contains(&p.x) && (-21.0..=0.0).contains(&p.y) && (0.0..=10.0).contains(&p.z) && (p.x <= X0 || (p.x - CX).hypot(p.y + 21.0) >= 21.0)
+}
+
+/// Rounds of radius 2 about the top front corner of the arc: what each edge's round alone
+/// takes off there (between the edge and the ball, on the edge's side of its contacts).
+fn off_long(p: Vec3) -> bool {
+ in_part(p) && p.y < -19.0 && p.z > 8.0 && (p.y + 19.0).hypot(p.z - 8.0) > 2.0
+}
+/// The upright's ball, 2 from the front and 23 from the arc's axis.
+fn upright_centre() -> f64 {
+ CX - (23.0f64 * 23.0 - 4.0).sqrt()
+}
+fn off_upright(p: Vec3) -> bool {
+ let (dx, dy) = (p.x - upright_centre(), p.y + 19.0);
+ let a = dy.atan2(dx);
+ in_part(p) && a >= -std::f64::consts::FRAC_PI_2 && a <= (-2.0f64).atan2(CX - upright_centre()) && dx.hypot(dy) > 2.0
+}
+fn off_arc(p: Vec3) -> bool {
+ let rho = (p.x - CX).hypot(p.y + 21.0);
+ in_part(p) && p.y >= -21.0 && rho < 23.0 && p.z > 8.0 && (rho - 23.0).hypot(p.z - 8.0) > 2.0
+}
+/// Kept when all three are rounded and the corner with them: within 2 of a ball centre 2 from
+/// all three faces (z ≤ 8, y ≥ −19, 23 from the arc's axis), the nearest on a face, an edge
+/// or the corner of that region.
+fn kept_by_balls(p: Vec3) -> bool {
+ let c = Vec3::new(upright_centre(), -19.0, 8.0);
+ let inside = |q: Vec3| q.z <= 8.0 + 1e-12 && q.y >= -19.0 - 1e-12 && (q.x - CX).hypot(q.y + 21.0) >= 23.0 - 1e-12;
+ let mut near =
+ vec![c, Vec3::new(p.x.min(c.x), -19.0, 8.0), Vec3::new(c.x, -19.0, p.z.min(8.0)), Vec3::new(p.x, p.y, 8.0), Vec3::new(p.x, -19.0, p.z)];
+ let (dx, dy) = (p.x - CX, p.y + 21.0);
+ let d = dx.hypot(dy);
+ if d > 1e-9 {
+ let (ux, uy) = (dx / d, dy / d);
+ near.push(Vec3::new(CX + ux * 23.0, -21.0 + uy * 23.0, p.z));
+ near.push(Vec3::new(CX + ux * 23.0, -21.0 + uy * 23.0, 8.0));
+ }
+ in_part(p) && (inside(p) || near.iter().filter(|q| inside(**q)).any(|q| q.dist(p) <= 2.0))
+}
+
+/// Volume of the points of the box about the corner where `f` holds (midpoint rule).
+fn corner_volume(f: impl Fn(Vec3) -> bool) -> f64 {
+ let h = 0.02;
+ let (lo, hi) = (Vec3::new(38.0, -21.0, 7.5), Vec3::new(42.5, -17.5, 10.0));
+ let n = |a: f64, b: f64| ((b - a) / h).round() as usize;
+ let mut count = 0usize;
+ for i in 0..n(lo.x, hi.x) {
+ for j in 0..n(lo.y, hi.y) {
+ for k in 0..n(lo.z, hi.z) {
+ if f(lo + Vec3::new((i as f64 + 0.5) * h, (j as f64 + 0.5) * h, (k as f64 + 0.5) * h)) {
+ count += 1;
+ }
+ }
+ }
+ }
+ count as f64 * h * h * h
+}
+
+/// Two or three of the edges at the arc's top front corner rounded together: the strips cut
+/// each other in a crease (the long one running on past it to end in the arc wall, as far as
+/// its contact reaches along the arc's edge), and with all three a piece of the ball touching
+/// the three faces fills the corner. What they take off: each round alone, less what each alone
+/// takes in a box about the corner, plus what they take there together (rolling-ball rounds
+/// trim each other where each one's corner region ends; with three, what no ball inside the
+/// part reaches).
+#[test]
+fn rounds_meeting_at_a_corner_of_an_arc_wall() {
+ let offs: [(Vec3, fn(Vec3) -> bool); 3] = [(LONG, off_long), (arc_top(), off_arc), (UPRIGHT, off_upright)];
+ let alone: Vec<f64> = offs.iter().map(|(p, f)| removed(true, &[*p]) - corner_volume(f)).collect();
+ for which in [vec![0, 2], vec![0, 1], vec![1, 2], vec![0, 1, 2]] {
+ let pts: Vec<Vec3> = which.iter().map(|i| offs[*i].0).collect();
+ let fs: Vec<fn(Vec3) -> bool> = which.iter().map(|i| offs[*i].1).collect();
+ let together = if which.len() == 3 { corner_volume(|p| in_part(p) && !kept_by_balls(p)) } else { corner_volume(|p| fs.iter().any(|f| f(p))) };
+ let want = which.iter().map(|i| alone[*i]).sum::<f64>() + together;
+ let got = removed(true, &pts);
+ assert!((got - want).abs() < 0.03, "{which:?}: removed {got} vs {want}");
+ }
+}
+
+/// The ball at the knife-edge tip: 2 below the top line and 23 from the arc's axis.
+fn tip_ball() -> Vec2 {
+ Vec2::new(CX - (23.0f64 * 23.0 - 19.0 * 19.0).sqrt(), -2.0)
+}
+
+/// Integral over the cusp between the arc and the top line (midpoint rule, the last cell of
+/// each column cut at the top line), from `x0` to the tip.
+fn over_cusp(x0: f64, f: impl Fn(f64, f64) -> f64) -> f64 {
+ let (hx, hy) = (0.001, 0.0002);
+ let mut sum = 0.0;
+ let mut x = x0 + hx / 2.0;
+ while x < CX {
+ let lo = -21.0 + (441.0 - (x - CX) * (x - CX)).max(0.0).sqrt();
+ let n = ((0.0 - lo) / hy).ceil().max(0.0) as usize;
+ sum += (0..n)
+ .map(|j| {
+ let (y0, y1) = (lo + j as f64 * hy, (lo + (j + 1) as f64 * hy).min(0.0));
+ f(x, (y0 + y1) * 0.5) * (y1 - y0)
+ })
+ .sum::<f64>()
+ * hx;
+ x += hx;
+ }
+ sum
+}
+
+/// Whether the tip's round takes off (x, y), all the way up: the cusp beyond the ball, on the
+/// tip's side of its contacts.
+fn off_tip(x: f64, y: f64) -> bool {
+ let k = tip_ball();
+ let a = (y - k.y).atan2(x - k.x);
+ (x - k.x).hypot(y - k.y) > 2.0 && a >= (-21.0 - k.y).atan2(CX - k.x) && a <= std::f64::consts::FRAC_PI_2
+}
+
+/// The knife-edge tip (the arc and the top line meeting at no angle) rounds to the ball 2 from
+/// both, 13 back from the tip; its chamfer cuts the cusp at the chord between the same contacts.
+#[test]
+fn a_knife_edge_tip_rounds_where_the_ball_fits() {
+ let k = tip_ball();
+ let round = over_cusp(k.x - 1.0, |x, y| if off_tip(x, y) { 1.0 } else { 0.0 }) * 10.0;
+ let got = removed(true, &[TIP]);
+ assert!((got - round).abs() < round * 1e-3, "round: removed {got} vs {round}");
+ // The chord from the top line's contact to the arc's.
+ let (a, b) = (Vec2::new(k.x, 0.0), k + (Vec2::new(CX, -21.0) - k) * (2.0 / 23.0));
+ let beyond = |x: f64, y: f64| (b.x - a.x) * (y - a.y) - (b.y - a.y) * (x - a.x) > 0.0;
+ let flat = over_cusp(k.x - 1.0, |x, y| if beyond(x, y) { 1.0 } else { 0.0 }) * 10.0;
+ let got = removed(false, &[TIP]);
+ assert!((got - flat).abs() < flat * 1e-3, "chamfer: removed {got} vs {flat}");
+}
+
+/// The tip's round with the arc's or the back edge's at the top, where all three meet: as at
+/// the front corner, each alone less what both would take twice — over the tip's corner region,
+/// the other's (above 8 + √(4 − d²), d across from its ball's path).
+#[test]
+fn rounds_meeting_at_a_knife_edge_tip() {
+ let k = tip_ball();
+ let tip = removed(true, &[TIP]);
+ let arc_d = |x: f64, y: f64| 23.0 - (x - CX).hypot(y + 21.0);
+ let back_d = |_: f64, y: f64| y + 2.0;
+ for (edge, d) in [(arc_top(), &arc_d as &dyn Fn(f64, f64) -> f64), (BACK, &back_d)] {
+ let both = over_cusp(k.x - 1.0, |x, y| {
+ let d = d(x, y);
+ if off_tip(x, y) && d > 0.0 && d < 2.0 { 2.0 - (4.0 - d * d).sqrt() } else { 0.0 }
+ });
+ let want = tip + removed(true, &[edge]) - both;
+ let got = removed(true, &[edge, TIP]);
+ assert!((got - want).abs() < want * 1e-3, "{edge:?}: removed {got} vs {want}");
+ }
+}
+
+/// Chamfers of the long top edge and the arc's top edge meeting at the front corner: their
+/// planes (the arc's a cone) cut each other. Each alone, less what both take: over the top's
+/// corner, 10 − z above both 8 + d (d across from the front face, or from the arc toward its axis).
+#[test]
+fn chamfers_meeting_at_a_corner_of_an_arc_wall() {
+ let h = 0.002;
+ let mut both = 0.0;
+ for i in 0..((44.0 - 36.0) / h) as usize {
+ for j in 0..(3.0 / h) as usize {
+ let (x, y) = (36.0 + (i as f64 + 0.5) * h, -21.0 + (j as f64 + 0.5) * h);
+ let rho = (x - CX).hypot(y + 21.0);
+ if in_part(Vec3::new(x, y, 9.99)) && y < -19.0 && rho < 23.0 {
+ both += (2.0 - (y + 21.0).max(rho - 21.0)).max(0.0) * h * h;
+ }
+ }
+ }
+ let want = removed(false, &[LONG]) + removed(false, &[arc_top()]) - both;
+ let got = removed(false, &[LONG, arc_top()]);
+ assert!((got - want).abs() < want * 1e-3, "removed {got} vs {want}");
+}
+
+/// A fillet over an earlier one at the end of its edge, as a feature of its own: the new round
+/// ends in the earlier one (running on past it across the next face when the earlier one's end
+/// is shorter than the new round), taking off what the two take together.
+#[test]
+fn a_round_ending_in_an_earlier_round_matches_both_together() {
+ for (first, then) in [
+ (LONG, LEFT),
+ (LONG, LEFT_FRONT),
+ (LONG, arc_top()),
+ (arc_top(), LONG),
+ (LONG, UPRIGHT),
+ (arc_top(), UPRIGHT),
+ // At the knife-edge tip, where the first round's end takes in the tip's corner.
+ (arc_top(), TIP),
+ (BACK, TIP),
+ (arc_top(), BACK),
+ ] {
+ one_then_the_other(first, then);
+ }
+}
+
+/// The back edge rounded first, then the arc's top edge: the arc's round leaves 0.05 mm³ more at
+/// the knife-edge tip than both together, or the other order.
+#[test]
+#[ignore = "not yet: the arc's round after the back edge's leaves 0.05 mm³ more at the tip"]
+fn the_arc_rounded_after_the_back_edge_matches_both_together() {
+ one_then_the_other(BACK, arc_top());
+}
+
+/// The edge at `first` rounded (2), then the one at `then` as a fillet of its own, against both
+/// rounded together.
+fn one_then_the_other(first: Vec3, then: Vec3) {
+ let body = arc_part();
+ let step = crate::fillet(&body, &[first], 2.0).unwrap();
+ let after = crate::fillet(&step, &[then], 2.0).unwrap();
+ let v = volume(&after);
+ let together = volume(&crate::fillet(&body, &[first, then], 2.0).unwrap());
+ // Within the display meshes' accuracy (two different B-reps, meshed apart).
+ assert!((v - together).abs() < 5e-3, "{first:?} then {then:?}: {v} vs together {together}");
+}
+
+/// Edges rounded together come out the same in any order: a round made first doesn't carry the
+/// next one on along its arc into edges nobody selected.
+#[test]
+fn rounds_together_in_any_order() {
+ let body = arc_part();
+ for (a, b) in [(UPRIGHT, LONG), (TIP, arc_top()), (TIP, BACK)] {
+ let v = |x: &[Vec3]| volume(&crate::fillet(&body, x, 2.0).unwrap());
+ let (ab, ba) = (v(&[a, b]), v(&[b, a]));
+ assert!((ab - ba).abs() < 1e-3, "{a:?} + {b:?}: {ab} vs {ba}");
+ }
+}
+
+/// The blends this part needs the corner build for (and the back edge, rolled into the tip) at
+/// 0.01 and 100 times the part's size, the radius scaled with it: they take off what they take at
+/// full size, scaled by the cube, so the build's tolerances and limits follow the model's size.
+#[test]
+fn corner_blends_hold_at_any_scale() {
+ let cases: [(&str, Vec<Vec<Vec3>>); 6] = [
+ ("tip and arc", vec![vec![TIP, arc_top()]]),
+ ("arc and tip", vec![vec![arc_top(), TIP]]),
+ ("back into the tip", vec![vec![BACK]]),
+ ("arc, then tip", vec![vec![arc_top()], vec![TIP]]),
+ ("back, then tip", vec![vec![BACK], vec![TIP]]),
+ ("arc, then back", vec![vec![arc_top()], vec![BACK]]),
+ ];
+ // What a blend takes off the part scaled by `k`, over k³, through a display plan of matching
+ // accuracy.
+ let removed = |k: f64, steps: &[Vec<Vec3>]| {
+ let volume = |b: &Body| b.display_plan(2e-4 * k).unwrap().evaluate().measure().volume;
+ let body = scaled_arc_part(k);
+ let mut b = body.clone();
+ for pts in steps {
+ let pts: Vec<Vec3> = pts.iter().map(|p| *p * k).collect();
+ b = crate::fillet(&b, &pts, 2.0 * k).unwrap_or_else(|e| panic!("at {k}x: {steps:?}: {e}"));
+ assert!(b.validity().is_empty(), "at {k}x: {steps:?}: {:?}", b.validity());
+ }
+ (volume(&body) - volume(&b)) / (k * k * k)
+ };
+ for (name, steps) in &cases {
+ let full = removed(1.0, steps);
+ for k in [0.01, 100.0] {
+ let got = removed(k, steps);
+ assert!((got - full).abs() < full * 1e-4, "{name} at {k}x: removed {got} (scaled back) vs {full}");
+ }
+ }
+}
diff --git a/crates/kernel/src/issue_851_tests.rs b/crates/kernel/src/issue_851_tests.rs
index ba0673e45f..1bea650c93 100644
--- a/crates/kernel/src/issue_851_tests.rs
+++ b/crates/kernel/src/issue_851_tests.rs
@@ -163,7 +163,7 @@ fn arc_top_removed(size: f64, round: bool) -> f64 {
/// Volume through the display planner (the mesh the app draws): closed and exact where the
/// legacy mesher behind `measure` can leak at a zero-angle corner like the one at the tip.
-fn planned_volume(b: &Body) -> f64 {
+pub(crate) fn planned_volume(b: &Body) -> f64 {
let mesh = b.display_plan(2e-4).unwrap().evaluate();
let key = |p: Vec3| [p.x.to_bits(), p.y.to_bits(), p.z.to_bits()];
let mut uses: std::collections::HashMap<([u64; 3], [u64; 3]), i32> = std::collections::HashMap::new();
diff --git a/crates/kernel/src/loopblend.rs b/crates/kernel/src/loopblend.rs
index 7538747e21..ab50132a99 100644
--- a/crates/kernel/src/loopblend.rs
+++ b/crates/kernel/src/loopblend.rs
@@ -271,6 +271,27 @@ fn build(
side = sd;
walls.push(wf);
}
+ // A run ends in the cross-section through its end vertex: the face there must hold it (a
+ // plane square to the run). One at an angle cuts the blend's two contacts at different
+ // places, which the rolling-ball blend handles.
+ if open {
+ let ends = [
+ (edges.first().map(|e| e.front().clone()), segs.first().map(|s| (s.start(), *s))),
+ (edges.last().map(|e| e.back().clone()), segs.last().map(|s| (s.end(), *s))),
+ ];
+ for (v, seg) in ends {
+ let (Some(v), Some((p, s))) = (v, seg) else { return Err(KernelError::Failed("run end".into())) };
+ let t = s.tangent(p).ok_or_else(|| unsupported("degenerate loop edge"))?;
+ let square = faces
+ .iter()
+ .enumerate()
+ .filter(|(gi, g)| *gi != fi && !walls.contains(gi) && g.vertex_iter().any(|x| x == v))
+ .all(|(_, g)| plane_normal(g).is_some_and(|gn| gn.dot(t).abs() > 1.0 - 1e-6));
+ if !square {
+ return Err(unsupported("a run of edges ending at a face at an angle"));
+ }
+ }
+ }
// Cross-section at a loop point: into the face (m) and up the wall (t, away from the edge,
// up a concave wall and down a convex one). The ball of radius r touches both at the
// setback s = r / tan(φ/2), φ the angle between m and t; its centre is on the bisector.
diff --git a/tests/action_matrix/baseline.json b/tests/action_matrix/baseline.json
index 6483585b25..abbb9eeaa0 100644
--- a/tests/action_matrix/baseline.json
+++ b/tests/action_matrix/baseline.json
@@ -8454,20 +8454,20 @@
"Wave/F2:side:a1": "curved.axis curved.tangent_plane",
"Wave/F2:side:a1|F2:side:a2": "edge.axis edge.normal_plane edge.project",
"Wave/F2:side:a1|F2:side:l3": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.normal_plane+edit edge.project",
- "Wave/F2:side:a1|F2:start": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
- "Wave/F2:side:a1|F2:top": "!edge.chamfer !edge.fillet edge.normal_plane edge.project edge.project+edit",
+ "Wave/F2:side:a1|F2:start": "edge.chamfer edge.fillet edge.normal_plane edge.project",
+ "Wave/F2:side:a1|F2:top": "edge.chamfer edge.fillet edge.normal_plane edge.project edge.project+edit",
"Wave/F2:side:a2": "curved.axis curved.tangent_plane",
"Wave/F2:side:a2|F2:side:a3": "edge.axis edge.normal_plane edge.normal_plane+edit edge.project",
- "Wave/F2:side:a2|F2:start": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
- "Wave/F2:side:a2|F2:top": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Wave/F2:side:a2|F2:start": "edge.chamfer edge.fillet edge.normal_plane edge.project",
+ "Wave/F2:side:a2|F2:top": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Wave/F2:side:a3": "curved.axis curved.tangent_plane",
"Wave/F2:side:a3|F2:side:a4": "edge.axis edge.normal_plane edge.normal_plane+edit edge.project",
- "Wave/F2:side:a3|F2:start": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
- "Wave/F2:side:a3|F2:top": "!edge.chamfer !edge.fillet edge.normal_plane edge.project edge.project+edit",
+ "Wave/F2:side:a3|F2:start": "edge.chamfer edge.fillet edge.normal_plane edge.project",
+ "Wave/F2:side:a3|F2:top": "edge.chamfer edge.fillet edge.normal_plane edge.project edge.project+edit",
"Wave/F2:side:a4": "curved.axis curved.tangent_plane",
"Wave/F2:side:a4|F2:side:l1": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project edge.project+edit",
- "Wave/F2:side:a4|F2:start": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
- "Wave/F2:side:a4|F2:top": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Wave/F2:side:a4|F2:start": "edge.chamfer edge.fillet edge.normal_plane edge.project",
+ "Wave/F2:side:a4|F2:top": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Wave/F2:side:l1": "face.angle_plane !face.draft_neutral face.extrude face.extrude+edit face.hole face.midplane face.offset_plane face.press_pull !face.shell face.sketch",
"Wave/F2:side:l1|F2:side:l2": "edge.axis edge.chamfer edge.fillet edge.fillet+edit edge.normal_plane edge.project",
"Wave/F2:side:l1|F2:start": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
@@ -9166,7 +9166,7 @@
},
"oracle/73-sm-hem": {
"Body1/F2:face:0": "face.angle_plane !face.draft_neutral face.extrude face.hole face.midplane face.offset_plane face.press_pull face.shell face.sketch",
- "Body1/F2:face:0|F2:face:3#[F2:face:0,F2:face:1,F2:face:4]": "edge.axis edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F2:face:0|F2:face:3#[F2:face:0,F2:face:1,F2:face:4]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F2:face:0|F2:face:4": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F2:face:0|F2:face:5#[F2:face:0,F2:face:1,F2:face:4]": "edge.axis edge.chamfer !edge.fillet edge.normal_plane edge.project",
"Body1/F2:face:0|F3:face:10": "edge.axis edge.normal_plane edge.project",
@@ -9179,7 +9179,7 @@
"Body1/F2:face:3#[F2:face:0,F2:face:1,F2:face:4]|F2:face:3#[F3:face:10,F3:face:11,F3:face:9]": "edge.axis edge.normal_plane edge.project",
"Body1/F2:face:3#[F2:face:0,F2:face:1,F2:face:4]|F2:face:4": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F2:face:3#[F3:face:10,F3:face:11,F3:face:9]": "face.angle_plane face.extrude !face.hole face.midplane face.offset_plane face.press_pull face.shell face.sketch",
- "Body1/F2:face:3#[F3:face:10,F3:face:11,F3:face:9]|F3:face:10": "edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F2:face:3#[F3:face:10,F3:face:11,F3:face:9]|F3:face:10": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F2:face:3#[F3:face:10,F3:face:11,F3:face:9]|F3:face:11": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F2:face:3#[F3:face:10,F3:face:11,F3:face:9]|F3:face:9": "edge.axis edge.normal_plane edge.project",
"Body1/F2:face:4": "face.angle_plane !face.draft_neutral face.extrude !face.hole face.midplane face.offset_plane face.press_pull face.shell face.sketch",
@@ -9466,7 +9466,7 @@
"Body1/F4:face:10|F4:face:14": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F4:face:10|F4:face:19": "edge.axis edge.normal_plane edge.project",
"Body1/F4:face:11": "face.angle_plane !face.draft_neutral face.extrude face.hole face.midplane face.offset_plane face.press_pull !face.shell face.sketch",
- "Body1/F4:face:11|F4:face:12": "edge.axis edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F4:face:11|F4:face:12": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F4:face:11|F4:face:13": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F4:face:11|F4:face:14": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F4:face:11|F4:face:20": "edge.axis edge.normal_plane edge.project",
@@ -11277,38 +11277,38 @@
"Body1/F3:end|F3:side:l4#[F3:end]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l1#1|F3:side:l1#2": "edge.axis edge.normal_plane edge.project",
"Body1/F3:side:l1#1|F3:side:l1#[F3:start]": "edge.axis edge.normal_plane edge.project",
- "Body1/F3:side:l1#1|F3:side:l2#1": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
- "Body1/F3:side:l1#1|F3:side:l4#1": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l1#1|F3:side:l2#1": "edge.chamfer edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l1#1|F3:side:l4#1": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l1#2|F3:side:l1#[F3:end]": "edge.axis edge.normal_plane edge.project",
- "Body1/F3:side:l1#2|F3:side:l2#2": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
- "Body1/F3:side:l1#2|F3:side:l4#2": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l1#2|F3:side:l2#2": "edge.chamfer edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l1#2|F3:side:l4#2": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l1#[F3:end]": "face.angle_plane !face.draft_neutral face.extrude face.hole face.midplane face.offset_plane face.press_pull !face.shell face.sketch",
- "Body1/F3:side:l1#[F3:end]|F3:side:l2#[F3:end]": "edge.axis !edge.chamfer !edge.fillet edge.normal_plane edge.project",
- "Body1/F3:side:l1#[F3:end]|F3:side:l4#[F3:end]": "edge.axis !edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l1#[F3:end]|F3:side:l2#[F3:end]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l1#[F3:end]|F3:side:l4#[F3:end]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l1#[F3:start]": "face.angle_plane !face.draft_neutral face.extrude face.hole face.midplane face.offset_plane face.press_pull !face.shell face.sketch",
- "Body1/F3:side:l1#[F3:start]|F3:side:l2#[F3:start]": "edge.axis !edge.chamfer !edge.fillet edge.normal_plane edge.project",
- "Body1/F3:side:l1#[F3:start]|F3:side:l4#[F3:start]": "edge.axis !edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l1#[F3:start]|F3:side:l2#[F3:start]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l1#[F3:start]|F3:side:l4#[F3:start]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l1#[F3:start]|F3:start": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l2#1": "curved.axis curved.tangent_plane",
"Body1/F3:side:l2#1|F3:side:l2#[F3:start]": "edge.axis edge.normal_plane edge.project",
- "Body1/F3:side:l2#1|F3:side:l3#1": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l2#1|F3:side:l3#1": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l2#2": "curved.axis curved.tangent_plane",
"Body1/F3:side:l2#2|F3:side:l2#[F3:end]": "edge.axis edge.normal_plane edge.project",
- "Body1/F3:side:l2#2|F3:side:l3#2": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l2#2|F3:side:l3#2": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l2#[F3:end]": "face.angle_plane !face.draft_neutral face.extrude face.hole face.midplane face.offset_plane face.press_pull !face.shell face.sketch",
- "Body1/F3:side:l2#[F3:end]|F3:side:l3#[F3:end]": "edge.axis !edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l2#[F3:end]|F3:side:l3#[F3:end]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l2#[F3:start]": "face.angle_plane !face.draft_neutral face.extrude face.hole face.midplane face.offset_plane face.press_pull !face.shell face.sketch",
- "Body1/F3:side:l2#[F3:start]|F3:side:l3#[F3:start]": "edge.axis !edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l2#[F3:start]|F3:side:l3#[F3:start]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l2#[F3:start]|F3:start": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l3#1|F3:side:l3#2": "edge.axis edge.normal_plane edge.project",
"Body1/F3:side:l3#1|F3:side:l3#[F3:start]": "edge.axis edge.normal_plane edge.project",
- "Body1/F3:side:l3#1|F3:side:l4#1": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l3#1|F3:side:l4#1": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l3#2|F3:side:l3#[F3:end]": "edge.axis edge.normal_plane edge.project",
- "Body1/F3:side:l3#2|F3:side:l4#2": "!edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l3#2|F3:side:l4#2": "edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l3#[F3:end]": "face.angle_plane !face.draft_neutral face.extrude face.hole face.offset_plane face.press_pull !face.shell face.sketch",
- "Body1/F3:side:l3#[F3:end]|F3:side:l4#[F3:end]": "edge.axis !edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l3#[F3:end]|F3:side:l4#[F3:end]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l3#[F3:start]": "face.angle_plane !face.draft_neutral face.extrude face.hole face.midplane face.offset_plane face.press_pull !face.shell face.sketch",
- "Body1/F3:side:l3#[F3:start]|F3:side:l4#[F3:start]": "edge.axis !edge.chamfer !edge.fillet edge.normal_plane edge.project",
+ "Body1/F3:side:l3#[F3:start]|F3:side:l4#[F3:start]": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l3#[F3:start]|F3:start": "edge.axis edge.chamfer edge.fillet edge.normal_plane edge.project",
"Body1/F3:side:l4#1": "curved.axis curved.tangent_plane",
"Body1/F3:side:l4#1|F3:side:l4#[F3:start]": "edge.axis edge.normal_plane edge.project",
diff --git a/tests/robustness/goldens.json b/tests/robustness/goldens.json
index 5c963874f7..2e1dce84d3 100644
--- a/tests/robustness/goldens.json
+++ b/tests/robustness/goldens.json
@@ -34,7 +34,7 @@
"30": {"area":853.525389,"bodies":1,"edges":23,"error":null,"faces":10,"outcome":"ok","rejected":0,"shells":1,"steps":["revolved section","chamfer"],"unsupported":0,"volume":1337.14821},
"31": {"area":10195.46137,"bodies":3,"edges":69,"error":null,"faces":30,"outcome":"ok","rejected":1,"shells":3,"steps":["box","cut box","fillet","join box","circular pattern","cut box","circular pattern","hole"],"unsupported":1,"volume":56416.127527},
"32": {"area":3220.802769,"bodies":1,"edges":51,"error":null,"faces":19,"outcome":"ok","rejected":0,"shells":1,"steps":["revolved section","cut sphere","cut box","cut box","join box"],"unsupported":0,"volume":7565.955897},
- "33": {"area":5285.817318,"bodies":2,"edges":59,"error":null,"faces":27,"outcome":"ok","rejected":0,"shells":3,"steps":["revolved section","fillet","join box","cut cylinder","chamfer","join box","chamfer","fillet"],"unsupported":2,"volume":13859.24945},
+ "33": {"area":5286.736353,"bodies":2,"edges":59,"error":null,"faces":27,"outcome":"ok","rejected":0,"shells":3,"steps":["revolved section","fillet","join box","cut cylinder","chamfer","join box","chamfer","fillet"],"unsupported":2,"volume":13858.467983},
"34": {"area":1086.303472,"bodies":1,"edges":30,"error":null,"faces":14,"outcome":"ok","rejected":0,"shells":1,"steps":["revolved section","cut sphere","hole"],"unsupported":0,"volume":2134.365275},
"35": {"area":4605.630216,"bodies":1,"edges":26,"error":null,"faces":11,"outcome":"ok","rejected":0,"shells":1,"steps":["box","fillet","join box"],"unsupported":0,"volume":13965.526982},
"36": {"area":10408.825748,"bodies":1,"edges":60,"error":null,"faces":26,"outcome":"ok","rejected":0,"shells":2,"steps":["revolved section","cut cylinder","join box","fillet","join cylinder"],"unsupported":0,"volume":55729.313103},
@@ -112,6 +112,7 @@
{"reason":"the last-resort tool nudge is tried the other way when it fails or leaves sliver faces the operands didn't have: seed 43's join builds and the design runs to the end, 31 and 78 come out with fewer faces (#827, #897)","seeds":[31,43,78]},
{"reason":"main's fillet changes since the last record (#926, #949) move seeds 33 and 91: a fillet step builds differently or is picked differently","seeds":[33,91]},
{"reason":"hole tangent inside a stepped boss: touching sews split zero-thickness curved walls, so a pattern of holes spaced by their diameter (touching) in a stepped body cuts exactly instead of by a tool nudge: 42 builds more faces (the walls split where the holes touch), 51 picks other edges afterwards","seeds":[42,51]},
+ {"reason":"corner blends on curved faces (#854): seed 33's last fillet (its second body) is built differently; its display-plan and measured volumes now agree (4442.73 mm³; on main they read 4439.42 and 4443.51)","seeds":[33]},
{"reason":"#952: a hole placed on a face drills into the material; seed 81's hole moves its volume by 0.1 mm\u00b3 (area by 0.04 mm\u00b2)","seeds":[81]}
]
}