Files
solidcraft/crates/kernel/src/polyhedron.rs
T
dc38349cbf Layer split stage 1: the B-rep record, native body file and Vec/Plane come from solidcore-record (#11496)
* Kernel: the B-rep record and the native body file come from solidcore-record

SolidCraft's portable B-rep record (`solidcraft_geom::brep`: brep.rs, topology, history,
envelope, part, curve2) and the native body file (`solidcraft_kernel::native`: the tagged binary
codec and the container) move to solidcore's `solidcore-record` crate: geometry as data, with
structural validation and no maths (solidcore's docs/layers.md, stage 1). Every caller uses
`solidcore_record::brep` and `solidcore_record::native`; the old copies are deleted.

What computes from coordinates stays with the kernel, in geom's `brep`:
- `brep::check`: the record's geometric checks (orthonormal frames, non-degenerate planes,
  unit revolution axes, non-singular placements). `check::validate` and
  `check::validate_built` are the record's validation and these together, and every caller of
  `Brep::validate` uses them, so what is accepted is unchanged;
- `brep::label`: a surface's natural ranges (a cone's apex), `curve_interval`,
  `edge_curve_interval` and `form_turns`;
- `brep::pcurve::eval`: a pcurve's point;
- `geometry::check`, `placement::moved` and `split_edges` become functions on the record.

The kernel's native module keeps the conversion between a body and its saved record
(metadata.rs) and checks the decoded record's geometry. `native/analytic.rs`, which no module
declared, is deleted.

solidcore-record is pinned to its rev on solidcore's `layer-record` branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Geometry: Vec2, Vec3, Plane and the profile types come from solidcore-record

The plain data of vectors and points, sketch planes and planar profiles (`Seg2`, `Loop2`,
`Region2`) moves to `solidcore-record`, with its constants and component-wise operators only
(owner decision, solidcore layer split). Their geometry stays in geom as traits:
`Vec2Geom`, `Vec3Geom`, `PlaneGeom`, `Seg2Geom`, `Loop2Geom`, `Region2Geom`, `Seg2ArcFit`,
`Loop2ArcFit` and `Region2ArcFit`, in scope with `use solidcraft_geom::prelude::*`. Every caller
names the types from `solidcore_record`; geom no longer defines or re-exports them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Kernel: pin solidcore-record to solidcore main f5e8e9a29

solidcore-record is merged on solidcore main (tangency-labs/solidcore#2519); its crate there is
identical to the rev pinned before but for its clippy configuration. The lock is regenerated
against the merged rev.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:04:26 -05:00

238 lines
11 KiB
Rust

//! Convex polyhedra from planes, and the local operations on a body's faces: shell (hollow out
//! with open faces), draft (tilt faces about a neutral plane) and offset faces, which are SMLib's
//! ([`crate::offset_backend`]). A polyhedron is its schema 4 record built directly from its
//! planes (vertices are triple-plane intersections, edges lines, faces planes, pcurves exact),
//! taken by SMLib and checked there.
use solidcraft_geom::prelude::*;
use std::collections::HashMap;
use solidcore_record::Vec3;
use solidcore_record::brep::{self as rec, Curve2, EdgeUseRef, Loop, OrientedEdge, OrientedFace};
use crate::body::Body;
use crate::{KernelError, Result};
/// A half-space `n · x <= d` (n is the outward unit normal).
#[derive(Clone, Copy, Debug)]
pub struct HalfSpace {
pub n: Vec3,
pub d: f64,
}
fn det3(a: Vec3, b: Vec3, c: Vec3) -> f64 {
a.dot(b.cross(c))
}
/// Vertices, and per half-space with a face its vertex loop (counter-clockwise about the
/// outward normal), of the convex polyhedron bounded by the half-spaces.
fn combinatorics(hs: &[HalfSpace]) -> Result<(Vec<Vec3>, Vec<(usize, Vec<usize>)>)> {
if hs.len() < 4 || hs.len() > 200 {
return Err(KernelError::Invalid("a polyhedron needs 4…200 planes".into()));
}
let scale = hs.iter().map(|h| h.d.abs()).fold(1.0, f64::max);
let eps = scale * 1e-9;
// Vertices: intersections of three planes inside all others.
let mut verts: Vec<Vec3> = Vec::new();
for i in 0..hs.len() {
for j in (i + 1)..hs.len() {
for k in (j + 1)..hs.len() {
let (a, b, c) = (hs[i], hs[j], hs[k]);
let den = det3(a.n, b.n, c.n);
if den.abs() < 1e-12 {
continue;
}
let x = (b.n.cross(c.n) * a.d + c.n.cross(a.n) * b.d + a.n.cross(b.n) * c.d) / den;
if !x.is_finite() || hs.iter().any(|h| h.n.dot(x) > h.d + eps * 10.0) {
continue;
}
if !verts.iter().any(|v| v.dist(x) < scale * 1e-8) {
verts.push(x);
}
}
}
}
if verts.len() < 4 {
return Err(KernelError::Invalid("the planes don't enclose a solid".into()));
}
// Faces: the vertices on each plane, ordered counter-clockwise about its outward normal.
let mut faces_idx: Vec<(usize, Vec<usize>)> = Vec::new();
for (hi, h) in hs.iter().enumerate() {
let on: Vec<usize> = (0..verts.len()).filter(|i| verts.get(*i).is_some_and(|v| (h.n.dot(*v) - h.d).abs() < scale * 1e-7)).collect();
if on.len() < 3 {
continue;
}
let c = on.iter().filter_map(|i| verts.get(*i)).fold(Vec3::ZERO, |a, v| a + *v) / on.len() as f64;
let u = h.n.any_perp();
let w = h.n.cross(u);
let mut ordered = on.clone();
ordered.sort_by(|a, b| {
let ang = |i: usize| verts.get(i).map(|v| (*v - c).dot(w).atan2((*v - c).dot(u))).unwrap_or(0.0);
ang(*a).total_cmp(&ang(*b))
});
faces_idx.push((hi, ordered));
}
Ok((verts, faces_idx))
}
/// The convex polyhedron bounded by the half-spaces.
pub fn convex_polyhedron(hs: &[HalfSpace]) -> Result<Body> {
let (verts, faces) = combinatorics(hs)?;
crate::smlib_sweeps::body_from_record(&polyhedron_record(hs, &verts, &faces)?, "polyhedron")
}
/// The record of the closed polyhedron with corners `verts` whose faces are `faces` (the
/// half-space each lies on, and its corners counter-clockwise about that half-space's outward
/// normal): each face on its plane with the outward normal as the natural one, each edge a line
/// used by its two faces, everything numbered in canonical order (faces as given, edges and
/// vertices as the faces first meet them).
fn polyhedron_record(hs: &[HalfSpace], verts: &[Vec3], faces: &[(usize, Vec<usize>)]) -> Result<rec::Brep> {
let bad = || KernelError::Failed("polyhedron: the planes do not close a solid".into());
let p = |i: usize| verts.get(i).map(|v| [v.x, v.y, v.z]).ok_or_else(bad);
let scale = verts.iter().map(|v| v.len()).fold(1.0, f64::max);
let tolerance = (scale * 1e-9).max(1e-7);
// Each edge by its corners as first met, with its uses in walking order.
let mut edge_of: HashMap<(usize, usize), u32> = HashMap::new();
let mut ends: Vec<(usize, usize)> = Vec::new();
let mut uses: Vec<Vec<EdgeUseRef>> = Vec::new();
let mut out = Vec::with_capacity(faces.len());
for (fi, (hi, cycle)) in faces.iter().enumerate() {
let n = hs.get(*hi).and_then(|h| h.n.normalized()).ok_or_else(bad)?;
let first = cycle.first().ok_or_else(bad)?;
let o = verts.get(*first).copied().ok_or_else(bad)?;
let (u, v) = (n.any_perp(), n.cross(n.any_perp()));
let uv = |q: [f64; 3]| {
let d = Vec3::new(q[0], q[1], q[2]) - o;
[d.dot(u), d.dot(v)]
};
let (mut lo, mut hi_uv) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]);
let mut edges = Vec::with_capacity(cycle.len());
for k in 0..cycle.len() {
let (Some(&a), Some(&b)) = (cycle.get(k), cycle.get((k + 1) % cycle.len())) else { return Err(bad()) };
let (e, forward) = match edge_of.get(&(b, a)) {
Some(&e) => (e, false),
None => {
if edge_of.contains_key(&(a, b)) {
return Err(bad());
}
let e = u32::try_from(ends.len()).map_err(|_| bad())?;
edge_of.insert((a, b), e);
ends.push((a, b));
uses.push(Vec::new());
(e, true)
}
};
let face = u32::try_from(fi).map_err(|_| bad())?;
let position = u32::try_from(k).map_err(|_| bad())?;
uses.get_mut(e as usize).ok_or_else(bad)?.push(EdgeUseRef { face, r#loop: 0, position, upper: !forward });
let &(s, t) = ends.get(e as usize).ok_or_else(bad)?;
let (ps, pt) = (uv(p(s)?), uv(p(t)?));
for q in [ps, pt] {
for i in 0..2 {
lo[i] = lo[i].min(q[i]);
hi_uv[i] = hi_uv[i].max(q[i]);
}
}
// The line in the plane's parameters, on the edge's interval in its direction.
edges.push(OrientedEdge { edge: e, forward, pcurve: Curve2::Spline { knots: vec![0.0, 0.0, 1.0, 1.0], points: vec![ps, pt] } });
}
let w = |x: Vec3| [x.x, x.y, x.z];
out.push(rec::Face {
nurbs: None,
surface: rec::Surface::Plane { origin: w(o), u_axis: w(u), v_axis: w(v) },
domain: [[lo[0], hi_uv[0]], [lo[1], hi_uv[1]]],
loops: vec![Loop::Edges { edges }],
});
}
// Vertices as the edges first meet them.
let mut vertex_of: HashMap<usize, u32> = HashMap::new();
let mut vertices: Vec<rec::Vertex> = Vec::new();
let mut edges = Vec::with_capacity(ends.len());
for ((s, t), uses) in ends.iter().copied().zip(uses) {
if uses.len() != 2 {
return Err(bad());
}
let mut number = |c: usize| -> Result<u32> {
if let Some(&i) = vertex_of.get(&c) {
return Ok(i);
}
let i = u32::try_from(vertices.len()).map_err(|_| bad())?;
vertices.push(rec::Vertex { point: p(c)?, tolerance });
vertex_of.insert(c, i);
Ok(i)
};
let vs = [number(s)?, number(t)?];
edges.push(rec::Edge {
nurbs: None,
curve: rec::Curve::Line { start: p(s)?, end: p(t)? },
interval: [0.0, 1.0],
vertices: vs,
tolerance,
uses,
});
}
let count = u32::try_from(out.len()).map_err(|_| bad())?;
let brep = rec::Brep {
version: rec::VERSION,
tolerance,
regions: vec![rec::Region { shells: vec![0], void: false }, rec::Region { shells: vec![0], void: false }],
shells: vec![rec::Shell::Faces { faces: (0..count).map(|face| OrientedFace { face, forward: true }).collect(), wires: vec![] }],
faces: out,
edges,
vertices,
};
solidcraft_geom::brep::check::validate(&brep).map_err(|e| KernelError::Failed(format!("polyhedron: {e}")))?;
Ok(brep)
}
/// Hollow a body: walls of `thickness` inside, open at the faces under `open` (SMLib's shell).
/// The result's history is over `[b]`: the inner walls are offsets of the faces they line. Each
/// kept planar wall and its inner lining carry the outer and inner shell roles of the face they
/// came from (face certificates: sketches and press-pulls attach to them), and the body keeps
/// the lines its faces were split along on purpose.
pub fn shell(b: &Body, open: &[Vec3], thickness: f64) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "shell");
crate::offset_backend::shell(b, open, thickness)?.inherit_split_lines(&[b]).with_shell_planar_sources(b, thickness, open)
}
/// Tilt the faces near `faces` by `angle` about their line on the neutral plane, so that they
/// lean in (positive angle) going along `pull` (SMLib's draft).
pub fn draft(b: &Body, faces: &[Vec3], neutral: &solidcore_record::Plane, pull: Vec3, angle: f64) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "draft");
b.require_brep("draft")?;
crate::offset_backend::draft(b, faces, neutral, pull, angle)
}
/// Move the faces at the given points along their outward normals by `distance` (negative: into
/// the body), SMLib's offset of faces: the faces around them are extended or trimmed to meet them.
pub fn offset_faces(b: &Body, at: &[Vec3], distance: f64) -> Result<Body> {
let _span = solidcraft_profile::span("kernel", "offset_faces");
b.require_brep("offset faces")?;
if !distance.is_finite() || distance.abs() > 1e6 {
return Err(KernelError::Invalid("offset distance".into()));
}
let healed = crate::boolean_record::healed(b)?.with_split_lines(b.splits.clone());
let size = healed.size();
let mesh = healed.mesh(&crate::MeshTolerance::chord((size * 1e-3).max(1e-3)))?;
let mut chosen: Vec<usize> = Vec::new();
for p in at {
let near = mesh
.triangles
.iter()
.zip(&mesh.tri_face)
.filter_map(|(t, f)| mesh.tri(t).map(|[x, y, z]| (solidcraft_geom::compare::closest_on_triangle(*p, x, y, z).dist(*p), *f as usize)))
.min_by(|a, c| a.0.total_cmp(&c.0));
match near {
Some((d, f)) if d < size * 1e-3 + 1e-6 => {
if !chosen.contains(&f) {
chosen.push(f);
}
}
_ => return Err(KernelError::Invalid(format!("no face at {:?}", [p.x, p.y, p.z]))),
}
}
let chosen = crate::offset::with_same_surface(&healed, &chosen);
let moved = crate::offset_backend::offset_faces(&healed, &chosen, distance)?;
Ok(crate::record::after(moved, &healed, &crate::record::counts(&[b])))
}