Wave 395/509: Kernel: planar source lineage finds each face's support through an index, with no budgets (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 15c31a96f jyviko: Kernel: planar source lineage finds each face's support through an index, with no budgets - 049b2bc40 jyviko: Lumps: a face-source table of another length is refused, never sliced - f60bf96df jyviko: Planar sources test: two bodies side by side joined as the record requires - e1b762c4b jyviko: Booleans and Shell keep the lines faces were split along on purpose Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -574,6 +574,22 @@ impl Body {
|
||||
self
|
||||
}
|
||||
|
||||
/// This body with the lines `inputs`' faces were split along on purpose added to its own:
|
||||
/// an operation combining bodies keeps their authored splits (each line once), as it keeps
|
||||
/// their regularization protection.
|
||||
pub(crate) fn inherit_split_lines(self, inputs: &[&Body]) -> Self {
|
||||
let mut lines: Vec<Vec<Vec3>> = self.split_keep().to_vec();
|
||||
for line in inputs.iter().flat_map(|input| input.split_keep()) {
|
||||
if !lines.contains(line) {
|
||||
lines.push(line.clone());
|
||||
}
|
||||
}
|
||||
if lines.len() == self.split_keep().len() {
|
||||
return self;
|
||||
}
|
||||
self.with_split_lines(Some(std::sync::Arc::new(lines)))
|
||||
}
|
||||
|
||||
/// Exact history of the operation that made this body, relative to that operation's
|
||||
/// operands (see [`crate::history`]); `None` when the operation does not report one.
|
||||
pub fn history(&self) -> Option<&crate::history::History> {
|
||||
@@ -1351,6 +1367,10 @@ impl Body {
|
||||
pub fn parts(&self, groups: &[Vec<usize>]) -> Result<Vec<Body>> {
|
||||
let regions = self.record.material_regions();
|
||||
let counts = [(self.face_count(), self.edge_count())];
|
||||
// Sources are by face position: a table of another length belongs to another body.
|
||||
if self.face_sources.as_ref().is_some_and(|all| all.len() != self.face_count()) {
|
||||
return Err(KernelError::Invalid("lumps: face source table does not match the body".into()));
|
||||
}
|
||||
groups
|
||||
.iter()
|
||||
.map(|group| {
|
||||
|
||||
@@ -49,7 +49,9 @@ pub fn union_all(bodies: &[&Body]) -> Result<Body> {
|
||||
if bodies.is_empty() {
|
||||
return Err(KernelError::Invalid("a union of no bodies".into()));
|
||||
}
|
||||
guard("SMLib union", || crate::smlib_boolean::smlib_union_all(bodies))?.with_preserved_union_planar_sources(bodies)
|
||||
guard("SMLib union", || crate::smlib_boolean::smlib_union_all(bodies))?
|
||||
.inherit_split_lines(bodies)
|
||||
.with_preserved_union_planar_sources(bodies)
|
||||
})
|
||||
}
|
||||
|
||||
@@ -64,9 +66,10 @@ fn apart(a: &Body, b: &Body) -> Result<bool> {
|
||||
}
|
||||
|
||||
/// A boolean's result with what its operands' faces stood for carried over: regularization
|
||||
/// protection and the planar construction and shell roles on supports it kept.
|
||||
/// protection, the lines they were split along on purpose, and the planar construction and shell roles on supports it kept.
|
||||
fn with_operand_roles(a: &Body, b: &Body, op: BoolOp, r: Result<Option<Body>>) -> Result<Option<Body>> {
|
||||
let r = r.map(|result| result.map(|body| body.inherit_regularization_protection(a).inherit_regularization_protection(b)));
|
||||
let r = r
|
||||
.map(|result| result.map(|body| body.inherit_regularization_protection(a).inherit_regularization_protection(b).inherit_split_lines(&[a, b])));
|
||||
match op {
|
||||
BoolOp::Cut => r.and_then(|result| result.map(|body| body.with_preserved_boolean_planar_sources(a, b, true)).transpose()),
|
||||
BoolOp::Union => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(&[a, b])).transpose()),
|
||||
|
||||
@@ -4,6 +4,7 @@ use super::{Body, FaceSource};
|
||||
use crate::{KernelError, Result, guard};
|
||||
use solidcraft_geom::brep::{self, Surface};
|
||||
use solidcraft_geom::{Plane, Vec3};
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// The oriented plane each face of `body` lies on (in face order), from its record: the
|
||||
@@ -64,14 +65,100 @@ impl Resolution {
|
||||
}
|
||||
}
|
||||
|
||||
/// The entries of `sorted` (ordered by their plane's normal x) whose normal x is within the
|
||||
/// resolution's angle of `nx` (and rounding): the only ones `same_support` can accept for a plane
|
||||
/// with that normal.
|
||||
fn normal_window<T>(sorted: &[T], plane: impl Fn(&T) -> &Plane, nx: f64, at: Resolution) -> &[T] {
|
||||
let window = 2. * at.angular + 1e-12;
|
||||
let first = sorted.partition_point(|t| plane(t).normal().x < nx - window);
|
||||
let last = sorted.partition_point(|t| plane(t).normal().x <= nx + window);
|
||||
sorted.get(first..last.max(first)).unwrap_or_default()
|
||||
/// The planes of a list indexed by their unit normal and their offset, so the planes that can be
|
||||
/// one support with a given plane at a resolution (`same_support`) are found without looking at
|
||||
/// the rest: a superset of them, which the caller decides on exactly with `same_support`.
|
||||
///
|
||||
/// Two unit normals within the resolution's angle (`|na × nb| <= angular`, `na · nb > 0`) differ
|
||||
/// by at most their angle, `asin(angular) <= π/2 · angular < 2 · angular`: the normal cells are
|
||||
/// twice that wide and a plane looks in its own cell and the neighbour on each side it is near.
|
||||
/// Their offsets from a common centre `c`, `d = (o - c) · n`, satisfy
|
||||
/// `d_b - d_a = (b.o - a.o) · n_b + (a.o - c) · (n_b - n_a)`, so a match is within
|
||||
/// `linear + |a.o - c| · |n_b - n_a|` of the plane's own offset; each cell is sorted by offset and
|
||||
/// searched in that window, widened by far more than the rounding of the offsets. A plane whose
|
||||
/// normal is not of unit length (a hostile record) is kept aside and offered to every query.
|
||||
struct PlaneIndex {
|
||||
cells: HashMap<[i64; 3], Vec<(f64, usize)>>,
|
||||
/// Entries whose normal is not unit to `UNIT`: offered to every query.
|
||||
loose: Vec<usize>,
|
||||
len: usize,
|
||||
centre: Vec3,
|
||||
/// The farthest origin of an indexed plane from `centre`.
|
||||
reach: f64,
|
||||
/// The bound on two matching normals' difference; the cells are `2 * normal_reach` wide.
|
||||
normal_reach: f64,
|
||||
linear: f64,
|
||||
}
|
||||
|
||||
/// How far from unit length a normal may be for the index's bounds to hold.
|
||||
const UNIT: f64 = 1e-9;
|
||||
|
||||
impl PlaneIndex {
|
||||
fn new<'a>(planes: impl Iterator<Item = &'a Plane> + Clone, at: Resolution) -> Self {
|
||||
let mut lo = Vec3::new(f64::INFINITY, f64::INFINITY, f64::INFINITY);
|
||||
let mut hi = -lo;
|
||||
for p in planes.clone().filter(|p| p.origin.is_finite()) {
|
||||
lo = Vec3::new(lo.x.min(p.origin.x), lo.y.min(p.origin.y), lo.z.min(p.origin.z));
|
||||
hi = Vec3::new(hi.x.max(p.origin.x), hi.y.max(p.origin.y), hi.z.max(p.origin.z));
|
||||
}
|
||||
let centre = if lo.is_finite() && hi.is_finite() { (lo + hi) * 0.5 } else { Vec3::ZERO };
|
||||
let normal_reach = 2. * at.angular + 4. * UNIT;
|
||||
let mut index = PlaneIndex { cells: HashMap::new(), loose: Vec::new(), len: 0, centre, reach: 0., normal_reach, linear: at.linear };
|
||||
for (position, plane) in planes.enumerate() {
|
||||
index.len += 1;
|
||||
let n = plane.normal();
|
||||
let d = (plane.origin - centre).dot(n);
|
||||
match index.cell(n) {
|
||||
Some(key) if (n.len() - 1.).abs() <= UNIT && d.is_finite() => {
|
||||
index.reach = index.reach.max((plane.origin - centre).len());
|
||||
index.cells.entry(key).or_default().push((d, position));
|
||||
}
|
||||
_ => index.loose.push(position),
|
||||
}
|
||||
}
|
||||
for cell in index.cells.values_mut() {
|
||||
cell.sort_by(|a, b| a.0.total_cmp(&b.0));
|
||||
}
|
||||
index
|
||||
}
|
||||
|
||||
fn cell(&self, n: Vec3) -> Option<[i64; 3]> {
|
||||
let width = 2. * self.normal_reach;
|
||||
let key = |v: f64| {
|
||||
let k = (v / width).floor();
|
||||
(k.is_finite() && k.abs() < 1e15).then_some(k as i64)
|
||||
};
|
||||
Some([key(n.x)?, key(n.y)?, key(n.z)?])
|
||||
}
|
||||
|
||||
/// The positions of the indexed planes that can be one support with `plane`, in no order:
|
||||
/// every one `same_support` accepts, and others it refuses.
|
||||
fn near(&self, plane: &Plane) -> Vec<usize> {
|
||||
let n = plane.normal();
|
||||
let offset = (plane.origin - self.centre).dot(n);
|
||||
let from_centre = (plane.origin - self.centre).len();
|
||||
let (Some(low), Some(high)) =
|
||||
(self.cell(n - Vec3::new(1., 1., 1.) * self.normal_reach), self.cell(n + Vec3::new(1., 1., 1.) * self.normal_reach))
|
||||
else {
|
||||
return (0..self.len).collect();
|
||||
};
|
||||
if (n.len() - 1.).abs() > UNIT || !offset.is_finite() || !from_centre.is_finite() {
|
||||
return (0..self.len).collect();
|
||||
}
|
||||
let window = self.linear + from_centre * self.normal_reach + 1e-12 * (1. + from_centre + self.reach);
|
||||
let mut out = self.loose.clone();
|
||||
for x in low[0]..=high[0] {
|
||||
for y in low[1]..=high[1] {
|
||||
for z in low[2]..=high[2] {
|
||||
let Some(cell) = self.cells.get(&[x, y, z]) else { continue };
|
||||
let first = cell.partition_point(|e| e.0 < offset - window);
|
||||
let last = cell.partition_point(|e| e.0 <= offset + window);
|
||||
out.extend(cell.get(first..last.max(first)).unwrap_or_default().iter().map(|e| e.1));
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether `a` and `b` are one oriented plane at resolution `at`: normals the same way within its
|
||||
@@ -203,14 +290,6 @@ impl Body {
|
||||
if inputs.iter().all(|input| input.face_sources().is_none()) {
|
||||
return Ok(self);
|
||||
}
|
||||
// Each body at most 16 384 faces, and the inputs together at most two such bodies' worth.
|
||||
if inputs.iter().fold(0usize, |n, input| n.saturating_add(input.face_count())) > 2 * 16_384
|
||||
|| inputs.iter().any(|input| input.face_count() > 16_384)
|
||||
|| self.face_count() > 16_384
|
||||
|| blocker.is_some_and(|b| b.face_count() > 16_384)
|
||||
{
|
||||
return Err(KernelError::Invalid("planar source face budget exceeded".into()));
|
||||
}
|
||||
if inputs.iter().any(|input| input.face_sources().is_some_and(|sources| sources.len() != input.face_count())) {
|
||||
return Err(KernelError::Invalid("planar source alignment mismatch".into()));
|
||||
}
|
||||
@@ -233,7 +312,6 @@ impl Body {
|
||||
let opposing = Plane::new(plane.origin, plane.x, -plane.y).ok_or_else(|| KernelError::Invalid("invalid opposing plane".into()))?;
|
||||
competing.push(opposing);
|
||||
}
|
||||
competing.sort_by(|a, b| a.normal().x.total_cmp(&b.normal().x));
|
||||
let mut candidates = Vec::new();
|
||||
let mut unknown_supports = Vec::new();
|
||||
let mut faces = Vec::new();
|
||||
@@ -271,33 +349,22 @@ impl Body {
|
||||
candidates.push((inner, source, true, cost));
|
||||
}
|
||||
}
|
||||
// Planes that match must have (nearly) the same unit normal (`same_support`), so the
|
||||
// lists are sorted by the normal's x and each face looks only at its window of them.
|
||||
unknown_supports.sort_by(|a, b| a.normal().x.total_cmp(&b.normal().x));
|
||||
// The candidates are taken in the order of their normal's x: where several match one
|
||||
// face, the first decides which the rest are compared with.
|
||||
candidates.sort_by(|a, b| a.0.normal().x.total_cmp(&b.0.normal().x));
|
||||
let mut work = 2_000_000usize;
|
||||
let unknown_index = PlaneIndex::new(unknown_supports.iter(), at);
|
||||
let competing_index = PlaneIndex::new(competing.iter(), at);
|
||||
let candidate_index = PlaneIndex::new(candidates.iter().map(|c| &c.0), at);
|
||||
let mut metadata = 2_000_000usize;
|
||||
let mut identity_bytes = 16_000_000usize;
|
||||
let mut result = Vec::new();
|
||||
for (index, actual) in actual_planes(&self)?.into_iter().enumerate() {
|
||||
let mut found = None;
|
||||
if let Some(actual) = actual {
|
||||
let mut blocked = false;
|
||||
let nx = actual.normal().x;
|
||||
for plane in normal_window(&unknown_supports, |p| p, nx, at) {
|
||||
work = work.checked_sub(1).ok_or_else(|| KernelError::Invalid("unknown planar source comparison budget exceeded".into()))?;
|
||||
if same_support(plane, &actual, at) {
|
||||
blocked = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for plane in normal_window(&competing, |p| p, nx, at) {
|
||||
work = work.checked_sub(1).ok_or_else(|| KernelError::Invalid("planar tool comparison budget exceeded".into()))?;
|
||||
if same_support(plane, &actual, at) {
|
||||
blocked = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
let on = |planes: &[Plane], index: &PlaneIndex| {
|
||||
index.near(&actual).into_iter().any(|i| planes.get(i).is_some_and(|plane| same_support(plane, &actual, at)))
|
||||
};
|
||||
let blocked = on(&unknown_supports, &unknown_index) || on(&competing, &competing_index);
|
||||
if blocked {
|
||||
let existing = self
|
||||
.face_sources()
|
||||
@@ -316,8 +383,9 @@ impl Body {
|
||||
continue;
|
||||
}
|
||||
let mut chosen: Option<(Plane, &FaceSource, bool, usize)> = None;
|
||||
for (plane, source, inner, cost) in normal_window(&candidates, |c| &c.0, nx, at) {
|
||||
work = work.checked_sub(1).ok_or_else(|| KernelError::Invalid("planar source comparison budget exceeded".into()))?;
|
||||
let mut near = candidate_index.near(&actual);
|
||||
near.sort_unstable();
|
||||
for (plane, source, inner, cost) in near.into_iter().filter_map(|i| candidates.get(i)) {
|
||||
if same_support(plane, &actual, at) {
|
||||
if let Some((previous_plane, previous_source, previous_inner, _)) = chosen {
|
||||
let Some(remaining) = identity_bytes.checked_sub(*cost) else {
|
||||
@@ -435,36 +503,8 @@ mod tests {
|
||||
/// beyond `a` along x), each face's source that of the face of its own operand on the same
|
||||
/// plane (none from `b` when `b_sources` is false).
|
||||
fn side_by_side(a: &Body, b: &Body, b_sources: bool) -> Body {
|
||||
let (ra, rb) = (a.record(), b.record());
|
||||
let mut r = ra.clone();
|
||||
let (nf, ne, nv, ns) = (r.faces.len() as u32, r.edges.len() as u32, r.vertices.len() as u32, r.shells.len() as u32);
|
||||
for mut face in rb.faces.clone() {
|
||||
for l in &mut face.loops {
|
||||
match l {
|
||||
brep::Loop::Edges { edges } => edges.iter_mut().for_each(|e| e.edge += ne),
|
||||
brep::Loop::Vertex { vertex } => *vertex += nv,
|
||||
}
|
||||
}
|
||||
r.faces.push(face);
|
||||
}
|
||||
for mut e in rb.edges.clone() {
|
||||
e.vertices = e.vertices.map(|v| v + nv);
|
||||
e.uses.iter_mut().for_each(|u| u.face += nf);
|
||||
r.edges.push(e);
|
||||
}
|
||||
r.vertices.extend(rb.vertices.iter().cloned());
|
||||
for mut sh in rb.shells.clone() {
|
||||
if let brep::Shell::Faces { faces, wires } = &mut sh {
|
||||
faces.iter_mut().for_each(|o| o.face += nf);
|
||||
wires.iter_mut().for_each(|w| *w += ne);
|
||||
}
|
||||
r.shells.push(sh);
|
||||
}
|
||||
for mut region in rb.regions.clone().into_iter().filter(|g| !g.void) {
|
||||
region.shells.iter_mut().for_each(|s| *s += ns);
|
||||
r.regions.push(region);
|
||||
}
|
||||
let mut combined = Body::from_record(r).unwrap();
|
||||
let part = brep::part::compound(&[a.record(), b.record()]).unwrap();
|
||||
let mut combined = Body::from_record(part.brep).unwrap();
|
||||
let planes = |x: &Body| actual_planes(x).unwrap();
|
||||
let (pa, pb, pc) = (planes(a), planes(b), planes(&combined));
|
||||
let a_right = a.outline_bounds().max.x;
|
||||
@@ -492,6 +532,47 @@ mod tests {
|
||||
combined
|
||||
}
|
||||
|
||||
/// The plane index offers every plane `same_support` accepts: planes turned and moved by
|
||||
/// about the resolution (either side of it, so across cell edges), far from the centre, and
|
||||
/// with normals not of unit length, each checked against a scan of them all.
|
||||
#[test]
|
||||
fn plane_index_finds_every_support_a_scan_finds() {
|
||||
let body = box_solid(Vec3::ZERO, Vec3::new(1000., 1000., 1000.)).unwrap();
|
||||
let at = Resolution::of(&body);
|
||||
let (eps, tol) = (at.angular, at.linear);
|
||||
let mut planes = Vec::new();
|
||||
let mut seed = 0x9e37_79b9_7f4a_7c15u64;
|
||||
let mut next = || {
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 7;
|
||||
seed ^= seed << 17;
|
||||
(seed >> 11) as f64 / (1u64 << 53) as f64 * 2. - 1.
|
||||
};
|
||||
for base in [Vec3::X, Vec3::Y, Vec3::Z, -Vec3::Z, Vec3::new(1., 2., 3.)] {
|
||||
for k in 0..200 {
|
||||
let base = base.normalized().unwrap();
|
||||
let n = (base + Vec3::new(next(), next(), next()) * (eps * 1.2)).normalized().unwrap();
|
||||
// A point of the base plane (through the world origin), near or far, moved off it
|
||||
// by up to one and a half times the resolution's distance.
|
||||
let r = Vec3::new(next(), next(), next()) * if k % 3 == 0 { 1e4 } else { 300. };
|
||||
let origin = r - base * r.dot(base) + n * (next() * tol * 1.5);
|
||||
let p = Plane::from_normal(origin, n).unwrap();
|
||||
planes.push(if k % 50 == 0 { Plane { x: p.x * 1.5, ..p } } else { p });
|
||||
}
|
||||
}
|
||||
let index = PlaneIndex::new(planes.iter(), at);
|
||||
let mut matches = 0;
|
||||
for query in &planes {
|
||||
let mut near = index.near(query);
|
||||
near.sort_unstable();
|
||||
let found: Vec<usize> = near.into_iter().filter(|&i| same_support(&planes[i], query, at)).collect();
|
||||
let scan: Vec<usize> = (0..planes.len()).filter(|&i| same_support(&planes[i], query, at)).collect();
|
||||
assert_eq!(found, scan);
|
||||
matches += scan.len();
|
||||
}
|
||||
assert!(matches > 2 * planes.len(), "the planes meet each other, not only themselves: {matches}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rounded_shell_planar_roles_are_exact_distinct_and_transformable() {
|
||||
for (width, thickness) in [(80., 2.), (100., 3.)] {
|
||||
|
||||
@@ -187,10 +187,11 @@ fn polyhedron_record(hs: &[HalfSpace], verts: &[Vec3], faces: &[(usize, Vec<usiz
|
||||
/// Hollow a body: walls of `thickness` inside, open at the faces under `open` (SMLib's shell).
|
||||
/// The result's history is over `[b]`: the inner walls are offsets of the faces they line. Each
|
||||
/// kept planar wall and its inner lining carry the outer and inner shell roles of the face they
|
||||
/// came from (face certificates: sketches and press-pulls attach to them).
|
||||
/// came from (face certificates: sketches and press-pulls attach to them), and the body keeps
|
||||
/// the lines its faces were split along on purpose.
|
||||
pub fn shell(b: &Body, open: &[Vec3], thickness: f64) -> Result<Body> {
|
||||
let _span = solidcraft_profile::span("kernel", "shell");
|
||||
crate::offset_backend::shell(b, open, thickness)?.with_shell_planar_sources(b, thickness, open)
|
||||
crate::offset_backend::shell(b, open, thickness)?.inherit_split_lines(&[b]).with_shell_planar_sources(b, thickness, open)
|
||||
}
|
||||
|
||||
/// Tilt the faces near `faces` by `angle` about their line on the neutral plane, so that they
|
||||
|
||||
@@ -18,10 +18,15 @@ fn stamped_shell_keeps_authored_painted_and_split_boundaries() {
|
||||
let side = (0..stock.face_count()).find(|i| stock.planar_face(*i).is_some_and(|p| p.normal().dot(Vec3::X) > 0.999 && p.origin.x == 20.)).unwrap();
|
||||
let split = crate::split_faces(&stock, &[side], &crate::SplitTool::Plane(Plane { origin: Vec3::new(0., 0., 8.), ..Plane::XY })).unwrap();
|
||||
assert!(split.split_lines().is_some());
|
||||
for protected in [painted, split] {
|
||||
// SMLib's shell makes no section strips: the ordinary cup is the stock's five kept faces,
|
||||
// their five linings and the rim (11). A paint over a whole face authors no boundary inside
|
||||
// it, so the painted cup has those same faces; the split side's line stays an edge on both
|
||||
// walls (13).
|
||||
for (protected, faces) in [(painted, ordinary.face_count()), (split, ordinary.face_count() + 2)] {
|
||||
let result = cup(&protected);
|
||||
assert!(result.regularization_protected);
|
||||
assert!(result.face_count() > ordinary.face_count(), "authored boundaries must survive both Shell regularizers");
|
||||
assert_eq!(result.face_count(), faces, "authored boundaries must survive Shell");
|
||||
assert_eq!(result.split_lines(), protected.split_lines());
|
||||
assert!(result.validity().is_empty());
|
||||
let expected = 40. * 30. * 24. - 38. * 28. * 23.;
|
||||
let mesh = result.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap();
|
||||
|
||||
@@ -4,4 +4,3 @@
|
||||
# Baseline: develop 5ada4fc8a with SMLib 90aabff (the run on 60b1c6a, aarch64 Linux).
|
||||
3604-cut-with-g2-swept-tool-along-projected-edge step 12 (solid.sweep): the path curves are not connected end to end
|
||||
3830-split-cup-by-extended-spline-surface not supported yet: surface.extend of a surface of more than one face (this one has 3)
|
||||
5126-join-menger-sponge-level-3 step 561 (solid.combine): unknown planar source comparison budget exceeded
|
||||
|
||||
Reference in New Issue
Block a user