Wave 314/509: kernel: a planar sheet's loop splits where it passes one vertex twice (and 3 more)

4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.

- 00faac965 jyviko: kernel: a planar sheet's loop splits where it passes one vertex twice
- 5d25684a1 jyviko: sheet tests: the flat pattern as SMLib's exact 2D boolean makes it
- 52343ba23 jyviko: Robustness tests: a round's tangent chain and the lid's closed-form volume
- bc6d31e60 jyviko: GPU tests build their designs with SMLib, and the GPU jobs fetch it

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
jyviko
2026-10-27 21:41:24 -04:00
parent 0fa9c52b30
commit 4cd4ebfa50
7 changed files with 99 additions and 39 deletions
+6
View File
@@ -593,6 +593,9 @@ jobs:
with:
key: native-gpu
save-if: ${{ (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop') && matrix.shard == 1 }}
- name: Fetch SMLib (crates/smlib/SMLIB_REV)
shell: bash
run: scripts/fetch-smlib.sh
- name: Set up compiler cache
uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11
with:
@@ -846,6 +849,9 @@ jobs:
with:
key: windows-fxc
save-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}
- name: Fetch SMLib (crates/smlib/SMLIB_REV)
shell: bash
run: scripts/fetch-smlib.sh
# One test at a time: WARP's shader JIT crashes now and then (a null read in
# d3d10warp.dll's JIT optimizer, about 1 run in 60) when several devices compile compute
# pipelines at once, which the parallel tests do. Minidumps showed it in WARP itself, not
+19 -12
View File
@@ -5425,9 +5425,14 @@ mod tests {
let expected = (6000.0 - std::f64::consts::PI * 120.0) * 2.5 - std::f64::consts::PI * 60.0;
assert!((vol(&s.solid().unwrap()) - expected).abs() < 0.5, "{}", vol(&s.solid().unwrap()));
assert!((vol(&s.flat_solid().unwrap()) - expected).abs() < 0.5, "{}", vol(&s.flat_solid().unwrap()));
// The machining record keeps the pocket's exact outline.
// The machining record keeps the pocket's exact outline: its four conics in their order,
// the loop started at any of them.
let machined = s.machining().unwrap();
assert!(machined.len() == 1 && machined[0].region.outer == pocket.outer, "{} records", machined.len());
let same_loop = |l: &Loop2| {
let n = pocket.outer.segs.len();
l.segs.len() == n && (0..n).any(|k| (0..n).all(|i| l.segs[(i + k) % n] == pocket.outer.segs[i]))
};
assert!(machined.len() == 1 && same_loop(&machined[0].region.outer), "{machined:?}");
}
#[test]
@@ -7006,10 +7011,12 @@ mod tests {
assert!((length - outline).abs() < 1e-9, "{position}: {length} vs {outline}");
assert!((s.base.area() - (whole - below(line))).abs() < 1e-9, "{position}: {} vs {}", s.base.area(), whole - below(line));
// The flat pattern: the base and f.len × (BA + 37) of flange, its outline the base's
// with the flange's two sides (bend and panel, a line each) in place of nothing.
// with the flange's two sides and its end in place of the trimmed line. Each side is
// one line through the bend and the panel: the union of the two has no vertex where
// their sides meet in line.
let regions = s.flat_regions().unwrap();
let (arcs, edges, length, shortest) = arcs_and_edges(&regions[0].outer);
assert!(regions[0].outer.is_line_arc() && (arcs, edges) == (4, 12) && shortest > 2.0, "{position}: {:?}", regions[0].outer);
assert!(regions[0].outer.is_line_arc() && (arcs, edges) == (4, 10) && shortest > 2.0, "{position}: {:?}", regions[0].outer);
assert!((length - (outline + 2.0 * (ba + panel))).abs() < 1e-9, "{position}: {length}");
let flat = whole - below(line) + f.len * (ba + panel);
assert!((regions[0].area() - flat).abs() < 1e-9, "{position}: {} vs {flat}", regions[0].area());
@@ -7168,13 +7175,12 @@ mod tests {
}
#[test]
fn a_base_trimmed_through_a_free_form_curve_follows_it_with_arcs() {
fn a_base_trimmed_through_a_free_form_curve_keeps_it_exact() {
// A 200 x 60 plate under a parabola 40 high: y = 60 + 160·(x/200)·(1 − x/200), a conic
// of weight 1. A flange 40 high inside on the right edge trims the base to x = 197,
// through the curve's end: 183.564 goes (∫ y from 197 to 200), and the bend runs up the
// line x = 197 to the curve, at y = 62.364. The planar booleans follow a curve they
// cut with tangent arcs within 0.001 mm: over the parabola's 220 mm that is at most
// 0.22 mm² of the base, and 0.001/cos 38° = 0.0013 of the bend where it meets the curve.
// line x = 197 to the curve, at y = 62.364. The planar booleans cut the curve exactly:
// the base keeps what is left of it as one conic, so the strip and the bend are exact.
// It used to become about 200 chords.
let (ba, quarter) = (std::f64::consts::PI, std::f64::consts::FRAC_PI_2);
let crowned = || {
@@ -7197,11 +7203,12 @@ mod tests {
let mut s = crowned();
let i = s.add_flange(pick, 40.0, quarter, 1.0, "inside", false).unwrap();
let outer = &s.base.outer;
let arcs = outer.segs.iter().filter(|e| matches!(e, Seg2::Arc { .. })).count();
assert!(outer.is_line_arc() && arcs > 1 && outer.segs.len() == arcs + 3 && arcs < 64, "{what}: {arcs} arcs of {}", outer.segs.len());
assert!((s.base.area() - (whole - strip)).abs() < 0.22, "{what}: {} vs {}", s.base.area(), whole - strip);
let conics = outer.segs.iter().filter(|e| matches!(e, Seg2::Conic { .. })).count();
let lines = outer.segs.iter().filter(|e| matches!(e, Seg2::Line { .. })).count();
assert!((conics, lines) == (1, 3), "{what}: {:?}", outer.segs);
assert!((s.base.area() - (whole - strip)).abs() < 1e-6, "{what}: {} vs {}", s.base.area(), whole - strip);
let f = s.flanges[i].clone();
assert!(f.p.dist(start) < 1e-9 && (f.len - len).abs() < 2e-3, "{what}: {f:?}");
assert!(f.p.dist(start) < 1e-9 && (f.len - len).abs() < 1e-9, "{what}: {f:?}");
assert!((flat_area(&s) - (s.base.area() + f.len * (ba + 37.0))).abs() < 1e-6, "{what}: {}", flat_area(&s));
holds_the_flat_material(&s, what);
let mut c = chorded(&crowned());
+12 -3
View File
@@ -409,7 +409,14 @@ fn ribs_flush_with_a_window_change_nothing_away_from_them() {
s.run_script(&Value::Array(lid.to_vec())).unwrap();
let measure = |s: &Session| s.model.state().body("Lid").map(|b| solidcraft_kernel::measure(&b.body).unwrap()).unwrap();
let (v0, a0) = (measure(&s).volume, measure(&s).area);
assert!((v0 - 6703.5222).abs() < 1e-3, "{v0}");
// The plate with its rounded corners, the skirt, less the window, the slot and the notch
// through the skirt: (76.8 × 89.3 - (4 - π) × 9) × 2.4 + (71.5 × 84 - 68.5 × 81) × 3
// - 68 × 61 × 2.4 - 44 × 10 × 2.4 - 22 × 1.5 × 3.
let lid = (76.8 * 89.3 - (4.0 - std::f64::consts::PI) * 9.0) * 2.4 + (71.5 * 84.0 - 68.5 * 81.0) * 3.0
- 68.0 * 61.0 * 2.4
- 44.0 * 10.0 * 2.4
- 22.0 * 1.5 * 3.0;
assert!((v0 - lid).abs() < 1e-3, "{v0} vs {lid}");
for (i, rib) in ribs.iter().enumerate() {
let reply = s.execute(rib["command"].as_str().unwrap(), &rib["params"]).unwrap();
let id = reply["feature"].as_u64().unwrap();
@@ -418,13 +425,15 @@ fn ribs_flush_with_a_window_change_nothing_away_from_them() {
assert!(!result.warning.as_deref().unwrap_or_default().contains("tool displacement"), "{:?}", result.warning);
let m = measure(&s);
let n = (i + 1) as f64;
// The measure's accuracy: SMLib's mass properties come within 2e-7 of a closed form.
let (dv, da) = (2e-7 * m.volume, 2e-7 * m.area);
// 1.6 x 6 x 11.7 less the 1.35 x 6 x 3 inside the skirt.
assert!((m.volume - (v0 + n * 88.02)).abs() < 1e-6, "rib {}: {}", i + 1, m.volume - v0);
assert!((m.volume - (v0 + n * 88.02)).abs() < dv, "rib {}: {}", i + 1, m.volume - v0);
// Top 9.6, outer side 6 x 8.7 above the skirt, inner side 6 x 11.7 (flush with the
// window's side), ends 2 x (1.6 x 11.7 - 1.35 x 3); the skirt top 8.1, its inner side
// 18 and 1.5 of the plate go under the rib.
let area = 9.6 + 52.2 + 70.2 + 29.34 - 8.1 - 18.0 - 1.5;
assert!((m.area - (a0 + n * area)).abs() < 1e-6, "rib {}: area {} (no slit adds any)", i + 1, m.area - a0);
assert!((m.area - (a0 + n * area)).abs() < da, "rib {}: area {} (no slit adds any)", i + 1, m.area - a0);
}
let bounds = s.model.state().body("Lid").unwrap().body.mesh(&solidcraft_kernel::MeshTolerance::chord(0.01)).unwrap().bounds();
assert!((bounds.max.z - 14.1).abs() < 1e-9, "{}", bounds.max.z);
+14 -4
View File
@@ -272,21 +272,31 @@ fn shell_after_a_drilled_hole() {
/// Rounding a box's edges one at a time: an edge running into an earlier round (of the same
/// radius or another) takes off about what each round alone would (the corner where they meet
/// is small).
/// is small). The upright runs on tangentially into the first round's end arc, and that into
/// the top right edge: its tangent chain, which the default (`tangent_chain`) rounds too, taking
/// off about what a round of that edge (38 long, past the first round) would as well.
#[test]
fn fillet_into_an_earlier_round() {
let box_ = json!({"command": "solid.box", "params": {"length": 60, "width": 40, "height": 15}});
let lost = |r: f64, len: f64| (1.0 - PI / 4.0) * r * r * len;
for r2 in [2.0, 3.0] {
let s = script(json!([
box_,
{"command": "solid.fillet", "params": {"edges": [[30, 0, 15]], "radius": 2}},
{"command": "solid.fillet", "params": {"edges": [[60, 0, 7]], "radius": r2}}
{"command": "solid.fillet", "params": {"edges": [[30, 0, 15]], "radius": 2, "tangent_chain": false}},
{"command": "solid.fillet", "params": {"edges": [[60, 0, 7]], "radius": r2, "tangent_chain": false}}
]));
let lost = |r: f64, len: f64| (1.0 - PI / 4.0) * r * r * len;
let want = 36000.0 - lost(2.0, 60.0) - lost(r2, 15.0);
let v = total_volume(&s);
assert!((v - want).abs() < 2.0, "r2 {r2}: {v} vs {want}");
}
let s = script(json!([
box_,
{"command": "solid.fillet", "params": {"edges": [[30, 0, 15]], "radius": 2}},
{"command": "solid.fillet", "params": {"edges": [[60, 0, 7]], "radius": 2}}
]));
let want = 36000.0 - lost(2.0, 60.0) - lost(2.0, 15.0) - lost(2.0, 38.0);
let v = total_volume(&s);
assert!((v - want).abs() < 2.0, "the upright's tangent chain: {v} vs {want}");
}
/// Clean seeds (seed 16: a partial face contact, fused), and the original seed 5 edge contact,
+3 -2
View File
@@ -26,8 +26,9 @@ wgpu = { workspace = true, features = ["metal", "vulkan", "dx12", "gles"] }
[dev-dependencies]
image = { workspace = true }
solidcraft-kernel = { workspace = true }
# Headless pictures of real designs (capture tests).
solidcraft-engine = { workspace = true, features = ["bundled-render-library"] }
# Headless pictures of real designs (capture tests), built by the real kernel: SMLib
# (scripts/fetch-smlib.sh), as in the apps.
solidcraft-engine = { workspace = true, features = ["bundled-render-library", "smlib"] }
solidcraft-io = { workspace = true }
serde_json = { workspace = true }
# The HLSL the D3D12 backend compiles (tests check it suits FXC).
+44 -17
View File
@@ -138,9 +138,12 @@ mod sheets {
for r in regions {
let (mut material, mut holes) = (Vec::new(), Vec::new());
let loops = std::iter::once(r.outer.ccw()).chain(r.holes.iter().map(|h| h.ccw().reversed()));
for piece in loops.flat_map(|lp| simple_loops(lp, tol * 10.0)) {
let face = face(&piece)?;
if piece.signed_area() > 0.0 { material.push(face) } else { holes.push(face) }
for lp in loops {
let near = tol * 10.0;
for piece in simple_loops(lp.segs.into_iter().map(|s| (s.start(), s)).collect(), |a, b| a.dist(*b) < near) {
let face = face(&piece)?;
if piece.signed_area() > 0.0 { material.push(face) } else { holes.push(face) }
}
}
let Some(material) = united(material)? else { continue };
sheets.push(match united(holes)? {
@@ -174,22 +177,23 @@ mod sheets {
Ok(sheets.pop())
}
/// A closed loop split where it passes a point twice (its segments' starts within `near`)
/// into loops that pass every point once.
fn simple_loops(lp: Loop2, near: f64) -> Vec<Loop2> {
let mut todo = vec![lp.segs];
/// A closed loop, each segment with where it starts, split where it passes a point twice
/// (`same` start for two of its segments) into loops that pass every point once.
fn simple_loops<K>(segs: Vec<(K, Seg2)>, same: impl Fn(&K, &K) -> bool) -> Vec<Loop2> {
let mut todo = vec![segs];
let mut out = Vec::new();
// Each split leaves two shorter loops, so the work is bounded by the segment count.
while let Some(segs) = todo.pop() {
let starts: Vec<Vec2> = segs.iter().map(Seg2::start).collect();
let repeat = (0..starts.len()).find_map(|i| (i + 1..starts.len()).find(|&j| starts[i].dist(starts[j]) < near).map(|j| (i, j)));
let repeat = (0..segs.len()).find_map(|i| (i + 1..segs.len()).find(|&j| same(&segs[i].0, &segs[j].0)).map(|j| (i, j)));
match repeat {
Some((i, j)) => {
let (inner, rest) = (segs[i..j].to_vec(), [&segs[j..], &segs[..i]].concat());
let mut rest = segs;
let inner: Vec<(K, Seg2)> = rest.drain(i..j).collect();
rest.rotate_left(i);
todo.push(inner);
todo.push(rest);
}
None => out.push(Loop2 { segs }),
None => out.push(Loop2 { segs: segs.into_iter().map(|(_, s)| s).collect() }),
}
}
out
@@ -224,24 +228,29 @@ mod sheets {
// Each loop as it runs in the plane, then split where it passes a point twice (a
// cut-out touching the outline, material meeting at a corner): counter-clockwise
// pieces are material, the others holes in the material that holds them.
// A loop passes a point twice where it passes one vertex of the record twice: the
// record's vertices, not their places, which may lie closer together than its
// tolerance at the ends of a short edge.
let mut pieces = Vec::new();
for lp in &face.loops {
let Loop::Edges { edges } = lp else { return Err(failed("face", format!("face {f} has a vertex loop"))) };
let mut segs = Vec::new();
for e in edges {
let edge = record.edges.get(e.edge as usize).ok_or_else(|| failed("edge", format!("edge {} is missing", e.edge)))?;
let run = Run::of(&record, e.edge as usize, e.forward).ok_or_else(|| failed("edge", format!("edge {} is missing", e.edge)))?;
let read = projected(&run, &Plane::XY, tol, &mut work)
.ok_or_else(|| failed("edge", format!("edge {} of face {f} is not read exactly in the plane", e.edge)))?;
segs.extend(read);
}
for e in edges.iter().filter_map(|e| record.edges.get(e.edge as usize)) {
for v in e.vertices {
// The first piece of the edge starts on the use's first vertex.
let start = if e.forward { edge.vertices[0] } else { edge.vertices[1] };
segs.extend(read.into_iter().enumerate().map(|(k, s)| ((k == 0).then_some(start), s)));
for v in edge.vertices {
touching |= *owner.entry(v).or_insert(f) != f;
}
}
// Seen from the face's normal, the outer loop runs counter-clockwise and holes clockwise.
let lp = if up > 0.0 { Loop2 { segs } } else { Loop2 { segs }.reversed() };
pieces.extend(simple_loops(lp, tol * 10.0));
for piece in simple_loops(segs, |a, b| a.is_some() && a == b) {
pieces.push(if up > 0.0 { piece } else { piece.reversed() });
}
}
let (outers, holes): (Vec<Loop2>, Vec<Loop2>) = pieces.into_iter().partition(|lp| lp.signed_area() > 0.0);
let first = out.len();
@@ -331,6 +340,24 @@ mod planar_tests {
assert!((result[0].area() - a.area() - b.area()).abs() < 1e-6);
}
}
#[test]
fn a_ledge_shorter_than_the_record_tolerance_reads_back_as_one_region() {
// A plate with a ledge 0.0001 tall along part of its lower edge: SMLib's record holds a
// tolerance of 2e-5 mm, so the ledge's short side has both ends within ten times that.
// Read back, its outline is one loop of six lines, not split into a loop of one line.
let ledged = Region2 {
outer: Loop2::polygon(
&[(100.0, 3.0), (100.0, 3.0001), (97.0, 3.0001), (97.0, 60.0), (0.0, 60.0), (0.0, 3.0)].map(|(x, y)| Vec2::new(x, y)),
),
holes: vec![],
};
let below = rectangle(Vec2::new(0.0, -12.0), Vec2::new(100.0, 0.0));
let out = planar_regions_boolean(std::slice::from_ref(&ledged), std::slice::from_ref(&below), BoolOp::Union, 1e-7).unwrap();
assert_eq!(out.len(), 2, "{out:?}");
let top = out.iter().find(|r| r.outer.contains(Vec2::new(50.0, 30.0))).unwrap();
assert!(top.outer.segs.len() == 6 && top.outer.is_closed(1e-9), "{top:?}");
assert!((top.area() - ledged.area()).abs() < 1e-9, "{}", top.area());
}
fn rectangle(a: Vec2, b: Vec2) -> Region2 {
Region2 { outer: Loop2::polygon(&[a, Vec2::new(b.x, a.y), b, Vec2::new(a.x, b.y)]), holes: vec![] }
}
@@ -1,5 +1,5 @@
{
"description": "A 76.8 x 89.3 x 2.4 lid plate (corner at x = 100) with its four vertical edges rounded 3 mm, a 1.5 mm skirt ring 3 mm high on it (outside 102.65..174.15 x 2.65..86.65), a 68 x 61 window and a 44 x 10 slot cut through, and a 22 x 6 notch in the skirt. Four 1.6 x 6 x 11.7 ribs are then joined standing on the plate (z = 2.4) over the skirt, each flush with a side of the window (x = 104.4 and x = 172.4). The joins needed retries that displaced the tool, and one left a zero-thickness slit through the skirt and plate at y = 25.5, far from any rib (#616). Each rib adds 1.6*6*11.7 - 1.35*6*3 = 88.02 mm3 and nothing changes away from it: 6703.5222 + 4 * 88.02 mm3.",
"description": "A 76.8 x 89.3 x 2.4 lid plate (corner at x = 100) with its four vertical edges rounded 3 mm, a 1.5 mm skirt ring 3 mm high on it (outside 102.65..174.15 x 2.65..86.65), a 68 x 61 window and a 44 x 10 slot cut through, and a 22 x 6 notch in the skirt. Four 1.6 x 6 x 11.7 ribs are then joined standing on the plate (z = 2.4) over the skirt, each flush with a side of the window (x = 104.4 and x = 172.4). The joins needed retries that displaced the tool, and one left a zero-thickness slit through the skirt and plate at y = 25.5, far from any rib (#616). Each rib adds 1.6*6*11.7 - 1.35*6*3 = 88.02 mm3 and nothing changes away from it: 6703.5344 + 4 * 88.02 mm3.",
"commands": [
{"command": "solid.box", "params": {"corner": [100, 0, 0], "length": 76.8, "width": 89.3, "height": 2.4, "body_name": "Lid"}},
{"command": "solid.fillet", "params": {"edges": [[100, 0, 1.2], [176.8, 0, 1.2], [100, 89.3, 1.2], [176.8, 89.3, 1.2]], "radius": 3}},