SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 139/509: kernel: sew assembles a schema 4 record and SMLib builds the body
jyvikoa1b9d92d2296
diff --git a/crates/kernel/src/sew.rs b/crates/kernel/src/sew.rsindex 36e46ba6f2..a5caccbe7d 100644--- a/crates/kernel/src/sew.rs+++ b/crates/kernel/src/sew.rs@@ -4,15 +4,20 @@//! Bézier chains). Vertices and edges at the same places are shared, so the faces close into//! one shell without booleans — for solids whose faces are known exactly, such as folded//! sheet metal.+//!+//! The faces are assembled into a schema 4 record with exactly the topology the descriptions+//! give ([`assemble`]: shared edges, shells, regions, canonical order), which SMLib builds the+//! body from. No tolerance stitching is involved: two sheets of material meeting along one+//! geometric edge keep an edge each.use std::collections::HashMap;use std::sync::Arc;-use mt::builder;+use solidcraft_geom::brep::eval::SurfaceEval;+use solidcraft_geom::brep::{self as b, Curve2, pcurve};use solidcraft_geom::{Ring, Vec3};-use truck_modeling as mt;-use crate::body::{Body, Solid, p3, v3};+use crate::body::Body;use crate::{KernelError, Result, guard};/// Most control points of one Bézier chain edge.@@ -219,65 +224,295 @@ fn welded(faces: &[FaceSpec]) -> Option<Vec<FaceSpec>> {)}+fn arr(p: Vec3) -> [f64; 3] {+ [p.x, p.y, p.z]+}++fn v3(p: [f64; 3]) -> Vec3 {+ Vec3::new(p[0], p[1], p[2])+}++/// The vertices and edges of the faces being sewn, shared by key.#[derive(Default)]-struct Cache {+struct Builder {+ vertices: Vec<[f64; 3]>,/// Vertices by point and fan (see [`corner_fans`]).- verts: HashMap<(Key, usize), mt::Vertex>,- edges: HashMap<(Key, usize, Key, usize, Option<Key>, usize), mt::Edge>,+ verts: HashMap<(Key, usize), u32>,+ edges: Vec<PartEdge>,+ by_key: HashMap<(Key, usize, Key, usize, Option<Key>, usize), u32>,}-impl Cache {- fn vertex(&mut self, p: Vec3, fan: usize) -> mt::Vertex {- self.verts.entry((key(p), fan)).or_insert_with(|| builder::vertex(p3(p))).clone()+impl Builder {+ fn vertex(&mut self, p: Vec3, fan: usize) -> Result<u32> {+ if let Some(v) = self.verts.get(&(key(p), fan)) {+ return Ok(*v);+ }+ let v = u32::try_from(self.vertices.len()).map_err(|_| KernelError::Invalid("sew: vertex budget exceeded".into()))?;+ self.vertices.push(arr(p));+ self.verts.insert((key(p), fan), v);+ Ok(v)+ }++ fn point(&self, v: u32) -> Vec3 {+ self.vertices.get(v as usize).copied().map_or(Vec3::ZERO, v3)}- /// The edge `e` on boundary sheet `sheet`, between the vertices of fans `fans` at its ends.- fn edge(&mut self, e: &EdgeSpec, sheet: usize, (fa, fb): (usize, usize)) -> Result<mt::Edge> {++ /// Where the vertex at `p` is (the first point met in its cell), `p` itself before any.+ fn at(&self, p: Vec3) -> Vec3 {+ self.verts.get(&(key(p), 0)).map_or(p, |v| self.point(*v))+ }++ /// The edge `e` on boundary sheet `sheet`, between the vertices of fans `fans` at its ends,+ /// and whether `e` runs along it.+ fn edge(&mut self, e: &EdgeSpec, sheet: usize, (fa, fb): (usize, usize)) -> Result<(u32, bool)> {let (a, b) = e.ends();let mid = e.mid_key();let (ka, kb) = (key(a), key(b));- if let Some(found) = self.edges.get(&(ka, fa, kb, fb, mid, sheet)) {- return Ok(found.clone());+ if let Some(found) = self.by_key.get(&(ka, fa, kb, fb, mid, sheet)) {+ return Ok((*found, true));}- if let Some(found) = self.edges.get(&(kb, fb, ka, fa, mid, sheet)) {- return Ok(found.inverse());+ if let Some(found) = self.by_key.get(&(kb, fb, ka, fa, mid, sheet)) {+ return Ok((*found, false));}- let (va, vb) = (self.vertex(a, fa), self.vertex(b, fb));- let made = match e {- EdgeSpec::Line { .. } => builder::line(&va, &vb),- EdgeSpec::Arc { mid, .. } => arc_edge(&va, &vb, *mid),+ let (va, vb) = (self.vertex(a, fa)?, self.vertex(b, fb)?);+ let (pa, pb) = (self.point(va), self.point(vb));+ let (curve, interval) = match e {+ EdgeSpec::Line { .. } => (b::Curve::Line { start: arr(pa), end: arr(pb) }, [0.0, 1.0]),+ EdgeSpec::Arc { mid, .. } => arc_curve(pa, pb, *mid)?,EdgeSpec::Chain { .. } => {- let curve = self.chain(e)?;- mt::Edge::try_new(&va, &vb, mt::Curve::BSplineCurve(curve)).map_err(|e| KernelError::Failed(format!("sew: chain edge: {e}")))?+ let (knots, points) = chain(e, pa, pb)?;+ let n = knots.last().copied().unwrap_or(1.0);+ (b::Curve::Spline { knots, points }, [0.0, n])}};- self.edges.insert((ka, fa, kb, fb, mid, sheet), made.clone());- Ok(made)+ let id = u32::try_from(self.edges.len()).map_err(|_| KernelError::Invalid("sew: edge budget exceeded".into()))?;+ self.edges.push(PartEdge { curve, interval, vertices: [va, vb] });+ self.by_key.insert((ka, fa, kb, fb, mid, sheet), id);+ Ok((id, true))}- /// A Bézier chain as a B-spline of its degree (inner knots as many times as the degree)- /// ending on the shared vertices.- fn chain(&mut self, e: &EdgeSpec) -> Result<mt::BSplineCurve<mt::Point3>> {- let EdgeSpec::Chain { degree, ctrl } = e else { return Err(KernelError::Invalid("sew: not a Bézier chain".into())) };- if !e.valid() {- return Err(KernelError::Invalid("sew: a Bézier chain needs degree·n + 1 finite control points".into()));+ /// The surface of face `fi` and whether its natural normal points outward; on a ruled face,+ /// each use's exact pcurve is filled in.+ fn surface(&self, fi: usize, f: &FaceSpec, loops: &mut [Vec<PartUse>], tol: f64) -> Result<(b::Surface, bool)> {+ let fail = |m: &str| KernelError::Invalid(format!("sew: face {fi}: {m}"));+ match &f.surface {+ SurfSpec::Plane => plane_of(f).map(|s| (s, true)).ok_or_else(|| fail("cannot attach a plane to a wire that is not on one plane")),+ SurfSpec::Revolved { a, b, axis_origin, axis, angle: _ } => {+ let s = revolved(*a, *b, *axis_origin, *axis).map_err(|m| fail(&m))?;+ Ok((s.clone(), outward(&s, f.probe)))+ }+ SurfSpec::Extruded { a, b, mid, dir } => {+ let c = circumcentre(*a, *mid, *b).ok_or_else(|| fail("an arc through points in line"))?;+ let n = (*mid - *a).cross(*b - *mid).normalized().ok_or_else(|| fail("an arc through points in line"))?;+ let z = dir.normalized().ok_or_else(|| fail("an extrusion of no length"))?;+ if n.cross(z).len() > 1e-9 {+ return Err(fail("not supported yet: an arc wall extruded askew to its arc's axis"));+ }+ let x = (*a - c).normalized().ok_or_else(|| fail("an arc of no radius"))?;+ let y = z.cross(x).normalized().ok_or_else(|| fail("an arc of no radius"))?;+ let frame = b::Frame { origin: arr(c), x_axis: arr(x), y_axis: arr(y) };+ let s = b::Surface::Cylinder { frame, radius: a.dist(c) };+ Ok((s.clone(), outward(&s, f.probe)))+ }+ SurfSpec::Ruled { a, b } => {+ let (ka, pa) = chain(a, self.at(a.ends().0), self.at(a.ends().1))?;+ let (kb, pb) = chain(b, self.at(b.ends().0), self.at(b.ends().1))?;+ let (EdgeSpec::Chain { degree: da, .. }, EdgeSpec::Chain { degree: db, .. }) = (a, b) else {+ return Err(KernelError::Invalid("sew: not a Bézier chain".into()));+ };+ if da != db || pa.len() != pb.len() || ka != kb {+ return Err(KernelError::Invalid("sew: ruled chains differ in pieces".into()));+ }+ let points = pa.iter().zip(&pb).map(|(p, q)| vec![*p, *q]).collect();+ let s = b::Surface::Spline { u_knots: ka.clone(), v_knots: vec![0.0, 0.0, 1.0, 1.0], points };+ for u in loops.iter_mut().flatten() {+ let e = self.edges.get(u.edge as usize).ok_or_else(|| fail("edge"))?;+ u.given = Some(ruled_pcurve(e, *da, &ka, [&pa, &pb], tol).ok_or_else(|| fail("not supported yet: an edge across a ruled face"))?);+ }+ Ok((s.clone(), outward(&s, f.probe)))+ }}- let d = *degree;- let n = (ctrl.len() - 1) / d;- let mut knots = vec![0.0; d + 1];- for i in 1..n {- knots.extend(std::iter::repeat_n(i as f64, d));+ }+}++/// A Bézier chain as a B-spline of its degree (inner knots as many times as the degree) ending on+/// `a` and `b` (its vertices).+fn chain(e: &EdgeSpec, a: Vec3, b: Vec3) -> Result<(Vec<f64>, Vec<[f64; 3]>)> {+ let EdgeSpec::Chain { degree, ctrl } = e else { return Err(KernelError::Invalid("sew: not a Bézier chain".into())) };+ if !e.valid() {+ return Err(KernelError::Invalid("sew: a Bézier chain needs degree·n + 1 finite control points".into()));+ }+ let d = *degree;+ let n = (ctrl.len() - 1) / d;+ let mut knots = vec![0.0; d + 1];+ for i in 1..n {+ knots.extend(std::iter::repeat_n(i as f64, d));+ }+ knots.extend(std::iter::repeat_n(n as f64, d + 1));+ let mut pts: Vec<[f64; 3]> = ctrl.iter().map(|p| arr(*p)).collect();+ if let Some(first) = pts.first_mut() {+ *first = arr(a);+ }+ if let Some(last) = pts.last_mut() {+ *last = arr(b);+ }+ Ok((knots, pts))+}++/// The exact pcurve of an edge of a ruled face `(1 − v)·A(u) + v·B(u)` (`rows` its chains A and+/// B, of `degree` on `knots`): a chain lying on A or B either way round is `(u(t), 0 or 1)` with+/// `u` affine in its parameter, and a line from a corner of A to the corner of B at the same `u`+/// is a ruling, `(u, t)`. `None` for any other edge.+fn ruled_pcurve(e: &PartEdge, degree: usize, knots: &[f64], rows: [&[[f64; 3]]; 2], tol: f64) -> Option<Curve2> {+ let near = |p: &[f64; 3], q: &[f64; 3]| v3(*p).dist(v3(*q)) <= tol;+ let n = *knots.last()?;+ match &e.curve {+ b::Curve::Spline { knots: ek, points } if ek.as_slice() == knots => {+ for (v, row) in [0.0, 1.0].into_iter().zip(rows) {+ if row.len() != points.len() {+ continue;+ }+ let forward = points.iter().zip(row).all(|(p, q)| near(p, q));+ let backward = points.iter().zip(row.iter().rev()).all(|(p, q)| near(p, q));+ if forward || backward {+ // Control points at the Greville abscissae give the affine u(t) exactly.+ let points = (0..points.len())+ .map(|i| {+ let xi = (1..=degree).map(|r| knots.get(i + r).copied().unwrap_or(0.0)).sum::<f64>() / degree as f64;+ [if forward { xi } else { n - xi }, v]+ })+ .collect();+ return Some(Curve2::Spline { knots: knots.to_vec(), points });+ }+ }+ None}- knots.extend(std::iter::repeat_n(n as f64, d + 1));- let mut pts: Vec<mt::Point3> = ctrl.iter().map(|p| p3(*p)).collect();- let (a, b) = e.ends();- if let Some(first) = pts.first_mut() {- *first = self.vertex(a, 0).point();+ b::Curve::Line { start, end } => {+ let corner = |p: &[f64; 3]| -> Option<[f64; 2]> {+ for (v, row) in [0.0, 1.0].into_iter().zip(rows) {+ if row.first().is_some_and(|q| near(p, q)) {+ return Some([0.0, v]);+ }+ if row.last().is_some_and(|q| near(p, q)) {+ return Some([n, v]);+ }+ }+ None+ };+ let (s, z) = (corner(start)?, corner(end)?);+ (s[0] == z[0] && s[1] != z[1]).then(|| Curve2::Spline { knots: vec![0.0, 0.0, 1.0, 1.0], points: vec![s, z] })}- if let Some(last) = pts.last_mut() {- *last = self.vertex(b, 0).point();+ _ => None,+ }+}++/// The plane of a face's boundary: through the mean of its control points (arcs' midpoints and+/// chains' control points included), its normal the one the outer loop runs counter-clockwise+/// about, summed about that mean (about a far origin the rounding of the sum grows with the+/// square of the distance, and turns a thin face's short normal). None when the boundary has no+/// area or leaves the plane by more than 10⁻⁶ mm.+fn plane_of(f: &FaceSpec) -> Option<b::Surface> {+ let points = |e: &EdgeSpec| -> Vec<Vec3> {+ match e {+ EdgeSpec::Line { a, b } => vec![*a, *b],+ EdgeSpec::Arc { a, b, mid } => vec![*a, *mid, *b],+ EdgeSpec::Chain { ctrl, .. } => ctrl.to_vec(),}- mt::BSplineCurve::try_new(mt::KnotVec::from(knots), pts).map_err(|e| KernelError::Failed(format!("sew: chain curve: {e}")))+ };+ let all: Vec<Vec3> = f.loops.iter().flatten().flat_map(points).collect();+ let mean = all.iter().fold(Vec3::ZERO, |s, p| s + *p) * (1.0 / all.len().max(1) as f64);+ let n = f.loops.first()?.iter().fold(Vec3::ZERO, |n, e| {+ let p = points(e);+ p.iter().zip(p.iter().skip(1)).fold(n, |n, (a, b)| n + (*a - mean).cross(*b - mean))+ });+ let n = n.normalized()?;+ if !mean.is_finite() || all.iter().any(|p| ((*p - mean).dot(n)).abs() > 1e-6) {+ return None;+ }+ let t = if n.x.abs() < 0.9 { Vec3::X } else { Vec3::Y };+ let u = (t - n * t.dot(n)).normalized()?;+ let v = n.cross(u).normalized()?;+ Some(b::Surface::Plane { origin: arr(mean), u_axis: arr(u), v_axis: arr(v) })+}++/// The surface the line `a`→`b` sweeps turning about the axis: a cylinder (the line along the+/// axis), a plane (square to it) or a cone (in a plane through it). A line skew to the axis+/// sweeps a hyperboloid, which has no exact form here.+fn revolved(a: Vec3, b: Vec3, origin: Vec3, axis: Vec3) -> std::result::Result<b::Surface, String> {+ let k = axis.normalized().ok_or("the axis has no direction")?;+ let foot = |p: Vec3| origin + k * (p - origin).dot(k);+ let (ra, rb) = (a - foot(a), b - foot(b));+ let along = (b - a).dot(k);+ let scale = ra.len().max(rb.len());+ if !(scale > 1e-12) {+ return Err("a line along the axis sweeps no surface".into());}+ if ra.cross(rb).len() > 1e-9 * scale * scale || ra.dot(rb) < 0.0 {+ return Err("not supported yet: a face revolved from a line skew to its axis or across it".into());+ }+ let x = if ra.len() >= rb.len() { ra } else { rb }.normalized().ok_or("a line on the axis")?;+ let frame = |z: Vec3| -> std::result::Result<b::Frame, String> {+ let y = z.cross(x).normalized().ok_or("frame")?;+ Ok(b::Frame { origin: arr(foot(a)), x_axis: arr(x), y_axis: arr(y) })+ };+ if along.abs() <= 1e-12 * (b - a).len() {+ let y = k.cross(x).normalized().ok_or("frame")?;+ return Ok(b::Surface::Plane { origin: arr(foot(a)), u_axis: arr(x), v_axis: arr(y) });+ }+ let slope = (rb.len() - ra.len()) / along;+ if slope.abs() <= 1e-12 {+ return Ok(b::Surface::Cylinder { frame: frame(k)?, radius: ra.len() });+ }+ // The cone widens along its z.+ let z = if slope > 0.0 { k } else { k * -1.0 };+ Ok(b::Surface::Cone { frame: frame(z)?, radius_at_origin: ra.len(), half_angle: slope.abs().atan() })+}++/// Whether the surface's natural normal at the probe point faces the probe's outward+/// direction (true without a probe, or where the point cannot be found on the surface).+fn outward(surface: &b::Surface, probe: Option<(Vec3, Vec3)>) -> bool {+ let Some((p, out)) = probe else { return true };+ let Ok(s) = SurfaceEval::new(surface) else { return true };+ let Some((_, su, sv)) = s.project(p, None, f64::INFINITY).and_then(|uv| s.derivs(uv[0], uv[1])) else { return true };+ su.cross(sv).dot(out) >= 0.0+}++/// Below this sagitta-to-half-chord ratio an arc is the exact rational quadratic from its ends+/// and midpoint, rather than a circle about its circumcentre: the centre of an arc 12 mm long+/// with a 0.08 µm sagitta (a 225 m radius) is found to about 1e-6 mm, and the circle about it+/// would miss the arc's own ends by as much.+const FLAT_ARC: f64 = 1e-2;++/// The arc from `a` to `b` through `mid` and its interval: a circle (angle from `a`), or for a+/// flat arc one rational quadratic: the middle control point on the line from the chord's+/// midpoint through `mid`, 2 / (1 − t²) as far, weight (1 − t²) / (1 + t²), where t is the+/// sagitta over the half chord.+fn arc_curve(a: Vec3, b: Vec3, mid: Vec3) -> Result<(b::Curve, [f64; 2])> {+ let fail = || KernelError::Invalid("sew: an arc through points in line".into());+ let m = (a + b) * 0.5;+ let half = a.dist(b) / 2.0;+ let chord = (b - a).normalized().ok_or_else(fail)?;+ let bow = mid - m;+ let t = bow.len() / half;+ if half > 1e-9 && t < FLAT_ARC && bow.dot(chord).abs() <= 1e-9 * half.max(1.0) {+ let w = (1.0 - t * t) / (1.0 + t * t);+ let apex = m + bow * (2.0 / (1.0 - t * t));+ let homogeneous = vec![[a.x, a.y, a.z, 1.0], [apex.x * w, apex.y * w, apex.z * w, w], [b.x, b.y, b.z, 1.0]];+ return Ok((b::Curve::RationalSpline { knots: vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0], homogeneous }, [0.0, 1.0]));+ }+ let c = circumcentre(a, mid, b).ok_or_else(fail)?;+ let n = (mid - a).cross(b - mid).normalized().ok_or_else(fail)?;+ let x = (a - c).normalized().ok_or_else(fail)?;+ let y = n.cross(x).normalized().ok_or_else(fail)?;+ let angle = |p: Vec3| {+ let r = p - c;+ r.dot(y).atan2(r.dot(x)).rem_euclid(std::f64::consts::TAU)+ };+ let end = angle(b);+ if !(end > 0.0) {+ return Err(fail());+ }+ Ok((b::Curve::Circle { frame: b::Frame { origin: arr(c), x_axis: arr(x), y_axis: arr(y) }, radius: a.dist(c) }, [0.0, end]))}/// Sew the faces into a closed solid.@@ -526,7 +761,7 @@ type Corner = (usize, usize, usize);/// Where the faces meeting at a point form several fans, joined to each other by no edge (a hole/// touching its face's outline at one point; two caps touching at a corner), the fan each corner/// there is in, from 1 for every fan past the first (corners not listed are in fan 0). Each fan-/// gets its own vertex, so that a face's loops share no vertex (truck's faces need that) and+/// gets its own vertex, so that a face's loops share no vertex and/// every vertex of the solid is a manifold one.fn corner_fans(faces: &[FaceSpec], sheets: &HashMap<EdgeUse, usize>) -> HashMap<Corner, usize> {type EdgeId = (Key, Key, Option<Key>, usize);@@ -593,181 +828,132 @@ fn corner_fans(faces: &[FaceSpec], sheets: &HashMap<EdgeUse, usize>) -> HashMap<out}-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);+/// The parent of `i` in a union-find forest, with path halving.+fn root(parent: &mut [usize], mut i: usize) -> usize {+ while let Some(&p) = parent.get(i) {+ if p == i {+ break;+ }+ let up = parent.get(p).copied().unwrap_or(p);+ if let Some(slot) = parent.get_mut(i) {+ *slot = up;}+ i = p;}- 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)));- }- }+ i+}++fn join(parent: &mut [usize], a: usize, b: usize) {+ let (a, b) = (root(parent, a), root(parent, b));+ if let Some(slot) = parent.get_mut(a) {+ *slot = b;+ }+}++/// The faces using each edge, a face once per use.+fn edge_users(edges: usize, faces: &[PartFace]) -> Result<Vec<Vec<usize>>> {+ let mut users: Vec<Vec<usize>> = vec![Vec::new(); edges];+ for (fi, f) in faces.iter().enumerate() {+ for u in f.loops.iter().flatten() {+ users.get_mut(u.edge as usize).ok_or_else(|| KernelError::Failed("sew: edge reference".into()))?.push(fi);}}- seen.len() == faces.len()+ Ok(users)}-/// Keep disconnected closed boundaries as distinct shells, preserving orientation.-fn closed_components(faces: Vec<mt::Face>) -> Result<Vec<mt::Shell>> {- const MAX_EDGE_USES: usize = 500_000;- const MAX_COMPONENTS: usize = 1024;- let fail = |s: &str| KernelError::Invalid(format!("sew: {s}"));- let mut by_edge: HashMap<mt::EdgeID, Vec<usize>> = HashMap::new();- let mut edge_uses = 0usize;- for (i, face) in faces.iter().enumerate() {- for edge in face.edge_iter() {- edge_uses = edge_uses.saturating_add(1);- if edge_uses > MAX_EDGE_USES {- return Err(fail("edge budget exceeded"));- }- let uses = by_edge.entry(edge.id()).or_default();- if uses.len() >= 2 {- return Err(fail("nonmanifold edge contact"));+/// The connected groups of faces (joined through shared edges), each ascending, and each face's+/// group.+fn components(faces: usize, users: &[Vec<usize>]) -> (Vec<Vec<usize>>, Vec<usize>) {+ let mut parent: Vec<usize> = (0..faces).collect();+ for u in users {+ for w in u.windows(2) {+ if let [a, b] = w {+ join(&mut parent, *a, *b);}- uses.push(i);}}- if by_edge.values().any(|uses| uses.len() != 2) {- return Err(fail("the faces do not close"));- }- let mut seen = vec![false; faces.len()];- let mut vertices = HashMap::new();- let mut components = Vec::new();- for first in 0..faces.len() {- if seen.get(first).copied().unwrap_or(true) {- continue;+ let mut group_of_root: HashMap<usize, usize> = HashMap::new();+ let mut groups: Vec<Vec<usize>> = Vec::new();+ let mut of = vec![0; faces];+ for f in 0..faces {+ let r = root(&mut parent, f);+ let next = groups.len();+ let g = *group_of_root.entry(r).or_insert(next);+ if g == next {+ groups.push(Vec::new());}- if components.len() >= MAX_COMPONENTS {- return Err(fail("component budget exceeded"));- }- let component = components.len();- let mut todo = vec![first];- if let Some(slot) = seen.get_mut(first) {- *slot = true;- }- let mut indices = Vec::new();- while let Some(i) = todo.pop() {- let face = faces.get(i).ok_or_else(|| fail("missing component face"))?;- indices.push(i);- for vertex in face.vertex_iter() {- if vertices.insert(vertex.id(), component).is_some_and(|previous| previous != component) {- return Err(fail("bodies touch only at a vertex"));- }- }- for edge in face.edge_iter() {- let adjacent = by_edge.get(&edge.id()).ok_or_else(|| fail("missing component edge"))?;- for j in adjacent {- let slot = seen.get_mut(*j).ok_or_else(|| fail("missing adjacent face"))?;- if !*slot {- *slot = true;- todo.push(*j);- }- }- }+ if let (Some(group), Some(slot)) = (groups.get_mut(g), of.get_mut(f)) {+ group.push(f);+ *slot = g;}- indices.sort_unstable();- let component_faces =- indices.into_iter().map(|i| faces.get(i).cloned().ok_or_else(|| fail("missing component face"))).collect::<Result<Vec<_>>>()?;- components.push(component_faces.into());}- Ok(components)+ (groups, of)}-/// 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;+/// A contact's edge sheets can end in separate vertex fans: each fan gets its own vertex at the+/// same point, so that every vertex of the boundary is a manifold one. A fan is the faces round+/// the vertex joined through the edges that end there.+fn split_vertex_fans(vertices: &mut Vec<[f64; 3]>, edges: &mut [PartEdge], faces: &[PartFace]) -> Result<()> {+ let users = edge_users(edges.len(), faces)?;+ let mut at: Vec<Vec<usize>> = vec![Vec::new(); vertices.len()];+ for (e, edge) in edges.iter().enumerate() {+ for v in edge.vertices {+ if let Some(list) = at.get_mut(v as usize)+ && list.last() != Some(&e)+ {+ list.push(e);}- 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)));- }- }+ }+ }+ for (v, incident) in at.iter().enumerate() {+ // Faces round the vertex, joined by each incident edge.+ let mut parent: HashMap<usize, usize> = HashMap::new();+ let mut local: Vec<usize> = Vec::new();+ let mut index = |f: usize, local: &mut Vec<usize>| -> usize {+ *parent.entry(f).or_insert_with(|| {+ local.push(local.len());+ local.len() - 1+ })+ };+ let mut edge_face = Vec::with_capacity(incident.len());+ for &e in incident {+ let fs: Vec<usize> = users.get(e).map(|u| u.iter().map(|f| index(*f, &mut local)).collect()).unwrap_or_default();+ for w in fs.windows(2) {+ if let [a, b] = w {+ join(&mut local, *a, *b);}}- 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());+ edge_face.push((e, fs.first().copied()));+ }+ let mut fan_of_root: HashMap<usize, u32> = HashMap::new();+ for (e, f) in edge_face {+ let Some(f) = f else { continue };+ let r = root(&mut local, f);+ let fan = match fan_of_root.get(&r) {+ Some(fan) => *fan,+ None => {+ // The first fan keeps the vertex; each other gets a copy.+ let fan = if fan_of_root.is_empty() {+ v as u32+ } else {+ let p = vertices.get(v).copied().ok_or_else(|| KernelError::Failed("sew: vertex".into()))?;+ vertices.push(p);+ u32::try_from(vertices.len() - 1).map_err(|_| KernelError::Invalid("sew: vertex budget exceeded".into()))?+ };+ fan_of_root.insert(r, fan);+ fan+ }+ };+ if let Some(edge) = edges.get_mut(e) {+ for end in &mut edge.vertices {+ if *end as usize == v {+ *end = fan;+ }}}}}- 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()+ Ok(())}fn sew_impl(faces: &[FaceSpec], touching: bool, sources: Option<&[Option<crate::FaceSource>]>) -> Result<(Body, Option<Vec<usize>>)> {@@ -785,173 +971,457 @@ fn sew_impl(faces: &[FaceSpec], touching: bool, sources: Option<&[Option<crate::}let welded = welded(faces);let faces = welded.as_deref().unwrap_or(faces);+ let (mut lo, mut hi) =+ (Vec3::new(f64::INFINITY, f64::INFINITY, f64::INFINITY), Vec3::new(f64::NEG_INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY));for f in faces {for l in &f.loops {+ if l.is_empty() {+ return Err(KernelError::Invalid("sew: an empty loop".into()));+ }for e in l {let (a, b) = e.ends();- // Ends that weld to one vertex would make truck panic on a zero-length edge (#268).+ // Ends that weld to one vertex make an edge of no length.if !e.valid() || !a.is_finite() || !b.is_finite() || a.dist(b) < 1e-9 || key(a) == key(b) {return Err(KernelError::Invalid("sew: a degenerate edge".into()));}+ lo = lo.min(a).min(b);+ hi = hi.max(a).max(b);}}}+ // The record's working tolerance: 10⁻⁶ of the solid's size, at least 10⁻⁵ mm (the tolerance+ // of a fitted face, `fill::face_tolerance`).+ let tol = (lo.dist(hi) * 1e-6).max(1e-5);guard("sew", || {// Separate fans at a point only where contact is expected (as for edge sheets); a plain// sew refuses bodies touching at a vertex.let (sheets, fans) = if touching { touching_sheets(faces)? } else { (HashMap::new(), HashMap::new()) };let fan = |c: Corner| fans.get(&c).copied().unwrap_or(0);- let mut cache = Cache::default();- let mut out: Vec<mt::Face> = Vec::with_capacity(faces.len());+ let mut built = Builder::default();+ let mut parts: Vec<Vec<Vec<PartUse>>> = Vec::with_capacity(faces.len());for (fi, f) in faces.iter().enumerate() {- let wires: Vec<mt::Wire> = f- .loops- .iter()- .enumerate()- .map(|(li, l)| {- let n = l.len().max(1);- l.iter()- .enumerate()- .map(|(ei, e)| {- cache.edge(e, sheets.get(&(fi, li, ei)).copied().unwrap_or(0), (fan((fi, li, ei)), fan((fi, li, (ei + 1) % n))))- })- .collect::<Result<Vec<_>>>()- .map(Into::into)- })- .collect::<Result<_>>()?;- let face = match &f.surface {- SurfSpec::Plane => match builder::try_attach_plane(&wires) {- Ok(face) => face,- // truck's fit loses thin faces away from the origin: see `plane_about_the_mean`.- Err(e) => {- let plane = plane_about_the_mean(&wires).ok_or_else(|| KernelError::Failed(format!("sew: face {fi}: {e}")))?;- mt::Face::try_new(wires, mt::Surface::Plane(plane)).map_err(|e| KernelError::Failed(format!("sew: face {fi}: {e}")))?- }- },- SurfSpec::Revolved { a, b, axis_origin, axis, angle } => {- let k = axis.normalized().ok_or_else(|| KernelError::Invalid("sew: axis".into()))?;- let (va, vb) = (builder::vertex(p3(*a)), builder::vertex(p3(*b)));- let swept: mt::Shell = builder::rsweep(&builder::line(&va, &vb), p3(*axis_origin), v3(k), mt::Rad(*angle));- let tmp = swept.face_iter().next().cloned().ok_or_else(|| KernelError::Failed("sew: revolved surface".into()))?;- curved(tmp.oriented_surface(), wires, f.probe, fi)?+ let mut loops = Vec::with_capacity(f.loops.len());+ for (li, l) in f.loops.iter().enumerate() {+ let n = l.len().max(1);+ let mut uses = Vec::with_capacity(l.len());+ for (ei, e) in l.iter().enumerate() {+ let sheet = sheets.get(&(fi, li, ei)).copied().unwrap_or(0);+ let (edge, forward) = built.edge(e, sheet, (fan((fi, li, ei)), fan((fi, li, (ei + 1) % n))))?;+ uses.push(PartUse { edge, forward, given: None });}- SurfSpec::Extruded { a, b, mid, dir } => {- let (va, vb) = (builder::vertex(p3(*a)), builder::vertex(p3(*b)));- let tmp: mt::Face = builder::tsweep(&arc_edge(&va, &vb, *mid), v3(*dir));- curved(tmp.oriented_surface(), wires, f.probe, fi)?- }- SurfSpec::Ruled { a, b } => {- let (ca, cb) = (cache.chain(a)?, cache.chain(b)?);- if ca.degree() != cb.degree() || ca.control_points().len() != cb.control_points().len() {- return Err(KernelError::Invalid("sew: ruled chains differ in pieces".into()));- }- let surface = mt::Surface::BSplineSurface(mt::BSplineSurface::homotopy(ca, cb));- curved(surface, wires, f.probe, fi)?- }- };- out.push(face);+ loops.push(uses);+ }+ parts.push(loops);}- let source_ids: HashMap<_, _> = out- .iter()- .enumerate()- .filter_map(|(i, f)| sources.and_then(|s| s.get(i)).and_then(Option::as_ref).map(|s| (f.id(), (f.orientation(), s))))- .collect();- if !sheets.is_empty() && !faces_connected(&out) {+ let mut out: Vec<PartFace> = Vec::with_capacity(faces.len());+ for (fi, (f, mut loops)) in faces.iter().zip(parts).enumerate() {+ let (surface, forward) = built.surface(fi, f, &mut loops, tol)?;+ out.push(PartFace { surface, forward, loops });+ }+ let Builder { mut vertices, mut edges, .. } = built;+ let users = edge_users(edges.len(), &out)?;+ if !sheets.is_empty() && components(out.len(), &users).0.len() > 1 {return Err(KernelError::Invalid("sew: bodies touch only along an edge".into()));}if !sheets.is_empty() {- out = split_vertex_fans(out)?;- }- // Faces keep their identity into the solid (grouped into shells) and the body.- let built: HashMap<mt::FaceID, usize> = out.iter().enumerate().map(|(i, f)| (f.id(), i)).collect();- let shells = closed_components(out)?;- let solid = Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("sew: the faces do not close: {e}")))?;- let from = solid.face_iter().map(|f| built.get(&f.id()).copied()).collect();- let body = Body::new(solid)?;- let mapped =- body.solid.face_iter().map(|f| source_ids.get(&f.id()).filter(|(o, _)| *o == f.orientation()).map(|(_, s)| (*s).clone())).collect();- Ok((body.with_face_sources(sources.map(|_| std::sync::Arc::new(mapped))), from))+ split_vertex_fans(&mut vertices, &mut edges, &out)?;+ }+ // Each edge bounds two faces, and separate bodies share no vertex.+ if users.iter().any(|u| u.len() > 2) {+ return Err(KernelError::Invalid("sew: nonmanifold edge contact".into()));+ }+ if users.iter().any(|u| u.len() != 2) {+ return Err(KernelError::Invalid("sew: the faces do not close".into()));+ }+ let (groups, group_of) = components(out.len(), &users);+ if groups.len() > b::MAX_SHELLS {+ return Err(KernelError::Invalid("sew: component budget exceeded".into()));+ }+ let mut vertex_group: Vec<Option<usize>> = vec![None; vertices.len()];+ for (e, edge) in edges.iter().enumerate() {+ let Some(&g) = users.get(e).and_then(|u| u.first()).and_then(|f| group_of.get(*f)) else { continue };+ for v in edge.vertices {+ let slot = vertex_group.get_mut(v as usize).ok_or_else(|| KernelError::Failed("sew: vertex reference".into()))?;+ if slot.is_some_and(|other| other != g) {+ return Err(KernelError::Invalid("sew: bodies touch only at a vertex".into()));+ }+ *slot = Some(g);+ }+ }+ let made = assemble(Parts { vertices, edges, faces: out, tolerance: tol }, true)?;+ let smlib = solidcraft_smlib::Brep::from_record(&made.brep, true).map_err(|e| KernelError::Failed(format!("sew: SMLib: {e}")))?;+ let (body, order) = crate::native::body_from_smlib_ordered(&smlib)?;+ // The face of `faces` each face of the body was built from: record face `c` is SMLib's+ // face `c`, which the order places in the body.+ let from = order.and_then(|o| {+ let mut from = vec![None; body.face_count()];+ for (spec, &c) in made.faces.iter().enumerate() {+ let j = if o.faces.is_empty() { c } else { *o.faces.get(c)? };+ *from.get_mut(j)? = Some(spec);+ }+ from.into_iter().collect::<Option<Vec<usize>>>()+ });+ let mapped = sources.map(|s| {+ let mapped: Vec<Option<crate::FaceSource>> = match &from {+ Some(from) => from.iter().map(|i| s.get(*i).cloned().flatten()).collect(),+ None => vec![None; body.face_count()],+ };+ Arc::new(mapped)+ });+ Ok((body.with_face_sources(mapped), from))})}-/// Below this sagitta-to-half-chord ratio an arc is built as its exact rational quadratic from-/// its ends and midpoint. truck's three-point arc (circumcentre, then a turn about it) misses-/// its own ends on very flat arcs: one 12 mm long with a 0.08 µm sagitta (a 225 m radius) ends-/// about 1e-6 mm off its vertex, and a planar face holding it far from the origin could not be-/// given a plane (its wire's points no longer closed).-const FLAT_ARC: f64 = 1e-2;+/// One face to [`assemble`].+pub(crate) struct PartFace {+ pub surface: b::Surface,+ /// The surface's natural normal points out of the material (on a sheet: to its front).+ pub forward: bool,+ /// The loops, counter-clockwise about the face's outward normal, the outer one first.+ pub loops: Vec<Vec<PartUse>>,+}-/// The arc from `a` to `b` through `mid`: the exact rational quadratic for a flat arc, truck's-/// three-point arc otherwise (and should the curve be refused, which its exact ends make-/// impossible).-fn arc_edge(a: &mt::Vertex, b: &mt::Vertex, mid: Vec3) -> mt::Edge {- let (pa, pb) = (a.point(), b.point());- let (pa, pb) = (Vec3::new(pa.x, pa.y, pa.z), Vec3::new(pb.x, pb.y, pb.z));- flat_arc(pa, pb, mid)- .and_then(|curve| mt::Edge::try_new(a, b, mt::Curve::NurbsCurve(curve)).ok())- .unwrap_or_else(|| builder::circle_arc(a, b, p3(mid)))+/// One use of an edge in a loop: whether the loop runs along it, and its exact pcurve where the+/// caller holds one (on the edge's interval, in its direction).+pub(crate) struct PartUse {+ pub edge: u32,+ pub forward: bool,+ pub given: Option<Curve2>,}-/// A flat arc (see [`FLAT_ARC`]) through its midpoint `mid` as one rational quadratic: the middle-/// control point on the line from the chord's midpoint through `mid`, 2 / (1 − t²) as far, weight-/// (1 − t²) / (1 + t²), where t is the sagitta over the half chord. None for a deeper arc, or-/// when `mid` is not halfway along the chord.-fn flat_arc(a: Vec3, b: Vec3, mid: Vec3) -> Option<mt::NurbsCurve<mt::Vector4>> {- let m = (a + b) * 0.5;- let half = a.dist(b) / 2.0;- let chord = (b - a).normalized()?;- let bow = mid - m;- let t = bow.len() / half;- if !(half > 1e-9) || !(t < FLAT_ARC) || bow.dot(chord).abs() > 1e-9 * half.max(1.0) {- return None;- }- let w = (1.0 - t * t) / (1.0 + t * t);- let apex = m + bow * (2.0 / (1.0 - t * t));- let h = |p: Vec3, w: f64| mt::Vector4::new(p.x * w, p.y * w, p.z * w, w);- Some(mt::NurbsCurve::new(mt::BSplineCurve::new(mt::KnotVec::bezier_knot(2), vec![h(a, 1.0), h(apex, w), h(b, 1.0)])))+pub(crate) struct PartEdge {+ pub curve: b::Curve,+ pub interval: [f64; 2],+ pub vertices: [u32; 2],}-/// A curved face on `surf`, turned so its normal at the probe points outward.-fn curved(mut surf: mt::Surface, wires: Vec<mt::Wire>, probe: Option<(Vec3, Vec3)>, fi: usize) -> Result<mt::Face> {- use mt::{ParametricSurface3D, SearchParameter};- if let Some((p, outward)) = probe- && let Some((u, v)) = surf.search_parameter(p3(p), None, 100)- {- let n = surf.normal(u, v);- if Vec3::new(n.x, n.y, n.z).dot(outward) < 0.0 {- surf = mt::Invertible::inverse(&surf);+/// Faces on shared edges and vertices, to be made a record; `tolerance` is every vertex's and+/// edge's, and the record's.+pub(crate) struct Parts {+ pub vertices: Vec<[f64; 3]>,+ pub edges: Vec<PartEdge>,+ pub faces: Vec<PartFace>,+ pub tolerance: f64,+}++/// An assembled record, with the canonical index of each face of the parts and of each edge+/// (`None` for an edge no face uses).+pub(crate) struct Assembled {+ pub brep: b::Brep,+ pub faces: Vec<usize>,+ pub edges: Vec<Option<usize>>,+}++/// The schema 4 record of `parts`: each face its pcurves (the caller's exact ones where given,+/// else `pcurve::pcurves`) and parameter box; the faces grouped into shells through shared edges;+/// closed shells (every edge used twice in them) enclosing material, or a cavity where the+/// faces' outward normals enclose negative volume, each cavity in the solid around it; open+/// shells (sheets) in the infinite region; everything in canonical order and validated.+/// `solid`: every shell must be closed.+pub(crate) fn assemble(parts: Parts, solid: bool) -> Result<Assembled> {+ let fail = |m: String| KernelError::Invalid(format!("sew: {m}"));+ let Parts { vertices, edges, faces, tolerance: tol } = parts;+ let nf = faces.len();+ if nf == 0 {+ return Err(fail("no faces".into()));+ }+ // The loops as the record keeps them: relative to the surface's natural normal.+ let loops: Vec<Vec<Vec<(u32, bool, Option<&Curve2>)>>> = faces+ .iter()+ .map(|f| {+ f.loops+ .iter()+ .map(|l| {+ if f.forward {+ l.iter().map(|u| (u.edge, u.forward, u.given.as_ref())).collect()+ } else {+ l.iter().rev().map(|u| (u.edge, !u.forward, u.given.as_ref())).collect()+ }+ })+ .collect()+ })+ .collect();+ let mut pcs: Vec<Vec<Vec<Curve2>>> = Vec::with_capacity(nf);+ let mut domains = Vec::with_capacity(nf);+ for (fi, (f, ls)) in faces.iter().zip(&loops).enumerate() {+ let mut uses = Vec::with_capacity(ls.len());+ for l in ls {+ let mut u = Vec::with_capacity(l.len());+ for &(e, forward, given) in l {+ let edge = edges.get(e as usize).ok_or_else(|| fail("edge reference".into()))?;+ u.push(pcurve::EdgeUse { edge: e, curve: &edge.curve, interval: edge.interval, forward, tolerance: tol, given });+ }+ uses.push(u);+ }+ let pc = pcurve::pcurves(&f.surface, &uses, tol).map_err(|e| KernelError::Failed(format!("sew: face {fi}: {e}")))?;+ domains.push(domain_of(&f.surface, &pc).ok_or_else(|| fail(format!("face {fi} has no area in its parameters")))?);+ pcs.push(pc);+ }+ let users = edge_users(edges.len(), &faces)?;+ let (groups, _) = components(nf, &users);+ if groups.len() > b::MAX_SHELLS {+ return Err(fail("component budget exceeded".into()));+ }+ let closed: Vec<bool> = groups+ .iter()+ .map(|g| {+ g.iter()+ .flat_map(|f| faces.get(*f).into_iter().flat_map(|f| f.loops.iter().flatten()))+ .all(|u| users.get(u.edge as usize).is_some_and(|x| x.len() >= 2))+ })+ .collect();+ if solid && closed.iter().any(|c| !c) {+ return Err(fail("the faces do not close".into()));+ }+ // Closed shells: the volume their outward normals enclose, positive for a solid's outside.+ let flux_of = |g: &[usize], field: &dyn Fn(Vec3) -> Vec3| -> Result<f64> {+ let mut sum = 0.0;+ for &f in g {+ let (Some(face), Some(pc), Some(ls), Some(dom)) = (faces.get(f), pcs.get(f), loops.get(f), domains.get(f)) else { continue };+ let s = SurfaceEval::new(&face.surface).map_err(|e| KernelError::Failed(format!("sew: face {f}: {e}")))?;+ let uses: Vec<Vec<(&Curve2, bool)>> = pc.iter().zip(ls).map(|(c, l)| c.iter().zip(l).map(|(c, u)| (c, u.1)).collect()).collect();+ let flux = face_flux(&s, dom[1][0], &uses, field).ok_or_else(|| KernelError::Failed(format!("sew: face {f} cannot be evaluated")))?;+ sum += if face.forward { flux } else { -flux };+ }+ Ok(sum)+ };+ let mut volume = vec![0.0; groups.len()];+ for (k, g) in groups.iter().enumerate() {+ if closed.get(k).copied().unwrap_or(false) {+ let v = flux_of(g, &|p| p * (1.0 / 3.0))?;+ if !(v.abs() > 0.0) || !v.is_finite() {+ return Err(fail("a closed shell encloses no volume".into()));+ }+ if let Some(slot) = volume.get_mut(k) {+ *slot = v;+ }+ }+ }+ let outers: Vec<usize> = (0..groups.len()).filter(|k| volume.get(*k).is_some_and(|v| *v > 0.0)).collect();+ // Each cavity in the smallest solid around it (by the winding number of one of its points).+ let mut cavities: Vec<Vec<usize>> = vec![Vec::new(); groups.len()];+ for k in (0..groups.len()).filter(|k| volume.get(*k).is_some_and(|v| *v < 0.0)) {+ let around = if let [only] = outers.as_slice() {+ Some(*only)+ } else {+ let q = groups+ .get(k)+ .and_then(|g| g.first())+ .and_then(|f| faces.get(*f))+ .and_then(|f| f.loops.first()?.first())+ .and_then(|u| edges.get(u.edge as usize))+ .and_then(|e| vertices.get(e.vertices[0] as usize))+ .map(|p| v3(*p))+ .ok_or_else(|| fail("cavity".into()))?;+ let field = move |p: Vec3| {+ let d = p - q;+ let r = d.len();+ d * (1.0 / (4.0 * std::f64::consts::PI * r * r * r))+ };+ let mut best: Option<(f64, usize)> = None;+ for &o in &outers {+ let w = flux_of(groups.get(o).map_or(&[][..], Vec::as_slice), &field)?;+ let v = volume.get(o).copied().unwrap_or(0.0);+ if (w - 1.0).abs() < 0.5 && best.is_none_or(|(b, _)| v < b) {+ best = Some((v, o));+ }+ }+ best.map(|(_, o)| o)+ };+ let o = around.ok_or_else(|| fail("a cavity lies in no solid".into()))?;+ cavities.get_mut(o).ok_or_else(|| fail("cavity".into()))?.push(k);+ }+ // Regions, and the shells numbered by first appearance in them.+ let mut shell_group: Vec<usize> = Vec::new();+ let mut shell_of: HashMap<usize, u32> = HashMap::new();+ let mut number = |g: usize, shell_group: &mut Vec<usize>| -> u32 {+ *shell_of.entry(g).or_insert_with(|| {+ shell_group.push(g);+ (shell_group.len() - 1) as u32+ })+ };+ let open: Vec<usize> = (0..groups.len()).filter(|k| !closed.get(*k).copied().unwrap_or(false)).collect();+ let infinite: Vec<u32> = outers.iter().chain(&open).map(|g| number(*g, &mut shell_group)).collect();+ let mut regions = vec![b::Region { shells: infinite, void: false }];+ for &o in &outers {+ let mut shells = vec![number(o, &mut shell_group)];+ for &c in cavities.get(o).into_iter().flatten() {+ shells.push(number(c, &mut shell_group));+ }+ regions.push(b::Region { shells, void: false });+ }+ for &o in &outers {+ for &c in cavities.get(o).into_iter().flatten() {+ regions.push(b::Region { shells: vec![number(c, &mut shell_group)], void: true });+ }+ }+ // Faces in first appearance walking shells; edges walking faces → loops → uses (backwards on+ // a face whose side in its shell is reversed), with their uses; vertices walking edges.+ let index = |i: usize| u32::try_from(i).map_err(|_| fail("index".into()));+ let mut face_new = vec![usize::MAX; nf];+ let mut face_order = Vec::with_capacity(nf);+ for g in &shell_group {+ for &f in groups.get(*g).into_iter().flatten() {+ if face_new.get(f) == Some(&usize::MAX) {+ if let Some(slot) = face_new.get_mut(f) {+ *slot = face_order.len();+ }+ face_order.push(f);+ }+ }+ }+ let mut edge_new: Vec<Option<usize>> = vec![None; edges.len()];+ let mut edge_order = Vec::with_capacity(edges.len());+ let mut uses: Vec<Vec<b::EdgeUseRef>> = vec![Vec::new(); edges.len()];+ for (fnew, &f) in face_order.iter().enumerate() {+ let forward = faces.get(f).is_some_and(|x| x.forward);+ for (li, l) in loops.get(f).into_iter().flatten().enumerate() {+ let n = l.len();+ for k in 0..n {+ let p = if forward { k } else { n - 1 - k };+ let &(e, fwd, _) = l.get(p).ok_or_else(|| fail("edge reference".into()))?;+ let slot = edge_new.get_mut(e as usize).ok_or_else(|| fail("edge reference".into()))?;+ if slot.is_none() {+ *slot = Some(edge_order.len());+ edge_order.push(e as usize);+ }+ let at = b::EdgeUseRef { face: index(fnew)?, r#loop: index(li)?, position: index(p)?, upper: !fwd };+ uses.get_mut(e as usize).ok_or_else(|| fail("edge reference".into()))?.push(at);+ }+ }+ }+ let mut vertex_new: Vec<Option<u32>> = vec![None; vertices.len()];+ let mut out_vertices = Vec::new();+ let mut out_edges = Vec::with_capacity(edge_order.len());+ for &e in &edge_order {+ let edge = edges.get(e).ok_or_else(|| fail("edge reference".into()))?;+ let mut ends = [0u32; 2];+ for (end, v) in ends.iter_mut().zip(edge.vertices) {+ let slot = vertex_new.get_mut(v as usize).ok_or_else(|| fail("vertex reference".into()))?;+ *end = match slot {+ Some(n) => *n,+ None => {+ let n = index(out_vertices.len())?;+ let point = *vertices.get(v as usize).ok_or_else(|| fail("vertex reference".into()))?;+ out_vertices.push(b::Vertex { point, tolerance: tol });+ *slot = Some(n);+ n+ }+ };}+ let edge_uses = uses.get(e).cloned().unwrap_or_default();+ out_edges.push(b::Edge { curve: edge.curve.clone(), interval: edge.interval, vertices: ends, tolerance: tol, uses: edge_uses });}- mt::Face::try_new(wires, surf).map_err(|e| KernelError::Failed(format!("sew: face {fi}: {e}")))+ let emap = |e: u32| edge_new.get(e as usize).copied().flatten().ok_or_else(|| fail("edge reference".into())).and_then(index);+ let mut out_faces = Vec::with_capacity(nf);+ for &f in &face_order {+ let (Some(face), Some(ls), Some(pc), Some(domain)) = (faces.get(f), loops.get(f), pcs.get(f), domains.get(f)) else {+ return Err(fail("face reference".into()));+ };+ let mut record_loops = Vec::with_capacity(ls.len());+ for (l, c) in ls.iter().zip(pc) {+ let mut oriented = Vec::with_capacity(l.len());+ for (&(e, forward, _), pcurve) in l.iter().zip(c) {+ oriented.push(b::OrientedEdge { edge: emap(e)?, forward, pcurve: pcurve.clone() });+ }+ record_loops.push(b::Loop::Edges { edges: oriented });+ }+ out_faces.push(b::Face { surface: face.surface.clone(), domain: *domain, loops: record_loops });+ }+ let mut shells = Vec::with_capacity(shell_group.len());+ for g in &shell_group {+ let mut oriented = Vec::new();+ for &f in groups.get(*g).into_iter().flatten() {+ let face = face_new.get(f).copied().ok_or_else(|| fail("face reference".into())).and_then(index)?;+ oriented.push(b::OrientedFace { face, forward: faces.get(f).is_some_and(|x| x.forward) });+ }+ shells.push(b::Shell::Faces { faces: oriented, wires: Vec::new() });+ }+ let brep = b::Brep { version: b::VERSION, tolerance: tol, regions, shells, faces: out_faces, edges: out_edges, vertices: out_vertices };+ brep.validate().map_err(|e| KernelError::Failed(format!("sew: the record is invalid: {e}")))?;+ Ok(Assembled { brep, faces: face_new, edges: edge_new })}-/// The plane of a boundary that truck's fit (`builder::try_attach_plane`) refused: truck's fit-/// again, on the boundary moved so that the mean of its control points is the origin, and the-/// plane moved back. None when truck refuses that one too (the boundary is not flat within-/// truck's 1e-6, or has no area).-///-/// truck sums the cross products of consecutive control points about a centre, and takes the-/// points' sum for that centre (it divides by the number of wires, not of points): eight times as-/// far from the origin as a rectangle of four lines. The sum is the same about any centre; its-/// rounding is not. It grows with the square of the centre's distance, and on a thin face, whose-/// normal is short, turns the normal far enough for truck's own flatness test to fail: truck-/// finds a 0.00013 x 30 mm face 360 mm from the origin 2e-6 mm out of the plane it fitted. With-/// the centre at the origin the same face is 1e-14 mm out at most.-fn plane_about_the_mean(wires: &[mt::Wire]) -> Option<mt::Plane> {- let (mut sum, mut count) = (Vec3::ZERO, 0usize);- for p in wires.iter().flat_map(|w| w.edge_iter()).flat_map(|e| e.oriented_curve().lift_up().control_points().clone()) {- sum += Vec3::new(p.x / p.w, p.y / p.w, p.z / p.w);- count += 1;- }- let mean = sum * (1.0 / count.max(1) as f64);- if !mean.is_finite() {- return None;+/// A face's parameter box: around its pcurves' control points (a B-spline lies in their hull),+/// held inside the surface's natural domain (one turn where periodic). None when it has no+/// width in either direction.+fn domain_of(surface: &b::Surface, pcs: &[Vec<Curve2>]) -> Option<[[f64; 2]; 2]> {+ let (mut lo, mut hi) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]);+ for c in pcs.iter().flatten() {+ let points: Vec<[f64; 2]> = match c {+ Curve2::Spline { points, .. } => points.clone(),+ Curve2::RationalSpline { homogeneous, .. } => homogeneous.iter().map(|h| [h[0] / h[2], h[1] / h[2]]).collect(),+ };+ for p in points {+ for d in 0..2 {+ lo[d] = lo[d].min(p[d]);+ hi[d] = hi[d].max(p[d]);+ }+ }}- let moved: Vec<mt::Wire> = wires.iter().map(|w| builder::transformed(w, mt::Matrix4::from_translation(v3(-mean)))).collect();- match builder::try_attach_plane(&moved).ok()?.surface() {- mt::Surface::Plane(plane) => Some(mt::Transformed::transformed(&plane, mt::Matrix4::from_translation(v3(mean)))),- _ => None,+ let natural = surface.natural();+ let mut out = [[0.0; 2]; 2];+ for d in 0..2 {+ let (mut a, mut z) = (lo[d], hi[d]);+ match natural[d] {+ b::Natural::Periodic => z = z.min(a + std::f64::consts::TAU),+ b::Natural::Range(n0, n1) => {+ a = a.max(n0);+ z = z.min(n1);+ }+ }+ if !(a < z) {+ return None;+ }+ out[d] = [a, z];+ }+ Some(out)+}++/// Four-point Gauss–Legendre nodes and weights on `[−1, 1]`.+const GAUSS4: [(f64, f64); 4] = [+ (-0.861_136_311_594_052_6, 0.347_854_845_137_453_8),+ (-0.339_981_043_584_856_3, 0.652_145_154_862_546_2),+ (0.339_981_043_584_856_3, 0.652_145_154_862_546_2),+ (0.861_136_311_594_052_6, 0.347_854_845_137_453_8),+];++/// Pieces each pcurve is integrated in, and how many Gauss panels cover a v range.+const FLUX_PIECES: usize = 32;+const FLUX_PANELS: usize = 4;++/// The flux of `field` through a face, `∫∫ field(S)·(S_u × S_v) du dv` over the (u, v) region its+/// loops (record convention, each use its pcurve and direction) bound, by Green's theorem:+/// `∮ −G du` with `G(u, v) = ∫ field·N ds` from `v0` to `v`. A quadrature for the sign of a+/// shell's volume (`field = p / 3`) or a winding number, which only has to be right to well+/// under a half: no geometry is made from it. Loops round a periodic direction need no seam+/// edge, as a seam's two runs at constant u add nothing to `∮ G du`.+fn face_flux(s: &SurfaceEval, v0: f64, loops: &[Vec<(&Curve2, bool)>], field: &dyn Fn(Vec3) -> Vec3) -> Option<f64> {+ let g = |u: f64, v: f64| -> Option<f64> {+ let (mut sum, h) = (0.0, (v - v0) / FLUX_PANELS as f64);+ for panel in 0..FLUX_PANELS {+ let a = v0 + h * panel as f64;+ for (x, w) in GAUSS4 {+ let t = a + 0.5 * h * (x + 1.0);+ let (p, su, sv) = s.derivs(u, t)?;+ sum += 0.5 * h * w * field(p).dot(su.cross(sv));+ }+ }+ sum.is_finite().then_some(sum)+ };+ let mut total = 0.0;+ for (c, forward) in loops.iter().flatten() {+ let [t0, t1] = c.interval()?;+ let at = |k: f64| {+ let f = k / FLUX_PIECES as f64;+ c.eval(if *forward { t0 + (t1 - t0) * f } else { t1 - (t1 - t0) * f })+ };+ for k in 0..FLUX_PIECES {+ let (a, m, z) = (at(k as f64)?, at(k as f64 + 0.5)?, at(k as f64 + 1.0)?);+ total -= g(m[0], m[1])? * (z[0] - a[0]);+ }}+ total.is_finite().then_some(total)}#[cfg(test)]@@ -1220,13 +1690,10 @@ mod tests {#[test]fn thin_faces_away_from_the_origin_get_their_planes() {// Slabs 30 x 2 mm and 0.00013 to 0.1 mm thick, away from the origin and turned off the- // axes. truck's plane fit sums the cross products of a boundary's points about a centre- // and takes the points' sum for it, eight times as far from the origin as a rectangle;- // on the thin faces its normal then comes out so far off that truck finds a- // 0.00013 x 30 mm face at (-300, -200, 5) 2e-6 mm out of its own plane and refuses it:- // `cannot attach a plane to a wire that is not on one plane`. Nine of these 45 slabs- // have such a face. (Thinner slabs meet another limit, at the origin too: a face- // 0.00003 mm wide and askew to the axes is sewn but gets no triangles.)+ // axes. A plane fitted by summing the cross products of a boundary's points about a far+ // centre turns a thin face's short normal so far that a 0.00013 x 30 mm face at+ // (-300, -200, 5) lies 2e-6 mm out of it; summed about the boundary's mean it lies+ // within 1e-14 mm.let turned = |about_z: f64, about_x: f64| {let (sz, cz) = about_z.sin_cos();let (sx, cx) = about_x.sin_cos();