From 4b418c0d2d5564db5139a089ca7da165f075b94d Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Thu, 22 Oct 2026 09:02:24 -0400 Subject: [PATCH] kernel: how a body's material regions meet, read from the record Brep::region_contacts lists each pair of material regions that shares a face, an edge (used by faces of both) or a vertex, with the most it shares; pairs not listed are apart. Body::region_contacts reports it for a boolean's result (lump positions as in Body::lumps), and Body::parts cuts a body into groups of lumps (lumps is parts of one each). Exact facts from the record only: no geometry, no decision. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt (cherry picked from commit 64a1d688e68e5f0c5b1f9e4fe0d2facfaa4744be) --- crates/geom/src/brep/part.rs | 95 ++++++++++++++++++++++++++++++++++++ crates/kernel/src/body.rs | 30 ++++++++++-- 2 files changed, 121 insertions(+), 4 deletions(-) diff --git a/crates/geom/src/brep/part.rs b/crates/geom/src/brep/part.rs index b6c946c3e..5520b36fe 100644 --- a/crates/geom/src/brep/part.rs +++ b/crates/geom/src/brep/part.rs @@ -3,6 +3,8 @@ //! of its faces, edges and vertices was in the whole. A lump of a body is the part of one of its //! material regions; material inside one of its voids (an island) is a lump of its own. Records //! of bodies apart from each other join into one by [`Brep::compound`]. +use serde::{Deserialize, Serialize}; + use super::{Brep, EdgeUseRef, Invalid, Loop, OrientedFace, Region, Result, Shell, require}; /// A record cut from a larger one, and the source index of each of its items. @@ -14,6 +16,26 @@ pub struct Part { pub vertices: Vec, } +/// The most two material regions of a record share, least first: a point, a curve, an area. +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum Contact { + /// A vertex and no edge or face: they touch at a point. + Vertex, + /// An edge and no face: they touch along a curve. + Edge, + /// A face: they meet over an area. + Face, +} + +/// Two material regions that meet (positions in [`Brep::material_regions`], the lower first), +/// and the most they share. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct RegionContact { + pub regions: [usize; 2], + pub contact: Contact, +} + /// First-appearance numbering of a subset of `n` source items. struct Renumber { new: Vec>, @@ -45,6 +67,79 @@ impl Brep { self.regions.iter().enumerate().skip(1).filter(|(_, r)| !r.void).map(|(i, _)| i).collect() } + /// How the material regions meet, read from the record: each pair of regions that shares a + /// face, an edge or a vertex, with the most they share. `regions` index + /// [`Brep::material_regions`] (so a body's lumps); pairs not listed are apart. Regions share + /// an edge where it is used by faces of both (more than two faces), a vertex where edges or + /// vertex loops of both end at it. Sorted by pair. + pub fn region_contacts(&self) -> Result> { + let material = self.material_regions(); + // The material regions (positions in `material`) each face, edge and vertex belongs to. + let mut on_face: Vec> = vec![Vec::new(); self.faces.len()]; + let mut on_edge: Vec> = vec![Vec::new(); self.edges.len()]; + let mut on_vertex: Vec> = vec![Vec::new(); self.vertices.len()]; + let mark = |list: &mut Vec>, i: u32, k: usize| -> Result<()> { + let owners = list.get_mut(i as usize).ok_or(Invalid("contact reference"))?; + if owners.last() != Some(&k) { + owners.push(k); + } + Ok(()) + }; + for (k, &r) in material.iter().enumerate() { + let region = self.regions.get(r).ok_or(Invalid("region reference"))?; + for &s in ®ion.shells { + match self.shells.get(s as usize).ok_or(Invalid("shell reference"))? { + Shell::Faces { faces, wires } => { + for f in faces { + mark(&mut on_face, f.face, k)?; + for l in &self.faces.get(f.face as usize).ok_or(Invalid("face reference"))?.loops { + match l { + Loop::Edges { edges } => { + for u in edges { + mark(&mut on_edge, u.edge, k)?; + } + } + Loop::Vertex { vertex } => mark(&mut on_vertex, *vertex, k)?, + } + } + } + for &e in wires { + mark(&mut on_edge, e, k)?; + } + } + Shell::Wire { edges } => { + for &e in edges { + mark(&mut on_edge, e, k)?; + } + } + Shell::Vertex { vertex } => mark(&mut on_vertex, *vertex, k)?, + } + } + } + for (e, owners) in on_edge.iter().enumerate() { + for &v in &self.edges.get(e).ok_or(Invalid("edge reference"))?.vertices { + for &k in owners { + let list = on_vertex.get_mut(v as usize).ok_or(Invalid("contact reference"))?; + if !list.contains(&k) { + list.push(k); + } + } + } + } + let mut pairs = std::collections::BTreeMap::<[usize; 2], Contact>::new(); + for (owners, contact) in [(&on_face, Contact::Face), (&on_edge, Contact::Edge), (&on_vertex, Contact::Vertex)] { + for list in owners.iter().filter(|l| l.len() > 1) { + for (i, &a) in list.iter().enumerate() { + for &b in list.iter().skip(i + 1) { + let most = pairs.entry([a.min(b), a.max(b)]).or_insert(contact); + *most = (*most).max(contact); + } + } + } + } + Ok(pairs.into_iter().map(|(regions, contact)| RegionContact { regions, contact }).collect()) + } + /// The part made of the material regions `regions` (indices into `self.regions`, bounded, /// not voids): each with its outer shell, its open and wire shells, and a void for each /// closed inner shell. An island inside one of those voids is in the part, inside it, when diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rs index 3e383323b..ae9189f55 100644 --- a/crates/kernel/src/body.rs +++ b/crates/kernel/src/body.rs @@ -1209,11 +1209,33 @@ impl Body { if self.is_mesh() || regions.len() < 2 { return Ok(vec![self.clone()]); } + self.parts(&(0..regions.len()).map(|k| vec![k]).collect::>()) + } + + /// How the body's lumps meet (positions as in [`Body::lumps`]): each pair that shares a face, + /// an edge or a vertex, with the most it shares, read from the record. Pairs not listed are + /// apart. Empty for a mesh body or a body in one piece. + pub fn region_contacts(&self) -> Result> { + if self.is_mesh() { + return Ok(Vec::new()); + } + self.record.region_contacts().map_err(|e| KernelError::Invalid(format!("region contacts: {e}"))) + } + + /// The body cut into parts: one per group of its lumps (positions as in [`Body::lumps`]), + /// each the lumps listed with the voids inside them. The parts carry their history over + /// `[self]`, as lumps do. + pub fn parts(&self, groups: &[Vec]) -> Result> { + let regions = self.record.material_regions(); let counts = [(self.face_count(), self.edge_count())]; - regions - .into_iter() - .map(|r| { - let part = self.record.part(&[r]).map_err(|e| KernelError::Failed(format!("lump: {e}")))?; + groups + .iter() + .map(|group| { + let picked = group + .iter() + .map(|&k| regions.get(k).copied().ok_or_else(|| KernelError::Invalid(format!("no lump {k}")))) + .collect::>>()?; + let part = self.record.part(&picked).map_err(|e| KernelError::Failed(format!("lump: {e}")))?; let sources = self .face_sources .as_ref()