SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
fix: join connected solids at exact edge contacts
bherbruck22672585c9df
diff --git a/crates/kernel/src/prism.rs b/crates/kernel/src/prism.rsindex 3af7298392..2c29606fac 100644--- a/crates/kernel/src/prism.rs+++ b/crates/kernel/src/prism.rs@@ -511,7 +511,7 @@ fn sew_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<Region2>],faces.push(FaceSpec { loops, surface: SurfSpec::Plane, probe: None });}}- Some(crate::sew::sew(&faces))+ Some(crate::sew::sew_touching(&faces))}fn simple_prism_boolean(a: &Body, b: &Body, op: BoolOp) -> Option<Result<Option<Body>>> {diff --git a/crates/kernel/src/sew.rs b/crates/kernel/src/sew.rsindex e210ec0fd2..cfcfe18177 100644--- a/crates/kernel/src/sew.rs+++ b/crates/kernel/src/sew.rs@@ -65,24 +65,24 @@ fn key(p: Vec3) -> Key {#[derive(Default)]struct Cache {verts: HashMap<Key, mt::Vertex>,- edges: HashMap<(Key, Key, Option<Key>), mt::Edge>,+ edges: HashMap<(Key, Key, Option<Key>, usize), mt::Edge>,}impl Cache {fn vertex(&mut self, p: Vec3) -> mt::Vertex {self.verts.entry(key(p)).or_insert_with(|| builder::vertex(p3(p))).clone()}- fn edge(&mut self, e: &EdgeSpec) -> mt::Edge {+ fn edge(&mut self, e: &EdgeSpec, sheet: usize) -> mt::Edge {let (a, b) = e.ends();let mid = match e {EdgeSpec::Arc { mid, .. } => Some(key(*mid)),EdgeSpec::Line { .. } => None,};let (ka, kb) = (key(a), key(b));- if let Some(found) = self.edges.get(&(ka, kb, mid)) {+ if let Some(found) = self.edges.get(&(ka, kb, mid, sheet)) {return found.clone();}- if let Some(found) = self.edges.get(&(kb, ka, mid)) {+ if let Some(found) = self.edges.get(&(kb, ka, mid, sheet)) {return found.inverse();}let (va, vb) = (self.vertex(a), self.vertex(b));@@ -90,13 +90,198 @@ impl Cache {EdgeSpec::Line { .. } => builder::line(&va, &vb),EdgeSpec::Arc { mid, .. } => builder::circle_arc(&va, &vb, p3(mid)),};- self.edges.insert((ka, kb, mid), made.clone());+ self.edges.insert((ka, kb, mid, sheet), made.clone());made}}/// Sew the faces into a closed solid.pub fn sew(faces: &[FaceSpec]) -> Result<Body> {+ sew_impl(faces, false)+}++/// Separate boundary sheets at a shared geometric edge without moving it.+/// The face adjacency must still describe one connected solid boundary.+pub(crate) fn sew_touching(faces: &[FaceSpec]) -> Result<Body> {+ sew_impl(faces, true)+}++type EdgeUse = (usize, usize, usize);++fn touching_sheets(faces: &[FaceSpec]) -> Result<HashMap<EdgeUse, usize>> {+ type Use = (EdgeUse, Vec3, Vec3, Vec3);+ let mut uses: HashMap<(Key, Key), Vec<Use>> = HashMap::new();+ for (fi, face) in faces.iter().enumerate() {+ let Some(outer) = face.loops.first() else { continue };+ let normal = outer+ .iter()+ .fold(Vec3::ZERO, |n, e| {+ let (a, b) = e.ends();+ n + a.cross(b)+ })+ .normalized();+ for (li, lp) in face.loops.iter().enumerate() {+ for (ei, e) in lp.iter().enumerate() {+ if matches!(e, EdgeSpec::Line { .. }) && matches!(face.surface, SurfSpec::Plane) {+ let (a, b) = e.ends();+ let (ka, kb) = (key(a), key(b));+ let k = if ka < kb { (ka, kb) } else { (kb, ka) };+ if let Some(n) = normal {+ uses.entry(k).or_default().push(((fi, li, ei), a, b, n));+ }+ }+ }+ }+ }+ let mut sheets = HashMap::new();+ for group in uses.values().filter(|g| g.len() > 2) {+ if group.len() != 4 {+ return Err(KernelError::Invalid("sew: unsupported edge contact".into()));+ }+ let mut paired = std::collections::HashSet::new();+ for (i, (use_a, a, b, n)) in group.iter().enumerate() {+ if paired.contains(&i) {+ continue;+ }+ let t = (*b - *a).normalized().ok_or_else(|| KernelError::Invalid("sew: a degenerate contact".into()))?;+ // Pair the two faces bounding each material wedge, not the empty+ // wedge between them. Each pair uses the edge in opposite directions.+ let j = group+ .iter()+ .enumerate()+ .find_map(|(j, (_, c, d, m))| {+ (i != j+ && !paired.contains(&j)+ && key(*a) == key(*d)+ && key(*b) == key(*c)+ && n.cross(t).dot(*m) < -1e-8+ && m.cross(-t).dot(*n) < -1e-8)+ .then_some(j)+ })+ .ok_or_else(|| KernelError::Invalid("sew: ambiguous edge contact".into()))?;+ let use_b = group.get(j).ok_or_else(|| KernelError::Invalid("sew: edge contact".into()))?.0;+ let sheet = paired.len() / 2;+ sheets.insert(*use_a, sheet);+ sheets.insert(use_b, sheet);+ paired.insert(i);+ paired.insert(j);+ }+ }+ Ok(sheets)+}++fn faces_connected(faces: &[mt::Face]) -> bool {+ let mut by_edge: HashMap<mt::EdgeID, Vec<usize>> = HashMap::new();+ for (i, f) in faces.iter().enumerate() {+ for e in f.edge_iter() {+ by_edge.entry(e.id()).or_default().push(i);+ }+ }+ let mut seen = std::collections::HashSet::new();+ let mut todo = vec![0];+ while let Some(i) = todo.pop() {+ if seen.insert(i)+ && let Some(f) = faces.get(i)+ {+ for e in f.edge_iter() {+ if let Some(adjacent) = by_edge.get(&e.id()) {+ todo.extend(adjacent.iter().copied().filter(|j| !seen.contains(j)));+ }+ }+ }+ }+ seen.len() == faces.len()+}++/// A contact's edge sheets can terminate in separate vertex fans. Give each fan+/// its own vertex at the same coordinates so the boundary remains a manifold.+fn split_vertex_fans(faces: Vec<mt::Face>) -> Result<Vec<mt::Face>> {+ let mut by_vertex: HashMap<mt::VertexID, Vec<usize>> = HashMap::new();+ let mut by_edge: HashMap<mt::EdgeID, Vec<usize>> = HashMap::new();+ let mut vertices = HashMap::new();+ for (i, f) in faces.iter().enumerate() {+ for v in f.vertex_iter() {+ vertices.insert(v.id(), v.clone());+ by_vertex.entry(v.id()).or_default().push(i);+ }+ for e in f.edge_iter() {+ by_edge.entry(e.id()).or_default().push(i);+ }+ }+ let mut replacements: HashMap<(mt::VertexID, usize), mt::Vertex> = HashMap::new();+ for (id, members) in &mut by_vertex {+ members.sort_unstable();+ members.dedup();+ let mut seen = std::collections::HashSet::new();+ let mut fans = Vec::new();+ for start in members.iter().copied() {+ if seen.contains(&start) {+ continue;+ }+ let mut todo = vec![start];+ let mut fan = Vec::new();+ while let Some(i) = todo.pop() {+ if !seen.insert(i) {+ continue;+ }+ fan.push(i);+ if let Some(f) = faces.get(i) {+ for e in f.edge_iter().filter(|e| e.absolute_front().id() == *id || e.absolute_back().id() == *id) {+ if let Some(adjacent) = by_edge.get(&e.id()) {+ todo.extend(adjacent.iter().copied().filter(|j| !seen.contains(j)));+ }+ }+ }+ }+ fans.push(fan);+ }+ if fans.len() > 1 {+ let original = vertices.get(id).ok_or_else(|| KernelError::Failed("sew: missing contact vertex".into()))?;+ for fan in fans {+ let vertex = builder::vertex(original.point());+ for i in fan {+ replacements.insert((*id, i), vertex.clone());+ }+ }+ }+ }+ let mut edges = HashMap::new();+ for (i, f) in faces.iter().enumerate() {+ for e in f.edge_iter() {+ edges.entry(e.id()).or_insert_with(|| {+ let (a, b) = (e.absolute_front(), e.absolute_back());+ let a = replacements.get(&(a.id(), i)).unwrap_or(a);+ let b = replacements.get(&(b.id(), i)).unwrap_or(b);+ mt::Edge::new(a, b, e.curve())+ });+ }+ }+ faces+ .into_iter()+ .map(|f| {+ let wires: Vec<mt::Wire> = f+ .absolute_boundaries()+ .iter()+ .map(|w| {+ w.edge_iter()+ .map(|e| {+ let rebuilt = edges.get(&e.id()).ok_or_else(|| KernelError::Failed("sew: missing contact edge".into()))?;+ Ok(if e.front() == e.absolute_front() { rebuilt.clone() } else { rebuilt.inverse() })+ })+ .collect::<Result<Vec<_>>>()+ .map(Into::into)+ })+ .collect::<Result<_>>()?;+ let mut rebuilt = mt::Face::try_new(wires, f.surface()).map_err(|e| KernelError::Failed(format!("sew: contact face: {e}")))?;+ if !f.orientation() {+ rebuilt.invert();+ }+ Ok(rebuilt)+ })+ .collect()+}++fn sew_impl(faces: &[FaceSpec], touching: bool) -> Result<Body> {if faces.len() < 4 || faces.len() > 200_000 {return Err(KernelError::Invalid("a solid needs 4…200000 faces".into()));}@@ -111,10 +296,18 @@ pub fn sew(faces: &[FaceSpec]) -> Result<Body> {}}guard("sew", || {+ let sheets = if touching { touching_sheets(faces)? } else { HashMap::new() };let mut cache = Cache::default();let mut out: Vec<mt::Face> = Vec::with_capacity(faces.len());for (fi, f) in faces.iter().enumerate() {- let wires: Vec<mt::Wire> = f.loops.iter().map(|l| l.iter().map(|e| cache.edge(e)).collect::<Vec<_>>().into()).collect();+ let wires: Vec<mt::Wire> = f+ .loops+ .iter()+ .enumerate()+ .map(|(li, l)| {+ l.iter().enumerate().map(|(ei, e)| cache.edge(e, sheets.get(&(fi, li, ei)).copied().unwrap_or(0))).collect::<Vec<_>>().into()+ })+ .collect();let face = match f.surface {SurfSpec::Plane => builder::try_attach_plane(&wires).map_err(|e| KernelError::Failed(format!("sew: face {fi}: {e}")))?,SurfSpec::Revolved { a, b, axis_origin, axis, angle } => {@@ -132,6 +325,12 @@ pub fn sew(faces: &[FaceSpec]) -> Result<Body> {};out.push(face);}+ if !sheets.is_empty() && !faces_connected(&out) {+ return Err(KernelError::Invalid("sew: bodies touch only along an edge".into()));+ }+ if !sheets.is_empty() {+ out = split_vertex_fans(out)?;+ }let shell: mt::Shell = out.into();let solid = Solid::try_new(vec![shell]).map_err(|e| KernelError::Failed(format!("sew: the faces do not close: {e}")))?;Body::new(solid)diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsindex 30144e1f88..b65c41a559 100644--- a/crates/kernel/src/tests.rs+++ b/crates/kernel/src/tests.rs@@ -318,7 +318,7 @@ fn planar_booleans_with_coincident_faces() {}#[test]-fn stepped_logo_join_never_moves_faces_to_hide_an_edge_pinch() {+fn connected_logo_join_preserves_exact_faces_at_edge_contact() {let mut body = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 10.0)).unwrap();for (i, (lo, hi)) in[(Vec3::new(0.0, 0.0, 10.0), Vec3::new(10.0, 10.0, 20.0)), (Vec3::new(-10.0, 0.0, 10.0), Vec3::new(0.0, 10.0, 20.0))].into_iter().enumerate()@@ -336,8 +336,21 @@ fn stepped_logo_join_never_moves_faces_to_hide_an_edge_pinch() {assert!(m.bbox.max.dist(Vec3::new(10.0, 20.0, 20.0)) < 1e-9);}let tool = box_solid(Vec3::new(-10.0, 10.0, 10.0), Vec3::new(0.0, 20.0, 20.0)).unwrap();- let error = boolean(&body, &tool, BoolOp::Union).unwrap_err();- assert!(error.to_string().contains("zero-thickness edge contact"), "{error}");+ let logo = boolean(&body, &tool, BoolOp::Union).unwrap().unwrap();+ assert!(logo.validity().is_empty());+ let m = measure(&logo).unwrap();+ assert!((m.volume - 5000.0).abs() < 1e-6);+ assert!(m.bbox.min.dist(Vec3::new(-10.0, 0.0, 0.0)) < 1e-9);+ assert!(m.bbox.max.dist(Vec3::new(10.0, 20.0, 20.0)) < 1e-9);+ let tops =+ logo.faces(0.01).unwrap().iter().filter(|f| f.plane_normal.is_some_and(|n| n.z > 0.999999) && (f.centroid.z - 20.0).abs() < 1e-9).count();+ assert_eq!(tops, 1);+ let text = step_export(&[&logo], "SolveCraft").unwrap();+ let imported = step_import(&text).unwrap();+ assert_eq!(imported.bodies.len(), 1);+ let roundtrip = &imported.bodies.first().unwrap().body;+ assert!(roundtrip.validity().is_empty());+ assert!((measure(roundtrip).unwrap().volume - 5000.0).abs() < 1e-6);// An intentional overlap removes the pinch without any automatic displacement.let overlap = box_solid(Vec3::new(-10.0, 10.0, 10.0), Vec3::new(0.1, 20.0, 20.0)).unwrap();let joined = boolean(&body, &overlap, BoolOp::Union).unwrap().unwrap();