From 42c41464aa2c11b391598d587fe32dfa77e8d2d7 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Thu, 22 Oct 2026 00:48:06 -0400 Subject: [PATCH] kernel: planar regions stay one 2D arrangement; prism booleans are SMLib's boolean The prism module kept two things: the 2D arrangement of planar regions (planar_regions_boolean, and extrude_planar_regions, which normalises the material with it, proves the pieces apart and extrudes them with crate::extrude, SMLib's extrusion with its face sources), and a second route to the solid boolean: prism operands read section by section, the result sewn and its history rebuilt from section tags (prism_boolean, prism_union_between_caps, the stacked and free-form variants, prism_lineage.rs) and the column-local variant (prism_local.rs). On SMLib a boolean is smlib_boolean, with SMLib's own history: the second route is deleted, with its tests (prism_spline_tests.rs, the stack/prism tests in planar_tests) of what no longer exists. The section tags shrink to what the arrangement uses: the free-form segment a fitted arc stands for. wall_along reads a record surface (cylinder, revolved line, spline net) for clearance.rs. The 2D tests and the wall test keep their assertions. lib.rs (coordinator): drop `mod prism_local;`. (not built: base in progress) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt --- crates/kernel/src/prism.rs | 1866 +---------------------- crates/kernel/src/prism_lineage.rs | 538 ------- crates/kernel/src/prism_local.rs | 353 ----- crates/kernel/src/prism_spline_tests.rs | 87 -- 4 files changed, 60 insertions(+), 2784 deletions(-) delete mode 100644 crates/kernel/src/prism_lineage.rs delete mode 100644 crates/kernel/src/prism_local.rs delete mode 100644 crates/kernel/src/prism_spline_tests.rs diff --git a/crates/kernel/src/prism.rs b/crates/kernel/src/prism.rs index d1be421f3..95300ae19 100644 --- a/crates/kernel/src/prism.rs +++ b/crates/kernel/src/prism.rs @@ -1,26 +1,15 @@ -//! Booleans of prisms in 2D: when the target is a prism (two caps square to one direction, -//! walls of planes and cylinders along it) and the tool a prism along the same direction -//! spanning the target's height, the result is the prism over the 2D boolean of their -//! sections. Plates with holes, slots and patterns of them: exact, and immune to the mesh -//! intersection's trouble with walls meeting along lines. -//! Stepped extrusions (case floors and walls) use sections between every cap level, so a -//! circular boss can meet the rim without shifting either operand off its exact plane. +//! Booleans of planar regions in 2D (an arrangement of their lines, arcs and free-form +//! curves), the extrusion of planar material from them, and the test of whether a record +//! surface is a wall swept along a direction. use std::borrow::Cow; +use solidcraft_geom::brep::Surface; use solidcraft_geom::{Aabb2, Loop2, Plane, Region2, Seg2, Vec2, Vec3}; -use truck_modeling as mt; -use crate::body::{Body, from_p3}; +use crate::body::Body; use crate::{BoolOp, KernelError, Result}; -#[path = "prism_lineage.rs"] -mod lineage; - -#[cfg(test)] -#[path = "prism_spline_tests.rs"] -mod spline_tests; - const MAX_PLANAR_SEGMENTS: usize = 8192; const MAX_PLANAR_EVENTS: usize = 131_072; const MAX_PLANAR_PAIRS: usize = 16_000_000; @@ -195,83 +184,25 @@ pub fn extrude_planar_regions(plane: &Plane, regions: &[Region2], start: f64, en }) } -/// A prism: the plane of its bottom cap (normal along the walls), its height and section (its -/// segments' tags alongside). -struct Prism { - lo: f64, - hi: f64, - section: Section, -} - -/// What a section's segment was made from, for the history of what is built over it: an -/// operand's cap edge (`edge`, by its place in the operand's edge order), the wall face beside it -/// (`wall`), and the operand's vertices (by [`Index`]) the segment starts and ends at (`None` -/// where it was split off a longer one). Where the wall ends with a slab of a stepped operand, at -/// a cap whose outline runs along the whole segment, `far` is the operand's edge there (the -/// segment may have been read off a cap at another level). A segment carried through levels -/// beside the same wall keeps the vertices it was read at, which may lie at another level: they -/// say which line two walls meet along, not which edge of it. `None` fields: not known (no -/// history then). +/// What a section's segment is, through [`boolean2d_tagged`]: the free-form segment (by +/// number) the arc it is was fitted to, so the result's pieces of it get the exact curve back. #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) struct Tag { - pub operand: usize, - pub wall: Option, - pub edge: Option, - pub far: Option, - pub start: Option, - pub end: Option, - /// Inside [`boolean2d_tagged`] only: the free-form segment (by number) the arc this tags - /// was fitted to, so the result's pieces of it get the exact curve back. - pub free: Option, +struct Tag { + free: Option, } -/// A segment nothing is known of. -const BLANK: Tag = Tag { operand: 0, wall: None, edge: None, far: None, start: None, end: None, free: None }; - -impl Tag { - /// The segment run the other way. - fn reversed(self) -> Tag { - Tag { start: self.end, end: self.start, ..self } - } - - /// Piece `k` of `n` the segment was split into, in its direction. - fn piece(self, k: usize, n: usize) -> Tag { - Tag { start: if k == 0 { self.start } else { None }, end: if k + 1 == n { self.end } else { None }, ..self } - } - - /// The segment beside `wall` instead (`None`: not known). Its edge and vertices were read - /// beside the wall it leaves, so they are dropped with it. - fn beside(self, wall: Option) -> Tag { - if wall == self.wall { self } else { Tag { operand: self.operand, wall, ..BLANK } } - } -} - -/// An operand's [`Index`], built when first needed (only bodies that are prisms are read). -pub(crate) struct LazyIndex<'a> { - body: &'a Body, - operand: usize, - index: std::cell::OnceCell, -} - -impl<'a> LazyIndex<'a> { - fn new(body: &'a Body, operand: usize) -> LazyIndex<'a> { - LazyIndex { body, operand, index: std::cell::OnceCell::new() } - } - - fn get(&self) -> &Index { - self.index.get_or_init(|| Index::new(self.body, self.operand)) - } -} +/// A segment that is no fitted arc. +const BLANK: Tag = Tag { free: None }; /// Regions with a tag for each segment: per region, per loop (outer, then holes), per segment. #[derive(Clone, Debug, Default, PartialEq)] -pub(crate) struct Section { - pub regions: Vec, - pub tags: Vec>>, +struct Section { + regions: Vec, + tags: Vec>>, } impl Section { - /// Regions whose segments nothing is known of. + /// Regions none of whose segments is a fitted arc. fn untagged(regions: &[Region2]) -> Section { let tags = regions.iter().map(|r| std::iter::once(&r.outer).chain(&r.holes).map(|l| vec![BLANK; l.segs.len()]).collect()).collect(); Section { regions: regions.to_vec(), tags } @@ -296,19 +227,6 @@ impl Section { .unwrap_or_default() } - /// One region from its loops (each segment tagged): the loop with the largest area is the - /// outer one. - fn from_loops(loops: Vec<(Loop2, Vec)>) -> Option
{ - let ((outer, outer_tags), holes) = split_outer(loops)?; - let (holes, hole_tags): (Vec, Vec>) = holes.into_iter().unzip(); - Some(Section { regions: vec![Region2 { outer, holes }], tags: vec![std::iter::once(outer_tags).chain(hole_tags).collect()] }) - } - - /// Region `r` alone. - fn region(&self, r: usize) -> Section { - Section { regions: self.regions.get(r).cloned().into_iter().collect(), tags: vec![self.region_tags(r)] } - } - /// Every segment in order (regions, then loops) with its tag. fn segments(&self) -> (Vec, Vec) { let mut out = (Vec::new(), Vec::new()); @@ -323,83 +241,11 @@ impl Section { out } - /// Each segment's tag mapped by `f`. - fn retag(&mut self, f: impl Fn(Tag) -> Tag) { - for t in self.tags.iter_mut().flatten().flatten() { - *t = f(*t); - } - } - - /// Mark each segment of a slab with its `far` edge: the operand's edge where its wall meets - /// one of `caps` (the outlines of the operand's caps ending the slab). - /// - /// The operand's topology settles it where `top` gives the wall's edge (the wall ends at the - /// caps in that one edge, [`Stations::top_edge`]): that edge is over every segment beside it. - /// - /// Otherwise, for a wall meeting the caps in several edges (its top split at vertices an - /// earlier operation left, or beside a wall across it there) or carrying on past the caps - /// elsewhere, which edge is over a segment depends on where the segment lies along the wall, - /// and nothing in the topology says that. Only there is position compared: the segment takes - /// the edge of the cap segment beside the same wall it runs along end to end. A segment - /// along none, or along segments of different edges, stays unmarked; so do those past - /// `budget` (segment pairs compared). - fn mark_far(&mut self, caps: &[&Section], top: impl Fn(usize) -> Option, tol: f64, budget: &mut usize) { - let mut tops: std::collections::HashMap> = std::collections::HashMap::new(); - // The caps' segments by wall, gathered only once a wall needs position. - let mut by_wall: Option)>>> = None; - for (reg, tags) in self.regions.iter().zip(&mut self.tags) { - for (lp, tags) in std::iter::once(®.outer).chain(®.holes).zip(tags) { - for (seg, tag) in lp.segs.iter().zip(tags) { - let Some(w) = tag.wall else { continue }; - if let Some(e) = *tops.entry(w).or_insert_with(|| top(w)) { - tag.far = Some(e); - continue; - } - let by_wall = by_wall.get_or_insert_with(|| { - let mut by_wall: std::collections::HashMap)>> = std::collections::HashMap::new(); - for (segs, tags) in caps.iter().map(|c| c.segments()) { - for (seg, tag) in segs.into_iter().zip(tags) { - if let Some(w) = tag.wall { - by_wall.entry(w).or_default().push((seg, tag.edge)); - } - } - } - by_wall - }); - let Some(beside) = by_wall.get(&w) else { continue }; - let Some(left) = budget.checked_sub(beside.len()) else { continue }; - *budget = left; - // The one edge it runs along (`Some(None)`: along none, or not one edge). - let mut along: Option> = None; - for (_, edge) in beside.iter().filter(|(t, _)| runs_along(seg, t, tol)) { - along = match along { - None => Some(*edge), - Some(e) if e == *edge => Some(e), - Some(_) => Some(None), - }; - } - if let Some(Some(e)) = along { - tag.far = Some(e); - } - } - } - } - } - - /// Segments beside a wall another crosses between levels `lo` and `hi` are not beside it - /// all the way: their walls are not known. - fn drop_crossed(&mut self, stations: &Stations, lo: f64, hi: f64, tol: f64) { - self.retag(|t| match t.wall { - Some(w) if stations.across(w, lo, hi, tol) => t.beside(None), - _ => t, - }); - } - /// Loops oriented: outers counter-clockwise, holes clockwise; the tags following their /// segments. fn oriented(&self) -> Section { let turn = |lp: &Loop2, tags: Vec, reverse: bool| -> (Loop2, Vec) { - if reverse { (lp.reversed(), tags.into_iter().rev().map(Tag::reversed).collect()) } else { (lp.clone(), tags) } + if reverse { (lp.reversed(), tags.into_iter().rev().collect()) } else { (lp.clone(), tags) } }; let mut out = Section::default(); for (r, reg) in self.regions.iter().enumerate() { @@ -419,266 +265,40 @@ impl Section { } } -/// An operand's faces, edges and vertices by identity, to tag the section segments read off its -/// caps ([`Tag`]). -pub(crate) struct Index { - operand: usize, - /// Each edge's place in the edge order. - edges: std::collections::HashMap, - /// Per edge (edge order): the faces it bounds, and its ends (by vertex number). - bounds: Vec<(Vec, Option, Option)>, - /// The edges between each pair of faces (lesser first; a face twice for a seam). - between: std::collections::HashMap<(usize, usize), Vec>, - /// Each vertex's number (first seen along the edge order). - vertices: std::collections::HashMap, - /// Each vertex's point, by number. - points: Vec, - /// Per edge (edge order): whether it is a line. - lines: Vec, - /// Per edge (edge order) that is not a line: the points its curve lies within (see - /// [`control_hull`]); `None` where they are not known. - hulls: Vec>>, -} - -impl Index { - fn new(b: &Body, operand: usize) -> Index { - let (edges, bounds) = crate::body::edge_order(b.solid.face_iter()); - let mut vertices = std::collections::HashMap::new(); - let mut points = Vec::new(); - for e in &edges { - for v in [e.absolute_front(), e.absolute_back()] { - if let std::collections::hash_map::Entry::Vacant(slot) = vertices.entry(v.id()) { - slot.insert(points.len()); - points.push(from_p3(v.point())); - } +/// Certify that a curved wall is swept along `d` (unit) from its surface record: a cylinder or +/// a revolved line about an axis along `d`, or a spline net whose rows run along `d` (either +/// parameter) with weights that separate into one factor per parameter. Seam vertices alone +/// cannot establish this: a half-cylinder's seam normals can both be perpendicular to a +/// transverse direction, silently filling its hole. A plane is no curved wall. +pub(crate) fn wall_along(surface: &Surface, d: Vec3, tol: f64, remaining: &mut usize) -> bool { + let v3 = |p: [f64; 3]| Vec3::new(p[0], p[1], p[2]); + let along = |a: Vec3| a.normalized().is_some_and(|a| a.cross(d).len() < 1e-9); + let points: Vec> = match surface { + Surface::Cylinder { frame, .. } => return along(v3(frame.x_axis).cross(v3(frame.y_axis))), + Surface::PlacedRevolution { profile, axis, matrix, .. } => { + let solidcraft_geom::brep::Curve::Line { start, end } = &**profile else { return false }; + let (Some(a), Some(m)) = (v3(*axis).normalized(), (v3(*end) - v3(*start)).normalized()) else { return false }; + if a.cross(m).len() > 1e-9 { + return false; // A conical meridian is not a cylindrical wall. } + // The axis placed by the column-major matrix (a direction: no translation). + let c = |k: usize| matrix[0][k] * a.x + matrix[1][k] * a.y + matrix[2][k] * a.z; + return c(3).abs() < 1e-12 && along(Vec3::new(c(0), c(1), c(2))); } - let lines = edges.iter().map(|e| matches!(e.curve(), mt::Curve::Line(_))).collect(); - let hulls = edges.iter().map(|e| control_hull(&e.curve())).collect(); - let mut between: std::collections::HashMap<(usize, usize), Vec> = std::collections::HashMap::new(); - for (i, fs) in bounds.iter().enumerate() { - match fs.as_slice() { - [f] => between.entry((*f, *f)).or_default().push(i), - [f, g] => between.entry((*f.min(g), *f.max(g))).or_default().push(i), - _ => {} - } + Surface::Spline { points, .. } => points.iter().map(|r| r.iter().map(|p| (v3(*p), 1.0)).collect()).collect(), + Surface::RationalSpline { homogeneous, .. } => { + homogeneous.iter().map(|r| r.iter().map(|p| (Vec3::new(p[0] / p[3], p[1] / p[3], p[2] / p[3]), p[3])).collect()).collect() } - let bounds = edges - .iter() - .zip(bounds) - .map(|(e, fs)| (fs, vertices.get(&e.absolute_front().id()).copied(), vertices.get(&e.absolute_back().id()).copied())) - .collect(); - Index { operand, edges: crate::record::edge_index(&b.solid), bounds, between, vertices, points, lines, hulls } - } - - /// The tag of the segments read off edge `e` (as it runs in a wire) of cap face `cap`. - fn tag(&self, e: &mt::Edge, cap: usize) -> Tag { - let edge = self.edges.get(&e.id()).copied(); - let wall = edge.and_then(|i| self.bounds.get(i)).and_then(|(fs, _, _)| match fs.as_slice() { - [x, y] if *x == cap => Some(*y), - [x, y] if *y == cap => Some(*x), - _ => None, - }); - Tag { - operand: self.operand, - wall, - edge, - far: None, - start: self.vertices.get(&e.front().id()).copied(), - end: self.vertices.get(&e.back().id()).copied(), - free: None, - } - } - - /// The loops of cap face `f` (number `cap`) as segments, each with its tag; `None` where an - /// edge isn't a line or an arc in the plane. - fn loops(&self, f: &mt::Face, cap: usize, plane: &Plane, tol: f64, work: &mut usize, segments: &mut usize) -> Option)>> { - let mut loops = Vec::new(); - for w in f.boundaries() { - let (mut segs, mut tags) = (Vec::new(), Vec::new()); - for e in w.edge_iter() { - let pieces = if FREE_FORM.with(|c| c.get()) { - crate::prism_curve::segment_fitted(e, plane, tol, PLANAR_FIT_TOL, work)? - } else { - crate::prism_curve::segment(e, plane, tol, work)? - }; - *segments = segments.checked_sub(pieces.len())?; - let tag = self.tag(e, cap); - tags.extend((0..pieces.len()).map(|k| tag.piece(k, pieces.len()))); - segs.extend(pieces); - } - loops.push((Loop2 { segs }, tags)); - } - Some(loops) - } -} - -/// Where an operand's walls along a direction end other than at its caps: at edges between two -/// walls that do not run along the direction (between pieces of one surface an earlier operation -/// left apart). A section segment carried through a level keeps the wall it was read beside -/// only where these say so, as its operand's prism or slab is read. -struct Stations { - /// Each wall's highest level. - tops: std::collections::HashMap, - /// Per wall, the edges across it: the other wall and the edge's lowest and highest levels. - /// A curve other than a line spans every level, unless it lies at one level. - cross: std::collections::HashMap>, -} - -impl Stations { - /// From the operand's walls (by face number, with their highest levels). - fn new(index: &Index, tops: std::collections::HashMap, d: Vec3, plane: &Plane, tol: f64) -> Stations { - let mut cross: std::collections::HashMap> = std::collections::HashMap::new(); - for (i, (fs, front, back)) in index.bounds.iter().enumerate() { - let [f, g] = fs[..] else { continue }; - if f == g || !tops.contains_key(&f) || !tops.contains_key(&g) { - continue; - } - let ends = front.and_then(|v| index.points.get(v)).zip(back.and_then(|v| index.points.get(v))); - let (lo, hi) = match ends { - Some((p, q)) if index.lines.get(i) == Some(&true) => { - let run = *q - *p; - if (run - d * run.dot(d)).len() < tol { - continue; // Along the direction: between walls over two segments. - } - let (h, k) = (plane.height(*p), plane.height(*q)); - (h.min(k), h.max(k)) - } - // A curve at one level (where a piece of a wall's surface stacked on another - // meets it: a boss's cylinder over the arc of the plate it stands on) crosses - // the walls there only. Any other spans every level. - _ => match index.hulls.get(i).and_then(Option::as_deref).map(|hull| level_span(hull, plane)) { - Some((lo, hi)) if hi - lo < tol => (lo, hi), - _ => (f64::NEG_INFINITY, f64::INFINITY), - }, - }; - cross.entry(f).or_default().push((g, lo, hi)); - cross.entry(g).or_default().push((f, lo, hi)); - } - Stations { tops, cross } - } - - /// The edges across wall `w`. - fn of(&self, w: usize) -> &[(usize, f64, f64)] { - self.cross.get(&w).map_or(&[], Vec::as_slice) - } - - /// The operand's edge (in `index`) where wall `w` ends at level `z`, when it ends there in - /// one edge: `z` is its top, no other wall crosses it there, and it meets the faces `caps` - /// (the caps at `z`) in exactly one edge. Found by topology alone, no position compared. The wall reaching no higher, every segment beside - /// it in a slab up to `z` ends on its edges at `z`, which are that one edge alone. - fn top_edge(&self, index: &Index, w: usize, caps: &[usize], z: f64, tol: f64) -> Option { - let ends = self.tops.get(&w).is_some_and(|t| (*t - z).abs() < tol); - if !ends || self.of(w).iter().any(|(_, l, h)| *l < z + tol && *h > z - tol) { - return None; - } - let mut edges = caps.iter().filter_map(|c| index.between.get(&(w.min(*c), w.max(*c)))).flatten(); - match (edges.next(), edges.next()) { - (Some(e), None) => Some(*e), - _ => None, - } - } - - /// Does wall `w` meet another wall across it between levels `lo` and `hi` (not at them)? - fn across(&self, w: usize, lo: f64, hi: f64, tol: f64) -> bool { - self.of(w).iter().any(|(_, l, h)| *l < hi - tol && *h > lo + tol) - } - - /// The wall over a section segment beside wall `w` just past level `z`, when the segment - /// runs on through `z` without meeting a cap there: `w` itself when nothing crosses it at - /// `z`, and it reaches past; the one wall across it at `z` when it ends there; else not - /// known. - fn past(&self, w: usize, z: f64, tol: f64) -> Option { - let at: std::collections::BTreeSet = - self.of(w).iter().filter(|(_, l, h)| (*l - z).abs() < tol && (*h - z).abs() < tol).map(|(y, _, _)| *y).collect(); - let reaches = self.tops.get(&w).is_some_and(|t| *t > z + tol); - match (at.len(), reaches) { - (0, true) => Some(w), - (1, false) => at.first().copied(), - _ => None, - } - } -} - -/// The most control points [`control_hull`] reads of one curve. -const MAX_HULL_POINTS: usize = 4096; - -/// The points curve `c` lies within: a B-spline's control points, or a NURBS curve's where its -/// weights are positive (the curve then lies in their convex hull). `None` for a line, an -/// intersection curve, other weights or too many points. -fn control_hull(c: &mt::Curve) -> Option> { - match c { - mt::Curve::BSplineCurve(c) if c.control_points().len() <= MAX_HULL_POINTS => Some(c.control_points().iter().map(|p| from_p3(*p)).collect()), - mt::Curve::NurbsCurve(c) if c.control_points().len() <= MAX_HULL_POINTS => { - c.control_points().iter().map(|p| (p.w > 0.0 && p.w.is_finite()).then(|| Vec3::new(p.x / p.w, p.y / p.w, p.z / p.w))).collect() - } - _ => None, - } -} - -/// The lowest and highest levels of `points` (infinite where there are none, or one isn't -/// finite). -fn level_span(points: &[Vec3], plane: &Plane) -> (f64, f64) { - let span = points - .iter() - .map(|p| plane.height(*p)) - .try_fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), h| h.is_finite().then(|| (lo.min(h), hi.max(h)))); - match span { - Some((lo, hi)) if lo <= hi => (lo, hi), - _ => (f64::NEG_INFINITY, f64::INFINITY), - } -} - -/// The highest level of face `f`'s vertices. -fn top_of(f: &mt::Face, plane: &Plane) -> f64 { - f.vertex_iter().map(|v| plane.height(from_p3(v.point()))).fold(f64::NEG_INFINITY, f64::max) -} - -/// Certify that a curved wall is swept along `d` from its surface representation. -/// Seam vertices alone cannot establish this: a half-cylinder's seam normals can -/// both be perpendicular to a transverse direction, silently filling its hole. -pub(crate) fn wall_along(surface: &mt::Surface, d: Vec3, tol: f64, remaining: &mut usize) -> bool { - if let mt::Surface::RevolutedCurve(processor) = surface { - let revolution = processor.entity(); - let mt::Curve::Line(line) = revolution.entity_curve() else { return false }; - let axis = revolution.axis(); - let meridian = line.1 - line.0; - let local_axis = Vec3::new(axis.x, axis.y, axis.z); - let local_meridian = Vec3::new(meridian.x, meridian.y, meridian.z); - let (Some(a), Some(m)) = (local_axis.normalized(), local_meridian.normalized()) else { return false }; - if a.cross(m).len() > 1e-9 { - return false; // A conical meridian is not a cylindrical wall. - } - let placed = *processor.transform() * mt::Vector4::new(axis.x, axis.y, axis.z, 0.0); - return placed.w.abs() < 1e-12 && Vec3::new(placed.x, placed.y, placed.z).normalized().is_some_and(|a| a.cross(d).len() < 1e-9); - } - let dimensions = match surface { - mt::Surface::BSplineSurface(s) => (s.control_points().len(), s.control_points().first().map_or(0, Vec::len)), - mt::Surface::NurbsSurface(s) => (s.control_points().len(), s.control_points().first().map_or(0, Vec::len)), _ => return false, }; - let (rows, cols) = dimensions; + let (rows, cols) = (points.len(), points.first().map_or(0, Vec::len)); let count = rows.saturating_mul(cols); - let rectangular = match surface { - mt::Surface::BSplineSurface(s) => s.control_points().iter().all(|r| r.len() == cols), - mt::Surface::NurbsSurface(s) => s.control_points().iter().all(|r| r.len() == cols), - _ => false, - }; - if rows < 2 || cols < 2 || count > 16_384 || !rectangular { + if rows < 2 || cols < 2 || count > 16_384 || points.iter().any(|r| r.len() != cols) { return false; } let Some(left) = remaining.checked_sub(count.saturating_mul(2)) else { return false }; *remaining = left; - let points: Vec> = match surface { - mt::Surface::BSplineSurface(s) => s.control_points().iter().map(|r| r.iter().map(|p| (from_p3(*p), 1.0)).collect()).collect(), - mt::Surface::NurbsSurface(s) => { - s.control_points().iter().map(|r| r.iter().map(|p| (Vec3::new(p.x / p.w, p.y / p.w, p.z / p.w), p.w)).collect()).collect() - } - _ => return false, - }; - if points.iter().any(|r| r.len() != cols) - || points.iter().flatten().any(|(p, w)| !w.is_finite() || *w <= 0.0 || [p.x, p.y, p.z].iter().any(|x| !x.is_finite())) - { + if points.iter().flatten().any(|(p, w)| !w.is_finite() || *w <= 0.0 || !p.is_finite()) { return false; } let max_weight = points.iter().flatten().map(|p| p.1).fold(0.0, f64::max); @@ -722,98 +342,6 @@ pub(crate) fn wall_along(surface: &mt::Surface, d: Vec3, tol: f64, remaining: &m false } -/// The body as a prism along `d` (unit), seen in `plane` (normal `d`). -#[cfg(test)] -fn prism_of(b: &Body, d: Vec3, plane: &Plane, tol: f64) -> Option { - prism_tagged(b, d, plane, tol, &LazyIndex::new(b, 0)) -} - -/// [`prism_of`], its section's segments tagged from `index` (the body's). -fn prism_tagged(b: &Body, d: Vec3, plane: &Plane, tol: f64, index: &LazyIndex) -> Option { - // A simple extrusion with N section edges has N walls plus its cap faces. - // Even disconnected two-arc sections need at most 2N faces. Keep that - // complete planar arrangement envelope, independently of stepped limits. - let mut remaining_faces = MAX_PLANAR_SEGMENTS * 2; - let mut lo = f64::INFINITY; - let mut hi = f64::NEG_INFINITY; - let mut tops: Vec<(usize, &mt::Face)> = Vec::new(); - let mut top_h = Vec::new(); - let mut bottom_h = Vec::new(); - let mut walls = std::collections::HashMap::new(); - let mut wall_work = 262_144; - let mut curve_work = 2_000_000usize; - for (fi, f) in b.solid.face_iter().enumerate() { - remaining_faces = remaining_faces.checked_sub(1)?; - curve_work = curve_work.checked_sub(1)?; - let surf = f.oriented_surface(); - if let mt::Surface::Plane(p) = &surf { - let n = p.normal(); - let n = Vec3::new(n.x, n.y, n.z).normalized()?; - let h = plane.height(from_p3(p.origin())); - if n.dot(d) > 1.0 - 1e-9 { - tops.push((fi, f)); - top_h.push(h); - hi = hi.max(h); - continue; - } - if n.dot(d) < -1.0 + 1e-9 { - bottom_h.push(h); - lo = lo.min(h); - continue; - } - if n.dot(d).abs() > 1e-9 { - return None; - } - walls.insert(fi, top_of(f, plane)); - continue; - } - if !wall_along(&surf, d, tol, &mut wall_work) { - return None; - } - walls.insert(fi, top_of(f, plane)); - } - // One height for every top (and bottom) cap. - if top_h.iter().any(|h| (h - hi).abs() > tol) || bottom_h.iter().any(|h| (h - lo).abs() > tol) || !(lo.is_finite() && hi > lo + tol) { - return None; - } - let mut section = Section::default(); - let mut remaining_segments = MAX_PLANAR_SEGMENTS; - let mut remaining_loops = MAX_PLANAR_SEGMENTS; - for (fi, f) in tops { - remaining_loops = remaining_loops.checked_sub(f.boundaries().len())?; - let loops = index.get().loops(f, fi, plane, tol, &mut curve_work, &mut remaining_segments)?; - let one = Section::from_loops(loops)?; - section.regions.extend(one.regions); - section.tags.extend(one.tags); - } - section.drop_crossed(&Stations::new(index.get(), walls, d, plane, tol), lo, hi, tol); - Some(Prism { lo, hi, section }) -} - -/// The loop with the largest area is the outer one. -fn split_outer(mut loops: Vec<(Loop2, T)>) -> Option<((Loop2, T), Vec<(Loop2, T)>)> { - let i = (0..loops.len()).max_by(|a, b| loops[*a].0.signed_area().abs().total_cmp(&loops[*b].0.signed_area().abs()))?; - let outer = loops.remove(i); - Some((outer, loops)) -} - -fn heights_of(b: &Body, plane: &Plane) -> (f64, f64) { - b.solid.vertex_iter().map(|v| plane.height(from_p3(v.point()))).fold((f64::INFINITY, f64::NEG_INFINITY), |m, h| (m.0.min(h), m.1.max(h))) -} - -/// Does `s` run along `t` from end to end? Two lines, `s`'s ends on `t`; two arcs of one -/// circle, `s`'s ends and middle on `t`. -fn runs_along(s: &Seg2, t: &Seg2, tol: f64) -> bool { - let on = |p: Vec2| t.point_at(closest_param(t, p)).dist(p) < tol; - match (*s, *t) { - (Seg2::Line { .. }, Seg2::Line { .. }) => on(s.start()) && on(s.end()), - (Seg2::Arc { center: c, radius: r, .. }, Seg2::Arc { center: d, radius: q, .. }) => { - c.dist(d) < tol && (r - q).abs() < tol && on(s.start()) && on(s.end()) && on(s.point_at(0.5)) - } - _ => false, - } -} - /// Points where two segments cross (parameters on each), lines and arcs only. /// /// Curves that touch within the tolerance (a line tangent to an arc, two circles tangent inside @@ -1055,15 +583,6 @@ fn closest_param(segment: &Seg2, point: Vec2) -> f64 { } } -fn dist_to(regions: &[Region2], p: Vec2) -> f64 { - regions - .iter() - .flat_map(|r| std::iter::once(&r.outer).chain(&r.holes)) - .flat_map(|l| l.segs.iter()) - .map(|s| s.point_at(closest_param(s, p)).dist(p)) - .fold(f64::INFINITY, f64::min) -} - /// The bounding box of a line or an arc, grown by twice the tolerance (and by the rounding of /// its own corners). Whatever lies within the tolerance of the segment lies in the box. `None` /// for other segments and for values that are not finite: no box, and nothing is skipped for it. @@ -1121,8 +640,7 @@ fn boolean2d(a: &[Region2], b: &[Region2], op: BoolOp, tol: f64) -> Option Option
{ @@ -1147,16 +665,15 @@ fn fitted(s: &Section, sources: &mut Vec, fit: f64) -> Option
{ for (l, lp) in std::iter::once(®.outer).chain(®.holes).enumerate() { let (mut segs, mut ts) = (Vec::new(), Vec::new()); for (i, seg) in lp.segs.iter().enumerate() { - let tag = s.tag(r, l, i); if seg.is_line_or_arc() { segs.push(*seg); - ts.push(tag); + ts.push(s.tag(r, l, i)); continue; } let arcs = seg.fit_arcs(fit)?; pieces = pieces.checked_add(arcs.len()).filter(|n| *n <= MAX_PLANAR_SEGMENTS)?; let n = arcs.len(); - ts.extend((0..n).map(|k| Tag { free: Some(sources.len()), ..tag.piece(k, n) })); + ts.extend(std::iter::repeat_n(Tag { free: Some(sources.len()) }, n)); segs.extend(arcs); sources.push(*seg); } @@ -1334,7 +851,7 @@ fn exact_again(out: Section, sources: &[Seg2], tol: f64) -> Section { /// One loop of [`exact_again`]: its segments and their tags. fn exact_loop(lp: &Loop2, tags: &[Tag], sources: &[Seg2], near: f64) -> (Vec, Vec) { let n = lp.segs.len(); - let tag = |i: usize| Tag { free: None, ..tags.get(i).copied().unwrap_or(BLANK) }; + let tag = |_: usize| BLANK; let free = |i: usize| tags.get(i).and_then(|t| t.free); let plain = || (lp.segs.clone(), (0..n).map(tag).collect::>()); // Start at the first segment of a run (a loop that is one run stays as it is). @@ -1379,8 +896,7 @@ fn exact_loop(lp: &Loop2, tags: &[Tag], sources: &[Seg2], near: f64) -> (Vec Option Option= MAX_PLANAR_SEGMENTS { return None; } - kept.push((p, tag.piece(k, n))); + kept.push((p, tag)); } } } @@ -1601,8 +1117,8 @@ fn boolean2d_arcs(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option Option= MAX_PLANAR_SEGMENTS { return None; } - let tag = tag.piece(k, n); match op { BoolOp::Union if !ins => kept.push((p, tag)), BoolOp::Intersect if ins => kept.push((p, tag)), - BoolOp::Cut if ins => kept.push((p.reversed(), tag.reversed())), + BoolOp::Cut if ins => kept.push((p.reversed(), tag)), _ => {} } } @@ -1698,8 +1213,6 @@ fn boolean2d_arcs(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option, near: f64) -> Vec<(Loop2, Vec)> out } -fn split_seg(seg: &Seg2, pts: &[Vec2], tol: f64) -> Option> { - let mut ts: Vec = pts - .iter() - .filter_map(|p| { - // A point within `tol` of an arc is within `tol` of its circle: the others need no - // (sampled) projection. - if let Seg2::Arc { center, radius, .. } = seg - && (p.dist(*center) - radius).abs() >= tol - { - return None; - } - // A point within `tol` of an end is that end (the sewing welds them into one): a cut - // there would leave a piece with no length. - if p.dist(seg.start()) < tol || p.dist(seg.end()) < tol { - return None; - } - let t = closest_param(seg, *p); - (t > 1e-9 && t < 1.0 - 1e-9 && seg.point_at(t).dist(*p) < tol).then_some(t) - }) - .collect(); - ts.sort_by(f64::total_cmp); - ts.dedup_by(|x, y| (*x - *y).abs() < 1e-9); - let mut out = Vec::new(); - let mut t0 = 0.0; - for t1 in ts.into_iter().chain(std::iter::once(1.0)) { - out.push(match *seg { - Seg2::Line { .. } => Seg2::Line { a: seg.point_at(t0), b: seg.point_at(t1) }, - Seg2::Arc { center, radius, start, sweep } => Seg2::Arc { center, radius, start: start + sweep * t0, sweep: sweep * (t1 - t0) }, - _ => trimmed(seg, t0, t1, seg.point_at(t0), seg.point_at(t1)), - }); - t0 = t1; - } - Some(out) -} - -/// The union of two prisms along `d` stacked end to end (or overlapping) with different -/// sections, sewn from its faces: each slab between the prisms' end levels has walls over its -/// section's outline; each level has a face up over the section below less the one above, and -/// a face down over the one above less the one below. Every outline is split where any other -/// meets it, so the faces share their edges. `None` when a slab is empty or a curve isn't a -/// line or an arc. -fn sew_stack(plane: &Plane, d: Vec3, pa: &Prism, pb: &Prism, tol: f64, history: &lineage::Context) -> Option> { - let mut levels = vec![pa.lo, pa.hi, pb.lo, pb.hi]; - levels.sort_by(f64::total_cmp); - levels.dedup_by(|x, y| (*x - *y).abs() < tol); - let covers = |p: &Prism, z0: f64, z1: f64| p.lo <= z0 + tol && p.hi >= z1 - tol; - let mut slabs: Vec
= Vec::new(); - for w in levels.windows(2) { - let (z0, z1) = (*w.first()?, *w.get(1)?); - let s = match (covers(pa, z0, z1), covers(pb, z0, z1)) { - (true, true) => boolean2d_tagged(&pa.section, &pb.section, BoolOp::Union, tol)?, - (true, false) => pa.section.clone(), - (false, true) => pb.section.clone(), - (false, false) => return None, - }; - slabs.push(s.oriented()); - } - sew_sections(plane, d, &levels, &slabs, tol, false, history) -} - -/// Sew the exact sections between successive levels, including empty gaps. With `coalesce`, -/// walls over one segment through successive slabs are one face. -fn sew_sections( - plane: &Plane, - d: Vec3, - levels: &[f64], - slabs: &[Section], - tol: f64, - coalesce: bool, - history: &lineage::Context, -) -> Option> { - if levels.len() != slabs.len() + 1 - || slabs.len() > 128 - || plane.normal().dot(d) < 1. - 1e-12 - || levels.iter().any(|z| !z.is_finite()) - || levels.windows(2).any(|z| z[0] >= z[1]) - { - return None; - } - let mut blocks = Vec::new(); - let mut start = None; - for (i, slab) in slabs.iter().enumerate() { - if slab.regions.is_empty() { - if let Some(first) = start.take() { - blocks.push((first, i)); - } - } else if start.is_none() { - start = Some(i); - } - } - if let Some(first) = start { - blocks.push((first, slabs.len())); - } - if blocks.is_empty() { - return None; - } - Some((|| { - let mut pieces = Vec::new(); - let mut remaining_constructed_faces = MAX_PLANAR_SEGMENTS * 2; - let mut remaining_faces = MAX_PLANAR_SEGMENTS * 2; - for (first, end) in blocks { - let tagged = slabs.get(first).ok_or_else(|| KernelError::Failed("missing prism section".into()))?; - let section = &tagged.regions; - if slabs[first..end].iter().all(|s| s.regions == *section) { - let edge_count = section.iter().flat_map(|r| std::iter::once(&r.outer).chain(&r.holes)).flat_map(|l| &l.segs).fold(0usize, |n, s| { - n.saturating_add(match s { - Seg2::Arc { sweep, .. } if sweep.abs() > 1.5 * std::f64::consts::PI => 2, - _ => 1, - }) - }); - remaining_constructed_faces = remaining_constructed_faces - .checked_sub(edge_count.saturating_add(section.len().saturating_mul(2))) - .ok_or_else(|| KernelError::Failed("prism construction face budget".into()))?; - // This is a NEW exact extrusion of the current Boolean section, - // not copied lineage from either operand's old footprint. - for (r, piece) in crate::extrude(plane, section, levels[first], levels[end])?.into_iter().enumerate() { - remaining_faces = - remaining_faces.checked_sub(piece.face_count()).ok_or_else(|| KernelError::Failed("prism output face budget".into()))?; - // Each slab's section, as read there: the same outline, but its walls - // read beside whichever operand is there. - let layers = - (first..end).map(|k| Some((slabs.get(k)?.region(r), *levels.get(k)?, *levels.get(k + 1)?))).collect::>>(); - let layers = layers.ok_or_else(|| KernelError::Failed("missing prism section".into()))?; - pieces.push((piece, lineage::Built::Extruded { layers })); - } - } else { - let (piece, built) = sew_connected_sections(plane, d, &levels[first..=end], &slabs[first..end], tol, coalesce, history) - .ok_or_else(|| KernelError::Failed("stepped prism construction failed".into()))??; - remaining_faces = - remaining_faces.checked_sub(piece.face_count()).ok_or_else(|| KernelError::Failed("prism output face budget".into()))?; - pieces.push((piece, built)); - } - } - let mut old = std::collections::HashMap::new(); - let mut shells = Vec::new(); - let mut remaining_map_faces = MAX_PLANAR_SEGMENTS * 2; - for (piece, _) in &pieces { - for (index, face) in piece.solid.face_iter().enumerate() { - remaining_map_faces = remaining_map_faces.checked_sub(1).ok_or_else(|| KernelError::Failed("prism output face budget".into()))?; - let source = piece.face_sources().and_then(|s| s.get(index)).and_then(Option::as_ref); - if old.insert(face.id(), Some((face.orientation(), source))).is_some() { - old.insert(face.id(), None); - } - } - shells.extend(piece.solid.boundaries().iter().cloned()); - } - let body = Body::new(crate::body::Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("prism compound: {e}")))?)?; - let sources = body - .solid - .face_iter() - .map(|face| match old.get(&face.id()) { - Some(Some((orientation, source))) if *orientation == face.orientation() => source.cloned(), - _ => None, - }) - .collect(); - let body = body.with_face_sources(Some(std::sync::Arc::new(sources))); - Ok(history.attach(body, &pieces)) - })()) -} - -/// Stable exact identity for the bounded analytic segment subset. -fn wall_key(s: &Seg2) -> Option<[u64; 6]> { - let bits = |v: f64| v.is_finite().then(|| if v == 0. { 0 } else { v.to_bits() }); - match s { - Seg2::Line { a, b } => Some([0, bits(a.x)?, bits(a.y)?, bits(b.x)?, bits(b.y)?, 0]), - Seg2::Arc { center, radius, start, sweep } => Some([1, bits(center.x)?, bits(center.y)?, bits(*radius)?, bits(*start)?, bits(*sweep)?]), - // Its ends and a point between them: free-form segments with the same ones are the same - // curve as far as a wall over it goes. - _ => { - let (a, m, b) = (s.start(), s.point_at(0.5), s.end()); - let h = |x: f64, y: f64| bits(x).zip(bits(y)).map(|(x, y)| x ^ y.rotate_left(17)); - Some([2, h(a.x, a.y)?, h(m.x, m.y)?, h(b.x, b.y)?, bits(m.x)?, bits(m.y)?]) - } - } -} - -/// A free-form segment as the control points of the cubic Bézier it is (a quadratic raised to -/// a cubic); `None` for those no cubic is exactly (rational conics, higher degrees). -fn cubic_of(s: &Seg2) -> Option<[Vec2; 4]> { - match *s { - Seg2::Cubic { p0, p1, p2, p3 } => Some([p0, p1, p2, p3]), - Seg2::Conic { a, apex, b, w } if (w - 1.0).abs() < 1e-12 => Some([a, a + (apex - a) * (2.0 / 3.0), b + (apex - b) * (2.0 / 3.0), b]), - Seg2::Bezier { n: 3, p } => Some([p[0], p[1], p[2], p[3]]), - _ => None, - } -} - -/// A genuinely stepped connected axial block has no single extrusion footprint. -fn sew_connected_sections( - plane: &Plane, - d: Vec3, - levels: &[f64], - slabs: &[Section], - tol: f64, - coalesce: bool, - history: &lineage::Context, -) -> Option> { - use crate::sew::{EdgeSpec, FaceSpec, SurfSpec}; - // Faces at each level: up where the slab below sticks out, down where the one above does. - let diff = |x: &Section, y: &Section| -> Option
{ - match (x.regions.is_empty(), y.regions.is_empty()) { - (true, _) => Some(Section::default()), - (false, true) => Some(x.clone()), - (false, false) => boolean2d_tagged(x, y, BoolOp::Cut, tol).map(|r| r.oriented()), - } - }; - let empty = Section::default(); - let mut caps: Vec<(f64, bool, Section)> = Vec::new(); - for (k, z) in levels.iter().enumerate() { - let below: &Section = if k == 0 { &empty } else { slabs.get(k - 1)? }; - let above: &Section = slabs.get(k).unwrap_or(&empty); - caps.push((*z, true, diff(below, above)?)); - caps.push((*z, false, diff(above, below)?)); - } - // Every segment end, everywhere: outlines split there. - let loops_of = - |rs: &[Region2]| -> Vec { rs.iter().flat_map(|r| std::iter::once(r.outer.clone()).chain(r.holes.iter().cloned())).collect() }; - let mut pts: Vec = Vec::new(); - for lp in slabs.iter().flat_map(|s| loops_of(&s.regions)).chain(caps.iter().flat_map(|c| loops_of(&c.2.regions))) { - for sg in &lp.segs { - pts.push(sg.start()); - pts.push(sg.end()); - } - } - // Ends within `tol` of each other are one point. The 2D boolean closes its loops within - // `tol`, not exactly: where a font's nearly round curve was read as an arc, the arc ends a - // few hundredths of a micron from the curve next to it. Sewing joins only ends at the same - // point, so such a loop would not close. - let cell = |u: Vec2| ((u.x / tol).floor() as i64, (u.y / tol).floor() as i64); - let mut ends: Vec = Vec::new(); - let mut grid: std::collections::HashMap<(i64, i64), Vec> = std::collections::HashMap::new(); - let weld = |ends: &[Vec2], grid: &std::collections::HashMap<(i64, i64), Vec>, u: Vec2| -> Option { - let (cx, cy) = cell(u); - (cx - 1..=cx + 1) - .flat_map(|x| (cy - 1..=cy + 1).map(move |y| (x, y))) - .filter_map(|c| grid.get(&c)) - .flatten() - .filter_map(|&i| ends.get(i).copied()) - .find(|e| e.dist(u) <= tol) - }; - for &u in &pts { - if weld(&ends, &grid, u).is_none() { - grid.entry(cell(u)).or_default().push(ends.len()); - ends.push(u); - } - } - // Welding above keeps its original encounter order. Side splitting needs - // only the distinct stations, whose resulting parameters are sorted anyway. - // Deduplicate in place, with bounded sorting work and no extra point list. - if pts.len() <= MAX_PLANAR_SEGMENTS * 8 { - pts.sort_unstable_by(|a, b| a.x.total_cmp(&b.x).then(a.y.total_cmp(&b.y))); - pts.dedup_by_key(|p| (p.x.to_bits(), p.y.to_bits())); - } - // A piece of a free-form curve whose ends weld into one point (a font's curve cut a hair from - // its end) is no edge and has no wall: the pieces on either side meet there. (Lines and arcs - // are left as they were: such a piece of one fails the sewing, as before.) - let short = |s: &Seg2| { - !s.is_line_or_arc() - && s.length() <= 2.0 * tol - && matches!((weld(&ends, &grid, s.start()), weld(&ends, &grid, s.end())), (Some(p), Some(q)) if p == q) - }; - // One curve between two ends, as the walls and the caps beside them each read it: their - // sections come from different booleans, which split it from different pieces, so the - // control points can differ by a hair, and sewing tells edges apart by them. The first - // reading stands for all of them. - let chains: std::cell::RefCell> = std::cell::RefCell::new(Vec::new()); - let same_chain = |c: [Vec3; 4]| -> [Vec3; 4] { - let mid = |k: &[Vec3; 4]| (k[0] + (k[1] + k[2]) * 3.0 + k[3]) * 0.125; - let mut known = chains.borrow_mut(); - for k in known.iter() { - if mid(k).dist(mid(&c)) <= tol * 10.0 { - if k[0] == c[0] && k[3] == c[3] { - return *k; - } - if k[0] == c[3] && k[3] == c[0] { - return [k[3], k[2], k[1], k[0]]; - } - } - } - known.push(c); - c - }; - let at = |u: Vec2, z: f64| plane.to_world(u) + d * z; - let welded = |u: Vec2, z: f64| at(weld(&ends, &grid, u).unwrap_or(u), z); - // One edge between two ends, whichever way a wall or a cap reads the curve there: a piece of - // a font's curve so short that one section reads it as an arc within the tolerance, where - // another has the curve itself (the same letters cut again), is one edge. The first reading - // stands for all of them. - let readings: std::cell::RefCell> = std::cell::RefCell::new(Vec::new()); - let same_edge = |spec: EdgeSpec, a: Vec3, b: Vec3, mid: Vec3| -> EdgeSpec { - let mut known = readings.borrow_mut(); - for (ka, kb, km, k) in known.iter() { - if km.dist(mid) <= tol * 10.0 { - if *ka == a && *kb == b { - return k.clone(); - } - if *ka == b && *kb == a { - return k.reversed(); - } - } - } - known.push((a, b, mid, spec.clone())); - spec - }; - let edge = |sg: &Seg2, z: f64| -> Option { - Some(match sg { - Seg2::Line { .. } => EdgeSpec::Line { a: welded(sg.start(), z), b: welded(sg.end(), z) }, - Seg2::Arc { .. } => { - let (a, b, mid) = (welded(sg.start(), z), welded(sg.end(), z), at(sg.point_at(0.5), z)); - same_edge(EdgeSpec::Arc { a, b, mid }, a, b, mid) - } - _ => { - let [p0, p1, p2, p3] = cubic_of(sg)?; - let c = same_chain([welded(p0, z), at(p1, z), at(p2, z), welded(p3, z)]); - let mid = (c[0] + (c[1] + c[2]) * 3.0 + c[3]) * 0.125; - same_edge(EdgeSpec::Chain { degree: 3, ctrl: c.to_vec().into() }, c[0], c[3], mid) - } - }) - }; - // Exact oriented generated segments alone define a run. No support fitting, - // proximity matching, or old face lineage is used here. - // Each run, with what its wall is over in each of its slabs (for the result's history). - type Run = (usize, usize, Seg2, Vec); - let mut runs: Vec = Vec::new(); - let mut last = std::collections::BTreeMap::new(); - let mut remaining = MAX_PLANAR_SEGMENTS * 2; - for (i, slab) in slabs.iter().enumerate() { - for (r, reg) in slab.regions.iter().enumerate() { - for (l, lp) in std::iter::once(®.outer).chain(®.holes).enumerate() { - // The loop's walls in order: the run each joins, its tag and where it ends. - let mut around: Vec<(usize, Tag, Vec2)> = Vec::new(); - for (si, sg0) in lp.segs.iter().enumerate() { - let pieces = split_seg(sg0, &pts, tol)?; - let (n, tag) = (pieces.len(), slab.tag(r, l, si)); - for (k, sg) in pieces.into_iter().enumerate() { - if short(&sg) { - continue; - } - remaining = remaining.checked_sub(1)?; - let key = wall_key(&sg)?; - let prior = if coalesce { last.get(&key).copied() } else { None }; - let run = match prior.map(|index| runs.get_mut(index).map(|run: &mut Run| (index, run))) { - Some(None) => return None, - Some(Some((index, run))) if run.1 == i => { - run.1 = i + 1; - index - } - // Duplicate oriented boundaries in one slab are not - // a valid reason to reconstruct a larger wall. - Some(Some((_, run))) if run.1 == i + 1 => return None, - _ => { - if coalesce { - last.insert(key, runs.len()); - } - runs.push((i, i + 1, sg, Vec::new())); - runs.len() - 1 - } - }; - around.push((run, tag.piece(k, n), sg.end())); - } - } - // Each wall runs into the next one of its loop, the last into the first. - for (k, (run, tag, at)) in around.iter().enumerate() { - let next = around.get((k + 1) % around.len())?.0; - runs.get_mut(*run)?.3.push(lineage::Slab { tag: *tag, next, at: *at }); - } - } - } - } - let mut faces: Vec = Vec::new(); - let mut sources = Vec::new(); - let mut specs: Vec = Vec::with_capacity(runs.len()); - let frame_is_orthonormal = plane.origin.is_finite() - && plane.x.is_finite() - && plane.y.is_finite() - && d.is_finite() - && (plane.x.len2() - 1.).abs() <= 64. * f64::EPSILON - && (plane.y.len2() - 1.).abs() <= 64. * f64::EPSILON - && (d.len2() - 1.).abs() <= 64. * f64::EPSILON - && plane.x.dot(plane.y).abs() <= 64. * f64::EPSILON - && plane.x.dot(d).abs() <= 64. * f64::EPSILON - && plane.y.dot(d).abs() <= 64. * f64::EPSILON; - for (first, end, sg, over) in runs { - let (z0, z1) = (levels[first], levels[end]); - let (a, b) = (sg.start(), sg.end()); - let mut lp3 = Vec::with_capacity(2 + 2 * (end - first)); - lp3.push(edge(&sg, z0)?); - // Keep station vertices at both ends: neighboring stepped walls/caps - // must share complete edges rather than create T-junctions. - for k in first..end { - lp3.push(EdgeSpec::Line { a: welded(b, levels[k]), b: welded(b, levels[k + 1]) }); - } - lp3.push(edge(&sg.reversed(), z1)?); - for k in (first..end).rev() { - lp3.push(EdgeSpec::Line { a: welded(a, levels[k + 1]), b: welded(a, levels[k]) }); - } - let outward = plane.dir_to_world(sg.derivative(0.5)).cross(d).normalized()?; - let surface = match sg { - Seg2::Line { .. } => SurfSpec::Plane, - Seg2::Arc { .. } => SurfSpec::Extruded { a: at(a, z0), b: at(b, z0), mid: at(sg.point_at(0.5), z0), dir: d * (z1 - z0) }, - // A free-form wall: the lines along `d` joining the curve at both levels. - _ => SurfSpec::Ruled { a: edge(&sg, z0)?, b: edge(&sg, z1)? }, - }; - faces.push(FaceSpec { loops: vec![lp3], surface, probe: Some((at(sg.point_at(0.5), (z0 + z1) / 2.0), outward)) }); - // Axis-aligned generated lines have a common oriented support frame - // independent of axial stations or along-line endpoint interpolation. - let generated_plane = if coalesce - && frame_is_orthonormal - && let Seg2::Line { a, b } = sg - { - let (origin, x) = if a.y == b.y && a.x != b.x { - (at(Vec2::new(0., a.y), 0.), plane.x * (b.x - a.x).signum()) - } else if a.x == b.x && a.y != b.y { - (at(Vec2::new(a.x, 0.), 0.), plane.y * (b.y - a.y).signum()) - } else { - (Vec3::ZERO, Vec3::ZERO) - }; - (origin.is_finite() && x.len2() > 0.).then_some(Plane { origin, x, y: d }) - } else { - None - }; - sources.push((generated_plane.is_some() || end > first + 1).then_some(crate::FaceSource::ExtrudeSide { - segment: sg, - plane: generated_plane, - coalesced: end > first + 1, - })); - specs.push(lineage::Spec::Wall { levels: levels.get(first..=end)?.to_vec(), slabs: over }); - } - for (z, up, rs) in &caps { - for (ri, r) in rs.regions.iter().enumerate() { - let mut loops = Vec::new(); - for lp in std::iter::once(&r.outer).chain(&r.holes) { - let mut segs: Vec = Vec::new(); - for sg in &lp.segs { - segs.extend(split_seg(sg, &pts, tol)?.into_iter().filter(|s| !short(s))); - } - let segs: Vec = if *up { segs } else { segs.iter().rev().map(Seg2::reversed).collect() }; - loops.push(segs.iter().map(|sg| edge(sg, *z)).collect::>>()?); - } - faces.push(FaceSpec { loops, surface: SurfSpec::Plane, probe: None }); - sources.push(None); - specs.push(lineage::Spec::Cap { section: rs.region(ri), z: *z, up: *up }); - } - } - let sewn = crate::sew::sew_touching_with_sources(&faces, &sources).map(|(body, from)| (body, lineage::Built::Sewn { specs, faces: from })); - // Generated walls joined on their common supports: the piece's history over the operands, - // carried through the joining. - Some(if coalesce { - sewn.and_then(|(body, built)| { - let body = history.attach(body.clone(), &[(&body, built)]).regularize_generated_planar_faces()?; - Ok((body, lineage::Built::Traced)) - }) - } else { - sewn - }) -} - -#[cfg(test)] -fn simple_prism_boolean(a: &Body, b: &Body, op: BoolOp) -> Option>> { - simple_prism_indexed(a, b, op, [&LazyIndex::new(a, 0), &LazyIndex::new(b, 1)]) -} - -/// [`prism_boolean`] of single prisms, the operands' indexes given. -fn simple_prism_indexed(a: &Body, b: &Body, op: BoolOp, [ia, ib]: [&LazyIndex; 2]) -> Option>> { - let size = a.size().max(b.size()); - let tol = (size * 1e-7).max(1e-9) * 10.0; - // Candidate directions (each line once, pointing up). - let dirs: Vec = directions(a, b)?.into_iter().map(|n| if n.dot(Vec3::new(1e-3, 1e-6, 1.0)) < 0.0 { -n } else { n }).collect(); - let (d, plane, pa, pb) = dirs.into_iter().find_map(|d| { - let plane = Plane::from_normal(Vec3::ZERO, d)?; - let pa = prism_tagged(a, d, &plane, tol, ia)?; - let pb = prism_tagged(b, d, &plane, tol, ib)?; - Some((d, plane, pa, pb)) - })?; - let history = lineage::Context::new(op, [a, b], [ia.get(), ib.get()], plane, tol, Some([(pa.lo, pa.hi), (pb.lo, pb.hi)])); - let (blo, bhi) = heights_of(b, &plane); - let spans = blo <= pa.lo + tol && bhi >= pa.hi - tol; - let same = (pb.lo - pa.lo).abs() < tol && (pb.hi - pa.hi).abs() < tol; - let area = - |rs: &[Region2]| rs.iter().map(|r| r.outer.signed_area().abs() - r.holes.iter().map(|h| h.signed_area().abs()).sum::()).sum::(); - // Prisms of one section overlapping or touching end to end: one longer prism. - let stacked = op == BoolOp::Union && !same && pb.lo <= pa.hi + tol && pa.lo <= pb.hi + tol; - let ok = match op { - BoolOp::Cut | BoolOp::Intersect => spans, - BoolOp::Union => same || stacked, - }; - if !ok { - return None; - } - let section = boolean2d_tagged(&pa.section, &pb.section, op, tol)?; - let regions = §ion.regions; - if regions.is_empty() { - return Some(Ok(None)); - } - let (u, x, y) = (area(regions), area(&pa.section.regions), area(&pb.section.regions)); - let alike = |v: f64| (u - v).abs() <= tol * (1.0 + u); - // A tool that misses its target (or an intersection that is one operand whole) leaves it - // as it is: the B-rep boolean reuses that operand itself, where this would rebuild it. - if matches!(op, BoolOp::Cut | BoolOp::Intersect) && (same_area(u, x, tol) || (op == BoolOp::Intersect && same_area(u, y, tol))) { - return None; - } - let (lo, hi) = if stacked { - // Different sections (a boss hanging over a plate's edge): sewn slab by slab. - if !alike(x) || !alike(y) { - return sew_stack(&plane, d, &pa, &pb, tol, &history).map(|r| r.map(Some)); - } - // One outline end to end: also slab by slab, so the history follows each operand's - // walls (one longer prism, whose walls are made from both). - if let Some(Ok(body)) = sew_stack(&plane, d, &pa, &pb, tol, &history) - && body.history().is_some() - { - return Some(Ok(Some(body))); - } - (pa.lo.min(pb.lo), pa.hi.max(pb.hi)) - } else { - (pa.lo, pa.hi) - }; - let base = plane.offset(lo); - let bodies = match crate::extrude(&base, regions, 0.0, hi - lo) { - Ok(b) => b, - Err(e) => return Some(Err(e)), - }; - // Each body over its region. - let mut pieces: Vec<(Body, lineage::Built)> = - bodies.into_iter().enumerate().map(|(r, b)| (b, lineage::Built::Extruded { layers: vec![(section.region(r), lo, hi)] })).collect(); - let last = pieces.pop()?; - if !pieces.is_empty() { - // Several pieces: one body of several lumps (the last first). - pieces.push(last); - pieces.rotate_right(1); - let shells: Vec = pieces.iter().flat_map(|(b, _)| b.solid.boundaries().iter().cloned()).collect(); - return Some( - crate::body::Solid::try_new(shells) - .map_err(|e| crate::KernelError::Failed(e.to_string())) - .and_then(Body::new) - .map(|body| Some(history.attach(body, &pieces))), - ); - } - Some(Ok(Some(history.attach(last.0.clone(), &[last])))) -} - -/// The directions to try the operands as prisms along: the first eight plane directions of the -/// target (in its face order), then those of the tool's caps (a pair of opposite plane faces) -/// that the target has further on. A target cut many times over (a line of text, a group of -/// letters at a time) has more plane directions than eight, its walls' among them: in face -/// order its caps' direction can come too late. `None` past the face budget. -fn directions(a: &Body, b: &Body) -> Option> { - if a.face_count().saturating_add(b.face_count()) > MAX_PLANAR_SEGMENTS * 2 { - return None; - } - let normals = |x: &Body| -> Vec { - x.solid - .face_iter() - .filter_map(|f| match f.oriented_surface() { - mt::Surface::Plane(p) => { - let n = p.normal(); - Vec3::new(n.x, n.y, n.z).normalized() - } - _ => None, - }) - .collect() - }; - let mut target: Vec = Vec::new(); - for n in normals(a) { - if !target.iter().any(|m| m.dot(n).abs() > 1.0 - 1e-9) { - target.push(n); - } - } - let tool = normals(b); - let capped = |d: &Vec3| tool.iter().any(|n| n.dot(*d) > 1.0 - 1e-9) && tool.iter().any(|n| n.dot(*d) < -1.0 + 1e-9); - let mut dirs: Vec = target.iter().take(8).copied().collect(); - dirs.extend(target.iter().skip(8).filter(|d| capped(d)).take(8)); - Some(dirs) -} - -/// The direction `b` is a prism (or a stack of prisms) along: the first of its planar faces' -/// normals along which it is one. `None` when there is none. -pub(crate) fn prism_axis(b: &Body) -> Option { - if b.face_count() > MAX_PLANAR_SEGMENTS { - return None; - } - let tol = (b.size() * 1e-7).max(1e-9) * 10.0; - let index = LazyIndex::new(b, 1); - let mut tried: Vec = Vec::new(); - for f in b.solid.face_iter() { - let mt::Surface::Plane(p) = f.oriented_surface() else { continue }; - let n = p.normal(); - let Some(n) = Vec3::new(n.x, n.y, n.z).normalized() else { continue }; - if tried.iter().any(|m| m.dot(n).abs() > 1.0 - 1e-9) { - continue; - } - tried.push(n); - if tried.len() > 16 { - return None; - } - let plane = Plane::from_normal(Vec3::ZERO, n)?; - if stack_tagged(b, n, &plane, tol, &index).is_some() { - return Some(n); - } - } - None -} - -/// Whether a boolean of sections left one of area `v` as it was (area `u` after): the same to -/// within rounding, as the very same outline gives (a change is at least a sliver `tol` wide). -fn same_area(u: f64, v: f64, tol: f64) -> bool { - (u - v).abs() <= 1e-9 * u.abs().max(v.abs()) + tol * tol -} - -/// A stepped extrusion (case floor plus walls), recovered from its cap events. -/// Downward caps add a section above their level; upward caps remove one. -#[cfg(test)] -fn stack_of(b: &Body, d: Vec3, plane: &Plane, tol: f64) -> Option> { - stack_tagged(b, d, plane, tol, &LazyIndex::new(b, 0)) -} - -/// [`stack_of`], its sections' segments tagged from `index` (the body's). -fn stack_tagged(b: &Body, d: Vec3, plane: &Plane, tol: f64, index: &LazyIndex) -> Option> { - if let Some(p) = prism_tagged(b, d, plane, tol, index) { - return Some(vec![p]); - } - if b.face_count() > 2048 { - return None; - } - let mut events = Vec::new(); - let mut walls = std::collections::HashMap::new(); - let mut wall_work = 262_144; - let mut curve_work = 2_000_000; - let mut segments = usize::MAX; - for (fi, f) in b.solid.face_iter().enumerate() { - let surf = f.oriented_surface(); - if let mt::Surface::Plane(p) = &surf { - let n = p.normal(); - let n = Vec3::new(n.x, n.y, n.z).normalized()?; - if n.dot(d).abs() > 1.0 - 1e-9 { - let section = Section::from_loops(index.get().loops(f, fi, plane, tol, &mut curve_work, &mut segments)?)?; - events.push((plane.height(from_p3(p.origin())), n.dot(d) > 0.0, section.oriented(), fi)); - continue; - } - if n.dot(d).abs() > 1e-9 { - return None; - } - } else if !wall_along(&surf, d, tol, &mut wall_work) { - return None; - } - walls.insert(fi, top_of(f, plane)); - } - let mut levels: Vec = events.iter().map(|(z, _, _, _)| *z).collect(); - levels.sort_by(f64::total_cmp); - levels.dedup_by(|x, y| (*x - *y).abs() < tol); - if levels.len() < 2 || levels.len() > 64 || levels.iter().any(|z| !z.is_finite()) { - return None; - } - let stations = Stations::new(index.get(), walls, d, plane, tol); - let mut current = Section::default(); - let mut stack: Vec = Vec::new(); - let mut budget = MAX_PLANAR_PAIRS; - for (i, z) in levels.iter().enumerate() { - // The caps here end the slab below: its walls meet them. - if let Some(below) = stack.last_mut().filter(|p| (p.hi - *z).abs() < tol) { - let (faces, caps): (Vec, Vec<&Section>) = - events.iter().filter(|(h, _, _, _)| (*h - *z).abs() < tol).map(|(_, _, s, f)| (*f, s)).unzip(); - below.section.mark_far(&caps, |w| stations.top_edge(index.get(), w, &faces, *z, tol), tol, &mut budget); - } - // The segments carried here run on past it, beside the walls there. - current.retag(|t| match t.wall { - Some(w) => t.beside(stations.past(w, *z, tol)), - None => t, - }); - // Remove terminating material before adding any material starting here. - for up in [true, false] { - for (_, _, section, _) in events.iter().filter(|(h, u, _, _)| (*h - *z).abs() < tol && *u == up) { - current = match (current.regions.is_empty(), up) { - (true, false) => section.clone(), - (true, true) => return None, - (false, _) => boolean2d_tagged(¤t, section, if up { BoolOp::Cut } else { BoolOp::Union }, tol)?, - }; - } - } - if let Some(next) = levels.get(i + 1) - && !current.regions.is_empty() - { - current.drop_crossed(&stations, *z, *next, tol); - stack.push(Prism { lo: *z, hi: *next, section: current.oriented() }); - } - } - (current.regions.is_empty() && !stack.is_empty()).then_some(stack) -} - -#[cfg(test)] -fn stack_boolean(a: &Body, b: &Body, op: BoolOp) -> Option>> { - stack_indexed(a, b, op, [&LazyIndex::new(a, 0), &LazyIndex::new(b, 1)], true) -} - -/// [`prism_boolean`] of stepped prisms, the operands' indexes given. A union is taken of -/// operands that end at a common level when `common_cap` is set, else of those that don't (see -/// [`prism_union_between_caps`]). -fn stack_indexed(a: &Body, b: &Body, op: BoolOp, [ia, ib]: [&LazyIndex; 2], common_cap: bool) -> Option>> { - // Common-cap joins and overlapping partial-depth cuts of aligned stepped prisms can - // retain their exact section boundaries instead of intersecting meshes. - // Nonaligned bodies retain their existing B-rep path. - if !matches!(op, BoolOp::Union | BoolOp::Cut) { - return None; - } - if op == BoolOp::Cut && a.face_count().saturating_add(b.face_count()) > 2048 { - return None; - } - fn section(ps: &[Prism], lo: f64, hi: f64, tol: f64) -> Section { - ps.iter().find(|p| p.lo <= lo + tol && p.hi >= hi - tol).map(|p| p.section.clone()).unwrap_or_default() - } - let tol = (a.size().max(b.size()) * 1e-7).max(1e-9) * 10.0; - let dirs = directions(a, b)?; - let ends = |ps: &[Prism]| ps.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), p| (lo.min(p.lo), hi.max(p.hi))); - let (d, plane, pa, pb) = dirs.into_iter().find_map(|d| { - let plane = Plane::from_normal(Vec3::ZERO, d)?; - let pa = stack_tagged(a, d, &plane, tol, ia)?; - let pb = stack_tagged(b, d, &plane, tol, ib)?; - let (ea, eb) = (ends(&pa), ends(&pb)); - let shared = (ea.0 - eb.0).abs() < tol || (ea.1 - eb.1).abs() < tol; - match op { - BoolOp::Union if shared != common_cap => return None, - // A cut tool may extend past a cap into empty space. Exact slab sections - // discard that space rather than intersecting coincident cylinder walls. - BoolOp::Cut if ea.1 <= eb.0 + tol || eb.1 <= ea.0 + tol => return None, - _ => {} - } - Some((d, plane, pa, pb)) - })?; - let mut levels: Vec = pa.iter().chain(&pb).flat_map(|p| [p.lo, p.hi]).collect(); - levels.sort_by(f64::total_cmp); - levels.dedup_by(|x, y| (*x - *y).abs() < tol); - let mut slabs = Vec::new(); - let mut work = 0usize; - let mut output_edges = 0usize; - let area = - |rs: &[Region2]| rs.iter().map(|r| r.outer.signed_area().abs() - r.holes.iter().map(|h| h.signed_area().abs()).sum::()).sum::(); - // Whether some slab's section came out other than the target's (else the tool missed it). - let mut changed = false; - let edges = |regions: &[Region2]| regions.iter().flat_map(|r| std::iter::once(&r.outer).chain(&r.holes)).map(|l| l.segs.len()).sum::(); - for w in levels.windows(2) { - let (lo, hi) = (*w.first()?, *w.get(1)?); - let (x, y) = (section(&pa, lo, hi, tol), section(&pb, lo, hi, tol)); - let before = area(&x.regions); - if op == BoolOp::Cut { - let count = edges(&x.regions).saturating_add(edges(&y.regions)); - work = work.saturating_add(count.saturating_mul(count)); - if work > 32_000_000 { - return None; - } - } - let s = match (x.regions.is_empty(), y.regions.is_empty(), op) { - (true, _, BoolOp::Cut | BoolOp::Intersect) | (_, true, BoolOp::Intersect) => Section::default(), - (true, _, BoolOp::Union) => y, - (_, true, _) => x, - _ => boolean2d_tagged(&x, &y, op, tol)?, - }; - changed |= !same_area(area(&s.regions), before, tol); - if op == BoolOp::Cut { - output_edges = output_edges.saturating_add(edges(&s.regions)); - if output_edges > 8192 { - return None; - } - } - slabs.push(s.oriented()); - } - if slabs.iter().all(|s| s.regions.is_empty()) { - return Some(Ok(None)); - } - // A cut that takes nothing leaves the target as it is: the B-rep boolean reuses it itself, - // where this would rebuild it. - if op == BoolOp::Cut && !changed { - return None; - } - let history = lineage::Context::new(op, [a, b], [ia.get(), ib.get()], plane, tol, None); - let coalesce = op == BoolOp::Cut - && !a.regularization_protected - && !b.regularization_protected - && a.split_keep().is_empty() - && b.split_keep().is_empty() - && a.paint().is_none_or(|p| p.faces.is_empty()) - && b.paint().is_none_or(|p| p.faces.is_empty()); - sew_sections(&plane, d, &levels, &slabs, tol, coalesce, &history).map(|r| r.map(Some)) -} - -thread_local! { - /// Set while [`prism_boolean_free_form`] runs: spline outlines are read as arcs within - /// [`PLANAR_FIT_TOL`] instead of refusing the prism. - static FREE_FORM: std::cell::Cell = const { std::cell::Cell::new(false) }; -} - -/// [`prism_boolean`] for prisms whose walls are splines (swept along one): the outlines are -/// fitted by arcs within [`PLANAR_FIT_TOL`], so the result is exact to that, and the walls it -/// keeps are those arcs. Only for bodies the caller knows are such sweeps. -pub(crate) fn prism_boolean_free_form(a: &Body, b: &Body, op: BoolOp) -> Option>> { - /// Clears the flag however the boolean ends, a caught panic included. - struct Reset; - impl Drop for Reset { - fn drop(&mut self) { - FREE_FORM.with(|c| c.set(false)); - } - } - FREE_FORM.with(|c| c.set(true)); - let _reset = Reset; - prism_boolean(a, b, op) -} - -/// Boolean of prisms along a common direction, in 2D (see the module notes); `None` when it -/// doesn't apply. The result carries its history over `[a, b]` (see [`lineage`]). -pub(crate) fn prism_boolean(a: &Body, b: &Body, op: BoolOp) -> Option>> { - // Each operand's index is built once, and only if it is read as a prism. - let index = [&LazyIndex::new(a, 0), &LazyIndex::new(b, 1)]; - crate::guard("prism boolean", || Ok(simple_prism_indexed(a, b, op, index).or_else(|| stack_indexed(a, b, op, index, true)))).ok().flatten() -} - -/// [`prism_boolean`] of a union of stepped prisms along one direction that end at different -/// levels (a barrel joined between two faces of a wider part, its ends flush with them), which -/// that route leaves to the B-rep boolean: for when that boolean has failed. `None` for other -/// operations and operands. -pub(crate) fn prism_union_between_caps(a: &Body, b: &Body, op: BoolOp) -> Option>> { - if op != BoolOp::Union { - return None; - } - let index = [&LazyIndex::new(a, 0), &LazyIndex::new(b, 1)]; - crate::guard("prism boolean", || Ok(stack_indexed(a, b, op, index, false))).ok().flatten() -} - #[cfg(test)] mod planar_tests { use super::*; @@ -2644,370 +1331,17 @@ mod planar_tests { Region2 { outer: Loop2::polygon(&[a, Vec2::new(b.x, a.y), b, Vec2::new(a.x, b.y)]), holes: vec![] } } #[test] - fn simple_prism_retains_large_analytic_section_budget() { - let count = 2050; - let radius = 1000.; - let points: Vec<_> = (0..count) - .map(|i| { - let angle = std::f64::consts::TAU * i as f64 / count as f64; - Vec2::new(radius * angle.cos(), radius * angle.sin()) - }) - .collect(); - let region = Region2 { outer: Loop2::polygon(&points), holes: vec![] }; - let stock = crate::extrude(&Plane::XY, &[region], 0., 2.).unwrap().pop().unwrap(); - assert_eq!(stock.face_count(), count + 2); - assert!(stock.face_count() > 2048 && stock.validity().is_empty()); - let before: Vec<_> = stock.solid.vertex_iter().map(|v| (v.id(), v.point())).collect(); - let recovered = prism_of(&stock, Vec3::Z, &Plane::XY, 1e-5).expect("large simple line prism remains supported"); - assert_eq!(recovered.section.regions.len(), 1); - assert_eq!(recovered.section.regions[0].outer.segs.len(), count); - assert!(recovered.section.regions[0].outer.segs.iter().all(|s| matches!(s, Seg2::Line { .. }))); - let area = count as f64 * radius * radius * (std::f64::consts::TAU / count as f64).sin() / 2.; - assert!((recovered.section.regions[0].area() - area).abs() < area * 1e-12); - assert!((recovered.lo - 0.).abs() < 1e-8 && (recovered.hi - 2.).abs() < 1e-8); - let cutter = crate::box_solid(Vec3::new(-1001., -1001., -1.), Vec3::new(1001., 1001., 3.)).unwrap(); - assert!( - simple_prism_boolean(&stock, &cutter, BoolOp::Cut) - .expect("large analytic section routes through the exact simple path") - .unwrap() - .is_none() - ); - assert_eq!(stock.solid.vertex_iter().map(|v| (v.id(), v.point())).collect::>(), before); - } - #[test] - fn curved_stop_cut_constructs_fresh_current_cap_for_only_uniform_lump() { - let cylinder = crate::cylinder(Vec3::new(25., 25., 0.), Vec3::Z, 2., 20.).unwrap(); - let stop = crate::box_solid(Vec3::new(19., 19., 1.), Vec3::new(31., 31., 2.)).unwrap(); - let roof = crate::boolean(&cylinder, &stop, BoolOp::Union).unwrap().unwrap(); - let original = rectangle(Vec2::new(20., 20.), Vec2::new(30., 30.)); - let tool = crate::extrude(&Plane::XY, &[original], 0., 25.).unwrap().pop().unwrap(); - let before_tool = crate::step_export(&[&tool], "tool").unwrap(); - let before_roof = crate::step_export(&[&roof], "roof").unwrap(); - let trimmed = crate::boolean(&tool, &roof, BoolOp::Cut).unwrap().unwrap(); - let lumps = trimmed.lumps().unwrap(); - assert_eq!(lumps.len(), 2); - let mut lower = 0; - let mut upper = 0; - for lump in &lumps { - assert!(lump.validity().is_empty()); - let mesh = lump.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - if mesh.contains(Vec3::new(21., 21., 0.5)) { - lower += 1; - assert!(!mesh.contains(Vec3::new(25., 25., 0.5))); - assert!(!mesh.contains(Vec3::new(21., 21., 1.5))); - assert!((mesh.measure().volume - (100. - 4. * std::f64::consts::PI)).abs() < 0.002); - let sources = lump.face_sources().expect("fresh actual extrusion has complete sources"); - assert_eq!(sources.len(), lump.face_count()); - assert!(sources.iter().all(Option::is_some)); - let mut caps = 0; - for source in sources.iter().flatten() { - match source { - crate::FaceSource::ExtrudeCap { region, plane, .. } => { - assert_eq!(region.holes.len(), 1); - assert!((region.area() - (100. - 4. * std::f64::consts::PI)).abs() < 1e-8); - assert!(plane.normal().z.abs() > 1. - 1e-10); - assert!((plane.origin.z - if plane.normal().z > 0. { 1. } else { 0. }).abs() < 1e-8); - caps += 1; - } - crate::FaceSource::ExtrudeSide { .. } => {} - _ => panic!("old producer lineage must not survive a changed Boolean footprint"), - } - } - assert_eq!(caps, 2); - } else { - upper += 1; - assert!(mesh.contains(Vec3::new(21., 21., 3.))); - assert!(!mesh.contains(Vec3::new(25., 25., 3.))); - assert!(mesh.contains(Vec3::new(25., 25., 22.))); - assert!( - lump.face_sources().is_none_or(|s| s - .iter() - .all(|s| s.is_none() || matches!(s, Some(crate::FaceSource::ExtrudeSide { coalesced: true, plane: None, .. })))), - "genuinely stepped geometry has no durable certificate" - ); - assert!((mesh.measure().volume - (18. * (100. - 4. * std::f64::consts::PI) + 500.)).abs() < 0.02); - } - } - assert_eq!((lower, upper), (1, 1)); - assert_eq!(crate::step_export(&[&tool], "tool").unwrap(), before_tool); - assert_eq!(crate::step_export(&[&roof], "roof").unwrap(), before_roof); - } - fn stepped_tab_stock() -> Body { - let stock = crate::box_solid(Vec3::new(-20., -15., 0.), Vec3::new(20., 15., 24.)).unwrap(); - let tab = crate::box_solid(Vec3::new(-12., -25., 8.), Vec3::new(-4., -15., 16.)).unwrap(); - crate::boolean(&stock, &tab, BoolOp::Union).unwrap().unwrap() - } - - fn coplanar_joins(body: &Body) -> usize { - let faces: Vec<_> = body.solid.face_iter().collect(); - let mut adjacency = std::collections::HashMap::<_, Vec>::new(); - for (i, face) in faces.iter().enumerate() { - for edge in face.edge_iter() { - adjacency.entry(edge.id()).or_default().push(i); - } - } - adjacency - .values() - .filter(|faces| { - let [a, b] = faces.as_slice() else { return false }; - let (Some(pa), Some(pb)) = (body.planar_face(*a), body.planar_face(*b)) else { return false }; - let (na, nb) = (pa.normal(), pb.normal()); - na.dot(nb) > 1. - 1e-12 && (pb.origin - pa.origin).dot(na).abs() < 1e-10 - }) - .count() - } - - #[test] - fn shell_of_joined_stepped_tabs_has_no_artificial_planar_stations() { - let stock = stepped_tab_stock(); - let snapshot = crate::step_export(&[&stock], "unchanged stock").unwrap(); - assert_eq!(coplanar_joins(&stock), 0); - let shell = crate::shell(&stock, &[Vec3::new(0., 0., 24.)], 1.).unwrap(); - assert_eq!(coplanar_joins(&shell), 0, "Shell must not add internal edges across continuous planar walls"); - assert!(shell.validity().is_empty()); - let mesh = shell.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - let expected = 40. * 30. * 24. + 8. * 10. * 8. - (38. * 28. * 23. + 6. * 10. * 6.); - assert!((mesh.measure().volume - expected).abs() < 1e-6); - for (point, material) in [ - (Vec3::new(0., 0., 0.5), true), - (Vec3::new(0., 0., 10.), false), - (Vec3::new(0., -14.5, 10.), true), - (Vec3::new(19.5, 0., 10.), true), - (Vec3::new(-8., -24.5, 12.), true), - (Vec3::new(-8., -20., 12.), false), - (Vec3::new(0., -18., 9.), false), - ] { - assert_eq!(mesh.contains(point), material, "wrong material at {point:?}"); - } - let step = crate::step_export(&[&shell], "stepped tab shell").unwrap(); - let reopened = crate::step_import(&step).unwrap(); - let body = &reopened.bodies[0].body; - assert_eq!(body.face_count(), shell.face_count()); - assert_eq!(coplanar_joins(body), 0); - assert!((body.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap().measure().volume - expected).abs() < 1e-6); - assert_eq!(crate::step_export(&[&stock], "unchanged stock").unwrap(), snapshot); - } - - #[test] - fn contiguous_analytic_walls_remove_faces_but_retain_vertical_stations() { - for curved in [false, true] { - let outer = if curved { - Region2 { outer: Loop2::circle(Vec2::ZERO, 10.), holes: vec![] } - } else { - rectangle(Vec2::new(-10., -10.), Vec2::new(10., 10.)) - }; - let mut upper = outer.clone(); - upper.holes.push(if curved { - Loop2::circle(Vec2::ZERO, 5.).reversed() - } else { - rectangle(Vec2::new(-5., -5.), Vec2::new(5., 5.)).outer.reversed() - }); - let slabs = vec![Section::untagged(&[outer]), Section::untagged(&[upper])]; - // Sections nothing is known of: no history, the construction alone is under test. - let operand = crate::extrude(&Plane::XY, &[rectangle(Vec2::new(-1., -1.), Vec2::new(1., 1.))], 0., 1.).unwrap().pop().unwrap(); - let index = LazyIndex::new(&operand, 0); - let history = lineage::Context::new(BoolOp::Cut, [&operand, &operand], [index.get(), index.get()], Plane::XY, 1e-7, None); - let old = sew_sections(&Plane::XY, Vec3::Z, &[0., 2., 20.], &slabs, 1e-7, false, &history).unwrap().unwrap(); - let merged = sew_sections(&Plane::XY, Vec3::Z, &[0., 2., 20.], &slabs, 1e-7, true, &history).unwrap().unwrap(); - let count = if curved { 2 } else { 4 }; - assert_eq!(old.face_count() - merged.face_count(), count); - let marked: Vec<_> = merged.solid.face_iter().enumerate().filter(|(i, _)| merged.face_was_coalesced(*i)).collect(); - assert_eq!(marked.len(), count); - for (_, face) in marked { - assert_eq!(face.boundaries()[0].len(), 6, "all axial station vertices are retained"); - let heights: Vec<_> = face.vertex_iter().map(|v| v.point().z).collect(); - for z in [0., 2., 20.] { - assert!(heights.contains(&z)); - } - } - assert!(old.face_sources().is_none_or(|s| s.iter().all(Option::is_none))); - let expected = if curved { std::f64::consts::PI * (100. * 20. - 25. * 18.) } else { 400. * 20. - 100. * 18. }; - let mesh = merged.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - assert!((mesh.measure().volume - expected).abs() < 0.03); - assert!(mesh.contains(Vec3::new(0., 0., 1.))); - assert!(!mesh.contains(Vec3::new(0., 0., 10.))); - assert!(merged.validity().is_empty()); - assert_ne!(wall_key(&slabs[0].regions[0].outer.segs[0]), wall_key(&slabs[0].regions[0].outer.segs[0].reversed())); - } - } - - #[test] - fn cut_run_coalescing_respects_authored_splits_and_face_paint() { - let region = Region2 { outer: Loop2::circle(Vec2::ZERO, 10.), holes: vec![] }; - let tool_region = Region2 { outer: Loop2::circle(Vec2::ZERO, 5.), holes: vec![] }; - let stock = crate::extrude(&Plane::XY, &[region], 0., 20.).unwrap().pop().unwrap(); - let cutter = crate::extrude(&Plane::XY, &[tool_region], 2., 22.).unwrap().pop().unwrap(); - let merged = stack_boolean(&stock, &cutter, BoolOp::Cut).unwrap().unwrap().unwrap(); - let protected = [ - stock.clone().with_split_lines(Some(std::sync::Arc::new(vec![vec![Vec3::new(10., 0., 0.), Vec3::new(10., 0., 20.)]]))), - stock.with_paint(Some(crate::Paint { opacity: 1., faces: vec![crate::FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }] })), - ]; - for input in protected { - let output = stack_boolean(&input, &cutter, BoolOp::Cut).unwrap().unwrap().unwrap(); - assert_eq!(output.face_count(), merged.face_count() + 2); - assert!((0..output.face_count()).all(|i| !output.face_was_coalesced(i))); - // Independent circular chord-volume bound: 2*pi*(10*20+5*18)*1e-5 < .019. - let expected = std::f64::consts::PI * (100. * 20. - 25. * 18.); - for body in [&output, &merged] { - let mesh = body.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - assert!((mesh.measure().volume - expected).abs() < 0.03); - assert!(mesh.contains(Vec3::new(0., 0., 1.))); - assert!(!mesh.contains(Vec3::new(0., 0., 10.))); - assert!(mesh.contains(Vec3::new(7., 0., 10.))); - } - } - } - - #[test] - fn annular_inward_tool_recovers_exact_stacks_before_cap_policy() { - let plane = Plane::XY; - let mut region = rectangle(Vec2::ZERO, Vec2::new(40.0, 30.0)); - region.holes.push(Loop2::circle(Vec2::new(20.0, 15.0), 5.0)); - let mut stock = crate::extrude(&plane, std::slice::from_ref(®ion), 0.0, 20.0).unwrap().pop().unwrap(); - for (lo, hi) in [(20.0, 30.0), (30.0, 35.0)] { - let positive = crate::extrude(&plane, std::slice::from_ref(®ion), lo, hi).unwrap().pop().unwrap(); - stock = crate::boolean(&stock, &positive, BoolOp::Union).unwrap().unwrap(); - } - let mut grown = rectangle(Vec2::new(-0.3, -0.3), Vec2::new(40.3, 30.3)); - grown.holes = region.holes; - let tool = crate::extrude(&plane, &[grown], 30.0, 35.6).unwrap().pop().unwrap(); - let tol = stock.size().max(tool.size()) * 1e-6; - let a = stack_of(&stock, Vec3::Z, &plane, tol).expect("annular stock qualifies"); - let b = stack_of(&tool, Vec3::Z, &plane, tol).expect("overrun tool qualifies"); - assert_eq!(a.len(), 1); - assert_eq!(b.len(), 1); - assert!((a[0].lo - 0.0).abs() < tol && (a[0].hi - 35.0).abs() < tol); - assert!((b[0].lo - 30.0).abs() < tol && (b[0].hi - 35.6).abs() < tol); - assert_eq!(a[0].section.regions[0].holes.len(), 1); - assert_eq!(b[0].section.regions[0].holes.len(), 1); - assert!((a[0].section.regions[0].area() - (1200.0 - 25.0 * std::f64::consts::PI)).abs() < 1e-8); - assert!(simple_prism_boolean(&stock, &tool, BoolOp::Cut).is_none()); - let result = stack_boolean(&stock, &tool, BoolOp::Cut).expect("qualified overlapping stacks").unwrap().unwrap(); - assert_eq!(result.shell_count(), 1); - assert!(result.validity().is_empty()); - let mesh = result.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - let expected = (1200.0 - 25.0 * std::f64::consts::PI) * 30.0; - // An inscribed circular mesh at radial chord error 1e-5 has volume - // deficit below 2*pi*R*height*error, conservatively 0.01 mm^3 here. - assert!((mesh.measure().volume - expected).abs() < 0.02); - for (point, present) in [ - (Vec3::new(5.0, 5.0, 29.0), true), - (Vec3::new(5.0, 5.0, 31.0), false), - (Vec3::new(20.0, 15.0, 29.0), false), - (Vec3::new(24.8, 15.0, 29.0), false), - (Vec3::new(25.2, 15.0, 29.0), true), - ] { - assert_eq!(mesh.contains(point), present, "{point:?}"); - } - } - #[test] - fn annular_partial_cut_overruns_and_interior_lumps_preserve_material() { - let area = 1200.0 - 25.0 * std::f64::consts::PI; - for seam in [0.0, 0.37] { - for plane in [Plane::XY, Plane::new(Vec3::new(30.0, 20.0, 10.0), Vec3::X, Vec3::Z).unwrap()] { - let mut region = rectangle(Vec2::ZERO, Vec2::new(40.0, 30.0)); - region.holes.push(Loop2::circle_from(Vec2::new(20.0, 15.0), 5.0, seam)); - let stock = crate::extrude(&plane, std::slice::from_ref(®ion), 0.0, 35.0).unwrap().pop().unwrap(); - let before = crate::step_export(&[&stock], "source").unwrap(); - for (lo, hi, retained, shells) in [(30.0, 35.6, 30.0, 1), (-0.6, 5.0, 30.0, 1), (10.0, 15.0, 30.0, 2), (30.0, 35.0, 30.0, 1)] { - let tool = crate::extrude(&plane, std::slice::from_ref(®ion), lo, hi).unwrap().pop().unwrap(); - let result = stack_boolean(&stock, &tool, BoolOp::Cut).expect("exact aligned cut path").unwrap().unwrap(); - assert_eq!(result.shell_count(), shells); - assert!(result.validity().is_empty()); - let mesh = result.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - assert!((mesh.measure().volume - retained * area).abs() < 0.02); - let at = |x: f64, y: f64, z: f64| plane.to_world(Vec2::new(x, y)) + plane.normal() * z; - for z in [2.5, 12.5, 32.5] { - let material = !(lo < z && z < hi); - assert_eq!(mesh.contains(at(5.0, 5.0, z)), material); - assert!(!mesh.contains(at(20.0, 15.0, z))); - assert_eq!(mesh.contains(at(25.2, 15.0, z)), material); - } - let public = crate::boolean(&stock, &tool, BoolOp::Cut).unwrap().unwrap(); - assert!((public.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap().measure().volume - retained * area).abs() < 0.02); - if lo == 30.0 && hi > 35.0 { - let imported = crate::step_import(&crate::step_export(&[&result], "inward annular cut").unwrap()).unwrap(); - assert!(imported.warnings.is_empty()); - let saved = &imported.bodies.first().unwrap().body; - assert!((saved.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap().measure().volume - 30.0 * area).abs() < 0.02); - let next = crate::extrude(&plane, std::slice::from_ref(®ion), 25.0, 31.0).unwrap().pop().unwrap(); - let shortened = crate::boolean(saved, &next, BoolOp::Cut).unwrap().unwrap(); - let next_volume = shortened.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap().measure().volume; - assert!( - (next_volume - 25.0 * area).abs() < 0.02, - "seam {seam}, plane {plane:?}, next cut volume {next_volume}, expected {}", - 25.0 * area - ); - assert!(shortened.contains(at(5.0, 5.0, 24.0))); - assert!(!shortened.contains(at(5.0, 5.0, 26.0))); - assert!(!shortened.contains(at(20.0, 15.0, 24.0))); - } - } - let clear = crate::extrude(&plane, std::slice::from_ref(®ion), 36.0, 40.0).unwrap().pop().unwrap(); - assert!(stack_boolean(&stock, &clear, BoolOp::Cut).is_none()); - let unchanged = crate::boolean(&stock, &clear, BoolOp::Cut).unwrap().unwrap(); - assert!(std::sync::Arc::ptr_eq(&stock.solid, &unchanged.solid), "disjoint Cut must retain exact source topology"); - let unchanged_mesh = unchanged.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - let source_mesh = stock.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - assert_eq!(unchanged_mesh.measure().volume, source_mesh.measure().volume); - // tessellate() floors tolerance at body.size()*1e-6. The arc - // polygon's area error is at most perimeter*radial chord error. - let bound = std::f64::consts::TAU * 5.0 * 35.0 * (stock.size() * 1e-6).max(1e-5) + 1e-5; - assert!((unchanged_mesh.measure().volume - 35.0 * area).abs() < bound); - assert!(!unchanged_mesh.contains(plane.to_world(Vec2::new(20.0, 15.0)) + plane.normal() * 12.5)); - let all = crate::extrude(&plane, std::slice::from_ref(®ion), -1.0, 36.0).unwrap().pop().unwrap(); - assert!(stack_boolean(&stock, &all, BoolOp::Cut).unwrap().unwrap().is_none()); - assert_eq!(crate::step_export(&[&stock], "source").unwrap(), before); - } - } - } - #[test] - fn annular_partial_cut_preserves_unequal_radii_and_conservative_refusals() { - let mut region = rectangle(Vec2::ZERO, Vec2::new(40.0, 30.0)); - region.holes.push(Loop2::circle(Vec2::new(20.0, 15.0), 5.0)); - let stock = crate::extrude(&Plane::XY, std::slice::from_ref(®ion), 0.0, 35.0).unwrap().pop().unwrap(); - let before = crate::step_export(&[&stock], "unchanged source").unwrap(); - let mut larger_hole = region.clone(); - larger_hole.holes = vec![Loop2::circle(Vec2::new(20.0, 15.0), 5.1)]; - let tool = crate::extrude(&Plane::XY, &[larger_hole], 30.0, 36.0).unwrap().pop().unwrap(); - let result = stack_boolean(&stock, &tool, BoolOp::Cut).unwrap().unwrap().unwrap(); - let expected = (1200.0 - 25.0 * std::f64::consts::PI) * 30.0 + std::f64::consts::PI * (5.1_f64.powi(2) - 25.0) * 5.0; - let mesh = result.mesh(&crate::MeshTolerance::chord(1e-5)).unwrap(); - assert!((mesh.measure().volume - expected).abs() < 0.02); - assert!(mesh.contains(Vec3::new(25.05, 15.0, 32.0))); - assert!(!mesh.contains(Vec3::new(25.2, 15.0, 32.0))); - assert!(!mesh.contains(Vec3::new(20.0, 15.0, 32.0))); - let interior = crate::extrude(&Plane::XY, std::slice::from_ref(®ion), 10.0, 15.0).unwrap().pop().unwrap(); - for d in [Vec3::X, Vec3::Y] { - let plane = Plane::from_normal(Vec3::ZERO, d).unwrap(); - let tol = stock.size() * 1e-6; - assert!(stack_of(&stock, d, &plane, tol).is_none(), "transverse cylinder axis must not fill the hole"); - assert!(stack_of(&interior, d, &plane, tol).is_none()); - } - assert!(stack_boolean(&stock, &interior, BoolOp::Union).is_none(), "Union retains its common-cap policy"); - let tapered = crate::extrude_tapered(&Plane::XY.offset(30.0), &rectangle(Vec2::ZERO, Vec2::new(40.0, 30.0)), 6.0, 1.0, 0.05).unwrap(); - assert!(stack_boolean(&stock, &tapered, BoolOp::Cut).is_none(), "slanted walls are not aligned prisms"); - let curved_cap = crate::sphere(Vec3::new(20.0, 15.0, 35.0), 5.0).unwrap(); - assert!(stack_boolean(&stock, &curved_cap, BoolOp::Cut).is_none()); - let pieces = - (0..350).map(|i| crate::box_solid(Vec3::new(i as f64 * 3.0, 0.0, 0.0), Vec3::new(i as f64 * 3.0 + 1.0, 1.0, 1.0)).unwrap()).collect(); - let over_budget = crate::ops::join_pieces(pieces).unwrap().unwrap(); - assert!(over_budget.face_count() > 2048); - assert!(stack_boolean(&over_budget, &interior, BoolOp::Cut).is_none()); - assert_eq!(crate::step_export(&[&stock], "unchanged source").unwrap(), before); - } - #[test] fn curved_prism_wall_requires_positive_separable_rational_weights() { let surface = |mixed: bool| { let weight = if mixed { 2.0 } else { 1.0 }; - let points = vec![ - vec![mt::Vector4::new(0.0, 0.0, 0.0, 1.0), mt::Vector4::new(0.0, 0.0, 10.0, 1.0)], - vec![mt::Vector4::new(5.0, 0.0, 0.0, 1.0), mt::Vector4::new(5.0 * weight, 0.0, 10.0 * weight, weight)], - ]; - mt::Surface::NurbsSurface(mt::NurbsSurface::new(mt::BSplineSurface::new( - (mt::KnotVec::bezier_knot(1), mt::KnotVec::bezier_knot(1)), - points, - ))) + Surface::RationalSpline { + u_knots: vec![0., 0., 1., 1.], + v_knots: vec![0., 0., 1., 1.], + homogeneous: vec![ + vec![[0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 10.0, 1.0]], + vec![[5.0, 0.0, 0.0, 1.0], [5.0 * weight, 0.0, 10.0 * weight, weight]], + ], + } }; assert!(wall_along(&surface(false), Vec3::Z, 1e-5, &mut 1000)); assert!(!wall_along(&surface(true), Vec3::Z, 1e-5, &mut 1000), "parallel Euclidean controls alone do not certify a rational sweep"); @@ -3015,86 +1349,6 @@ mod planar_tests { assert!(!wall_along(&surface(false), Vec3::Z, 1e-5, &mut 0)); } #[test] - fn partial_depth_cuts_touching_a_through_hole_use_exact_stacked_sections() { - let plane = Plane::named("XY").unwrap(); - let mut plate = rectangle(Vec2::ZERO, Vec2::new(100., 60.)); - plate.holes.push(rectangle(Vec2::new(25., 20.), Vec2::new(30., 30.)).outer); - let stock = crate::extrude(&plane, &[plate], 0., 2.5).unwrap().pop().unwrap(); - let low = crate::extrude(&plane, &[rectangle(Vec2::new(20., 20.), Vec2::new(30., 30.))], 0., 1.5).unwrap().pop().unwrap(); - let high = crate::extrude(&plane, &[rectangle(Vec2::new(25., 20.), Vec2::new(35., 30.))], 1., 2.5).unwrap().pop().unwrap(); - for tools in [[&low, &high], [&high, &low]] { - let mut result = stock.clone(); - for tool in tools { - let target = result; - result = stack_boolean(&target, tool, BoolOp::Cut).expect("exact stack path").unwrap().unwrap(); - // The second cut's target has walls in pieces across its slabs, followed level by - // level: its history is exact. - let exact = crate::boolean_record::tests::Reach { made: 0., moved: 0. }; - crate::boolean_record::tests::checked(&result, &[&target, tool], 1e-3, exact, &|_| false); - } - assert!(result.validity().is_empty()); - assert_eq!(result.shell_count(), 1); - assert!((crate::measure(&result).unwrap().volume - 14_725.).abs() < 1e-6); - let mesh = result.mesh(&crate::MeshTolerance::chord(1e-4)).unwrap(); - for (point, material) in [ - (Vec3::new(22.5, 25., 0.5), false), - (Vec3::new(22.5, 25., 2.), true), - (Vec3::new(32.5, 25., 0.5), true), - (Vec3::new(32.5, 25., 2.), false), - (Vec3::new(27.5, 25., 1.25), false), - (Vec3::new(10., 10., 1.25), true), - ] { - assert_eq!(mesh.contains(point), material, "{point:?}"); - } - let imported = crate::step_import(&crate::step_export(&[&result], "layered cut").unwrap()).unwrap(); - assert!(imported.warnings.is_empty()); - assert!((crate::measure(&imported.bodies.first().unwrap().body).unwrap().volume - 14_725.).abs() < 1e-6); - let next = crate::extrude(&plane, &[rectangle(Vec2::new(20., 20.), Vec2::new(25., 30.))], 1.5, 2.5).unwrap().pop().unwrap(); - let opened = crate::boolean(&imported.bodies.first().unwrap().body, &next, BoolOp::Cut).unwrap().unwrap(); - assert!((crate::measure(&opened).unwrap().volume - 14_675.).abs() < 1e-6); - assert!(opened.validity().is_empty()); - } - } - #[test] - fn far_edges_of_a_stepped_slab_come_from_the_operand_topology() { - // A block with a notch in its back, read along -y: the slab from the notch floor to the - // front has three segments beside the top face, read off the back and the notch floor. - // The top face ends at the front in one edge: the far edge of all three, found with no - // position compared (no pair budget). - let notched = Loop2::polygon(&[ - Vec2::new(0., 0.), - Vec2::new(40., 0.), - Vec2::new(40., 30.), - Vec2::new(25., 30.), - Vec2::new(25., 25.), - Vec2::new(15., 25.), - Vec2::new(15., 30.), - Vec2::new(0., 30.), - ]); - let block = crate::extrude(&Plane::named("XY").unwrap(), &[Region2 { outer: notched, holes: vec![] }], 0., 20.).unwrap().pop().unwrap(); - let (d, tol) = (-Vec3::Y, 1e-6); - let plane = Plane::from_normal(Vec3::ZERO, d).unwrap(); - let normal = |f: &mt::Face| crate::blend::plane_normal(f).unwrap_or(Vec3::ZERO); - let faces: Vec<(usize, &mt::Face)> = block.solid.face_iter().enumerate().collect(); - let find = |n: Vec3| faces.iter().find(|(_, f)| normal(f).dot(n) > 1. - 1e-9).map(|(i, _)| *i).unwrap(); - let (top, front) = (find(Vec3::Z), find(-Vec3::Y)); - let walls = faces.iter().filter(|(_, f)| normal(f).dot(d).abs() < 1e-9).map(|(i, f)| (*i, top_of(f, &plane))).collect(); - let index = Index::new(&block, 0); - let stations = Stations::new(&index, walls, d, &plane, tol); - let cap = Section::from_loops(index.loops(faces[front].1, front, &plane, tol, &mut 1000, &mut 1000).unwrap()).unwrap().oriented(); - let edge = match index.between.get(&(top.min(front), top.max(front))).map(Vec::as_slice) { - Some([e]) => *e, - other => panic!("one edge between the top and the front: {other:?}"), - }; - let mut slab = stack_of(&block, d, &plane, tol).unwrap().pop().unwrap(); - assert!((slab.lo + 25.).abs() < tol && slab.hi.abs() < tol); - let beside_top = |s: &Section| s.segments().1.into_iter().filter(|t| t.wall == Some(top)).map(|t| t.far).collect::>(); - assert_eq!(beside_top(&slab.section), vec![Some(edge); 3], "read as a stack"); - slab.section.retag(|t| Tag { far: None, ..t }); - slab.section.mark_far(&[&cap], |w| stations.top_edge(&index, w, &[front], 0., tol), tol, &mut 0); - assert_eq!(beside_top(&slab.section), vec![Some(edge); 3], "by topology alone"); - } - #[test] fn compound_planar_extrusion_normalizes_overlap_and_retains_islands() { let plane = Plane::named("XY").unwrap(); let a = rectangle(Vec2::ZERO, Vec2::new(10.0, 10.0)); @@ -3108,7 +1362,7 @@ mod planar_tests { let body = extrude_planar_regions(&plane, &[annulus, inner], 0.0, 2.0).unwrap(); let expected = (100.0 - std::f64::consts::PI * 5.0) * 2.0; assert!((crate::measure(&body).unwrap().volume - expected).abs() < 0.1); - assert_eq!(body.solid.boundaries().len(), 2); + assert_eq!(body.shell_count(), 2); let a = rectangle(Vec2::ZERO, Vec2::new(10.0, 10.0)); let b = rectangle(Vec2::new(10.0, 10.0), Vec2::new(20.0, 20.0)); assert!(extrude_planar_regions(&plane, &[a, b], 0.0, 2.0).is_err()); diff --git a/crates/kernel/src/prism_lineage.rs b/crates/kernel/src/prism_lineage.rs deleted file mode 100644 index 0fb977595..000000000 --- a/crates/kernel/src/prism_lineage.rs +++ /dev/null @@ -1,538 +0,0 @@ -//! The history of a prism boolean's result (see [`super::prism_boolean`]), from what its faces -//! were built over: each wall over a section segment whose [`Tag`] says which operand wall it -//! was read beside, each cap over a section region lying on operand caps at its level. Edges -//! follow from the same tags: a wall's edge with a cap is the operand's edge between them (or -//! the meeting of the wall with the other operand's cap); an edge between walls at a section -//! vertex is the operand's edge there (or the meeting of two operands' walls). - -use std::collections::{BTreeSet, HashMap}; - -use solidcraft_geom::{Plane, Region2, Vec2, Vec3}; -use truck_modeling as mt; - -use super::{Index, Section, Tag, dist_to, inside}; -use crate::BoolOp; -use crate::body::{Body, edge_order, from_p3}; -use crate::history::{EdgeOrigin, FaceOrigin, FaceOrigin::Face, FaceProv, Side}; - -/// A cap of an operand: a planar face square to the prism direction. -struct Cap { - origin: FaceOrigin, - /// Its level and whether it faces along the direction. - z: f64, - up: bool, - outline: Outline, -} - -/// A section's regions with the walls its outline was read beside and its segments' middles, -/// to tell whether two sections overlap. -struct Outline { - regions: Vec, - walls: BTreeSet<(usize, usize)>, - middles: Vec, -} - -impl Outline { - fn of(s: &Section) -> Outline { - let (segs, tags) = s.segments(); - Outline { - regions: s.regions.clone(), - walls: tags.iter().filter_map(|t| Some((t.operand, t.wall?))).collect(), - middles: segs.iter().map(|g| g.point_at(0.5)).collect(), - } - } -} - -/// What a prism boolean's result is built from: the operands (target, tool), the direction and -/// the plane square to it that sections are drawn in, and for simple prisms each operand's -/// extent along the direction. -pub(super) struct Context<'a> { - pub op: BoolOp, - pub operands: [&'a Body; 2], - pub index: [&'a Index; 2], - pub plane: Plane, - pub tol: f64, - pub heights: Option<[(f64, f64); 2]>, - /// Both operands' caps, read once (see [`Context::caps`]). - caps: std::cell::OnceCell>>, -} - -/// How one piece of the result was built. -pub(super) enum Built { - /// One body of `crate::extrude` of a section's one region through `layers`: successive - /// slabs (the section as read in each, between its two levels), bottom first, all of one - /// outline. Several where operands stacked end to end share an outline (one wall then lies - /// over each operand's wall in turn, and is made from all of them). - Extruded { layers: Vec<(Section, f64, f64)> }, - /// Sewn (`sew_connected_sections`) from these faces, the sewing saying which each face of - /// the piece was built from (`None`: it could not). - Sewn { specs: Vec, faces: Option> }, - /// Built some other way, carrying its own history over the operands (none: not known). - Traced, -} - -/// A face sewn into a stepped prism. -pub(super) enum Spec { - /// A wall over one section segment through successive slabs, between successive `levels` - /// (one more than `slabs`): what it is over in each slab. - Wall { levels: Vec, slabs: Vec }, - /// A cap over `section` at level `z`, facing along the direction when `up`. - Cap { section: Section, z: f64, up: bool }, -} - -/// A wall in one slab: over a segment tagged `tag`; `next` is the wall over the next segment -/// of its loop in that slab, which it meets at `at`. -pub(super) struct Slab { - pub tag: Tag, - pub next: usize, - pub at: Vec2, -} - -impl Spec { - /// The wall's slab between levels `lo` and `hi` (`hi` above `lo`). - fn slab(&self, lo: f64, hi: f64) -> Option<&Slab> { - let Spec::Wall { levels, slabs } = self else { return None }; - let mid = (lo + hi) / 2.0; - slabs.iter().zip(levels.windows(2)).find(|(_, z)| z[0] < mid && mid < z[1]).map(|(s, _)| s) - } - - /// The wall's slab at its bottom level, when that is `z`. - fn bottom(&self, z: f64, tol: f64) -> Option<&Slab> { - let Spec::Wall { levels, slabs } = self else { return None }; - ((levels.first()? - z).abs() <= tol).then_some(slabs.first()?) - } - - /// The wall's slab at its top level, when that is `z`. - fn top(&self, z: f64, tol: f64) -> Option<&Slab> { - let Spec::Wall { levels, slabs } = self else { return None }; - ((levels.last()? - z).abs() <= tol).then_some(slabs.last()?) - } - - /// The wall's slab at its bottom or top level `z`. - fn end(&self, z: f64, tol: f64) -> Option<&Slab> { - self.bottom(z, tol).or_else(|| self.top(z, tol)) - } -} - -/// A face of an extruded piece: a wall or a cap. -#[derive(Clone, Copy)] -enum Kind { - /// The wall over this segment of the section. - Wall(usize), - Cap(usize), -} - -impl<'a> Context<'a> { - pub(super) fn new(op: BoolOp, operands: [&'a Body; 2], index: [&'a Index; 2], plane: Plane, tol: f64, heights: Option<[(f64, f64); 2]>) -> Self { - Context { op, operands, index, plane, tol, heights, caps: std::cell::OnceCell::new() } - } - - /// `body`, made of `pieces` (their shells in order), with its history over the operands - /// (none where it is not known). - pub(super) fn attach>(&self, body: Body, pieces: &[(B, Built)]) -> Body { - let pieces: Vec<(&Body, &Built)> = pieces.iter().map(|(b, k)| (b.borrow(), k)).collect(); - let (faces, edges) = self.history(&pieces).unzip(); - crate::record::traced(body, &crate::record::counts(&self.operands), faces, edges.as_ref()) - } - - /// The faces (each a region of operand faces, and whether it is one untouched) and the edges - /// (by identity) of the pieces, in order; `None` where something is not known. - pub(super) fn history(&self, pieces: &[(&Body, &Built)]) -> Option<(Vec, HashMap>)> { - let caps = self.caps.get_or_init(|| self.caps()).as_deref()?; - let mut faces = Vec::new(); - let mut edges = HashMap::new(); - for (body, built) in pieces { - let (f, e) = match built { - Built::Extruded { layers } => self.extruded(caps, body, layers)?, - Built::Sewn { specs, faces } => self.sewn(caps, body, specs, faces.as_deref()?)?, - Built::Traced => { - let h = body.history()?; - faces.extend(h.faces.iter().cloned()); - edges.extend(crate::record::edges_by_identity(body, h)); - continue; - } - }; - faces.extend(f.into_iter().map(|(origins, whole)| crate::record::region(origins, whole))); - edges.extend(e); - } - // Pieces of one body can share an origin. - crate::record::mark_shared_split(&mut faces); - Some((faces, edges)) - } - - /// Both operands' caps, their outlines tagged. - fn caps(&self) -> Option> { - let d = self.plane.normal(); - let mut caps = Vec::new(); - let (mut work, mut segments) = (2_000_000usize, super::MAX_PLANAR_SEGMENTS * 2); - for (operand, (body, index)) in self.operands.iter().zip(self.index).enumerate() { - for (face, f) in body.solid.face_iter().enumerate() { - let mt::Surface::Plane(p) = f.oriented_surface() else { continue }; - let n = p.normal(); - let n = Vec3::new(n.x, n.y, n.z).normalized()?; - if n.dot(d).abs() < 1.0 - 1e-9 { - continue; - } - let section = Section::from_loops(index.loops(f, face, &self.plane, self.tol, &mut work, &mut segments)?)?; - let (z, up) = (self.plane.height(from_p3(p.origin())), n.dot(d) > 0.0); - caps.push(Cap { origin: Face { operand, face }, z, up, outline: Outline::of(§ion.oriented()) }); - } - } - Some(caps) - } - - /// The operand caps under a result cap over `section` at level `z` (facing along the - /// direction when `up`): the target's caps there facing the same way, and the tool's facing - /// the same way (a union or intersection) or the other way (a cut, whose tool's caps bound - /// what it leaves), wherever they overlap the section. - fn cap_origins(&self, caps: &[Cap], section: &Section, z: f64, up: bool) -> BTreeSet { - let outline = Outline::of(section); - caps.iter() - .filter(|c| { - let facing = match c.origin { - Face { operand: 1, .. } if self.op == BoolOp::Cut => c.up != up, - _ => c.up == up, - }; - facing && (c.z - z).abs() < self.tol && self.overlap(&outline, &c.outline) - }) - .map(|c| c.origin) - .collect() - } - - /// Do two sections (at one level) overlap? Where their outlines share a wall, or a point of - /// one's outline, clear of the other's, lies inside it. - fn overlap(&self, x: &Outline, y: &Outline) -> bool { - let within = |x: &Outline, y: &Outline| x.middles.iter().any(|m| dist_to(&y.regions, *m) > self.tol && inside(&y.regions, *m)); - !x.walls.is_disjoint(&y.walls) || within(x, y) || within(y, x) - } - - /// The operand wall a segment was read beside. - fn wall(t: Tag) -> Option { - Some(Face { operand: t.operand, face: t.wall? }) - } - - /// The operand's edges (by number) bounding exactly the faces `faces`. - fn edges_between(&self, operand: usize, [f, g]: [usize; 2]) -> &[usize] { - self.index.get(operand).and_then(|index| index.between.get(&(f.min(g), f.max(g)))).map_or(&[], Vec::as_slice) - } - - /// Is the wall over a segment tagged `t` between `lo` and `hi` its operand wall untouched? - /// The whole cap edge it was read off, the operand's whole height (simple prisms), and a - /// wall with no other cap edges than its two. - fn whole(&self, caps: &[Cap], t: Tag, lo: f64, hi: f64) -> bool { - let (Some(heights), Some(wall), Some(_), Some(_)) = (self.heights, t.wall, t.start, t.end) else { return false }; - let Some((l, h)) = heights.get(t.operand) else { return false }; - let Some(index) = self.index.get(t.operand) else { return false }; - let cap_edges: usize = caps - .iter() - .filter_map(|c| match c.origin { - Face { operand, face } if operand == t.operand => index.between.get(&(face.min(wall), face.max(wall))).map(Vec::len), - _ => None, - }) - .sum(); - (lo - l).abs() < self.tol && (hi - h).abs() < self.tol && cap_edges == 2 - } - - /// The origins of the edge between the wall over a segment tagged `t` and a cap lying on the - /// operand faces `cap`: the operand's edge between the wall and its own cap there (the very - /// edge the segment was read off, or the one it runs along where its slab ends: the one - /// running through `at`, a point of the edge, where the wall meets its caps along several), - /// else where the wall meets the cap (all of the faces it lies on). - fn cap_edge(&self, t: Tag, cap: &BTreeSet, at: Vec3) -> Option> { - let (x, w) = (t.operand, t.wall?); - let own: Vec = - cap.iter().filter_map(|o| if let Face { operand, face } = *o { (operand == x).then_some(face) } else { None }).collect(); - let index = self.index.get(x)?; - let beside = |e: &usize| index.bounds.get(*e).is_some_and(|(fs, _, _)| fs.contains(&w) && fs.iter().any(|f| own.contains(f))); - if let Some(e) = [t.edge, t.far].into_iter().flatten().find(beside) { - return Some(vec![EdgeOrigin::Edge { operand: x, edge: e }]); - } - let along: Vec = own.iter().flat_map(|c| self.edges_between(x, [w, *c])).copied().collect(); - match along.as_slice() { - [e] => Some(vec![EdgeOrigin::Edge { operand: x, edge: *e }]), - [] => Some(vec![EdgeOrigin::meet(Self::wall(t)?, Side::new(cap.iter().copied())?)]), - // One wall with openings meets its caps along several edges (a side wall with ports - // cut through it meets the ports' floors at each port): the one this edge lies on, - // else (a new opening beside them) where the wall meets the cap. - many => match self.edge_through(x, many, at)? { - Some(edge) => Some(vec![EdgeOrigin::Edge { operand: x, edge }]), - None => Some(vec![EdgeOrigin::meet(Self::wall(t)?, Side::new(cap.iter().copied())?)]), - }, - } - } - - /// Of the operand's edges `edges`, the one the point `at` lies on (`Some(None)` when none - /// does; `None` when several do). - fn edge_through(&self, operand: usize, edges: &[usize], at: Vec3) -> Option> { - if edges.len() > 4096 { - return None; - } - let body = self.operands.get(operand)?; - let order = crate::body::edge_order(body.solid.face_iter()).0; - let mut on = edges.iter().filter(|e| { - order.get(**e).is_some_and(|edge| { - use mt::{BoundedCurve, ParametricCurve}; - let c = edge.curve(); - let (t0, t1) = c.range_tuple(); - // The edge as a fine polyline: a line exactly, an arc within its chords' sag. - let n = if matches!(c, mt::Curve::Line(_)) { 1 } else { 64 }; - let pts: Vec = (0..=n).map(|k| from_p3(c.subs(t0 + (t1 - t0) * k as f64 / n as f64))).collect(); - let length: f64 = pts.windows(2).map(|w| w[0].dist(w[1])).sum(); - let near = self.tol * 10.0 + if n == 1 { 0.0 } else { length * 2e-3 }; - pts.windows(2).any(|w| at.dist_to_segment(w[0], w[1]) <= near) - }) - }); - match (on.next(), on.next()) { - (Some(e), None) => Some(Some(*e)), - (None, _) => Some(None), - _ => None, - } - } - - /// The origins of the edge between the walls over two segments where the first (tagged - /// `t1`) runs into the second (`t2`), between levels `lo` and `hi`: the operand's edge there - /// between its walls (along the line through the operand vertex the segments meet at, else - /// the one edge between them), where two operands' walls meet, or none within one wall (a - /// segment split there). - fn junction(&self, t1: Tag, t2: Tag, lo: f64, hi: f64) -> Option> { - let (p, q) = (Self::wall(t1)?, Self::wall(t2)?); - if t1.operand != t2.operand { - return Some(vec![EdgeOrigin::meet(p, q)]); - } - let (x, w1, w2) = (t1.operand, t1.wall?, t2.wall?); - match (t1.end, t2.start) { - // At that vertex: the operand's edge there (a seam, within one wall), else two edges - // of one wall's cap outline running on through it. - (Some(v), Some(u)) if v == u => self.edge_over(x, [w1, w2], Some(v), lo, hi).or_else(|| (w1 == w2).then(Vec::new)), - _ if w1 == w2 => Some(Vec::new()), - // Elsewhere (a segment split off there, or read off another cap): only the operand's - // walls are around the edge, so the operand has its edge between them there, and - // that is the one edge between them over these levels where there is one. - _ => self.edge_over(x, [w1, w2], None, lo, hi), - } - } - - /// The operand's edge between the walls `faces` that runs over the levels `lo` to `hi`, - /// when it has exactly one; with `at`, among the edges between them chained to that vertex. - /// The segments' vertex was read at one level and carried through others, and the line - /// between two walls is in several edges where vertices an earlier operation left (stations) - /// split it: the levels say which of them a slab's edge runs along. - fn edge_over(&self, operand: usize, faces: [usize; 2], at: Option, lo: f64, hi: f64) -> Option> { - let index = self.index.get(operand)?; - let between = self.edges_between(operand, faces); - if between.len() > 4096 { - return None; - } - let ends: Vec<(Option, Option)> = - between.iter().map(|e| index.bounds.get(*e).map_or((None, None), |(_, front, back)| (*front, *back))).collect(); - // With `at`: the edges reached from it through shared vertices. - let mut chained = vec![at.is_none(); between.len()]; - let mut reached: Vec = at.into_iter().collect(); - while let Some(p) = reached.pop() { - for (k, (front, back)) in ends.iter().enumerate() { - if !chained[k] && (*front == Some(p) || *back == Some(p)) { - chained[k] = true; - reached.extend(if *front == Some(p) { *back } else { *front }); - } - } - } - let height = |v: Option| v.and_then(|v| index.points.get(v)).map(|p| self.plane.height(*p)); - let mut over = between.iter().zip(&ends).zip(chained).filter_map(|((e, (front, back)), chained)| { - let (a, b) = (height(*front)?, height(*back)?); - (chained && a.min(b) <= lo + self.tol && a.max(b) >= hi - self.tol).then_some(*e) - }); - match (over.next(), over.next()) { - (Some(edge), None) => Some(vec![EdgeOrigin::Edge { operand, edge }]), - _ => None, - } - } - - /// The origins of the edge between walls over one segment stacked at a level (tagged `t1` - /// below, `t2` above): within one wall (none), along the operand's edge between two of its - /// walls, or where two operands' walls meet. - fn stacked(&self, t1: Tag, t2: Tag) -> Option> { - let (p, q) = (Self::wall(t1)?, Self::wall(t2)?); - if p == q { - return Some(Vec::new()); - } - if t1.operand != t2.operand { - return Some(vec![EdgeOrigin::meet(p, q)]); - } - // An edge across the direction at a level: the levels cannot tell edges apart here. - self.one_edge(t1.operand, [t1.wall?, t2.wall?]) - } - - /// The operand's edge between the faces `faces`, when it has exactly one. - fn one_edge(&self, operand: usize, faces: [usize; 2]) -> Option> { - match self.edges_between(operand, faces) { - [edge] => Some(vec![EdgeOrigin::Edge { operand, edge: *edge }]), - _ => None, - } - } - - /// Faces and edges of a piece `crate::extrude` built from a section of one region through - /// `layers` (see [`Built::Extruded`]). Its history says which faces are walls over which - /// segment (numbered over the region's loops in order) and which are its caps; the start - /// cap's wires run over the segments in loop order (as the extrude builds them), so the - /// vertex after each wire edge is where one segment runs into the next, or splits. A wall - /// through several layers is made from the wall each layer's segment was read beside, and - /// an edge between two walls from the operand edges there in each layer. - #[allow(clippy::type_complexity)] - fn extruded( - &self, - caps: &[Cap], - body: &Body, - layers: &[(Section, f64, f64)], - ) -> Option<(Vec<(BTreeSet, bool)>, HashMap>)> { - let h = body.history()?; - let ((first, lo, _), (last, _, hi)) = (layers.first()?, layers.last()?); - let (lo, hi) = (*lo, *hi); - let tags: Vec> = layers.iter().map(|(section, ..)| section.segments().1).collect(); - let count = tags.first()?.len(); - if tags.iter().any(|t| t.len() != count) { - return None; - } - let tag = |layer: usize, segment: usize| tags.get(layer).and_then(|t| t.get(segment)).copied(); - let tops = [self.cap_origins(caps, first, lo, false), self.cap_origins(caps, last, hi, true)]; - let kinds: Vec = h - .faces - .iter() - .map(|f| match f.origins.as_slice() { - [FaceOrigin::Profile { segment }] => (*segment < count).then_some(Kind::Wall(*segment)), - [FaceOrigin::Cap { end }] => Some(Kind::Cap(usize::from(*end))), - _ => None, - }) - .collect::>()?; - let faces = kinds - .iter() - .map(|k| match *k { - Kind::Wall(segment) => { - let walls = (0..layers.len()).map(|layer| Self::wall(tag(layer, segment)?)).collect::>>()?; - let whole = match layers { - [(_, lo, hi)] => self.whole(caps, tag(0, segment)?, *lo, *hi), - _ => false, - }; - Some((walls, whole)) - } - Kind::Cap(end) => Some(tops.get(end).filter(|o| !o.is_empty())?.clone()).map(|o| (o, false)), - }) - .collect::>>()?; - let (edges, bounds) = edge_order(body.solid.face_iter()); - let position: HashMap = edges.iter().enumerate().map(|(i, e)| (e.id(), i)).collect(); - // The segment of the wall beside an edge of the start cap. - let segment_of = |e: &mt::Edge| -> Option { - bounds.get(*position.get(&e.id())?)?.iter().find_map(|f| match h.faces.get(*f)?.origins.as_slice() { - [FaceOrigin::Profile { segment }] => Some(*segment), - _ => None, - }) - }; - let start = kinds.iter().position(|k| matches!(k, Kind::Cap(0)))?; - // At each vertex of the start cap: the segment running into it, the one running out, - // and whether that is one segment the extrude split there. - let mut junctions: HashMap = HashMap::new(); - for w in body.solid.face_iter().nth(start)?.absolute_boundaries() { - let es: Vec = w.edge_iter().cloned().collect(); - let segs: Vec = es.iter().map(segment_of).collect::>()?; - if segs.windows(2).any(|p| p.first() > p.get(1)) { - return None; - } - for (k, e) in es.iter().enumerate() { - let (s, next) = (*segs.get(k)?, *segs.get((k + 1) % segs.len())?); - junctions.insert(e.back().id(), (s, next, s == next && k + 1 != segs.len())); - } - } - let mut origins = HashMap::new(); - for (e, fs) in edges.iter().zip(&bounds) { - let [f, g] = fs.as_slice() else { return None }; - let o = match (kinds.get(*f)?, kinds.get(*g)?) { - (Kind::Wall(segment), Kind::Cap(end)) | (Kind::Cap(end), Kind::Wall(segment)) => { - let layer = if *end == 0 { 0 } else { layers.len() - 1 }; - self.cap_edge(tag(layer, *segment)?, tops.get(*end)?, crate::heal::edge_points(e).get(2).copied()?)? - } - (Kind::Wall(..), Kind::Wall(..)) => { - let (s, next, split) = *[e.absolute_front().id(), e.absolute_back().id()].iter().find_map(|v| junctions.get(v))?; - let mut o = BTreeSet::new(); - for (layer, (_, lo, hi)) in layers.iter().enumerate() { - let (t, u) = (tag(layer, s)?, tag(layer, next)?); - // A segment the extrude split in two runs on through the vertex between. - let (t, u) = if split { (Tag { end: None, ..t }, Tag { start: None, ..t }) } else { (t, u) }; - o.extend(self.junction(t, u, *lo, *hi)?); - } - o.into_iter().collect() - } - _ => return None, - }; - origins.insert(e.id(), o); - } - Some((faces, origins)) - } - - /// Faces and edges of a piece sewn from `specs`: the sewing reports which spec each face was - /// built from. Walls meeting at a vertex of their loop (when two walls meet at both ends, - /// the edge's vertex says which); walls over one segment meeting at a level; walls meeting - /// caps. - #[allow(clippy::type_complexity)] - fn sewn( - &self, - caps: &[Cap], - body: &Body, - specs: &[Spec], - built: &[usize], - ) -> Option<(Vec<(BTreeSet, bool)>, HashMap>)> { - let cap_of: Vec>> = specs - .iter() - .map(|s| match s { - Spec::Cap { section, z, up } => Some(self.cap_origins(caps, section, *z, *up)).filter(|o| !o.is_empty()), - Spec::Wall { .. } => None, - }) - .collect(); - let faces = built - .iter() - .map(|i| match specs.get(*i)? { - Spec::Wall { slabs, .. } => Some((slabs.iter().map(|s| Self::wall(s.tag)).collect::>()?, false)), - Spec::Cap { .. } => cap_of.get(*i)?.clone().map(|o| (o, false)), - }) - .collect::>>()?; - let (edges, bounds) = edge_order(body.solid.face_iter()); - let mut origins = HashMap::new(); - for (e, fs) in edges.iter().zip(&bounds) { - let [f, g] = fs.as_slice() else { return None }; - let (i, j) = (*built.get(*f)?, *built.get(*g)?); - let (x, y) = (specs.get(i)?, specs.get(j)?); - // The edge's levels, lower first, and where it stands in plan. - let (front, back) = (from_p3(e.absolute_front().point()), from_p3(e.absolute_back().point())); - let (h1, h2) = (self.plane.height(front), self.plane.height(back)); - let (lo, hi) = (h1.min(h2), h1.max(h2)); - let middle = || crate::heal::edge_points(e).get(2).copied(); - let o = match (x, y) { - (Spec::Wall { .. }, Spec::Cap { .. }) => self.cap_edge(x.end(lo, self.tol)?.tag, cap_of.get(j)?.as_ref()?, middle()?)?, - (Spec::Cap { .. }, Spec::Wall { .. }) => self.cap_edge(y.end(lo, self.tol)?.tag, cap_of.get(i)?.as_ref()?, middle()?)?, - (Spec::Wall { .. }, Spec::Wall { .. }) if hi - lo <= self.tol => { - // One over the other at a level: the lower first. - let (below, above) = match (x.top(lo, self.tol), y.bottom(lo, self.tol)) { - (Some(s), Some(t)) => (s, t), - _ => (y.top(lo, self.tol)?, x.bottom(lo, self.tol)?), - }; - self.stacked(below.tag, above.tag)? - } - (Spec::Wall { .. }, Spec::Wall { .. }) => { - // Side by side within a slab: the vertex the edge stands on (in plan) says - // which way round they meet. - let (s, t) = (x.slab(lo, hi)?, y.slab(lo, hi)?); - let p = self.plane.to_local(front); - let at = |q: &Vec2| p.dist(*q) < self.tol * 10.0; - if s.next == j && at(&s.at) { - self.junction(s.tag, t.tag, lo, hi)? - } else if t.next == i && at(&t.at) { - self.junction(t.tag, s.tag, lo, hi)? - } else { - return None; - } - } - _ => return None, - }; - origins.insert(e.id(), o); - } - Some((faces, origins)) - } -} diff --git a/crates/kernel/src/prism_local.rs b/crates/kernel/src/prism_local.rs deleted file mode 100644 index e2bbbcfc2..000000000 --- a/crates/kernel/src/prism_local.rs +++ /dev/null @@ -1,353 +0,0 @@ -//! Booleans of a prism tool with a target that is a prism along the tool's direction only round -//! the tool: a pocket made deeper in a plate whose rim is chamfered, a ring cut round a -//! counterbored hole in a chamfered disc. The tool's walls lie on the target's there, which the -//! B-rep boolean can't intersect, and the 2D route ([`crate::prism::prism_boolean`]) declines the -//! target for a face far away (the chamfer) that is neither a wall along the direction nor a cap -//! square to it. -//! -//! The target is split by planes into a column round the tool that holds none of those faces; -//! the column takes the exact 2D boolean, and the pieces are glued back along the cut faces, as -//! [`crate::polybool::sliced_planar_boolean`] does for an all-planar tool beside curved faces. -//! The cuts are imprints (no boolean), each placed beside the tool on one of three axes: the -//! tool's direction and two square to it. A cut that leaves every offending face of the middle -//! piece beyond it goes first; otherwise one close beside the tool, which splits them (a -//! chamfer all round a disc is split into two pieces apart, which the next cut leaves out). - -use solidcraft_geom::{Plane, Vec3}; -use truck_modeling as mt; - -use crate::body::Body; -use crate::boolean_record::{self as recorded, Traced}; -use crate::{BoolOp, KernelError, Result}; - -/// Cuts at most, each splitting the middle piece once. -const MAX_CUTS: usize = 6; - -/// Cuts made with half boxes at most (two booleans each, with their retries): an imprint traced -/// wrong across a curved face is rare, and the booleans cost seconds on curved parts. -const MAX_BOX_CUTS: usize = 2; - -/// Operands a piece's history is over: `a`, `b`, then the two half boxes each cut may be made -/// with (dropped from the result, whose faces are none of theirs). -const OPERANDS: usize = 2 + 2 * MAX_CUTS; - -thread_local! { - /// Set while [`local_prism_boolean`] runs: the booleans it makes a cut with (a piece and a - /// half box) take the general path, not this one again. - static RUNNING: std::cell::Cell = const { std::cell::Cell::new(false) }; -} - -/// An extent along each of three axes. -type Extent = [(f64, f64); 3]; - -/// [`crate::prism::prism_boolean`] of `a` and the prism `b`, taken in a column of `a` round `b` -/// (see the module notes). `None` when `b` is not a prism, `a` is one along `b`'s direction -/// already, or no column round `b` is clear of `a`'s other faces: the caller goes on as before. -pub(crate) fn local_prism_boolean(a: &Body, b: &Body, op: BoolOp) -> Option>> { - // A cut or an intersection: what a tool meeting the target's walls fails on. A union (a - // shell's cavity joined with its opening) is left to the general path. - if !matches!(op, BoolOp::Cut | BoolOp::Intersect) || a.face_count() > 4096 || RUNNING.with(std::cell::Cell::get) { - return None; - } - /// Clears the flag however the boolean ends, a caught panic included. - struct Reset; - impl Drop for Reset { - fn drop(&mut self) { - RUNNING.with(|r| r.set(false)); - } - } - RUNNING.with(|r| r.set(true)); - let _reset = Reset; - let d = crate::prism::prism_axis(b)?; - let size = a.size().max(b.size()); - let tol = (size * 1e-7).max(1e-9) * 10.0; - let frame = Plane::from_normal(Vec3::ZERO, d)?; - let axes = [frame.x, frame.y, d]; - // Extents come from meshes this close to the faces, widened by as much. - let mesh_tol = (size * 1e-3).max(1e-4); - let tool = widened(extent(&b.mesh(&crate::MeshTolerance::chord(mesh_tol)).ok()?.positions, axes)?, mesh_tol); - let gap = size * 1e-4 + 1e-6; - let pieces = survey(a, d, tol, mesh_tol, axes)?.pieces; - if pieces.is_empty() { - return None; - } - // A piece of an offending face within a hair of the tool's box: no column round the tool - // can leave it out, so nothing is cut. - let reach = size * 2e-3 + 2.0 * gap; - if pieces.iter().any(|(_, e)| e.iter().zip(&tool).all(|((c0, c1), (t0, t1))| *c1 > t0 - reach && *c0 < t1 + reach)) { - return None; - } - let run = || -> Result> { - let fail = |m: &str| KernelError::Failed(format!("prism boolean in a column round the tool: {m}")); - let mut middle: Traced = (a.clone(), recorded::kept(a, 0, OPERANDS)); - let mut outside: Vec = Vec::new(); - // The sides already cut (axis, positive side): each is cut once. - let mut cut: Vec<(usize, bool)> = Vec::new(); - let mut box_cuts = 0; - for _ in 0..MAX_CUTS { - let survey = survey(&middle.0, d, tol, mesh_tol, axes).ok_or_else(|| fail("the middle piece"))?; - let off = survey.faces(); - if off.is_empty() { - break; - } - let (k, places, keep_positive) = - next_cut(&off, &tool, &survey.here, &survey.flat, &cut, axes, size, gap).ok_or_else(|| fail("no cut leaves the other faces out"))?; - cut.push((k, !keep_positive)); - let axis = axes[k]; - let (u, w) = (axes[(k + 1) % 3], axes[(k + 2) % 3]); - // The first of the places where the piece splits into parts that add up to it (a - // plane whose section through the piece doesn't close is passed over). The cut's - // half boxes, if it takes them, are operands `slot` and `slot + 1`. - let slot = 2 * cut.len(); - let (away, kept) = places - .iter() - .enumerate() - .find_map(|(i, x)| { - let plane = Plane::new(axis * *x, u, w)?; - let with_boxes = i == 0 && box_cuts < MAX_BOX_CUTS; - // Only a plane across an offending face can be traced wrong (a cone's piece - // meshed past its bounds): the others are taken as they are. - let verify = survey.pieces.iter().any(|(_, e)| e[k].0 < *x && e[k].1 > *x); - let r = split(&middle, &plane, axis, *x, keep_positive, slot, with_boxes, verify)?; - box_cuts += usize::from(r.2); - Some((r.0, r.1)) - }) - .ok_or_else(|| fail("a cut beside the tool"))?; - outside.extend(away); - middle = kept; - } - if !survey(&middle.0, d, tol, mesh_tol, axes).is_some_and(|s| s.pieces.is_empty()) { - return Err(fail("other faces are left round the tool")); - } - let r = match crate::prism::prism_boolean(&middle.0, b, op) { - Some(r) => r?, - None => return Err(fail("the column is not a prism along the tool")), - }; - crate::polybool::reassembled(a, b, op, &middle, r, outside, OPERANDS, &fail) - }; - Some(run()) -} - -/// `piece` split by `plane` (at `x` along `axis`, square to it): the parts away from the tool -/// and the one on its side (positive along `axis` when `keep_positive`), with their histories. -/// An imprint of the plane, taken as it is unless `verify`; else where its parts don't add up to -/// the piece (a plane across a cone can be traced wrong) and `with_boxes`, the piece's intersections with the half boxes -/// either side (the cut's operands `slot` and `slot + 1`), and then whether it took them. `None` -/// when neither adds up. -#[allow(clippy::too_many_arguments)] -fn split( - piece: &Traced, - plane: &Plane, - axis: Vec3, - x: f64, - keep_positive: bool, - slot: usize, - with_boxes: bool, - verify: bool, -) -> Option<(Vec, Traced, bool)> { - if !verify { - let (away, kept) = crate::polybool::split_beside(piece, plane, axis, x, keep_positive)?; - return Some((away, kept, false)); - } - let whole = crate::measure(&piece.0).ok()?.volume; - let adds_up = |away: &[Traced], kept: &Traced| { - let sum: Option = away.iter().chain([kept]).map(|(p, _)| crate::measure(p).ok().map(|m| m.volume)).sum(); - sum.is_some_and(|sum| (sum - whole).abs() <= whole.abs() * 5e-5 + 1e-9) - }; - if let Some((away, kept)) = crate::polybool::split_beside(piece, plane, axis, x, keep_positive) - && adds_up(&away, &kept) - { - return Some((away, kept, false)); - } - if !with_boxes { - return None; - } - let boxes = (crate::ops::half_box(&piece.0, plane, !keep_positive).ok()?, crate::ops::half_box(&piece.0, plane, keep_positive).ok()?); - let (h_away, h_kept) = (recorded::kept(&boxes.0, slot, OPERANDS), recorded::kept(&boxes.1, slot + 1, OPERANDS)); - let away = crate::ops::boolean(&piece.0, &boxes.0, BoolOp::Intersect).ok()?; - let kept = crate::ops::boolean(&piece.0, &boxes.1, BoolOp::Intersect).ok()??; - let away: Vec = away - .into_iter() - .map(|o| { - let h = recorded::of_pair(&o, &piece.1, &h_away); - (o, h) - }) - .collect(); - let kept: Traced = { - let h = recorded::of_pair(&kept, &piece.1, &h_kept); - (kept, h) - }; - adds_up(&away, &kept).then_some((away, kept, true)) -} - -/// The extent of `points` along each of `axes`; `None` for no points. -fn extent(points: &[Vec3], axes: [Vec3; 3]) -> Option { - if points.is_empty() { - return None; - } - let mut e = [(f64::INFINITY, f64::NEG_INFINITY); 3]; - for p in points { - for (slot, axis) in e.iter_mut().zip(axes) { - let t = p.dot(axis); - *slot = (slot.0.min(t), slot.1.max(t)); - } - } - e.iter().all(|(lo, hi)| lo.is_finite() && hi.is_finite()).then_some(e) -} - -/// What a cut is chosen from: a piece's extent (`here`), the mesh triangles of its faces that -/// are neither a wall along the direction nor a plane square to it (the faces that keep it from -/// being a prism along it: each one's index and extent), and its planar faces (unit normal, -/// offset along it) for a cut to keep out of. Extents are widened by the mesh's tolerance. -struct Survey { - here: Extent, - pieces: Vec<(usize, Extent)>, - flat: Vec<(Vec3, f64)>, -} - -impl Survey { - /// The extent of each offending face. - fn faces(&self) -> Vec { - let mut faces: Vec<(usize, Extent)> = Vec::new(); - for (i, e) in &self.pieces { - match faces.iter_mut().find(|(j, _)| j == i) { - Some((_, acc)) => { - for (x, y) in acc.iter_mut().zip(e) { - *x = (x.0.min(y.0), x.1.max(y.1)); - } - } - None => faces.push((*i, *e)), - } - } - faces.into_iter().map(|(_, e)| e).collect() - } -} - -/// [`Survey`] of `body` along `d`, from one mesh of it. `None` when it can't be meshed. -fn survey(body: &Body, d: Vec3, tol: f64, mesh_tol: f64, axes: [Vec3; 3]) -> Option { - let mut work = 262_144usize; - let mut flat = Vec::new(); - let off: Vec = body - .solid - .face_iter() - .map(|f| { - let surface = f.oriented_surface(); - match &surface { - mt::Surface::Plane(p) => { - let n = p.normal(); - let Some(n) = Vec3::new(n.x, n.y, n.z).normalized() else { return true }; - let o = p.origin(); - flat.push((n, n.dot(Vec3::new(o.x, o.y, o.z)))); - let along = n.dot(d).abs(); - // NaN counts as inside, as the comparisons it replaces did. - along.is_nan() || (1e-9..=1.0 - 1e-9).contains(&along) - } - _ => !crate::prism::wall_along(&surface, d, tol, &mut work), - } - }) - .collect(); - let mesh = body.mesh(&crate::MeshTolerance::chord(mesh_tol)).ok()?; - let here = widened(extent(&mesh.positions, axes)?, mesh_tol); - let mut pieces = Vec::new(); - if off.iter().any(|x| *x) { - for (t, fi) in mesh.triangles.iter().zip(&mesh.tri_face) { - let i = *fi as usize; - if !off.get(i).copied().unwrap_or(false) { - continue; - } - let Some(tri) = mesh.tri(t) else { continue }; - if let Some(e) = extent(&tri, axes) { - pieces.push((i, widened(e, mesh_tol))); - } - } - } - Some(Survey { here, pieces, flat }) -} - -/// `e` grown by `by` each way. -fn widened(mut e: Extent, by: f64) -> Extent { - for (lo, hi) in e.iter_mut() { - *lo -= by; - *hi += by; - } - e -} - -/// The next cut of the middle piece (its extent `here`, its planar faces `flat`): the axis, the -/// place along it and whether the tool's side is the positive one. A cut leaving the most -/// offending faces (`off`) wholly beyond it, on a side not `cut` yet, placed halfway to the nearest of them; failing -/// that, one beside the tool across the most of them (on an axis square to the direction -/// first). `None` when no cut beside the tool has any offending face beyond it. -#[allow(clippy::too_many_arguments)] -fn next_cut( - off: &[Extent], - tool: &Extent, - here: &Extent, - flat: &[(Vec3, f64)], - cut: &[(usize, bool)], - axes: [Vec3; 3], - size: f64, - gap: f64, -) -> Option<(usize, Vec, bool)> { - // Places between `near` (beside the tool) and `far`, best first, out of the planes of the - // piece's faces square to the axis. - let place = |k: usize, near: f64, far: f64| -> Option> { - let axis = axes[k]; - let places: Vec = [0.5, 0.37, 0.63, 0.25, 0.75, 0.1, 0.9] - .iter() - .map(|t| near + (far - near) * t) - .filter(|x| !flat.iter().any(|(n, o)| n.dot(axis).abs() > 1.0 - 1e-9 && (o * n.dot(axis).signum() - x).abs() < gap)) - .collect(); - (!places.is_empty()).then_some(places) - }; - let mut whole: Option<(usize, usize, Vec, bool)> = None; - let mut across: Option<(usize, usize, Vec, bool)> = None; - let beside = size * 2e-3; - for k in [0usize, 1, 2] { - let (t0, t1) = tool[k]; - let (h0, h1) = here[k]; - for positive_side in [true, false] { - if cut.contains(&(k, positive_side)) { - continue; - } - // Past the tool on this side: is there any of the piece to cut away? - let (edge, room) = if positive_side { (t1 + gap, h1 - t1) } else { (t0 - gap, t0 - h0) }; - if room <= 2.0 * gap { - continue; - } - let beyond: Vec = off - .iter() - .filter_map(|e| { - let (c0, c1) = e[k]; - if positive_side { (c0 > edge).then_some(c0) } else { (c1 < edge).then_some(c1) } - }) - .collect(); - if let Some(nearest) = beyond.iter().copied().reduce(if positive_side { f64::min } else { f64::max }) { - let Some(x) = place(k, edge, nearest) else { continue }; - if whole.as_ref().is_none_or(|(_, n, ..)| beyond.len() > *n) { - whole = Some((k, beyond.len(), x, !positive_side)); - } - continue; - } - if k == 2 && across.is_some() { - continue; - } - let near = edge + if positive_side { beside } else { -beside }; - let crossing = off.iter().filter(|e| if positive_side { e[k].1 > near } else { e[k].0 < near }).count(); - let limit = if positive_side { h1 } else { h0 }; - if crossing == 0 { - continue; - } - let Some(x) = place(k, edge, near + (near - edge)) - .map(|p| p.into_iter().filter(|x| if positive_side { *x < limit - gap } else { *x > limit + gap }).collect::>()) - .filter(|p| !p.is_empty()) - else { - continue; - }; - if across.as_ref().is_none_or(|(_, n, ..)| crossing > *n) { - across = Some((k, crossing, x, !positive_side)); - } - } - } - whole.or(across).map(|(k, _, x, keep_positive)| (k, x, keep_positive)) -} diff --git a/crates/kernel/src/prism_spline_tests.rs b/crates/kernel/src/prism_spline_tests.rs deleted file mode 100644 index 6fe0b48a7..000000000 --- a/crates/kernel/src/prism_spline_tests.rs +++ /dev/null @@ -1,87 +0,0 @@ -use super::*; - -/// A rounded square of four quadratic curves (a font's kind) about (20, 15). -fn rounded() -> Region2 { - let p = Vec2::new; - let q = |a: Vec2, apex: Vec2, b: Vec2| Seg2::Conic { a, apex, b, w: 1.0 }; - let segs = vec![ - q(p(10.0, 15.0), p(10.0, 5.0), p(20.0, 5.0)), - q(p(20.0, 5.0), p(30.0, 5.0), p(30.0, 15.0)), - q(p(30.0, 15.0), p(30.0, 25.0), p(20.0, 25.0)), - q(p(20.0, 25.0), p(10.0, 25.0), p(10.0, 15.0)), - ]; - Region2 { outer: Loop2 { segs }, holes: vec![] } -} - -fn block() -> Body { - crate::box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(40.0, 30.0, 10.0)).unwrap() -} - -/// Its free-form faces (the tool's walls kept as the curves they were). -fn spline_faces(b: &Body) -> usize { - b.solid.face_iter().filter(|f| matches!(f.surface(), mt::Surface::BSplineSurface(_) | mt::Surface::NurbsSurface(_))).count() -} - -/// A shape of a font's curves engraved into a block is decided in 2D, its walls the exact curves. -#[test] -fn an_engraving_of_quadratic_curves_is_exact_in_2d() { - let region = rounded(); - let area = region.outer.signed_area().abs(); - let tool = crate::extrude(&Plane::XY, std::slice::from_ref(®ion), 9.0, 11.0).unwrap().remove(0); - let out = prism_boolean(&block(), &tool, BoolOp::Cut).expect("the 2D route takes it").unwrap().unwrap(); - assert!(out.validity().is_empty(), "{:?}", out.validity()); - // Half the tool, measured as the result is (meshes of curved faces are off by about 1e-4). - let taken = 12000.0 - crate::measure(&out).unwrap().volume; - let half = crate::measure(&tool).unwrap().volume / 2.0; - assert!((taken - half).abs() < 1e-6 * half && (taken - area).abs() < 2e-4 * area, "{taken} vs {half} ({area})"); - assert_eq!(spline_faces(&out), 4); -} - -/// A shape running off the block's side is cut where its curves exactly cross the side. -#[test] -fn an_engraving_running_off_the_side_ends_on_its_exact_crossings() { - let region = rounded(); - // Moved 14 to the left: the block's side x = 0 cuts its two left curves. - let shift = |s: &Seg2| match *s { - Seg2::Conic { a, apex, b, w } => { - Seg2::Conic { a: a - Vec2::new(14.0, 0.0), apex: apex - Vec2::new(14.0, 0.0), b: b - Vec2::new(14.0, 0.0), w } - } - other => other, - }; - let moved = Region2 { outer: Loop2 { segs: region.outer.segs.iter().map(shift).collect() }, holes: vec![] }; - let tool = crate::extrude(&Plane::XY, std::slice::from_ref(&moved), 9.0, 11.0).unwrap().remove(0); - let out = prism_boolean(&block(), &tool, BoolOp::Cut).expect("the 2D route takes it").unwrap().unwrap(); - assert!(out.validity().is_empty(), "{:?}", out.validity()); - // What the block keeps of the shape: the shape's part at x > 0. - let inside = planar_regions_boolean( - std::slice::from_ref(&moved), - &[Region2 { - outer: Loop2::polygon(&[Vec2::new(0.0, 0.0), Vec2::new(40.0, 0.0), Vec2::new(40.0, 30.0), Vec2::new(0.0, 30.0)]), - holes: vec![], - }], - BoolOp::Intersect, - 1e-6, - ) - .unwrap(); - let area: f64 = inside.iter().map(|r| r.outer.signed_area().abs()).sum(); - let taken = 12000.0 - crate::measure(&out).unwrap().volume; - assert!((taken - area).abs() < 2e-4 * area, "{taken} vs {area}"); - assert!(spline_faces(&out) >= 2, "{}", spline_faces(&out)); -} - -/// A tool that misses its target leaves it as it is: the 2D route declines it (the B-rep -/// boolean then reuses the target itself). An engraving taking far less than a ten-thousandth -/// of a large part is a change all the same, and the route keeps it: told from the exact -/// sections, not from volumes measured off meshes, which could not tell it from no change. -#[test] -fn a_tool_that_misses_is_declined_and_a_fine_engraving_is_not() { - let big = crate::box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(200.0, 200.0, 10.0)).unwrap(); - let region = rounded(); - let tool = |lo: f64, hi: f64| crate::extrude(&Plane::XY, std::slice::from_ref(®ion), lo, hi).unwrap().remove(0); - assert!(prism_boolean(&big, &tool(10.0, 12.0), BoolOp::Cut).is_none(), "a tool above the part misses it"); - // 0.05 mm deep: 17 mm³ of a 400000 mm³ part. - let out = prism_boolean(&big, &tool(9.95, 11.0), BoolOp::Cut).expect("an engraving is a change").unwrap().unwrap(); - let taken = 400_000.0 - crate::measure(&out).unwrap().volume; - let want = region.outer.signed_area().abs() * 0.05; - assert!((taken - want).abs() < 2e-3 * want, "{taken} vs {want}"); -}