SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
feat(kernel): history across coalesced stepped walls (#136)
Iraklis Kourtis08d797235d28
diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex f35b5e34b7..60c98ad08c 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -378,7 +378,9 @@ fn polyline_mid(pts: &[Vec3]) -> (Vec3, f64) {}impl Body {- /// The very same body (shared data), not just an equal-looking one.+ /// The very same body (shared data), not just an equal-looking one. Its history (how an+ /// operation made it) is not part of it: an operation that leaves a body as it is (a cut by+ /// a tool clear of it) gives the same body, with that operation's history.pub fn same(&self, other: &Body) -> bool {std::sync::Arc::ptr_eq(&self.solid, &other.solid)&& match (&self.mesh, &other.mesh) {@@ -391,11 +393,6 @@ impl Body {&& self.splits == other.splits&& self.face_sources == other.face_sources&& self.regularization_protected == other.regularization_protected- && match (&self.history, &other.history) {- (Some(a), Some(b)) => std::sync::Arc::ptr_eq(a, b),- (None, None) => true,- _ => false,- }}pub(crate) fn new(solid: Solid) -> Result<Body> {diff --git a/crates/kernel/src/boolean_history_tests.rs b/crates/kernel/src/boolean_history_tests.rsindex c9d4d5789b..13dd0b3960 100644--- a/crates/kernel/src/boolean_history_tests.rs+++ b/crates/kernel/src/boolean_history_tests.rs@@ -290,7 +290,6 @@ fn box_minus_cylinder_prism() {/// A slot across the top (a stepped prism along y): the top and the box's ends come apart in/// pieces (Split); the slot's floor and sides are the tool's.#[test]-#[ignore = "fails until #136 is fixed"]fn slot_splits_a_face() {let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);let b = boxed(4.0, -1.0, 5.0, 6.0, 11.0, 11.0);@@ -368,7 +367,6 @@ fn glue_merges_across_the_seam() {/// Coincident faces pushed apart: a cut flush with the target's top, and a union of bodies/// standing on one floor (the floor that is cut back is both operands' floors).#[test]-#[ignore = "fails until #136 is fixed"]fn faces_pushed_apart() {let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);let tool = boxed(2.0, 2.0, 5.0, 8.0, 8.0, 10.0);@@ -425,9 +423,36 @@ fn faceted_tool() {assert_eq!(h.faces.iter().filter(|f| matches!(f.origins.first(), Some(FaceOrigin::Face { operand: 1, .. }))).count(), 3);}-/// A step cut into a certified box: the boolean leaves the faces it split on the box's planes-/// in pieces, which the planar regularization joins back; the joined body keeps the boolean's-/// history composed through the join.+/// A partial-depth cut of stepped prisms: walls over one segment through successive slabs are+/// sewn as one face (coalesced), which comes from the operand walls under it in every slab.+#[test]+fn coalesced_stepped_walls() {+ use solvecraft_geom::{Loop2, Plane, Region2, Vec2};+ for curved in [true, false] {+ let (outer, inner) = if curved {+ (Loop2::circle(Vec2::ZERO, 10.0), Loop2::circle(Vec2::ZERO, 5.0))+ } else {+ let square = |h: f64| Loop2::polygon(&[Vec2::new(-h, -h), Vec2::new(h, -h), Vec2::new(h, h), Vec2::new(-h, h)]);+ (square(10.0), square(5.0))+ };+ let stock = crate::extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0.0, 20.0).unwrap().pop().unwrap();+ let cutter = crate::extrude(&Plane::XY, &[Region2 { outer: inner, holes: vec![] }], 2.0, 22.0).unwrap().pop().unwrap();+ let r = boolean(&stock, &cutter, BoolOp::Cut).unwrap().unwrap();+ let h = verified(&r, &[&stock, &cutter], 0.01);+ // The stock's walls run whole from 0 to 20, one face each, past the cutter's floor.+ let walls: Vec<usize> = (0..r.face_count()).filter(|i| r.face_was_coalesced(*i)).collect();+ assert_eq!(walls.len(), if curved { 2 } else { 4 }, "{}", show(h));+ for i in walls {+ assert!(matches!(h.faces[i].origins.as_slice(), [FaceOrigin::Face { operand: 0, .. }]), "{}", show(h));+ assert_eq!(h.faces[i].change, Change::Modified, "{}", show(h));+ }+ }+}++/// A step cut into a box: the stepped prism path sews the box's face 3 in pieces at the+/// slab stations, and the joining of generated walls on their common supports makes it one face+/// again; the joined body keeps the sewn body's history composed through the join. A certified+/// box (whose planar regularization would join the same pieces) gets the same history.#[test]fn regularized_step_cut() {let (pa, pb) = (boxed(0.0, 0.0, 0.0, 30.0, 35.0, 7.5), boxed(0.0, 30.0, 2.5, 22.5, 50.0, 25.0));@@ -436,16 +461,10 @@ fn regularized_step_cut() {let h = verified(&r, &[&a, &b], 0.01);let plain = boolean(&pa, &pb, BoolOp::Cut).unwrap().unwrap();let ph = verified(&plain, &[&pa, &pb], 0.01);- // Uncertified, the box's face 3 stays in two pieces; certified, they are joined into one- // face, the only one from it.- assert_eq!(from(ph, face(0, 3)).len(), 2, "{}", show(ph));- assert_eq!(r.face_count() + 1, plain.face_count());- let joined = from(h, face(0, 3));- assert_eq!(joined.len(), 1, "{}", show(h));- assert_eq!(faces_of(h)[joined[0]], (Change::Modified, vec![face(0, 3)]));- // Every other face is as the boolean made it, in its order.- let rest = |h: &History| -> Vec<(Change, Vec<FaceOrigin>)> { faces_of(h).into_iter().filter(|(_, o)| *o != [face(0, 3)]).collect() };- assert_eq!(rest(h), rest(ph));+ let joined = from(ph, face(0, 3));+ assert_eq!(joined.len(), 1, "{}", show(ph));+ assert_eq!(faces_of(ph)[joined[0]], (Change::Modified, vec![face(0, 3)]));+ assert_eq!(faces_of(h), faces_of(ph), "{}", show(h));}/// A ring joined under a floor, its bore on the floor's hole (coincident cylinders): the ring'sdiff --git a/crates/kernel/src/boolean_record.rs b/crates/kernel/src/boolean_record.rsindex 272b6f283b..2f3060a193 100644--- a/crates/kernel/src/boolean_record.rs+++ b/crates/kernel/src/boolean_record.rs@@ -80,9 +80,7 @@ pub(crate) fn join(pieces: Vec<Traced>, counts: &[(usize, usize)]) -> Result<Optbreak;};all.extend(h.faces.iter().cloned());- for (e, prov) in edge_order(p.solid.face_iter()).0.iter().zip(&h.edges) {- edges.insert(e.id(), prov.origins.clone());- }+ edges.extend(record::edges_by_identity(p, h));}if let Some(faces) = faces.as_mut() {record::mark_shared_split(faces);diff --git a/crates/kernel/src/history.rs b/crates/kernel/src/history.rsindex d3ae9f9c5f..289fed7d98 100644--- a/crates/kernel/src/history.rs+++ b/crates/kernel/src/history.rs@@ -250,11 +250,10 @@ impl History {let mut faces = Vec::with_capacity(self.faces.len());for f in &self.faces {let mut origins = BTreeSet::new();- let (mut split, mut kept) = (f.change == Change::Split, f.change == Change::Kept);+ let mut kept = f.change == Change::Kept;for o in &f.origins {let (os, change) = map_face(*o)?;origins.extend(os);- split |= change == Some(Change::Split);kept &= change.is_none_or(|c| c == Change::Kept);}let origins: Vec<FaceOrigin> = origins.into_iter().collect();@@ -262,8 +261,6 @@ impl History {Change::Generated} else if origins.len() > 1 {Change::Merged- } else if split {- Change::Split} else if kept {Change::Kept} else {diff --git a/crates/kernel/src/history_tests.rs b/crates/kernel/src/history_tests.rsindex ea7ef05b03..86471d760d 100644--- a/crates/kernel/src/history_tests.rs+++ b/crates/kernel/src/history_tests.rs@@ -128,8 +128,9 @@ fn substitute_composes_kept_split_merged_and_generated_faces() {assert_eq!(op2.operands, 4);let f = &op2.faces;assert_eq!(f[0], prov(vec![face(1, 0)], Change::Kept));- // Two pieces of one face, merged back: one origin, so not a merge across faces.- assert_eq!(f[1], prov(vec![face(1, 1)], Change::Split));+ // Two pieces of one face, merged back: one origin, so not a merge across faces, and no+ // other face comes from it, so not split.+ assert_eq!(f[1], prov(vec![face(1, 1)], Change::Modified));assert_eq!(f[2], prov(vec![face(2, 4)], Change::Modified));assert_eq!(f[3], prov(vec![FaceOrigin::Profile { segment: 2 }], Change::Generated));assert_eq!(f[4], prov(vec![face(0, 5), face(3, 1)], Change::Merged));diff --git a/crates/kernel/src/modify_history_tests.rs b/crates/kernel/src/modify_history_tests.rsindex ca3eb8c1e1..eab98323d2 100644--- a/crates/kernel/src/modify_history_tests.rs+++ b/crates/kernel/src/modify_history_tests.rs@@ -248,6 +248,31 @@ fn shell_of_a_body_that_is_not_convex() {assert_eq!(offsets, 7, "{h:?}");}+/// A shell of a block with a tab joined on a side: the cavity Cut sews the walls in pieces+/// across its slabs and joins them on their common supports, the history carried through.+#[test]+fn shell_of_a_stepped_body_joins_its_walls() {+ let stock = box_solid(Vec3::new(-20.0, -15.0, 0.0), Vec3::new(20.0, 15.0, 24.0)).unwrap();+ let tab = box_solid(Vec3::new(-12.0, -25.0, 8.0), Vec3::new(-4.0, -15.0, 16.0)).unwrap();+ let b = boolean(&stock, &tab, BoolOp::Union).unwrap().unwrap();+ let r = crate::shell(&b, &[Vec3::new(0.0, 0.0, 24.0)], 1.0).unwrap();+ let h = verified(&r, &b, reach(1.0 * 1.5));+ // Every face of the body but the open top is lined by one inner wall.+ let offsets = h.faces.iter().filter(|f| matches!(f.origins.as_slice(), [FaceOrigin::Offset { .. }])).count();+ assert_eq!(offsets, b.face_count() - 1, "{h:?}");+}++/// A shell of a painted block: its faces are used as they are (unhealed), keeping the paint's+/// face order, with the history of that copy. Paint is an authored boundary, so the cavity Cut+/// keeps the side faces it sews across the rim's level in pieces (Split).+#[test]+fn shell_of_a_painted_body() {+ let b = painted_cube();+ let r = crate::shell(&b, &[Vec3::new(20.0, 15.0, 20.0)], 2.0).unwrap();+ let h = verified(&r, &b, reach(2.0));+ assert_eq!(changes(h), [0, 2, 8, 0, 5], "{h:?}");+}+#[test]fn draft_tilts_faces() {let b = cube();@@ -377,10 +402,15 @@ fn mirrored_copy_keeps_every_face_and_edge() {}}-/// The block with box cuts of each common shape: a notch through the back, a pocket, a step-/// along one end, a slot across the top, a hole through, a corner bitten out.-fn box_cuts() -> Vec<(&'static str, Body, Body)> {- let b = cube();+/// The block with a face painted: an authored boundary, so the cuts leave the faces they split+/// across their slabs in pieces (none of them joined on their common supports).+fn painted_cube() -> Body {+ cube().with_paint(Some(crate::Paint { opacity: 1., faces: vec![crate::FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }] }))+}++/// The block `b` with box cuts of each common shape: a notch through the back, a pocket, a+/// step along one end, a slot across the top, a hole through, a corner bitten out.+fn box_cuts_of(b: &Body) -> Vec<(&'static str, Body, Body)> {[("notch", Vec3::new(15.0, 25.0, -5.0), Vec3::new(25.0, 35.0, 25.0)),("pocket", Vec3::new(10.0, 10.0, 10.0), Vec3::new(30.0, 20.0, 25.0)),@@ -392,7 +422,7 @@ fn box_cuts() -> Vec<(&'static str, Body, Body)> {.into_iter().map(|(name, lo, hi)| {let tool = box_solid(lo, hi).unwrap();- let cut = boolean(&b, &tool, BoolOp::Cut).unwrap().unwrap();+ let cut = boolean(b, &tool, BoolOp::Cut).unwrap().unwrap();(name, cut, tool)}).collect()@@ -403,41 +433,52 @@ fn merged_meetings(h: &History) -> usize {h.edges.iter().flat_map(|e| &e.origins).filter(|o| matches!(o, EdgeOrigin::Meet { a, b } if a.single().is_none() || b.single().is_none())).count()}-/// A fillet right after a box cut. Where the cut leaves coplanar pieces (the step, slot and-/// bite leave the front face in pieces), the fillet's heal merges them, and the edge where the-/// round runs into that face meets all of it. Composed with the cut, over the block and the tool.+/// A fillet right after a box cut. The cut joins the walls it sews in pieces across its slabs+/// on their common supports, so the fillet finds whole faces. Where the block is painted the cut+/// keeps those pieces (it has more faces), the fillet's heal merges them, and the edges where+/// the round runs into such a face meet all of it. Composed with the cut, over the block and+/// the tool.#[test]fn fillet_after_box_cuts() {- let b = cube();let at = Vec3::new(5.0, 0.0, 20.0);- for (name, cut, tool) in box_cuts() {- let r = crate::fillet(&cut, &[at], 2.0).unwrap();- let h = verified(&r, &cut, reach(2.0 * 1.5));- assert_eq!(blends(h), [vec![edge(edge_at(&cut, at))]], "{name}");- let merged = matches!(name, "step" | "slot" | "bite");- assert_eq!(merged_meetings(h) > 0, merged, "{name}: {h:?}");- let mut through = h.clone();- through.substitute(0, cut.history().unwrap()).unwrap();- through.check(&r, &[&b, &tool]).unwrap();+ let plain = box_cuts_of(&cube());+ for (b, painted) in [(cube(), false), (painted_cube(), true)] {+ let cuts = if painted { box_cuts_of(&b) } else { plain.clone() };+ for ((name, cut, tool), (_, whole, _)) in cuts.into_iter().zip(&plain) {+ let r = crate::fillet(&cut, &[at], 2.0).unwrap();+ let h = verified(&r, &cut, reach(2.0 * 1.5));+ assert_eq!(blends(h), [vec![edge(edge_at(&cut, at))]], "{name}");+ let pieces = cut.face_count() > whole.face_count();+ assert_eq!(pieces, painted && name != "notch" && name != "hole", "{name} (painted: {painted})");+ assert_eq!(merged_meetings(h) > 0, pieces, "{name} (painted: {painted}): {h:?}");+ let mut through = h.clone();+ through.substitute(0, cut.history().unwrap()).unwrap();+ through.check(&r, &[&b, &tool]).unwrap();+ }}}/// A chamfer right after a box cut, its cutter's cut going the prism way along the edge: the/// cutter's walls meet the cut body's walls where a segment was split off. The cut body's ends/// have their outlines in collinear edges (pocket, step, bite), each matched by the segment-/// running along it; walls the cut left in pieces across the slabs (step, slot, bite) are-/// followed through the levels where one piece gives way to the next. Composed with the cut,-/// over the block and the tool.+/// running along it; walls the cut left in pieces across the slabs (step, slot, bite of the+/// painted block) are followed through the levels where one piece gives way to the next. Where+/// the cut joined those pieces, the line between two walls stays in edges split at the levels,+/// and each slab's edge runs along the one over its levels. Composed with the cut, over the+/// block and the tool.#[test]fn chamfer_after_box_cuts() {- let b = cube();let at = Vec3::new(5.0, 0.0, 20.0);- for (name, cut, tool) in box_cuts() {- let r = crate::chamfer(&cut, &[at], 2.0).unwrap();- let h = verified(&r, &cut, reach(2.0 * 1.5));- assert_eq!(with(h, &[edge(edge_at(&cut, at))]).len(), 1, "{name}: {h:?}");- let mut through = h.clone();- through.substitute(0, cut.history().unwrap()).unwrap();- through.check(&r, &[&b, &tool]).unwrap();+ for (b, painted) in [(cube(), false), (painted_cube(), true)] {+ for (name, cut, tool) in box_cuts_of(&b) {+ let r = crate::chamfer(&cut, &[at], 2.0).unwrap();+ let h = verified(&r, &cut, reach(2.0 * 1.5));+ // On the painted block the chamfer face keeps the boundaries the cut left.+ let faces = with(h, &[edge(edge_at(&cut, at))]).len();+ assert!(if painted { faces >= 1 } else { faces == 1 }, "{name} (painted: {painted}): {h:?}");+ let mut through = h.clone();+ through.substitute(0, cut.history().unwrap()).unwrap();+ through.check(&r, &[&b, &tool]).unwrap();+ }}}diff --git a/crates/kernel/src/planar_regularize.rs b/crates/kernel/src/planar_regularize.rsindex 7dda16879b..79593d2b4a 100644--- a/crates/kernel/src/planar_regularize.rs+++ b/crates/kernel/src/planar_regularize.rs@@ -1,6 +1,7 @@//! Exact topological removal of construction-induced planar subdivisions.//! Shared edge identity and complete construction lineage select the groups.use super::{Body, from_p3};+use crate::history::FaceOrigin;use crate::{Result, guard};use solvecraft_geom::Plane;use std::collections::{BTreeMap, HashMap, HashSet};@@ -115,6 +116,24 @@ fn merged_face(faces: &[&mt::Face], members: &[usize], plane: Plane, eligible: &mt::Face::try_new(wires, faces.get(*members.first()?)?.oriented_surface()).ok()}+/// `body` with its history: `input`'s faces with each output face made of the input faces+/// `members` lists for it (every edge of `body` one of `input`'s, by identity), composed with+/// the history of the operation that made `input`; none where `input` has none.+fn with_joined_history(body: Body, input: &Body, members: Vec<Vec<usize>>) -> Body {+ let Some(inner) = input.history() else { return body };+ let faces = members.into_iter().map(|m| (m.iter().map(|&face| FaceOrigin::Face { operand: 0, face }).collect(), m.len() == 1)).collect();+ let joined = crate::record::traced(+ body,+ &crate::record::counts(&[input]),+ Some(crate::record::regions(faces)),+ Some(&crate::record::edge_origins(&input.solid, 0)),+ );+ // Both steps are checked (`traced` against `input`, `through` composing over its checked+ // history); the composed operands' counts are not known here, so it is set in place.+ let history = crate::boolean_record::through(&joined, 0, Some(inner));+ Body { history: history.map(Arc::new), ..joined }+}+impl Body {pub(crate) fn regularize_certified_planar_faces(self) -> Result<Self> {self.regularize_planar_faces(false)@@ -252,6 +271,8 @@ impl Body {let mut shells = Vec::new();let mut output_sources = Vec::new();let mut output_ids = Vec::new();+ // The input faces each output face is made of, for its history.+ let mut output_members: Vec<Vec<usize>> = Vec::new();let mut offset = 0;for shell in self.solid.boundaries() {let mut output = Vec::new();@@ -260,12 +281,15 @@ impl Body {if let Some(merged) = replacements.get(&leader) {if offset == leader {output.push(merged.clone());+ let Some(members) = groups.remove(&leader) else { return Ok(None) };+ output_members.push(members);} else {offset += 1;continue;}} else {output.push(face.clone());+ output_members.push(vec![offset]);}output_ids.push(output.last().ok_or_else(|| crate::KernelError::Failed("missing regularized face".into()))?.id());let source = sources[offset].as_ref();@@ -291,7 +315,7 @@ impl Body {if !body.solid.face_iter().map(|f| f.id()).eq(output_ids) {return Ok(None);}- Ok(Some(body.with_face_sources(Some(Arc::new(output_sources)))))+ Ok(Some(with_joined_history(body.with_face_sources(Some(Arc::new(output_sources))), &self, output_members)))})?;Ok(result.unwrap_or(self))}diff --git a/crates/kernel/src/prism.rs b/crates/kernel/src/prism.rsindex dbbfa29866..9711cf0da9 100644--- a/crates/kernel/src/prism.rs+++ b/crates/kernel/src/prism.rs@@ -129,8 +129,10 @@ struct Prism {/// (`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). `None` fields: not known (no history-/// then).+/// 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).#[derive(Clone, Copy, Debug, PartialEq, Eq)]pub(crate) struct Tag {pub operand: usize,@@ -1094,7 +1096,8 @@ fn sew_stack(plane: &Plane, d: Vec3, pa: &Prism, pb: &Prism, tol: f64, history:sew_sections(plane, d, &levels, &slabs, tol, false, history)}-/// Sew the exact sections between successive levels, including empty gaps.+/// 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,@@ -1154,11 +1157,11 @@ fn sew_sections(pieces.push((piece, lineage::Built::Extruded { section: tagged.region(r), lo: levels[first], hi: levels[end] }));}} else {- let (piece, specs, faces) = sew_connected_sections(plane, d, &levels[first..=end], &slabs[first..end], tol, coalesce)+ 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, lineage::Built::Sewn { specs, faces }));+ pieces.push((piece, built));}}let mut old = std::collections::HashMap::new();@@ -1199,7 +1202,6 @@ fn wall_key(s: &Seg2) -> Option<[u64; 6]> {}/// A genuinely stepped connected axial block has no single extrusion footprint.-#[allow(clippy::type_complexity)]fn sew_connected_sections(plane: &Plane,d: Vec3,@@ -1207,7 +1209,8 @@ fn sew_connected_sections(slabs: &[Section],tol: f64,coalesce: bool,-) -> Option<Result<(Body, Vec<lineage::Spec>, Option<Vec<usize>>)>> {+ history: &lineage::Context,+) -> Option<Result<(Body, lineage::Built)>> {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<Section> {@@ -1244,52 +1247,54 @@ fn sew_connected_sections(};// Exact oriented generated segments alone define a run. No support fitting,// proximity matching, or old face lineage is used here.- let mut runs: Vec<(usize, usize, Seg2)> = Vec::new();+ // Each run, with what its wall is over in each of its slabs (for the result's history).+ type Run = (usize, usize, Seg2, Vec<lineage::Slab>);+ let mut runs: Vec<Run> = Vec::new();let mut last = std::collections::BTreeMap::new();let mut remaining = MAX_PLANAR_SEGMENTS * 2;- // What each face is over, for the result's history. Coalesced walls span several slabs- // and are not described: such a piece carries no history.- let mut specs: Vec<lineage::Spec> = Vec::new();for (i, slab) in slabs.iter().enumerate() {- let z0 = *levels.get(i)?;for (r, reg) in slab.regions.iter().enumerate() {for (l, lp) in std::iter::once(®.outer).chain(®.holes).enumerate() {- let first = specs.len();+ // 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() {remaining = remaining.checked_sub(1)?;let key = wall_key(&sg)?;- if coalesce {- if let Some(&index) = last.get(&key) {- let run: &mut (usize, usize, Seg2) = runs.get_mut(index)?;- if run.1 == i {- run.1 = i + 1;- continue;- }- // Duplicate oriented boundaries in one slab are not- // a valid reason to reconstruct a larger wall.- if run.1 == i + 1 {- return None;+ 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}- last.insert(key, runs.len());- } else {- specs.push(lineage::Spec::Wall { tag: tag.piece(k, n), z0, next: specs.len() + 1, at: sg.end() });- }- runs.push((i, i + 1, sg));+ };+ around.push((run, tag.piece(k, n), sg.end()));}}- // The loop's last wall runs into its first.- if !coalesce && let Some(lineage::Spec::Wall { next, .. }) = specs.last_mut() {- *next = first;+ // 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<FaceSpec> = Vec::new();let mut sources = Vec::new();+ let mut specs: Vec<lineage::Spec> = Vec::with_capacity(runs.len());let frame_is_orthonormal = plane.origin.is_finite()&& plane.x.is_finite()&& plane.y.is_finite()@@ -1300,7 +1305,7 @@ fn sew_connected_sections(&& 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) in runs {+ 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));@@ -1342,6 +1347,7 @@ fn sew_connected_sections(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() {@@ -1359,11 +1365,16 @@ fn sew_connected_sections(specs.push(lineage::Spec::Cap { section: rs.region(ri), z: *z, up: *up });}}- let sewn = crate::sew::sew_touching_with_sources(&faces, &sources);+ 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, _)| Ok((body.regularize_generated_planar_faces()?, specs, None)))+ sewn.and_then(|(body, built)| {+ let body = history.attach(body.clone(), &[(&body, built)]).regularize_generated_planar_faces()?;+ Ok((body, lineage::Built::Traced))+ })} else {- sewn.map(|(body, from)| (body, specs, from))+ sewn})}@@ -1399,7 +1410,7 @@ fn simple_prism_indexed(a: &Body, b: &Body, op: BoolOp, [ia, ib]: [&LazyIndex; 2let pb = prism_tagged(b, d, &plane, tol, ib)?;Some((d, plane, pa, pb))})?;- let history = lineage::Context { op, operands: [a, b], index: [ia.get(), ib.get()], plane, tol, heights: Some([(pa.lo, pa.hi), (pb.lo, pb.hi)]) };+ 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;@@ -1613,7 +1624,7 @@ fn stack_indexed(a: &Body, b: &Body, op: BoolOp, [ia, ib]: [&LazyIndex; 2]) -> Oif slabs.iter().all(|s| s.regions.is_empty()) {return Some(Ok(None));}- let history = lineage::Context { op, operands: [a, b], index: [ia.get(), ib.get()], plane, tol, heights: 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@@ -1801,14 +1812,7 @@ mod planar_tests {// 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 {- op: BoolOp::Cut,- operands: [&operand, &operand],- index: [index.get(), index.get()],- plane: Plane::XY,- tol: 1e-7,- heights: None,- };+ 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 };diff --git a/crates/kernel/src/prism_lineage.rs b/crates/kernel/src/prism_lineage.rsindex d3f8c95731..fdca95a49d 100644--- a/crates/kernel/src/prism_lineage.rs+++ b/crates/kernel/src/prism_lineage.rs@@ -53,6 +53,8 @@ pub(super) struct Context<'a> {pub plane: Plane,pub tol: f64,pub heights: Option<[(f64, f64); 2]>,+ /// Both operands' caps, read once (see [`Context::caps`]).+ caps: std::cell::OnceCell<Option<Vec<Cap>>>,}/// How one piece of the result was built.@@ -62,17 +64,53 @@ pub(super) enum Built {/// 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<Spec>, faces: Option<Vec<usize>> },+ /// 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 a section segment (tagged `tag`) from level `z0` up. `next` is the wall over- /// the next segment of its loop, which it meets at `at`.- Wall { tag: Tag, z0: f64, next: usize, at: Vec2 },+ /// 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<f64>, slabs: Vec<Slab> },/// 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 a piece: the wall over a segment with this tag between two levels, or a cap.#[derive(Clone, Copy)]enum Kind {@@ -80,7 +118,11 @@ enum Kind {Cap(usize),}-impl Context<'_> {+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<B: std::borrow::Borrow<Body>>(&self, body: Body, pieces: &[(B, Built)]) -> Body {@@ -92,18 +134,26 @@ impl Context<'_> {/// 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<FaceProv>, HashMap<mt::EdgeID, Vec<EdgeOrigin>>)> {- let caps = self.caps()?;+ 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 { section, lo, hi } => self.extruded(&caps, body, section, *lo, *hi)?,- Built::Sewn { specs, faces } => self.sewn(&caps, body, specs, faces.as_deref()?)?,+ Built::Extruded { section, lo, hi } => self.extruded(caps, body, section, *lo, *hi)?,+ 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);+ faces.extend(f.into_iter().map(|(origins, whole)| crate::record::region(origins, whole)));edges.extend(e);}- Some((crate::record::regions(faces), edges))+ // Pieces of one body can share an origin.+ crate::record::mark_shared_split(&mut faces);+ Some((faces, edges))}/// Both operands' caps, their outlines tagged.@@ -157,16 +207,9 @@ impl Context<'_> {Some(Face { operand: t.operand, face: t.wall? })}- /// The operand's edges (by number) bounding exactly the faces `faces`, and touching vertex- /// `at` when given.- fn edges_between(&self, operand: usize, [f, g]: [usize; 2], at: Option<usize>) -> Vec<usize> {- let Some(index) = self.index.get(operand) else { return Vec::new() };- let Some(between) = index.between.get(&(f.min(g), f.max(g))) else { return Vec::new() };- between- .iter()- .copied()- .filter(|e| at.is_none_or(|v| index.bounds.get(*e).is_some_and(|(_, front, back)| *front == Some(v) || *back == Some(v))))- .collect()+ /// 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?@@ -199,7 +242,7 @@ impl Context<'_> {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<usize> = own.iter().flat_map(|c| self.edges_between(x, [w, *c], None)).collect();+ let along: Vec<usize> = 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())?)]),@@ -208,10 +251,11 @@ impl Context<'_> {}/// The origins of the edge between the walls over two segments where the first (tagged- /// `t1`) runs into the second (`t2`): the operand's edge there between its walls (at 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) -> Option<Vec<EdgeOrigin>> {+ /// `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<Vec<EdgeOrigin>> {let (p, q) = (Self::wall(t1)?, Self::wall(t2)?);if t1.operand != t2.operand {return Some(vec![EdgeOrigin::meet(p, q)]);@@ -220,12 +264,47 @@ impl Context<'_> {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.one_edge(x, [w1, w2], Some(v)).or_else(|| (w1 == w2).then(Vec::new)),+ (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 where there is one.- _ => self.one_edge(x, [w1, w2], None),+ // 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<usize>, lo: f64, hi: f64) -> Option<Vec<EdgeOrigin>> {+ let index = self.index.get(operand)?;+ let between = self.edges_between(operand, faces);+ if between.len() > 4096 {+ return None;+ }+ let ends: Vec<(Option<usize>, Option<usize>)> =+ 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<usize> = 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<usize>| 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,}}@@ -240,13 +319,13 @@ impl Context<'_> {if t1.operand != t2.operand {return Some(vec![EdgeOrigin::meet(p, q)]);}- self.one_edge(t1.operand, [t1.wall?, t2.wall?], None)+ // 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` (touching vertex `at` when given), when it- /// has exactly one.- fn one_edge(&self, operand: usize, faces: [usize; 2], at: Option<usize>) -> Option<Vec<EdgeOrigin>> {- match self.edges_between(operand, faces, at).as_slice() {+ /// The operand's edge between the faces `faces`, when it has exactly one.+ fn one_edge(&self, operand: usize, faces: [usize; 2]) -> Option<Vec<EdgeOrigin>> {+ match self.edges_between(operand, faces) {[edge] => Some(vec![EdgeOrigin::Edge { operand, edge: *edge }]),_ => None,}@@ -317,7 +396,7 @@ impl Context<'_> {(Kind::Wall(t, ..), Kind::Cap(end)) | (Kind::Cap(end), Kind::Wall(t, ..)) => self.cap_edge(*t, tops.get(*end)?)?,(Kind::Wall(..), Kind::Wall(..)) => {let (t1, t2) = [e.absolute_front().id(), e.absolute_back().id()].iter().find_map(|v| junctions.get(v))?;- self.junction(*t1, *t2)?+ self.junction(*t1, *t2, lo, hi)?}_ => return None,};@@ -348,7 +427,7 @@ impl Context<'_> {let faces = built.iter().map(|i| match specs.get(*i)? {- Spec::Wall { tag, .. } => Some((std::iter::once(Self::wall(*tag)?).collect(), false)),+ Spec::Wall { slabs, .. } => Some((slabs.iter().map(|s| Self::wall(s.tag)).collect::<Option<_>>()?, false)),Spec::Cap { .. } => cap_of.get(*i)?.clone().map(|o| (o, false)),}).collect::<Option<Vec<_>>>()?;@@ -357,24 +436,34 @@ impl Context<'_> {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 o = match (specs.get(i)?, specs.get(j)?) {- (Spec::Wall { tag, .. }, Spec::Cap { .. }) => self.cap_edge(*tag, cap_of.get(j)?.as_ref()?)?,- (Spec::Cap { .. }, Spec::Wall { tag, .. }) => self.cap_edge(*tag, cap_of.get(i)?.as_ref()?)?,- (Spec::Wall { tag: t, z0: a0, next: ni, at: pi, .. }, Spec::Wall { tag: u, z0: b0, next: nj, at: pj, .. }) => {- if (a0 - b0).abs() > self.tol {- // One over the other: the lower first.- if a0 < b0 { self.stacked(*t, *u)? } else { self.stacked(*u, *t)? }+ 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 o = match (x, y) {+ (Spec::Wall { .. }, Spec::Cap { .. }) => self.cap_edge(x.end(lo, self.tol)?.tag, cap_of.get(j)?.as_ref()?)?,+ (Spec::Cap { .. }, Spec::Wall { .. }) => self.cap_edge(y.end(lo, self.tol)?.tag, cap_of.get(i)?.as_ref()?)?,+ (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 {- // The vertex the edge stands on (in plan) says which way round they meet.- let p = self.plane.to_local(from_p3(e.absolute_front().point()));- let at = |q: &Vec2| p.dist(*q) < self.tol * 10.0;- if *ni == j && at(pi) {- self.junction(*t, *u)?- } else if *nj == i && at(pj) {- self.junction(*u, *t)?- } else {- return None;- }+ return None;}}_ => return None,diff --git a/crates/kernel/src/record.rs b/crates/kernel/src/record.rsindex 95e6090bbe..dcb8cdefb2 100644--- a/crates/kernel/src/record.rs+++ b/crates/kernel/src/record.rs@@ -136,6 +136,11 @@ pub(crate) fn build(Ok(traced(Body::new(solid)?, counts, faces, edges))}+/// The origins of `body`'s edges by identity, from its history `h` (edges in its edge order).+pub(crate) fn edges_by_identity<'a>(body: &'a Body, h: &'a History) -> impl Iterator<Item = (mt::EdgeID, Vec<EdgeOrigin>)> + 'a {+ edge_order(body.solid.face_iter()).0.into_iter().zip(&h.edges).map(|(e, p)| (e.id(), p.origins.clone()))+}+/// The face and edge counts of `bodies`, for [`traced`].pub(crate) fn counts(bodies: &[&Body]) -> Vec<(usize, usize)> {bodies.iter().map(|b| (b.face_count(), b.edge_count())).collect()diff --git a/crates/kernel/src/surfaces.rs b/crates/kernel/src/surfaces.rsindex e5e4b6056a..3101dccc56 100644--- a/crates/kernel/src/surfaces.rs+++ b/crates/kernel/src/surfaces.rs@@ -36,8 +36,8 @@ fn surface_of(shell: mt::Shell) -> Body {paint: None,splits: None,face_sources: None,- regularization_protected: false,history: None,+ regularization_protected: false,}}