Files
makeCAD/crates/kernel/src/corner_g2_tests.rs
T
jyviko dc38349cbf Layer split stage 1: the B-rep record, native body file and Vec/Plane come from solidcore-record (#11496)
* Kernel: the B-rep record and the native body file come from solidcore-record

SolidCraft's portable B-rep record (`solidcraft_geom::brep`: brep.rs, topology, history,
envelope, part, curve2) and the native body file (`solidcraft_kernel::native`: the tagged binary
codec and the container) move to solidcore's `solidcore-record` crate: geometry as data, with
structural validation and no maths (solidcore's docs/layers.md, stage 1). Every caller uses
`solidcore_record::brep` and `solidcore_record::native`; the old copies are deleted.

What computes from coordinates stays with the kernel, in geom's `brep`:
- `brep::check`: the record's geometric checks (orthonormal frames, non-degenerate planes,
  unit revolution axes, non-singular placements). `check::validate` and
  `check::validate_built` are the record's validation and these together, and every caller of
  `Brep::validate` uses them, so what is accepted is unchanged;
- `brep::label`: a surface's natural ranges (a cone's apex), `curve_interval`,
  `edge_curve_interval` and `form_turns`;
- `brep::pcurve::eval`: a pcurve's point;
- `geometry::check`, `placement::moved` and `split_edges` become functions on the record.

The kernel's native module keeps the conversion between a body and its saved record
(metadata.rs) and checks the decoded record's geometry. `native/analytic.rs`, which no module
declared, is deleted.

solidcore-record is pinned to its rev on solidcore's `layer-record` branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Geometry: Vec2, Vec3, Plane and the profile types come from solidcore-record

The plain data of vectors and points, sketch planes and planar profiles (`Seg2`, `Loop2`,
`Region2`) moves to `solidcore-record`, with its constants and component-wise operators only
(owner decision, solidcore layer split). Their geometry stays in geom as traits:
`Vec2Geom`, `Vec3Geom`, `PlaneGeom`, `Seg2Geom`, `Loop2Geom`, `Region2Geom`, `Seg2ArcFit`,
`Loop2ArcFit` and `Region2ArcFit`, in scope with `use solidcraft_geom::prelude::*`. Every caller
names the types from `solidcore_record`; geom no longer defines or re-exports them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Kernel: pin solidcore-record to solidcore main f5e8e9a29

solidcore-record is merged on solidcore main (tangency-labs/solidcore#2519); its crate there is
identical to the rev pinned before but for its clippy configuration. The lock is regenerated
against the merged rev.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:04:26 -05:00

370 lines
18 KiB
Rust

use solidcore_record::Vec3;
use solidcore_record::brep as b;
use solidcraft_geom::prelude::*;
use crate::*;
/// The three r5 rounds at the corner (60, 40, 20) of a 60 x 40 x 20 box (ladder 07/009 and
/// 07/015).
fn box_corner() -> (Body, [Vec3; 3]) {
let b = box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(60.0, 40.0, 20.0)).unwrap();
(b, [Vec3::new(30.0, 40.0, 20.0), Vec3::new(60.0, 20.0, 20.0), Vec3::new(60.0, 40.0, 10.0)])
}
/// The worst curvature jump across the seams of the faces that are none of the box's planes or
/// rounds (the corner's: a sphere, or a patch), and the same clear of the hole's corners: a station counts there when
/// it is at least `share` of its seam's side (its edge and the edge that continues it smoothly:
/// SMLib splits each side in two) from the end of the side at a corner, a vertex where the seam
/// turns.
fn corner_seams(body: &Body, share: f64) -> (f64, f64, usize) {
let rec = brep_record(body).unwrap();
let corner_faces: Vec<usize> = rec
.faces
.iter()
.enumerate()
.filter(|(_, f)| !matches!(f.surface, b::Surface::Plane { .. } | b::Surface::PlaneThrough { .. } | b::Surface::Cylinder { .. }))
.map(|(i, _)| i)
.collect();
let edges: Vec<usize> = (0..rec.edges.len()).filter(|e| rec.edges[*e].uses.iter().any(|u| corner_faces.contains(&(u.face as usize)))).collect();
let report =
seam_diagnostics(body, &edges, 65, ContinuityTolerances { gap_mm: 1e-3, angle_deg: 1.0, curvature_per_mm: 1e-6, ..Default::default() })
.unwrap();
// The corner's vertices where its boundary turns: an end of two of its seams whose
// directions there differ.
let ends: Vec<(Vec3, Vec3, f64)> = report
.seams
.iter()
.flat_map(|s| {
let (p0, p1) = (s.points[0], *s.points.last().unwrap());
let d0 = (s.points[1] - p0).normalized().unwrap();
let d1 = (s.points[s.points.len() - 2] - p1).normalized().unwrap();
[(p0, d0, s.length), (p1, d1, s.length)]
})
.collect();
let turns =
|p: Vec3, d: Vec3| ends.iter().any(|(q, e, _)| q.dist(p) < 1e-6 && (d - *e).len() > 1e-6 && d.dot(*e) > -0.9998 && d.dot(*e) < 0.9998);
let (mut all, mut clear, mut n) = (0.0f64, 0.0f64, 0usize);
for s in &report.seams {
let (p0, p1) = (s.points[0], *s.points.last().unwrap());
let d0 = (s.points[1] - p0).normalized().unwrap();
let d1 = (s.points[s.points.len() - 2] - p1).normalized().unwrap();
let corner_end = if turns(p0, d0) {
Some(0.0)
} else if turns(p1, d1) {
Some(1.0)
} else {
None
};
for st in &s.stations {
all = all.max(st.curvature_jump_per_mm);
// Half a side per edge: `share` of the side is twice that of the edge.
if corner_end.is_none_or(|c| (st.edge_fraction - c).abs() >= 2.0 * share) {
clear = clear.max(st.curvature_jump_per_mm);
n += 1;
}
}
}
(all, clear, n)
}
/// The G2 corner of 07/015, set back the default 7.5 (1.5 r): one closed valid solid of the box's
/// six faces, the three rounds and the patch (10 faces, as the sphere corner's 07/009), within
/// the box, whose volume lies between the corner cube's hull of the body's points on its faces
/// (the body is convex) and the rounds' prisms, as the setback's own does; and across every
/// seam of the patch the curvature jump, a fifth per mm on the rolling ball's, is under
/// `CURVATURE_SHARE / r` clear of the hole's corners.
#[test]
fn the_box_corner_g2_patch_is_a_closed_solid_curvature_continuous_to_its_neighbours() {
let (body, edges) = box_corner();
let ball = fillet(&body, &edges, 5.0).unwrap();
let g2 = fillet_g2_corners(&body, &edges, 5.0, &[]).unwrap();
assert!(g2.validity().is_empty(), "{:?}", g2.validity());
let v = crate::validity::validity(&g2);
assert!(v.ok(), "{:?}", v);
let m = measure(&g2).unwrap();
let mb = measure(&ball).unwrap();
eprintln!("G2 corner: faces {} edges {} vertices {}, volume {:.6} (ball {:.6})", m.faces, m.edges, m.vertices, m.volume, mb.volume);
assert_eq!(m.faces, 10);
assert!((m.bbox.min - Vec3::ZERO).len() < 1e-6 && (m.bbox.max - Vec3::new(60.0, 40.0, 20.0)).len() < 1e-6, "{:?}", m.bbox);
let (all, clear, n) = corner_seams(&g2, 0.15);
let (ball_all, ball_clear, _) = corner_seams(&ball, 0.15);
eprintln!(
"G2 corner seams: worst jump {all:.4e} per mm, {clear:.4e} clear of the corners ({n} stations); the ball's {ball_all:.4e} / {ball_clear:.4e}"
);
assert!(clear <= CURVATURE_SHARE / 5.0, "{clear}");
}
/// Set back 8, as SMLib's own setback test: outside the corner cube [52, 60] x [32, 40] x
/// [12, 20] the body is the sphere corner's, and inside it the convex body holds the hull of its
/// points on the cube's faces (299.0201, by a hull of them sampled) and lies within the three
/// rounds' prisms (`fillet_setback_tests`).
#[test]
fn set_back_8_the_g2_corner_lies_between_the_hull_and_the_prisms() {
let pi = std::f64::consts::PI;
let (body, edges) = box_corner();
let sphere = measure(&fillet(&body, &edges, 5.0).unwrap()).unwrap().volume;
let g2 = fillet_g2_corners(&body, &edges, 5.0, &[(Vec3::new(60.0, 40.0, 20.0), 8.0)]).unwrap();
let v = measure(&g2).unwrap().volume;
let outside = sphere - (512.0 - 225.0 * (1.0 - pi / 4.0) - 125.0 * (1.0 - pi / 6.0));
let prisms = 512.0 - 225.0 * (1.0 - pi / 4.0) - 125.0 * (2f64.sqrt() - 1.0);
eprintln!("G2 corner set back 8: volume {v:.6} in [{:.6}, {:.6}]", outside + 299.0201, outside + prisms);
assert!(v > outside + 299.0201 && v < outside + prisms);
let (_, clear, _) = corner_seams(&g2, 0.15);
assert!(clear <= CURVATURE_SHARE / 5.0, "{clear}");
}
/// How far past the box (60, 40, 20) face `face` of `rec` reaches within its trim: the highest
/// `max(x - 60, y - 40, z - 20)` on it, bracketed `(lo, hi)` from its exact surface alone, with no
/// mesh. The surface (a polynomial B-spline) is cut into its Bézier patches and those split in
/// four (de Casteljau, exact up to rounding) while they can still hold a higher point: a patch
/// lies in the hull of its control points, so its controls' highest value bounds it from above
/// (`hi`), and its corners are points of the surface (`lo`, where inside the trim). A patch
/// clear of the trim (the face's pcurves, sampled densely in its (u, v)) is dropped; one whose
/// hull cannot beat `lo` by 1e-12 is done; one split 18 times counts its hull in `hi`. Returns
/// the bracket and the (u, v) where `lo` is reached.
fn past_the_box(rec: &b::Brep, face: usize) -> (f64, f64, [f64; 2]) {
use solidcraft_geom::bspline::{HPoint, segment};
let f = &rec.faces[face];
let (b::Surface::Spline { u_knots, v_knots, points }, None) = (&f.surface, &f.nurbs) else {
panic!("face {face} is no polynomial B-spline: {:?}", std::mem::discriminant(&f.surface));
};
let excess = |p: Vec3| (p.x - 60.0).max(p.y - 40.0).max(p.z - 20.0);
// The trim: every loop's pcurves as one polygon set, inside by the even-odd rule.
let mut rings: Vec<Vec<[f64; 2]>> = Vec::new();
for l in &f.loops {
let b::Loop::Edges { edges } = l else { continue };
let mut ring = Vec::new();
for oe in edges {
let [t0, t1] = oe.pcurve.interval().unwrap();
let mut seg: Vec<[f64; 2]> =
(0..=400).map(|k| solidcraft_geom::brep::pcurve::eval(&oe.pcurve, t0 + (t1 - t0) * f64::from(k) / 400.0).unwrap()).collect();
if !oe.forward {
seg.reverse();
}
ring.extend(seg);
}
rings.push(ring);
}
let inside = |w: [f64; 2]| {
let mut odd = false;
for r in &rings {
for k in 0..r.len() {
let (p, q) = (r[k], r[(k + 1) % r.len()]);
if (p[1] > w[1]) != (q[1] > w[1]) && w[0] < p[0] + (w[1] - p[1]) * (q[0] - p[0]) / (q[1] - p[1]) {
odd = !odd;
}
}
}
odd
};
let touches = |u: [f64; 2], v: [f64; 2]| {
rings.iter().flatten().any(|w| (u[0]..=u[1]).contains(&w[0]) && (v[0]..=v[1]).contains(&w[1]))
|| [[u[0], v[0]], [u[1], v[0]], [u[0], v[1]], [u[1], v[1]]].into_iter().any(inside)
};
// The Bézier patches: each knot span in u, then in v (control point [i][j], i along u).
let (nu, nv) = (points.len(), points[0].len());
let (p, q) = (u_knots.len() - nu - 1, v_knots.len() - nv - 1);
let spans = |k: &[f64], n: usize, d: usize| {
let mut x: Vec<f64> = k[d..=n].to_vec();
x.dedup();
x.windows(2).map(|w| [w[0], w[1]]).collect::<Vec<_>>()
};
type Patch = (Vec<Vec<Vec3>>, [f64; 2], [f64; 2], u32);
let mut todo: Vec<Patch> = Vec::new();
for su in spans(u_knots, nu, p) {
// Each v column cut to the u span: (p + 1) x nv.
let cols: Vec<Vec<HPoint>> = (0..nv)
.map(|j| {
let c: Vec<HPoint> = (0..nu).map(|i| HPoint::weighted(Vec3::from(points[i][j]), 1.0)).collect();
segment(p, u_knots, &c, su[0], su[1]).unwrap().1
})
.collect();
for sv in spans(v_knots, nv, q) {
let net: Vec<Vec<Vec3>> = (0..=p)
.map(|i| {
segment(q, v_knots, &cols.iter().map(|c| c[i]).collect::<Vec<_>>(), sv[0], sv[1]).unwrap().1.iter().map(|h| h.xyz()).collect()
})
.collect();
todo.push((net, su, sv, 0));
}
}
let half = |c: &[Vec3]| {
let (mut l, mut r, mut pts) = (Vec::new(), Vec::new(), c.to_vec());
while let (Some(&a), Some(&z)) = (pts.first(), pts.last()) {
l.push(a);
r.push(z);
pts = pts.windows(2).map(|w| w[0].lerp(w[1], 0.5)).collect();
}
r.reverse();
(l, r)
};
let (mut lo, mut hi, mut at) = (f64::NEG_INFINITY, f64::NEG_INFINITY, [f64::NAN; 2]);
while let Some((net, u, v, depth)) = todo.pop() {
if !touches(u, v) {
continue;
}
for (i, j, uv) in [(0, 0, [u[0], v[0]]), (p, 0, [u[1], v[0]]), (0, q, [u[0], v[1]]), (p, q, [u[1], v[1]])] {
let e = excess(net[i][j]);
if e > lo && inside(uv) {
(lo, at) = (e, uv);
}
}
let hull = net.iter().flatten().map(|c| excess(*c)).fold(f64::NEG_INFINITY, f64::max);
if hull <= lo + 1e-12 {
continue;
}
if depth == 18 {
hi = hi.max(hull);
continue;
}
// Split in u (each column of the net is a v row: split the rows across i), then in v.
let (mut a, mut z) = (vec![Vec::new(); p + 1], vec![Vec::new(); p + 1]);
for j in 0..=q {
let (l, r) = half(&net.iter().map(|row| row[j]).collect::<Vec<_>>());
for i in 0..=p {
a[i].push(l[i]);
z[i].push(r[i]);
}
}
let (um, vm) = (0.5 * (u[0] + u[1]), 0.5 * (v[0] + v[1]));
for (n, uu) in [(a, [u[0], um]), (z, [um, u[1]])] {
let (l, r): (Vec<_>, Vec<_>) = n.iter().map(|row| half(row)).unzip();
todo.push((l, uu, [v[0], vm], depth + 1));
todo.push((r, uu, [vm, v[1]], depth + 1));
}
}
(lo, hi.max(lo), at)
}
/// Long setbacks, where SMLib's own patch bulges past the faces (beyond about 2 r, by 0.25 at
/// 3 r): the G2 patch is fitted to the faces' own planes along their curves and stays inside the
/// box, G2 clear of the hole's corners. The body is convex (a box with its edges and corner
/// rounded), and a convex face lies on the inner side of every tangent plane: the patch meets
/// each of the box's planes tangentially along its seam there, so it reaches past none of them,
/// up to rounding (1e-9 mm, the patch's seams lie on the planes to 1e-13). Measured on the
/// patch's exact surface within its trim ([`past_the_box`]), not on a mesh of it.
#[test]
fn a_long_setback_keeps_the_g2_patch_inside_the_box() {
let (body, edges) = box_corner();
let mut wrong = Vec::new();
for s in [11.0, 12.0, 13.0, 14.0, 15.0] {
let g2 = fillet_g2_corners(&body, &edges, 5.0, &[(Vec3::new(60.0, 40.0, 20.0), s)]).unwrap();
let rec = brep_record(&g2).unwrap();
let patch: Vec<usize> = (0..rec.faces.len()).filter(|f| matches!(rec.faces[*f].surface, b::Surface::Spline { .. })).collect();
assert_eq!(patch.len(), 1, "{s}: one patch");
let (lo, hi, at) = past_the_box(&rec, patch[0]);
let (_, clear, _) = corner_seams(&g2, 0.15);
eprintln!("set back {s}: past the box by {lo:.4e} at (u, v) {at:?} (at most {hi:.4e}), curvature jump clear of the corners {clear:.3e}");
if !(hi <= 1e-9 && clear <= CURVATURE_SHARE / 5.0) {
wrong.push(format!("set back {s}: past the box by {lo:.4e}..{hi:.4e} at (u, v) {at:?}, curvature jump {clear:.3e}"));
}
}
assert!(wrong.is_empty(), "{wrong:#?}");
}
/// Every edge of a box rounded: eight corners, each set back and filled, one closed solid.
#[test]
fn a_box_with_every_edge_rounded_has_eight_g2_corners() {
let body = box_solid(Vec3::ZERO, Vec3::new(30.0, 20.0, 10.0)).unwrap();
let mut edges = Vec::new();
for (x, y) in [(0.0, 0.0), (30.0, 0.0), (0.0, 20.0), (30.0, 20.0)] {
edges.push(Vec3::new(x, y, 5.0));
}
for (y, z) in [(0.0, 0.0), (20.0, 0.0), (0.0, 10.0), (20.0, 10.0)] {
edges.push(Vec3::new(15.0, y, z));
}
for (x, z) in [(0.0, 0.0), (30.0, 0.0), (0.0, 10.0), (30.0, 10.0)] {
edges.push(Vec3::new(x, 10.0, z));
}
let g2 = fillet_g2_corners(&body, &edges, 2.0, &[]).unwrap();
assert!(g2.validity().is_empty(), "{:?}", g2.validity());
let v = crate::validity::validity(&g2);
let m = measure(&g2).unwrap();
eprintln!("eight G2 corners: {} faces, volume {:.4}, valid {}", m.faces, m.volume, v.ok());
assert!(v.ok(), "{v:?}");
assert_eq!(m.faces, 6 + 12 + 8);
}
/// What the G2 corner cannot do is refused: a setback naming no corner, one that does not reach
/// past where the rounds meet; two rounded edges at a corner are no G2 corner, the plain fillet.
#[test]
fn what_the_g2_corner_cannot_build_is_refused() {
let (body, edges) = box_corner();
let off = fillet_g2_corners(&body, &edges, 5.0, &[(Vec3::new(30.0, 20.0, 10.0), 8.0)]).unwrap_err().to_string();
assert!(off.contains("names no G2 corner"), "{off}");
let short = fillet_g2_corners(&body, &edges, 5.0, &[(Vec3::new(60.0, 40.0, 20.0), 4.0)]);
eprintln!("set back 4 at r5: {short:?}");
assert!(short.is_err());
let two = fillet_g2_corners(&body, &edges[..2], 5.0, &[]).unwrap();
let plain = fillet(&body, &edges[..2], 5.0).unwrap();
assert_eq!(measure(&two).unwrap().faces, measure(&plain).unwrap().faces);
}
/// The 60 x 40 x 20 box with a 20 x 20 x 10 notch cut from its top corner (60, 40, 20): its
/// inner corner (40, 20, 10) where three concave edges meet, and the notch's outer corner
/// (60, 20, 10) where the concave edge along x meets two convex ones.
fn notched() -> Body {
let a = box_solid(Vec3::ZERO, Vec3::new(60.0, 40.0, 20.0)).unwrap();
let b = box_solid(Vec3::new(40.0, 20.0, 10.0), Vec3::new(70.0, 50.0, 30.0)).unwrap();
boolean(&a, &b, BoolOp::Cut).unwrap().unwrap()
}
/// The notch's inner corner, three concave r5 rounds (ladder 07/019): set back 7.5 and filled,
/// one closed valid solid with the faces the ball corner has, the patch's seams G2 clear of the
/// hole's corners where the ball's jump 1/r.
#[test]
fn a_concave_corner_takes_the_g2_patch_too() {
let body = notched();
let edges = [Vec3::new(50.0, 20.0, 10.0), Vec3::new(40.0, 30.0, 10.0), Vec3::new(40.0, 20.0, 15.0)];
let ball = fillet(&body, &edges, 5.0).unwrap();
let g2 = fillet_g2_corners(&body, &edges, 5.0, &[]).unwrap();
assert!(g2.validity().is_empty(), "{:?}", g2.validity());
let v = crate::validity::validity(&g2);
assert!(v.ok(), "{v:?}");
let (m, mb) = (measure(&g2).unwrap(), measure(&ball).unwrap());
let (_, clear, n) = corner_seams(&g2, 0.15);
let (_, ball_clear, _) = corner_seams(&ball, 0.15);
eprintln!(
"concave G2 corner: {} faces (ball {}), volume {:.4} (ball {:.4}), jump clear of the corners {clear:.3e} ({n} stations), ball's {ball_clear:.3e}",
m.faces, mb.faces, m.volume, mb.volume
);
assert_eq!(m.faces, mb.faces);
assert!(clear <= CURVATURE_SHARE / 5.0 && ball_clear > 0.19, "{clear} {ball_clear}");
}
/// The notch's outer corner, two convex rounds and a concave one: SMLib sets back only a corner
/// of one convexity, so the G2 corner is refused as not supported (the rolling ball builds).
#[test]
fn a_mixed_convexity_corner_is_refused() {
let body = notched();
let edges = [Vec3::new(50.0, 20.0, 10.0), Vec3::new(60.0, 30.0, 10.0), Vec3::new(60.0, 20.0, 15.0)];
assert!(fillet(&body, &edges, 5.0).is_ok());
let err = fillet_g2_corners(&body, &edges, 5.0, &[]).unwrap_err().to_string();
eprintln!("mixed corner: {err}");
// The refusal names the corner and why: its rounds are not all of one convexity.
assert!(err.contains("not supported yet") && err.contains("(60.000, 20.000, 10.000)") && err.contains("all convex or all concave"), "{err}");
}
/// Curvature-continuous rounds (`fillet_g2`, equivalent radius 5) of the three edges at the box
/// corner: SMLib's own corner between them is its setback corner, whose fill for curvature
/// sections meets the rounds and faces curvature-continuously (SmBlendSetback.h: G2 for an order
/// 2 section), as the G2 patch filled between the curvature rounds' setback sections does: each
/// one closed valid solid, curvature-continuous across every seam round the corner clear of the
/// hole's corners.
#[test]
fn curvature_rounds_meet_at_a_g2_corner() {
let (body, edges) = box_corner();
let smlib_corner = fillet_g2(&body, &edges, 5.0).unwrap();
let g2 = fillet_g2_with_g2_corners(&body, &edges, 5.0, &[]).unwrap();
assert!(g2.validity().is_empty(), "{:?}", g2.validity());
let v = crate::validity::validity(&g2);
assert!(v.ok(), "{:?}", v);
let (_, clear, n) = corner_seams(&g2, 0.15);
let (_, smlib_clear, smlib_n) = corner_seams(&smlib_corner, 0.15);
assert!(n > 0 && clear <= CURVATURE_SHARE / 5.0, "{clear} over {n} stations");
assert!(smlib_n > 0 && smlib_clear <= CURVATURE_SHARE / 5.0, "SMLib's own corner: {smlib_clear} over {smlib_n} stations");
// Both differ only within the setback cube (side 1.5 r = 7.5) at the corner.
let (a, b) = (measure(&g2).unwrap().volume, measure(&smlib_corner).unwrap().volume);
assert!((a - b).abs() < 7.5f64.powi(3), "{a} vs {b}");
}