Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Wave 164/509: kernel: surfaces on the schema 4 record and SMLib

jyvikofde43b5317d8
diff --git a/crates/kernel/src/surface_offset.rs b/crates/kernel/src/surface_offset.rs
index 2e34338398..a19d34fa95 100644
--- a/crates/kernel/src/surface_offset.rs
+++ b/crates/kernel/src/surface_offset.rs
@@ -1,114 +1,17 @@
//! Offset surfaces (Surface › Offset): faces of a body copied out at a signed distance along
-//! their normals, as a new surface body. Planes and circular cylinders move exactly (as Thicken
-//! moves them); any other face gets a B-spline surface fitted through offset samples on a grid,
-//! refined until it is within a tolerance of the true offset everywhere it is checked. An
-//! offset as deep as a face's smallest concave radius would fold it over, and is refused,
-//! naming that radius. Neighbouring faces moved to the same place along their shared edge
-//! (meeting smoothly) keep sharing it; across a sharp edge they come apart. Faces that close up
-//! make a solid.
+//! their normals, as a new surface body. Each face goes onto its surface's offset, SMLib's exact
+//! offset (`smlib_offset_sheet`) of the face on its own; the offsets are then stitched where they
+//! meet within the tolerance, so neighbouring faces moved to the same place along their shared
+//! edge (meeting smoothly) keep sharing it, and across a sharp edge they come apart. Faces that
+//! close up make a solid. An offset SMLib cannot make (one that would fold a face over) is its
+//! error, never a fitted surface.
-use std::collections::HashMap;
-
-use mt::{BoundedCurve, InnerSpace, ParametricCurve, ParametricSurface, ParametricSurface3D, SearchNearestParameter};
-use solidcraft_geom::{Grid, Vec3};
-use truck_modeling as mt;
-
-use crate::body::{Body, from_p3, p3};
-use crate::build::interpolate_net;
-use crate::history::FaceOrigin;
-use crate::surfaces::{Offset, map_curve, map_surface, surface_body};
-use crate::{KernelError, Result, guard};
-
-/// Grid samples a side of a fitted offset starts with, and the most it is refined to.
-const START_GRID: usize = 12;
-const MAX_GRID: usize = 96;
-/// Samples along an edge of a fitted offset.
-const EDGE_SAMPLES: usize = 33;
-
-/// How one face moves along its normals: exactly (a plane, a circular cylinder) or onto
-/// surfaces fitted for the distances it was made for. Shared by Offset Surface and Thicken.
-pub(crate) struct FaceMover {
- face: mt::Face,
- how: How,
-}
-
-enum How {
- Exact(Offset),
- /// Each fitted distance (by its bits) and its surface (absolute parameters of the face's own
- /// surface); the face's outward sign (its orientation).
- Fitted {
- surfaces: Vec<(u64, mt::BSplineSurface<mt::Point3>)>,
- sign: f64,
- },
-}
-
-impl FaceMover {
- /// A mover for `face` at each of `distances` (along its outward normal), refused where a
- /// distance would fold it over; fitted faces within `tolerance`.
- pub(crate) fn new(face: &mt::Face, distances: &[f64], tolerance: f64) -> Result<FaceMover> {
- let how = match Offset::of(face) {
- Some(off) => {
- if let Offset::Cylinder { r, out, .. } = off
- && let Some(d) = distances.iter().find(|d| r + out * **d <= tolerance)
- {
- return Err(KernelError::Invalid(format!("{d} mm is as deep as the cylinder's radius ({r:.4} mm): it would fold the face over")));
- }
- How::Exact(off)
- }
- None => {
- let mut surfaces = Vec::new();
- for d in distances.iter().filter(|d| **d != 0.0) {
- if !surfaces.iter().any(|(b, _)| *b == d.to_bits()) {
- surfaces.push((d.to_bits(), fit(face, *d, tolerance)?));
- }
- }
- How::Fitted { surfaces, sign: if face.orientation() { 1.0 } else { -1.0 } }
- }
- };
- Ok(FaceMover { face: face.clone(), how })
- }
-
- /// Where the point `p` of the face goes at distance `d`.
- pub(crate) fn point(&self, p: Vec3, d: f64) -> Result<Vec3> {
- match &self.how {
- How::Exact(off) => Ok(off.map(p, d)),
- How::Fitted { .. } if d == 0.0 => Ok(p),
- How::Fitted { sign, .. } => offset_point(&self.face.surface(), p, sign * d),
- }
- }
-
- /// An edge curve of the face moved by `d` (exact, or a cubic through moved samples).
- pub(crate) fn curve(&self, c: &mt::Curve, d: f64) -> Result<mt::Curve> {
- match &self.how {
- How::Exact(off) => map_curve(off, c, d),
- How::Fitted { .. } if d == 0.0 => Ok(c.clone()),
- How::Fitted { .. } => {
- let (t0, t1) = c.range_tuple();
- let pts: Vec<Vec3> = (0..EDGE_SAMPLES)
- .map(|k| self.point(from_p3(c.subs(t0 + (t1 - t0) * k as f64 / (EDGE_SAMPLES - 1) as f64)), d))
- .collect::<Result<_>>()?;
- Ok(mt::Curve::BSplineCurve(crate::build::interpolate_cubic(&pts).ok_or_else(|| KernelError::Failed("offset edge".into()))?))
- }
- }
- }
-
- /// The face's surface moved by `d` (absolute: the face's orientation is kept apart).
- pub(crate) fn surface(&self, d: f64) -> Result<mt::Surface> {
- match &self.how {
- How::Exact(off) => map_surface(off, &self.face.surface(), d),
- How::Fitted { .. } if d == 0.0 => Ok(self.face.surface()),
- How::Fitted { surfaces, .. } => surfaces
- .iter()
- .find(|(b, _)| *b == d.to_bits())
- .map(|(_, s)| mt::Surface::BSplineSurface(s.clone()))
- .ok_or_else(|| KernelError::Failed("offset: no surface fitted for that distance".into())),
- }
- }
-}
+use crate::body::Body;
+use crate::{KernelError, Result};
/// The picked faces of `body` (indices in its face order) offset by `distance` along their
-/// outward normals (negative: against them) into one surface body. `tolerance`: how far a
-/// fitted face may stray from the true offset. A distance of zero copies the faces. The
+/// outward normals (negative: against them) into one surface body. `tolerance`: how far apart
+/// two offsets' edges may be and still be one edge. A distance of zero copies the faces. The
/// history is over `[body]`: each face is the offset of the one it came from.
pub fn offset_surface(body: &Body, faces: &[usize], distance: f64, tolerance: f64) -> Result<Body> {
body.require_brep("offset")?;
@@ -118,10 +21,10 @@ pub fn offset_surface(body: &Body, faces: &[usize], distance: f64, tolerance: f6
if !(tolerance.is_finite() && (1e-6..=10.0).contains(&tolerance)) {
return Err(KernelError::Invalid("the offset tolerance must be 0.000001…10 mm".into()));
}
- let all: Vec<mt::Face> = body.solid.face_iter().cloned().collect();
+ let count = body.face_count();
let mut picked: Vec<usize> = Vec::new();
for &i in faces {
- if i >= all.len() {
+ if i >= count {
return Err(KernelError::Invalid("no such face".into()));
}
if !picked.contains(&i) {
@@ -131,203 +34,14 @@ pub fn offset_surface(body: &Body, faces: &[usize], distance: f64, tolerance: f6
if picked.is_empty() {
return Err(KernelError::Invalid("pick the faces to offset".into()));
}
- let chosen: Vec<(usize, &mt::Face)> = picked.iter().filter_map(|i| all.get(*i).map(|f| (*i, f))).collect();
- if distance == 0.0 {
- let copy = surface_body(chosen.iter().map(|(_, f)| (*f).clone()).collect());
- return Ok(crate::record::rebuilt_body(copy, &[&body.solid], &crate::record::Rebuild::default()));
- }
- let size = body.size().max(1e-6);
- let moves: Vec<FaceMover> = chosen.iter().map(|(_, f)| FaceMover::new(f, &[distance], tolerance)).collect::<Result<_>>()?;
- guard("offset surface", || {
- let near = |a: Vec3, b: Vec3| a.dist(b) <= tolerance.max(size * 1e-7) * 4.0;
- // Moved vertices and edges, shared while every face moves them to the same place.
- let mut verts: HashMap<mt::VertexID, Vec<mt::Vertex>> = HashMap::new();
- let mut edges: HashMap<mt::EdgeID, Vec<mt::Edge>> = HashMap::new();
- let mut out = Vec::with_capacity(chosen.len());
- let mut history = Vec::with_capacity(chosen.len());
- for ((i, f), mv) in chosen.iter().zip(&moves) {
- let map = |p: Vec3| mv.point(p, distance);
- let mut vertex = |v: &mt::Vertex| -> Result<mt::Vertex> {
- let at = map(from_p3(v.point()))?;
- let list = verts.entry(v.id()).or_default();
- if let Some(found) = list.iter().find(|m| near(from_p3(m.point()), at)) {
- return Ok(found.clone());
- }
- let nv = mt::Vertex::new(p3(at));
- list.push(nv.clone());
- Ok(nv)
- };
- let mut wires = Vec::new();
- for w in f.absolute_boundaries() {
- let mut wire = Vec::new();
- for e in w.edge_iter() {
- let abs = if e.orientation() { e.clone() } else { e.inverse() };
- let (a, b) = (vertex(abs.front())?, vertex(abs.back())?);
- let c = abs.curve();
- let (t0, t1) = c.range_tuple();
- let mid = map(from_p3(c.subs(0.5 * (t0 + t1))))?;
- let list = edges.entry(abs.id()).or_default();
- let shared = list.iter().find(|m| {
- m.front().id() == a.id() && m.back().id() == b.id() && {
- let mc = m.curve();
- let (s0, s1) = mc.range_tuple();
- near(from_p3(mc.subs(0.5 * (s0 + s1))), mid)
- }
- });
- let moved = match shared {
- Some(m) => m.clone(),
- None => {
- let curve = mv.curve(&c, distance)?;
- let m = mt::Edge::new_unchecked(&a, &b, curve);
- list.push(m.clone());
- m
- }
- };
- wire.push(if e.orientation() { moved } else { moved.inverse() });
- }
- wires.push(mt::Wire::from(wire));
- }
- let surface = mv.surface(distance)?;
- let mut nf = mt::Face::new_unchecked(wires, surface);
- if !f.orientation() {
- nf.invert();
- }
- out.push(nf);
- history.push(crate::record::generated(vec![FaceOrigin::Offset { operand: 0, face: *i }]));
- }
- let operand = crate::record::Operand::new(body);
- // Faces that close up (every face of a smooth closed body) make a solid, as Stitch makes
- // one.
- let shell = mt::Shell::from(out);
- let result = match shell.shell_condition() {
- mt::ShellCondition::Closed => match crate::body::Solid::try_new(vec![shell.clone()]) {
- Ok(solid) => Body::new(solid)?,
- Err(_) => surface_body(shell.into_iter().collect()),
- },
- _ => surface_body(shell.into_iter().collect()),
- };
- crate::record::attach(result, &[operand], Some(history), HashMap::new())
- })
-}
-
-/// The point `p` on `s` (absolute) moved by `d` along the surface's own normal there.
-fn offset_point(s: &mt::Surface, p: Vec3, d: f64) -> Result<Vec3> {
- let (u, v) = s.search_nearest_parameter(p3(p), None, 100).ok_or_else(|| KernelError::Failed("offset: a point off its face".into()))?;
- let n = from_p3(mt::Point3::new(0.0, 0.0, 0.0) + s.normal(u, v));
- let n =
- n.normalized().ok_or_else(|| KernelError::Invalid("the face has a point with no normal (a pole or a crease): not supported yet".into()))?;
- Ok(from_p3(s.subs(u, v)) + n * d)
-}
-
-/// The fitted offset of a face that is not a plane or a circular cylinder.
-fn fit(f: &mt::Face, distance: f64, tolerance: f64) -> Result<mt::BSplineSurface<mt::Point3>> {
- let s = f.surface();
- let sign = if f.orientation() { 1.0 } else { -1.0 };
- let d = sign * distance;
- // The face's span in its surface's parameters: its boundary, found on the surface.
- let (mut u0, mut u1, mut v0, mut v1) = (f64::INFINITY, f64::NEG_INFINITY, f64::INFINITY, f64::NEG_INFINITY);
- for e in f.absolute_boundaries().iter().flat_map(|w| w.edge_iter()) {
- let c = e.curve();
- let (t0, t1) = c.range_tuple();
- for k in 0..=16 {
- let q = c.subs(t0 + (t1 - t0) * k as f64 / 16.0);
- if let Some((u, v)) = s.search_nearest_parameter(q, None, 100) {
- (u0, u1, v0, v1) = (u0.min(u), u1.max(u), v0.min(v), v1.max(v));
- }
- }
- }
- if !(u0.is_finite() && u1 > u0 && v0.is_finite() && v1 > v0) {
- return Err(KernelError::Failed("offset: the face's span on its surface".into()));
- }
- let at = |a: f64, b: f64| -> Result<Vec3> {
- let (u, v) = (u0 + (u1 - u0) * a, v0 + (v1 - v0) * b);
- let n = from_p3(mt::Point3::new(0.0, 0.0, 0.0) + s.normal(u, v));
- let n = n
- .normalized()
- .ok_or_else(|| KernelError::Invalid("the face has a point with no normal (a pole or a crease): not supported yet".into()))?;
- Ok(from_p3(s.subs(u, v)) + n * d)
- };
- // Folding over: moving a point by d along its normal shrinks lengths along a principal
- // direction by 1 - d·k (k > 0 where the surface bends toward its normal); at zero the
- // offset reaches the centre of curvature and folds. Refused with a margin, naming the
- // tightest radius on that side.
- let mut tightest: Option<f64> = None;
- for i in 0..=START_GRID {
- for j in 0..=START_GRID {
- let (u, v) = (u0 + (u1 - u0) * i as f64 / START_GRID as f64, v0 + (v1 - v0) * j as f64 / START_GRID as f64);
- let Some((k1, k2)) = principal_curvatures(&s, u, v) else { continue };
- for k in [k1, k2] {
- if d * k > 0.0 && 1.0 - d * k <= 0.05 {
- let r = 1.0 / k.abs();
- tightest = Some(tightest.map_or(r, |t: f64| t.min(r)));
- }
- }
- }
- }
- if let Some(r) = tightest {
- return Err(KernelError::Invalid(format!(
- "the offset is as deep as the face's smallest concave radius on that side ({r:.4} mm): it would fold the face over"
- )));
- }
- let mut n = START_GRID;
- loop {
- let grid = Grid::from_fn([n + 1, n + 1], |i, j| at(i as f64 / n as f64, j as f64 / n as f64))
- .ok_or_else(|| KernelError::TooLarge("offset: the sample grid".into()))?
- .try_map(|p| p)?;
- let surface = interpolate_net(&grid).map(|fit| fit.surface).ok_or_else(|| KernelError::Failed("offset: fitting the surface".into()))?;
- // Checked between the samples, where a fit strays most.
- let mut worst = 0.0f64;
- for i in 0..n {
- for j in 0..n {
- let (a, b) = ((i as f64 + 0.5) / n as f64, (j as f64 + 0.5) / n as f64);
- worst = worst.max(from_p3(surface.subs(a, b)).dist(at(a, b)?));
- }
- }
- if worst <= tolerance {
- // Re-parameterised to the face's own surface span, so boundary points found on the
- // old surface map onto it.
- return Ok(reparameterised(surface, (u0, u1), (v0, v1)));
- }
- if n >= MAX_GRID {
- return Err(KernelError::Invalid(format!(
- "the offset can't be fitted within {tolerance} mm (off by up to {worst:.4} mm): try a larger tolerance"
- )));
- }
- n = (n * 2).min(MAX_GRID);
- }
-}
-
-/// The principal curvatures of `s` at (u, v), signed: positive where the surface bends toward
-/// its normal there. `None` where it has no normal.
-fn principal_curvatures(s: &mt::Surface, u: f64, v: f64) -> Option<(f64, f64)> {
- let (su, sv) = (s.uder(u, v), s.vder(u, v));
- let n = s.normal(u, v);
- if !(n.magnitude2() > 0.5) {
- return None;
- }
- let (e, f, g) = (su.dot(su), su.dot(sv), sv.dot(sv));
- let (l, m, nn) = (s.uuder(u, v).dot(n), s.uvder(u, v).dot(n), s.vvder(u, v).dot(n));
- let det = e * g - f * f;
- if det.abs() < 1e-18 {
- return None;
- }
- let k = (l * nn - m * m) / det;
- let h = (e * nn - 2.0 * f * m + g * l) / (2.0 * det);
- let disc = (h * h - k).max(0.0).sqrt();
- Some((h + disc, h - disc))
-}
-
-/// `s` (on [0, 1]²) with its knots stretched onto `u` × `v`.
-fn reparameterised(s: mt::BSplineSurface<mt::Point3>, u: (f64, f64), v: (f64, f64)) -> mt::BSplineSurface<mt::Point3> {
- let stretch = |kv: &mt::KnotVec, (a, b): (f64, f64)| mt::KnotVec::from(kv.iter().map(|k| a + (b - a) * k).collect::<Vec<_>>());
- let (ku, kv) = (stretch(s.uknot_vec(), u), stretch(s.vknot_vec(), v));
- mt::BSplineSurface::new((ku, kv), s.control_points().clone())
+ crate::surfaces::offset_faces(body, &picked, distance, tolerance)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{box_solid, cylinder, measure, sphere};
+ use solidcraft_geom::Vec3;
fn rel(a: f64, b: f64) -> f64 {
(a - b).abs() / b.abs().max(1e-9)
@@ -336,7 +50,7 @@ mod tests {
crate::surfaces::nearest_face(b, p).unwrap()
}
fn edges(b: &Body) -> usize {
- b.solid.edge_iter().map(|e| e.id()).collect::<std::collections::HashSet<_>>().len()
+ b.edge_count()
}
/// Planes move exactly: a box's top 5 up is a 10 × 10 square at z = 15. Two faces across a
@@ -372,7 +86,7 @@ mod tests {
}
/// A sphere (fitted faces) moved out by 2: area 4π·12², within the tolerance; moved in to
- /// its centre, refused with its radius named.
+ /// its centre, refused.
#[test]
fn a_sphere_is_fitted_and_refused_past_its_centre() {
let s = sphere(Vec3::ZERO, 10.0).unwrap();
@@ -384,8 +98,7 @@ mod tests {
assert_eq!(edges(&out), edges(&s));
assert!(!out.is_surface(), "the offset sphere closes into a solid");
assert!(rel(measure(&out).unwrap().volume, 4.0 / 3.0 * std::f64::consts::PI * 1728.0) < 2e-3, "outward"); // (measured on meshes)
- let e = offset_surface(&s, &all, -10.0, 0.01).unwrap_err().to_string();
- assert!(e.contains("10.0000"), "{e}");
+ assert!(offset_surface(&s, &all, -10.0, 0.01).is_err());
}
/// A doubly curved patch (a saddle, a B-spline height field) moved by 1.5: every point of the
@@ -398,13 +111,13 @@ mod tests {
let z = |x: f64| 50.0 - (1600.0 - x * x).sqrt();
let rim = [Vec3::new(14.0, 0.0, z(14.0)), Vec3::new(0.0, 14.0, z(0.0)), Vec3::new(-14.0, 0.0, z(-14.0)), Vec3::new(0.0, -14.0, z(0.0))];
let cover = crate::patch_edges(&cup, &rim).unwrap();
- let face = cover.solid.face_iter().next().unwrap().clone();
+ let record = crate::native::brep_record(&cover).unwrap();
+ let s = solidcraft_geom::brep::eval::SurfaceEval::new(&record.faces[0].surface).unwrap();
let out = offset_surface(&cover, &[0], 1.5, 0.01).unwrap();
let mesh = out.mesh(&crate::MeshTolerance::chord(0.05)).unwrap();
- let s = face.surface();
for p in mesh.positions.iter().step_by(7) {
- let (u, v) = s.search_nearest_parameter(p3(*p), None, 100).unwrap();
- let dist = from_p3(s.subs(u, v)).dist(*p);
+ let uv = s.project(*p, None, f64::INFINITY).unwrap();
+ let dist = s.point(uv).unwrap().dist(*p);
assert!((dist - 1.5).abs() < 0.03, "{dist} at {p:?}");
}
}
diff --git a/crates/kernel/src/surfaces.rs b/crates/kernel/src/surfaces.rs
index a204b94897..0a059e7448 100644
--- a/crates/kernel/src/surfaces.rs
+++ b/crates/kernel/src/surfaces.rs
@@ -1,533 +1,621 @@
//! Surface bodies (open shells) and the operations that turn them into solids: Patch (a face
//! filling a closed loop of edges — planar, or B-spline patches for a loop that is not — or a
-//! planar sketch region), Stitch (surfaces sharing edges sewn
-//! into one body, a solid when they close), Trim (a surface cut by a tool, one side kept),
-//! Thicken (a surface offset along its normals into a solid), copying faces out of a body, and
-//! sheets swept from sketch curves (surface extrude, revolve, sweep and loft).
+//! planar sketch region), Stitch (surfaces sharing edges sewn into one body, a solid when they
+//! close), Thicken (a surface offset along its normals into a solid), copying, removing, turning
+//! over and taking apart faces of a body, extending a planar surface, and sheets swept from sketch
+//! curves (surface extrude, revolve, sweep and loft).
+//!
+//! Everything works on the body's schema 4 record. Taking faces out of a body, turning them over
+//! and making a flat face are exact on the record ([`Parts`] puts any set of faces, edges and
+//! vertices into a record's canonical order). Sweeps, stitching and offsets are SMLib's: each piece
+//! of a sheet goes to SMLib on its own (a chain of a sweep, a column of a loft, a face of an
+//! offset), the pieces' records are joined, and where pieces share edges SMLib stitches them.
+//!
+//! History is exact. A face taken from a body is that face (Kept), its edges the body's; a sheet's
+//! wall comes from the profile segments its edges in the start plane lie along; a stitched or
+//! offset face carries the tag of the face it was made from through SMLib.
-use std::collections::HashMap;
+use std::collections::BTreeSet;
-use mt::{BoundedCurve, InnerSpace, MetricSpace, ParametricCurve, ParametricSurface3D, SearchNearestParameter};
-use solidcraft_geom::{Plane, Region2, Seg2, UnitVec3, Vec2, Vec3};
-use truck_modeling as mt;
+use solidcraft_geom::brep::eval::CurveEval;
+use solidcraft_geom::brep::{self as b, Brep, Curve2};
+use solidcraft_geom::{Plane, Region2, Seg2, Vec2, Vec3};
-use crate::body::{Body, from_p3, p3};
-use crate::history::{Change, EdgeOrigin, FaceOrigin, FaceProv};
-use crate::record::{self, Rebuild, Side, rebuilt_body};
-use crate::{KernelError, Result, guard};
+use crate::body::Body;
+use crate::history::{Change, EdgeOrigin, EdgeProv, FaceOrigin, FaceProv, History};
+use crate::{KernelError, Result, record};
impl Body {
- /// A surface body: some shell does not close.
+ /// A surface body: some shell does not close (an edge bounds a face on one side only).
pub fn is_surface(&self) -> bool {
- !self.is_mesh() && self.solid.boundaries().iter().any(|s| s.shell_condition() != mt::ShellCondition::Closed)
+ !self.is_mesh() && crate::native::brep_record(self).is_ok_and(|r| r.edges.iter().any(|e| e.uses.len() == 1))
}
}
-/// A body of faces as they are (no orientation fix: a surface has no inside).
-pub(crate) fn surface_body(faces: Vec<mt::Face>) -> Body {
- surface_of(mt::Shell::from(faces))
+fn invalid(what: impl Into<String>) -> KernelError {
+ KernelError::Invalid(what.into())
}
-/// A body of a shell as it is.
-fn surface_of(shell: mt::Shell) -> Body {
- Body {
- solid: std::sync::Arc::new(mt::Solid::new_unchecked(vec![shell])),
- size: 0.0,
- boundary_tol: None,
- volume: Some(std::sync::Arc::new(std::sync::Mutex::new(None))),
- coarse_missing: None,
- mesh: None,
- color: None,
- paint: None,
- splits: None,
- face_sources: None,
- history: None,
- display_of: None,
- meshes: None,
- phased: false,
- tolerances: None,
- regularization_protected: false,
- }
+fn failed(what: impl Into<String>) -> KernelError {
+ KernelError::Failed(what.into())
}
-/// A body from faces: a solid when they close, else a surface; with the history of the
-/// operation that made the faces from `operands` as `rec` records.
-pub(crate) fn body_of(faces: Vec<mt::Face>, operands: &[&mt::Solid], rec: &Rebuild) -> Result<Body> {
- let shell = mt::Shell::from(faces);
- if shell.shell_condition() == mt::ShellCondition::Closed {
- crate::record::rebuilt(mt::Solid::new_unchecked(vec![shell]), operands, rec)
- } else {
- Ok(rebuilt_body(surface_of(shell), operands, rec))
- }
+fn v3(p: [f64; 3]) -> Vec3 {
+ Vec3::new(p[0], p[1], p[2])
}
-/// A planar surface filling a sketch region. Its history has no operands: the face is new.
-pub fn patch_region(plane: &Plane, region: &Region2) -> Result<Body> {
- let f = crate::build::face(plane, region)?;
- let mut rec = Rebuild::default();
- rec.made(&f, Vec::new());
- Ok(rebuilt_body(surface_body(vec![f]), &[], &rec))
+fn a3(v: Vec3) -> [f64; 3] {
+ [v.x, v.y, v.z]
}
-/// A chain's edge seeds numbered across all the chains: the segment at `i` of the chain that
-/// starts at segment `offset` is segment `offset + i`.
-fn numbered(seeds: &[(mt::EdgeID, usize)], offset: usize) -> Vec<(mt::EdgeID, Vec<usize>)> {
- seeds.iter().map(|(id, i)| (*id, vec![offset + i])).collect()
+fn index(i: usize) -> Result<u32> {
+ u32::try_from(i).map_err(|_| KernelError::TooLarge("a record index".into()))
}
-/// The faces truck swept from the edges `seeds`, each with the segments under the edge whose
-/// column it lies in (none where the faces don't follow the pattern; see [`record::follow`]).
-fn swept_sides(shell: &mt::Shell, seeds: &[(mt::EdgeID, Vec<usize>)], fixed: &[mt::VertexID]) -> Vec<Side> {
- let provs = record::columns(shell.face_iter(), seeds, None, record::Column::ToEnd, fixed);
- shell.face_iter().enumerate().map(|(k, f)| (f.clone(), provs.as_ref().and_then(|p| p.get(k).cloned().flatten()))).collect()
+// ---- Records of faces -------------------------------------------------------------------
+
+/// Faces, edges and vertices to be put into one record: each face with whether its shell uses it
+/// along its surface's natural normal, its loops naming `edges` and `vertices` by position here.
+/// Edges' `uses` are ignored ([`Parts::canonical`] works them out).
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Parts {
+ pub tolerance: f64,
+ pub vertices: Vec<b::Vertex>,
+ pub edges: Vec<b::Edge>,
+ pub faces: Vec<(b::Face, bool)>,
}
-/// A body of a sheet builder's faces: a surface, or a solid where they close; with the history
-/// of a body built from the chains' segments (none unless every face's is known).
-fn sheet_body(sides: Vec<Side>) -> Result<Body> {
- let history: Option<Vec<FaceProv>> = sides.iter().map(|(_, p)| p.clone()).collect();
- let shell = mt::Shell::from(sides.into_iter().map(|(f, _)| f).collect::<Vec<_>>());
- if shell.shell_condition() == mt::ShellCondition::Closed {
- return match crate::body::Solid::try_new(vec![shell.clone()]) {
- Ok(solid) => record::attach(Body::new(solid)?, &[], history, Default::default()),
- Err(_) => crate::record::rebuilt(mt::Solid::new_unchecked(vec![shell]), &[], &Rebuild::default()),
- };
- }
- record::attach(surface_of(shell), &[], history, Default::default())
+/// A record made by [`Parts::canonical`], with where each of its faces and edges came from
+/// (`faces[i]`: the part face of record face i; `edges` likewise). Parts no face uses are left out.
+pub(crate) struct Canonical {
+ pub brep: Brep,
+ pub faces: Vec<usize>,
+ pub edges: Vec<usize>,
}
-/// Most curve chains one surface extrude takes.
-const MAX_CHAINS: usize = 10_000;
+/// Where the parts of each record [`Parts::joined`] took begin: faces, edges, vertices.
+type Offsets = Vec<[usize; 3]>;
-/// A surface extruded from chains of sketch segments on `plane`: each chain (open, or closed
-/// such as a profile's boundary) moved straight from `start` to `end` along the plane normal
-/// (offsets in mm). The walls it sweeps form one surface body with no caps. Its history has no
-/// operands: every face is new.
-pub fn extrude_sheet(plane: &Plane, chains: &[Vec<Seg2>], start: f64, end: f64) -> Result<Body> {
- if !crate::build::frame_ok(plane) {
- return Err(KernelError::Invalid("extrude frame is not finite and orthonormal".into()));
- }
- if !(start.is_finite() && end.is_finite() && start.abs() < 1e7 && end.abs() < 1e7) {
- return Err(KernelError::Invalid("extrude distance is not finite".into()));
- }
- let (lo, hi) = if end >= start { (start, end) } else { (end, start) };
- if hi - lo < 1e-6 {
- return Err(KernelError::Invalid("extrude distance is zero".into()));
- }
- if chains.is_empty() || chains.len() > MAX_CHAINS {
- return Err(KernelError::Invalid("pick the curves or profiles to extrude".into()));
- }
- let base = plane.offset(lo);
- let along = crate::body::v3(plane.normal() * (hi - lo));
- let mut sides = Vec::new();
- let mut offset = 0;
- for chain in chains {
- let (wire, seeds) = crate::build::chain_wire_seeds(&base, chain)?;
- let walls: mt::Shell = guard("surface extrude", || Ok(mt::builder::tsweep(&wire, along)))?;
- sides.extend(swept_sides(&walls, &numbered(&seeds, offset), &[]));
- offset += chain.len();
- }
- sheet_body(sides)
+/// The record (by index) and its own index of a part numbered by `offsets` (`kind` 0 for faces, 1
+/// for edges).
+fn owner(offsets: &Offsets, part: usize, kind: usize) -> Option<(usize, usize)> {
+ let k = offsets.iter().rposition(|o| o[kind] <= part)?;
+ Some((k, part - offsets.get(k)?[kind]))
}
-/// A surface revolved from chains of sketch segments on `plane` about the sketch line through
-/// `axis_origin` along `axis_dir`: each chain turned from `start` through `sweep` radians (a
-/// full turn at most), positive angles carrying it toward the sketch normal. A chain end on the
-/// axis stays put there (a cone's apex, a sphere's pole). The walls form one surface body with
-/// no caps, or a solid where they close (a full turn of a closed curve, or of a curve from the
-/// axis back to it); its history has no operands: every face is new.
-pub fn revolve_sheet(plane: &Plane, chains: &[Vec<Seg2>], axis_origin: Vec2, axis_dir: Vec2, start: f64, sweep: f64) -> Result<Body> {
- use std::f64::consts::TAU;
- if !crate::build::frame_ok(plane) || !axis_origin.is_finite() || !axis_dir.is_finite() {
- return Err(KernelError::Invalid("revolve frame is not finite and orthonormal".into()));
+impl Parts {
+ /// Every face of `records` in one set of parts, each record's faces, edges and vertices after
+ /// the ones before it.
+ pub(crate) fn joined(records: &[&Brep]) -> Result<(Parts, Offsets)> {
+ let mut parts = Parts { tolerance: records.iter().map(|r| r.tolerance).fold(0.0, f64::max), ..Parts::default() };
+ let mut offsets = Vec::with_capacity(records.len());
+ for r in records {
+ offsets.push([parts.faces.len(), parts.edges.len(), parts.vertices.len()]);
+ let faces: Vec<(usize, bool)> = (0..r.faces.len()).map(|f| (f, false)).collect();
+ parts.add(r, &faces)?;
+ }
+ Ok((parts, offsets))
}
- if !(start.is_finite() && sweep.is_finite() && start.abs() <= TAU && sweep.abs() <= TAU + 1e-9) {
- return Err(KernelError::Invalid("revolve angles must be finite, a full turn at most".into()));
+
+ /// The faces `picked` of `r` (each with whether to turn it over), on `r`'s own edges and
+ /// vertices.
+ pub(crate) fn of(r: &Brep, picked: &[(usize, bool)]) -> Result<Parts> {
+ let mut parts = Parts { tolerance: r.tolerance, ..Parts::default() };
+ parts.add(r, picked)?;
+ Ok(parts)
}
- if sweep.abs() < 1e-6 {
- return Err(KernelError::Invalid("revolve angle is zero".into()));
+
+ /// Adds the faces `picked` of `r` with all of `r`'s edges and vertices, after the ones here.
+ fn add(&mut self, r: &Brep, picked: &[(usize, bool)]) -> Result<()> {
+ let (e0, v0) = (self.edges.len(), self.vertices.len());
+ let sides = face_sides(r);
+ let shift = |i: u32, by: usize| index(i as usize + by);
+ self.vertices.extend(r.vertices.iter().cloned());
+ for e in &r.edges {
+ let vertices = [shift(e.vertices[0], v0)?, shift(e.vertices[1], v0)?];
+ self.edges.push(b::Edge { vertices, uses: Vec::new(), ..e.clone() });
+ }
+ for &(f, turn) in picked {
+ let face = r.faces.get(f).ok_or_else(|| invalid(format!("no face {f}")))?;
+ let forward = sides.get(f).copied().unwrap_or(true) != turn;
+ let loops = face
+ .loops
+ .iter()
+ .map(|l| {
+ Ok(match l {
+ b::Loop::Edges { edges } => b::Loop::Edges {
+ edges: edges.iter().map(|u| Ok(b::OrientedEdge { edge: shift(u.edge, e0)?, ..u.clone() })).collect::<Result<_>>()?,
+ },
+ b::Loop::Vertex { vertex } => b::Loop::Vertex { vertex: shift(*vertex, v0)? },
+ })
+ })
+ .collect::<Result<_>>()?;
+ self.faces.push((b::Face { loops, ..face.clone() }, forward));
+ }
+ Ok(())
}
- if chains.is_empty() || chains.len() > MAX_CHAINS {
- return Err(KernelError::Invalid("pick the curves or profiles to revolve".into()));
+
+ /// The edges a face's loops use, in order.
+ fn uses_of(f: &b::Face) -> impl Iterator<Item = u32> + '_ {
+ f.loops.iter().flat_map(|l| match l {
+ b::Loop::Edges { edges } => edges.iter().map(|u| u.edge).collect::<Vec<_>>(),
+ b::Loop::Vertex { .. } => Vec::new(),
+ })
}
- let d = axis_dir.normalized().ok_or_else(|| KernelError::Invalid("revolve axis has no direction".into()))?;
- let side = |p: Vec2| d.cross(p - axis_origin);
- let on_axis = |p: Vec2| side(p).abs() < 1e-7;
- let (origin, n) = (plane.to_world(axis_origin), plane.normal());
- let axis = plane.dir_to_world(d).normalized().ok_or_else(|| KernelError::Invalid("revolve frame has no axis".into()))?;
- let mut sides = Vec::new();
- let mut offset = 0;
- for chain in chains {
- // On one side of the axis; the point farthest from it fixes the turning sense.
- let pts: Vec<Vec2> = chain.iter().flat_map(|s| s.polyline(1e-3)).collect();
- if pts.iter().any(|p| side(*p) < -1e-7) && pts.iter().any(|p| side(*p) > 1e-7) {
- return Err(KernelError::Invalid("the curves cross the revolve axis".into()));
+
+ /// The faces in shells: faces joined by an edge are in one shell, shells in the order of their
+ /// first face, each shell's faces in part order.
+ fn shells(&self) -> Result<Vec<Vec<usize>>> {
+ let n = self.faces.len();
+ let mut root: Vec<usize> = (0..n).collect();
+ let find = |root: &[usize], mut i: usize| {
+ while let Some(&g) = root.get(i).filter(|g| **g != i) {
+ i = g;
+ }
+ i
+ };
+ let mut first: Vec<Option<usize>> = vec![None; self.edges.len()];
+ for (fi, (f, _)) in self.faces.iter().enumerate() {
+ for e in Parts::uses_of(f) {
+ let slot = first.get_mut(e as usize).ok_or_else(|| invalid("an edge reference"))?;
+ match *slot {
+ None => *slot = Some(fi),
+ Some(other) => {
+ let (a, c) = (find(&root, other), find(&root, fi));
+ if let Some(g) = root.get_mut(a.max(c)) {
+ *g = a.min(c);
+ }
+ }
+ }
+ }
}
- let far = pts.iter().copied().max_by(|a, b| side(*a).abs().total_cmp(&side(*b).abs())).filter(|p| !on_axis(*p));
- let Some(far) = far else { return Err(KernelError::Invalid("the curves lie on the revolve axis".into())) };
- let radial = plane.to_world(far) - origin;
- let a = if axis.cross(radial).dot(n) < 0.0 { -axis } else { axis };
- let (first, last) = match (chain.first(), chain.last()) {
- (Some(f), Some(l)) => (f.start(), l.end()),
- _ => return Err(KernelError::Invalid("an empty curve chain".into())),
+ let mut shells: Vec<Vec<usize>> = Vec::new();
+ let mut shell_of: std::collections::HashMap<usize, usize> = std::collections::HashMap::new();
+ for fi in 0..n {
+ let s = *shell_of.entry(find(&root, fi)).or_insert_with(|| {
+ shells.push(Vec::new());
+ shells.len() - 1
+ });
+ if let Some(list) = shells.get_mut(s) {
+ list.push(fi);
+ }
+ }
+ Ok(shells)
+ }
+
+ /// The parts as one record in canonical order (docs/native-brep.md, "Canonical order"): shells
+ /// as [`Parts::shells`] groups them, a closed shell enclosing a region of its own; edges in
+ /// first appearance walking faces, loops and uses (backwards on a face used against its
+ /// natural normal), each edge's uses in that order; vertices in first appearance walking
+ /// edges, then vertex loops.
+ pub(crate) fn canonical(&self) -> Result<Canonical> {
+ if self.faces.is_empty() {
+ return Err(invalid("no faces"));
+ }
+ let shells = self.shells()?;
+ let order: Vec<usize> = shells.iter().flatten().copied().collect();
+ let face = |fi: usize| self.faces.get(fi).ok_or_else(|| invalid("a face reference"));
+ let mut edge_new: Vec<Option<u32>> = vec![None; self.edges.len()];
+ let mut edges_old: Vec<usize> = Vec::new();
+ let mut uses: Vec<Vec<b::EdgeUseRef>> = Vec::new();
+ for (nf, &fi) in order.iter().enumerate() {
+ let (f, forward) = face(fi)?;
+ for (li, l) in f.loops.iter().enumerate() {
+ let b::Loop::Edges { edges } = l else { continue };
+ let k = edges.len();
+ for step in 0..k {
+ let p = if *forward { step } else { k - 1 - step };
+ let Some(u) = edges.get(p) else { continue };
+ let slot = edge_new.get_mut(u.edge as usize).ok_or_else(|| invalid("an edge reference"))?;
+ let ne = match *slot {
+ Some(ne) => ne,
+ None => {
+ let ne = index(edges_old.len())?;
+ *slot = Some(ne);
+ edges_old.push(u.edge as usize);
+ uses.push(Vec::new());
+ ne
+ }
+ };
+ let at = b::EdgeUseRef { face: index(nf)?, r#loop: index(li)?, position: index(p)?, upper: !u.forward };
+ if let Some(list) = uses.get_mut(ne as usize) {
+ list.push(at);
+ }
+ }
+ }
+ }
+ let mut vertex_new: Vec<Option<u32>> = vec![None; self.vertices.len()];
+ let mut vertices: Vec<b::Vertex> = Vec::new();
+ let mut visit = |v: u32, vertices: &mut Vec<b::Vertex>| -> Result<u32> {
+ let slot = vertex_new.get_mut(v as usize).ok_or_else(|| invalid("a vertex reference"))?;
+ if let Some(nv) = *slot {
+ return Ok(nv);
+ }
+ let nv = index(vertices.len())?;
+ *slot = Some(nv);
+ vertices.push(self.vertices.get(v as usize).cloned().ok_or_else(|| invalid("a vertex reference"))?);
+ Ok(nv)
};
- let closed = first.dist(last) <= 1e-6;
- if closed && pts.iter().any(|p| on_axis(*p)) {
- return Err(KernelError::Invalid("not supported yet: a closed curve touching the revolve axis".into()));
+ let mut edges = Vec::with_capacity(edges_old.len());
+ for (old, uses) in edges_old.iter().zip(uses) {
+ let e = self.edges.get(*old).ok_or_else(|| invalid("an edge reference"))?;
+ let ends = [visit(e.vertices[0], &mut vertices)?, visit(e.vertices[1], &mut vertices)?];
+ edges.push(b::Edge { vertices: ends, uses, ..e.clone() });
}
- // The chain starts `start` round: its sketch frame turned there, so the wire's own edges
- // are the ones swept (and its faces can be followed back to them).
- let turn = |v: Vec3| crate::build::rotate_about(v, Vec3::ZERO, a, start);
- let turned = Plane { origin: crate::build::rotate_about(plane.origin, origin, a, start), x: turn(plane.x), y: turn(plane.y) };
- let (wire, seeds) = crate::build::chain_wire_seeds(&turned, chain)?;
- let fixed: Vec<mt::VertexID> = [(on_axis(first), wire.front_vertex()), (on_axis(last), wire.back_vertex())]
- .into_iter()
- .filter_map(|(apex, v)| v.filter(|_| apex).map(|v| v.id()))
- .collect();
- let walls: mt::Shell = guard("surface revolve", || {
- Ok(match (on_axis(first), on_axis(last)) {
- (true, _) => mt::builder::cone(&wire, crate::body::v3(a), mt::Rad(sweep)),
- (false, true) => mt::builder::cone(&wire.inverse(), crate::body::v3(a), mt::Rad(sweep)),
- (false, false) => mt::builder::rsweep(&wire, p3(origin), crate::body::v3(a), mt::Rad(sweep)),
- })
- })?;
- sides.extend(swept_sides(&walls, &numbered(&seeds, offset), &fixed));
- offset += chain.len();
+ let mut faces = Vec::with_capacity(order.len());
+ for &fi in &order {
+ let (f, _) = face(fi)?;
+ let mut loops = Vec::with_capacity(f.loops.len());
+ for l in &f.loops {
+ loops.push(match l {
+ b::Loop::Edges { edges } => b::Loop::Edges {
+ edges: edges
+ .iter()
+ .map(|u| {
+ let edge = edge_new.get(u.edge as usize).copied().flatten().ok_or_else(|| invalid("an edge reference"))?;
+ Ok(b::OrientedEdge { edge, ..u.clone() })
+ })
+ .collect::<Result<_>>()?,
+ },
+ b::Loop::Vertex { vertex } => b::Loop::Vertex { vertex: visit(*vertex, &mut vertices)? },
+ });
+ }
+ faces.push(b::Face { loops, ..f.clone() });
+ }
+ let mut numbered = 0usize;
+ let mut shell_records = Vec::with_capacity(shells.len());
+ let mut regions = vec![b::Region { shells: Vec::new(), void: false }];
+ for (s, members) in shells.iter().enumerate() {
+ let mut count: std::collections::HashMap<u32, usize> = std::collections::HashMap::new();
+ let mut list = Vec::with_capacity(members.len());
+ for &fi in members {
+ let (f, forward) = face(fi)?;
+ for e in Parts::uses_of(f) {
+ *count.entry(e).or_default() += 1;
+ }
+ list.push(b::OrientedFace { face: index(numbered)?, forward: *forward });
+ numbered += 1;
+ }
+ shell_records.push(b::Shell::Faces { faces: list, wires: Vec::new() });
+ let s = index(s)?;
+ if let Some(infinite) = regions.first_mut() {
+ infinite.shells.push(s);
+ }
+ if count.values().all(|c| *c >= 2) {
+ regions.push(b::Region { shells: vec![s], void: false });
+ }
+ }
+ let brep = Brep { version: b::VERSION, tolerance: self.tolerance, regions, shells: shell_records, faces, edges, vertices };
+ brep.validate().map_err(|e| failed(format!("faces into a record: {e}")))?;
+ Ok(Canonical { brep, faces: order, edges: edges_old })
}
- sheet_body(sides)
}
-/// A surface swept from chains of sketch segments on `plane` along a path that starts near
-/// them. Along a path whose direction runs on across every joint, lines slide the chains and
-/// arcs turn them, exactly; any other path (curves followed as polylines) goes through
-/// [`sweep_sheet_points`]. The walls form one surface body with no caps (a solid where they
-/// close); its history has no operands: every face is new.
-pub fn sweep_sheet(plane: &Plane, chains: &[Vec<Seg2>], path: &[crate::PathSeg]) -> Result<Body> {
- use crate::PathSeg;
- if !crate::build::frame_ok(plane) {
- return Err(KernelError::Invalid("sweep frame is not finite and orthonormal".into()));
- }
- if chains.is_empty() || chains.len() > MAX_CHAINS {
- return Err(KernelError::Invalid("pick the curves or profiles to sweep".into()));
- }
- let path = &PathSeg::flattened(path)[..];
- if path.is_empty() || path.len() > 1000 {
- return Err(KernelError::Invalid("the path needs 1…1000 segments".into()));
- }
- let ends: Vec<(Vec3, Vec3)> =
- path.iter().map(PathSeg::tangents).collect::<Option<_>>().ok_or_else(|| KernelError::Invalid("a path segment has no direction".into()))?;
- if ends.windows(2).any(|w| w[0].1.dot(w[1].0) < (1e-3f64).cos()) {
- return sweep_sheet_points(plane, chains, &crate::build::path_polyline(path)?);
- }
- let mut sides = Vec::new();
- let mut offset = 0;
- for chain in chains {
- let (mut cur, seeds) = crate::build::chain_wire_seeds(plane, chain)?;
- // Each edge's segments: the next stretch of the path starts from the edges the last one
- // carried them onto, in the same order.
- let mut seeds = numbered(&seeds, offset);
- for seg in path {
- let (part, map): (mt::Shell, Box<dyn Fn(Vec3) -> Vec3>) = match *seg {
- PathSeg::Line { a, b } => {
- (guard("surface sweep", || Ok(mt::builder::tsweep(&cur, crate::body::v3(b - a))))?, Box::new(move |p| p + (b - a)))
+/// Whether each face of `r` is used along its surface's natural normal (by its first oriented
+/// face).
+fn face_sides(r: &Brep) -> Vec<bool> {
+ let mut side = vec![None; r.faces.len()];
+ for s in &r.shells {
+ if let b::Shell::Faces { faces, .. } = s {
+ for f in faces {
+ if let Some(slot) = side.get_mut(f.face as usize) {
+ slot.get_or_insert(f.forward);
}
- PathSeg::Arc { center, axis, angle, .. } => {
- let k = axis.normalized().ok_or_else(|| KernelError::Invalid("a path arc has no axis".into()))?;
- let part = guard("surface sweep", || Ok(mt::builder::rsweep(&cur, p3(center), crate::body::v3(k), mt::Rad(angle))))?;
- (part, Box::new(move |p| crate::build::rotate_about(p, center, k, angle)))
- }
- // The path was flattened: no curves are left.
- PathSeg::Curve { .. } | PathSeg::Bezier(_) => return Err(KernelError::Invalid("a free-form path curve".into())),
- };
- let next = far_wire(&part, &cur, map.as_ref())?;
- sides.extend(swept_sides(&part, &seeds, &[]));
- seeds = next.edge_iter().map(|e| e.id()).zip(seeds.into_iter().map(|(_, n)| n)).collect();
- cur = next;
+ }
}
- offset += chain.len();
}
- sheet_body(sides)
+ side.into_iter().map(|s| s.unwrap_or(true)).collect()
}
-/// A surface swept from chains of sketch segments on `plane` along a 3D polyline path: one smooth
-/// B-spline wall per segment where the path has no corners, else ruled walls between the path's
-/// points, mitred at the corners (see [`sweep_sheet`]).
-pub fn sweep_sheet_points(plane: &Plane, chains: &[Vec<Seg2>], path: &[Vec3]) -> Result<Body> {
- sweep_sheet_points_with(plane, chains, path, &crate::SweepControl::default())
+/// The history of a record over `operands` operands: its faces' `faces`, each edge's origins as
+/// `edge` gives them (from the edge's index, the faces it bounds, ascending, and `faces`).
+fn record_history(r: &Brep, operands: usize, faces: Vec<FaceProv>, edge: impl Fn(usize, &[usize], &[FaceProv]) -> Vec<EdgeOrigin>) -> History {
+ let between = r.edges.iter().map(|e| e.uses.iter().map(|u| u.face as usize).collect::<BTreeSet<_>>().into_iter().collect::<Vec<_>>());
+ let edges = between.enumerate().map(|(i, between)| EdgeProv { origins: edge(i, &between, &faces), faces: between }).collect();
+ History { operands, faces, edges }
}
-/// [`sweep_sheet`] with sweep options. The default options are exactly [`sweep_sheet`]; any
-/// other orientation, a twist or an end scale follow the path as a polyline through stations
-/// (see [`sweep_sheet_points_with`]).
-pub fn sweep_sheet_with(plane: &Plane, chains: &[Vec<Seg2>], path: &[crate::PathSeg], ctl: &crate::SweepControl) -> Result<Body> {
- if ctl.is_default() {
- return sweep_sheet(plane, chains, path);
- }
- let path = &crate::PathSeg::flattened(path)[..];
- ctl.check()?;
- if path.is_empty() || path.len() > 1000 {
- return Err(KernelError::Invalid("the path needs 1…1000 segments".into()));
- }
- if path.iter().any(|s| s.tangents().is_none()) {
- return Err(KernelError::Invalid("a path segment has no direction".into()));
+/// The parameter box of a face's loops: the box of its pcurves' control points (each pcurve lies
+/// within its control polygon).
+fn uv_box(loops: &[b::Loop]) -> Option<[[f64; 2]; 2]> {
+ let mut bx = [[f64::INFINITY, f64::NEG_INFINITY]; 2];
+ for l in loops {
+ let b::Loop::Edges { edges } = l else { continue };
+ for u in edges {
+ let pts: Vec<[f64; 2]> = match &u.pcurve {
+ Curve2::Spline { points, .. } => points.clone(),
+ Curve2::RationalSpline { homogeneous, .. } => homogeneous.iter().map(|h| [h[0] / h[2], h[1] / h[2]]).collect(),
+ };
+ for p in pts {
+ for (d, x) in bx.iter_mut().zip(p) {
+ d[0] = d[0].min(x);
+ d[1] = d[1].max(x);
+ }
+ }
+ }
}
- sweep_sheet_points_with(plane, chains, &crate::build::path_polyline(path)?, ctl)
+ bx.iter().all(|d| d[0].is_finite() && d[1] > d[0]).then_some(bx)
}
-/// [`sweep_sheet_points`] with sweep options: orientation, twist and end scale.
-pub fn sweep_sheet_points_with(plane: &Plane, chains: &[Vec<Seg2>], path: &[Vec3], ctl: &crate::SweepControl) -> Result<Body> {
- ctl.check()?;
- if !crate::build::frame_ok(plane) {
- return Err(KernelError::Invalid("sweep frame is not finite and orthonormal".into()));
- }
- if chains.is_empty() || chains.len() > MAX_CHAINS {
- return Err(KernelError::Invalid("pick the curves or profiles to sweep".into()));
- }
- let ruled = sheet_body(crate::sweep_path::ruled_sheet(plane, chains, path, ctl)?)?;
- // Smooth walls where the path has no corners, kept when their area agrees with the ruled
- // walls' (a fit that went wrong falls back to those).
- if let Ok(Some(sides)) = crate::sweep_path::smooth_sheet(plane, chains, path, ctl)
- && let Ok(smooth) = sheet_body(sides)
- && let (Ok(a), Ok(b)) = (crate::measure(&smooth), crate::measure(&ruled))
- && (a.area - b.area).abs() <= 0.02 * b.area.abs()
- {
- return Ok(smooth);
- }
- Ok(ruled)
+/// A body of a record this module built, and whether it numbers its faces and edges as the
+/// record does (so a history in the record's order is the body's).
+fn record_body(r: &Brep) -> Result<(Body, bool)> {
+ imp::record_body(r)
}
-/// The far side of a sweep of the wire `start`: for each of its edges, in order and the same
-/// way round, the edge of `swept` that `map` carries it onto (matched by its ends and middle).
-fn far_wire(swept: &mt::Shell, start: &mt::Wire, map: &dyn Fn(Vec3) -> Vec3) -> Result<mt::Wire> {
- let near = |p: Vec3, q: Vec3| p.dist(q) <= 1e-6 * (1.0 + p.len().max(q.len()));
- let mid = |e: &mt::Edge| {
- let c = e.oriented_curve();
- let (t0, t1) = c.range_tuple();
- from_p3(c.subs((t0 + t1) / 2.0))
- };
- let mut out = Vec::new();
- for e in start.edge_iter() {
- let (a, b, m) = (map(from_p3(e.front().point())), map(from_p3(e.back().point())), map(mid(e)));
- let found = swept.edge_iter().find_map(|f| {
- let (fa, fb) = (from_p3(f.front().point()), from_p3(f.back().point()));
- if !near(mid(&f), m) {
- None
- } else if near(fa, a) && near(fb, b) {
- Some(f)
- } else if near(fa, b) && near(fb, a) {
- Some(f.inverse())
- } else {
- None
- }
- });
- out.push(found.ok_or_else(|| KernelError::Failed("sweep: lost the curves along the path".into()))?);
- }
- Ok(out.into())
+/// `body` with the history `h` over operands of `counts` faces and edges when its order is the
+/// record's, else with none.
+fn with_history(body: Body, same_order: bool, h: History, counts: &[(usize, usize)]) -> Result<Body> {
+ if same_order { body.with_history_counts(h, counts) } else { Ok(body.without_history()) }
}
-/// A surface lofted through two or more sections, each a chain of sketch segments on its plane,
-/// all open or all closed: ruled between two sections, one smooth face per segment through
-/// three or more. Closed sections are matched as the solid loft matches them; open ones are
-/// split to the same number of segments (longest first) and each turned to run the way the one
-/// before it does. Walls only, no caps; the history has no operands: every face is new.
-pub fn loft_sheet(sections: &[(Plane, Vec<Seg2>)]) -> Result<Body> {
- loft_sheet_with_rails(sections, &[], crate::RailFit::Scale)
+/// A surface body of the record `r` (faces another builder made) with no history.
+pub(crate) fn surface_body(r: &Brep) -> Result<Body> {
+ record_body(r).map(|(body, _)| body.without_history())
}
-/// [`loft_sheet`] following one or two guide rails (polylines from the first section to the last,
-/// through every section's curve; see [`crate::loft_rails`]), `fit` saying how they reshape the
-/// sections between. Without rails, the plain sheet loft.
-pub fn loft_sheet_with_rails(sections: &[(Plane, Vec<Seg2>)], rails: &[Vec<Vec3>], fit: crate::RailFit) -> Result<Body> {
- if sections.len() < 2 || sections.len() > 50 {
- return Err(KernelError::Invalid("a loft needs 2…50 sections".into()));
- }
- let closed: Vec<bool> = sections
- .iter()
- .map(|(_, c)| match (c.first(), c.last()) {
- (Some(f), Some(l)) if c.len() <= 4096 => Ok(l.end().dist(f.start()) <= 1e-6),
- _ => Err(KernelError::Invalid("a loft section has no curves, or too many".into())),
- })
- .collect::<Result<_>>()?;
- let all_closed = closed.iter().all(|c| *c);
- if !all_closed && closed.iter().any(|c| *c) {
- return Err(KernelError::Invalid("the loft sections must be all open or all closed".into()));
- }
- for (plane, chain) in sections {
- // Checks the frame, the numbers and that each chain runs end to end.
- if !crate::build::frame_ok(plane) {
- return Err(KernelError::Invalid("a loft section's frame is not finite and orthonormal".into()));
- }
- crate::build::chain_wire(plane, chain)?;
- }
- let (wires, sources, reversed) = if all_closed {
- let loops: Vec<(Plane, solidcraft_geom::Loop2)> = sections.iter().map(|(p, c)| (*p, solidcraft_geom::Loop2 { segs: c.clone() })).collect();
- crate::build::loft_wires(&loops)?
- } else {
- let n = sections.iter().map(|(_, c)| c.len()).max().unwrap_or(0);
- let mut wires = Vec::with_capacity(sections.len());
- let mut sources = Vec::with_capacity(sections.len());
- let mut prev: Option<(Vec3, Vec3)> = None;
- // Segments are numbered through the sections in the order given.
- let mut offset = 0;
- for (plane, chain) in sections {
- // Each piece with the segment it is (part of).
- let mut segs: Vec<(Seg2, usize)> = chain.iter().enumerate().map(|(i, s)| (*s, offset + i)).collect();
- offset += chain.len();
- // Split the longest segment in half until the counts match.
- while segs.len() < n {
- let Some(i) = segs.iter().enumerate().max_by(|a, b| a.1.0.length().total_cmp(&b.1.0.length())).map(|(i, _)| i) else { break };
- let (s, k) = segs[i];
- let (a, b) = s.split_half();
- segs.splice(i..=i, [(a, k), (b, k)]);
- }
- let ends = |c: &[(Seg2, usize)]| c.first().zip(c.last()).map(|(f, l)| (plane.to_world(f.0.start()), plane.to_world(l.0.end())));
- if let (Some((ps, pe)), Some((s, e))) = (prev, ends(&segs))
- && s.dist(ps) + e.dist(pe) > s.dist(pe) + e.dist(ps)
- {
- segs = segs.iter().rev().map(|(s, k)| (s.reversed(), *k)).collect();
- }
- prev = ends(&segs);
- let pieces: Vec<Seg2> = segs.iter().map(|(s, _)| *s).collect();
- wires.push(crate::build::uniform_chain_wire(plane, &pieces, false)?);
- sources.push(segs.iter().map(|(_, k)| vec![*k]).collect::<Vec<_>>());
- }
- (wires, sources, false)
- };
- let mut planes: Vec<Plane> = sections.iter().map(|(p, _)| *p).collect();
- if reversed {
- planes.reverse();
- }
- let faces = guard("surface loft", || {
- let all = crate::loft_rails::railed_wires(&planes, &wires, all_closed, rails, fit)?;
- // A plain loft falls back to ruled faces where the smooth one fails; a railed one has to
- // follow its rails.
- let smooth = if all.len() >= 3 { Some(crate::build::smooth_loft_faces(&all, &sources, all_closed)) } else { None };
- match smooth {
- Some(Ok(f)) => Ok(f),
- Some(Err(e)) if !rails.is_empty() => Err(e),
- _ => crate::build::ruled_loft_faces(&wires, &sources),
- }
- })?;
- sheet_body(faces)
+/// The faces `picked` of `body` (its record `r`; each with whether to turn it over) as their own
+/// body, each the body's face (Kept), every edge the body's.
+fn taken(body: &Body, r: &Brep, picked: &[(usize, bool)]) -> Result<Body> {
+ let c = Parts::of(r, picked)?.canonical()?;
+ let faces = c.faces.iter().map(|p| picked.get(*p).map_or(0, |(f, _)| *f)).map(|f| record::from_face(0, f, Change::Kept)).collect();
+ let h = record_history(&c.brep, 1, faces, |e, _, _| c.edges.get(e).map(|&edge| EdgeOrigin::Edge { operand: 0, edge }).into_iter().collect());
+ let (result, same) = record_body(&c.brep)?;
+ with_history(result, same, h, &record::counts(&[body]))
+}
+
+// ---- Patches ----------------------------------------------------------------------------
+
+/// A planar surface filling a sketch region. Its history has no operands: the face is new.
+pub fn patch_region(plane: &Plane, region: &Region2) -> Result<Body> {
+ if !crate::build::frame_ok(plane) {
+ return Err(invalid("patch frame is not finite and orthonormal"));
+ }
+ let tolerance = tolerance_of(region.outer.segs.iter().map(|s| plane.to_world(s.start())));
+ let mut parts = Parts { tolerance, ..Parts::default() };
+ // Seen from the plane's normal the outer loop runs counter-clockwise, holes clockwise.
+ let holes = region.holes.iter().map(|h| h.ccw().reversed());
+ let loops = std::iter::once(region.outer.ccw()).chain(holes).map(|lp| sketch_loop(&mut parts, plane, &lp.segs)).collect::<Result<Vec<_>>>()?;
+ let domain = uv_box(&loops).ok_or_else(|| invalid("the region has no area"))?;
+ parts.faces.push((b::Face { surface: crate::freeform::plane_surface(plane), domain, loops }, true));
+ let c = parts.canonical()?;
+ let h = record_history(&c.brep, 0, vec![record::generated(Vec::new())], |_, _, _| Vec::new());
+ let (body, same) = record_body(&c.brep)?;
+ with_history(body, same, h, &[])
+}
+
+/// A record tolerance for geometry spanning `points`: 10⁻⁶ of its size, at least 10⁻⁵ mm (the
+/// kernel's working tolerance).
+fn tolerance_of(points: impl Iterator<Item = Vec3>) -> f64 {
+ let mut bx = solidcraft_geom::Aabb3::EMPTY;
+ for p in points {
+ bx.add(p);
+ }
+ (bx.diagonal() * 1e-6).max(1e-5)
+}
+
+/// One closed loop of sketch segments on `plane` added to `parts` as an edge loop on the plane's
+/// surface: one edge per segment, each segment's start a vertex.
+fn sketch_loop(parts: &mut Parts, plane: &Plane, segs: &[Seg2]) -> Result<b::Loop> {
+ if segs.is_empty() || segs.len() > 100_000 {
+ return Err(invalid("a loop needs 1…100000 curves"));
+ }
+ let v0 = parts.vertices.len();
+ for s in segs {
+ parts.vertices.push(b::Vertex { point: a3(plane.to_world(s.start())), tolerance: parts.tolerance });
+ }
+ let mut edges = Vec::with_capacity(segs.len());
+ for (i, s) in segs.iter().enumerate() {
+ let (curve, pcurve) = crate::freeform::segment(plane, s)?;
+ let vertices = [index(v0 + i)?, index(v0 + (i + 1) % segs.len())?];
+ let edge = index(parts.edges.len())?;
+ parts.edges.push(b::Edge { curve, interval: crate::freeform::INTERVAL, vertices, tolerance: parts.tolerance, uses: Vec::new() });
+ edges.push(b::OrientedEdge { edge, forward: true, pcurve });
+ }
+ Ok(b::Loop::Edges { edges })
}
-/// The edge of a body nearest a point (by samples along each edge).
-pub(crate) fn edge_near(body: &Body, p: Vec3) -> Option<mt::Edge> {
- let mut best: Option<(f64, mt::Edge)> = None;
- for e in body.solid.edge_iter() {
- let c = e.curve();
- let (t0, t1) = c.range_tuple();
+/// The edge of a body nearest a point (by samples along each edge), within 5% of the body's size:
+/// its index in the body's edge order.
+pub(crate) fn edge_near(body: &Body, p: Vec3) -> Option<usize> {
+ let r = crate::native::brep_record(body).ok()?;
+ let mut best: Option<(f64, usize)> = None;
+ for (i, e) in r.edges.iter().enumerate() {
+ let Ok(c) = CurveEval::new(&e.curve) else { continue };
+ let [t0, t1] = e.interval;
for k in 0..=32 {
- let d = from_p3(c.subs(t0 + (t1 - t0) * k as f64 / 32.0)).dist(p);
- if best.as_ref().is_none_or(|(bd, _)| d < *bd) {
- best = Some((d, e.clone()));
+ let Some(q) = c.point(t0 + (t1 - t0) * k as f64 / 32.0) else { continue };
+ let d = q.dist(p);
+ if best.is_none_or(|(bd, _)| d < bd) {
+ best = Some((d, i));
}
}
}
best.filter(|(d, _)| *d <= body.size() * 0.05 + 1e-6).map(|(_, e)| e)
}
+/// A chain of a body's edges: each edge (its index in the body's edge order) and whether the
+/// chain runs along it.
+pub(crate) type Chain = Vec<(usize, bool)>;
+
/// A surface filling a closed loop of a body's edges (each picked by a point on it): one face on
-/// the body's own edges, planar when the loop is certainly planar ([`crate::plane_fit`]), else a
-/// B-spline height field over the loop's plane ([`crate::fill`]; loops that do not bound one are
-/// refused). Its history is over `[body]`: the face is new, its edges the body's own.
+/// the body's own edges, planar when every edge's curve lies in one plane by its own definition
+/// (its control points, or its circle's frame), else a B-spline patch ([`crate::fill`]; loops that
+/// do not bound one are refused). Its history is over `[body]`: the face is new, its edges the
+/// body's own.
pub fn patch_edges(body: &Body, at: &[Vec3]) -> Result<Body> {
body.require_brep("patch")?;
if at.is_empty() || at.len() > 10_000 {
- return Err(KernelError::Invalid("pick the edges of a closed loop".into()));
+ return Err(invalid("pick the edges of a closed loop"));
}
- guard("patch", || {
- let chain = picked_loop(body, at)?;
- let Some(face) = crate::plane_fit::planar_face(&chain, crate::fill::planarity_tolerance(body))? else {
- // Not certainly planar: a fitted surface.
- return crate::fill::fill_loop(body, &chain);
- };
- // A new face on the body's own edges.
- let mut rec = Rebuild::default();
- rec.made(&face, Vec::new());
- Ok(rebuilt_body(surface_body(vec![face]), &[&body.solid], &rec))
- })
+ let r = crate::native::brep_record(body)?;
+ let chain = picked_loop(body, at)?;
+ let Some(plane) = chain_plane(&r, &chain, crate::fill::planarity_tolerance(body))? else {
+ return crate::fill::fill_loop(body, &chain);
+ };
+ let surface = crate::freeform::plane_surface(&plane);
+ let mut parts = Parts { tolerance: r.tolerance, vertices: r.vertices.clone(), ..Parts::default() };
+ parts.edges = r.edges.iter().map(|e| b::Edge { uses: Vec::new(), ..e.clone() }).collect();
+ let mut uses = Vec::with_capacity(chain.len());
+ for &(e, forward) in &chain {
+ let edge = r.edges.get(e).ok_or_else(|| invalid("an edge reference"))?;
+ uses.push(b::pcurve::EdgeUse {
+ edge: index(e)?,
+ curve: &edge.curve,
+ interval: edge.interval,
+ forward,
+ tolerance: edge.tolerance,
+ given: None,
+ });
+ }
+ let pcurves = b::pcurve::pcurves(&surface, &[uses], r.tolerance).map_err(|e| failed(format!("patch: {e}")))?;
+ let edges = chain
+ .iter()
+ .zip(pcurves.into_iter().flatten())
+ .map(|(&(e, forward), pcurve)| Ok(b::OrientedEdge { edge: index(e)?, forward, pcurve }))
+ .collect::<Result<Vec<_>>>()?;
+ let loops = vec![b::Loop::Edges { edges }];
+ let domain = uv_box(&loops).ok_or_else(|| invalid("the loop encloses no area"))?;
+ parts.faces.push((b::Face { surface, domain, loops }, true));
+ let c = parts.canonical()?;
+ let h = record_history(&c.brep, 1, vec![record::generated(Vec::new())], |e, _, _| {
+ c.edges.get(e).map(|&edge| EdgeOrigin::Edge { operand: 0, edge }).into_iter().collect()
+ });
+ let (result, same) = record_body(&c.brep)?;
+ with_history(result, same, h, &record::counts(&[body]))
}
-/// The edges of `body` picked by points on them, chained into one closed loop (each turned to
-/// run along it). Call it under [`guard`]: sampling an intersection curve can fail in truck.
-pub(crate) fn picked_loop(body: &Body, at: &[Vec3]) -> Result<Vec<mt::Edge>> {
+/// The plane every curve of `chain` lies in by its definition, within `tol` (lines and splines by
+/// their control points, circles and ellipses by their frames), its axes turned so that the chain
+/// runs counter-clockwise about its normal; `None` when there is none.
+fn chain_plane(r: &Brep, chain: &Chain, tol: f64) -> Result<Option<Plane>> {
+ let edge = |e: usize| r.edges.get(e).ok_or_else(|| invalid("an edge reference"));
+ let mut points: Vec<Vec3> = Vec::new();
+ let mut axes: Vec<(Vec3, Vec3)> = Vec::new();
+ for &(e, _) in chain {
+ match &edge(e)?.curve {
+ b::Curve::Line { start, end } => points.extend([v3(*start), v3(*end)]),
+ b::Curve::Polyline { points: p } | b::Curve::Spline { points: p, .. } => points.extend(p.iter().map(|q| v3(*q))),
+ b::Curve::RationalSpline { homogeneous, .. } => {
+ points.extend(homogeneous.iter().map(|h| Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3])))
+ }
+ b::Curve::Circle { frame, .. } | b::Curve::Ellipse { frame, .. } => {
+ points.push(v3(frame.origin));
+ axes.push((v3(frame.origin), v3(frame.x_axis).cross(v3(frame.y_axis))));
+ }
+ b::Curve::SurfaceIntersection { .. } => return Ok(None),
+ }
+ }
+ let Some(&p0) = points.first() else { return Ok(None) };
+ // The normal: a circle's axis, else the widest cross product of the points about the first.
+ let normal = axes.first().map(|(_, n)| *n).or_else(|| {
+ let far = points.iter().copied().max_by(|a, c| a.dist(p0).total_cmp(&c.dist(p0)))?;
+ points.iter().map(|q| (far - p0).cross(*q - p0)).max_by(|a, c| a.len().total_cmp(&c.len()))
+ });
+ let Some(n) = normal.and_then(|n| n.normalized()) else { return Ok(None) };
+ let on = |q: Vec3| (q - p0).dot(n).abs() <= tol;
+ if !points.iter().all(|q| on(*q)) || axes.iter().any(|(c, a)| !on(*c) || a.cross(n).len() > 1e-9 * a.len().max(1.0)) {
+ return Ok(None);
+ }
+ // Which way round the chain runs about `n`: the turn of points along it.
+ let mut ring: Vec<Vec3> = Vec::new();
+ for &(e, forward) in chain {
+ let x = edge(e)?;
+ let c = CurveEval::new(&x.curve).map_err(|err| failed(format!("patch: {err}")))?;
+ let [t0, t1] = x.interval;
+ for k in 0..16 {
+ let f = k as f64 / 16.0;
+ ring.push(c.point(if forward { t0 + (t1 - t0) * f } else { t1 - (t1 - t0) * f }).ok_or_else(|| failed("patch: an edge has no point"))?);
+ }
+ }
+ let turn: f64 = ring.iter().zip(ring.iter().cycle().skip(1)).map(|(a, c)| (*a - p0).cross(*c - p0).dot(n)).sum();
+ let n = if turn < 0.0 { n * -1.0 } else { n };
+ let x = (if n.x.abs() < 0.9 { Vec3::X } else { Vec3::Y }).cross(n).normalized().ok_or_else(|| failed("patch plane"))?;
+ Ok(Plane::new(p0, x, n.cross(x)))
+}
+
+/// The edges of `body` picked by points on them, chained into one closed loop (each turned to run
+/// along it).
+pub(crate) fn picked_loop(body: &Body, at: &[Vec3]) -> Result<Chain> {
match picked_chain(body, at)? {
(chain, true) => Ok(chain),
- (_, false) => Err(KernelError::Invalid("the edges do not form a closed loop".into())),
+ (_, false) => Err(invalid("the edges do not form a closed loop")),
}
}
-/// The edges of `body` picked by points on them, chained end to end (each turned to run along
-/// the chain), and whether the chain closes: a closed loop starts with the last edge picked; an
-/// open chain runs from the free end met first in pick order. Edges that branch, or form more
-/// than one chain, are refused. Call it under [`guard`], as [`picked_loop`].
-pub(crate) fn picked_chain(body: &Body, at: &[Vec3]) -> Result<(Vec<mt::Edge>, bool)> {
- let mut edges: Vec<mt::Edge> = Vec::new();
+/// The edges of `body` picked by points on them, chained end to end (each turned to run along the
+/// chain), and whether the chain closes: a closed loop starts with the last edge picked; an open
+/// chain runs from the free end met first in pick order. Edges that branch, or form more than one
+/// chain, are refused.
+pub(crate) fn picked_chain(body: &Body, at: &[Vec3]) -> Result<(Chain, bool)> {
+ let r = crate::native::brep_record(body)?;
+ let mut edges: Vec<usize> = Vec::new();
for p in at {
- let e = edge_near(body, *p).ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}")))?;
- if !edges.iter().any(|x| x.id() == e.id()) {
+ let e = edge_near(body, *p).ok_or_else(|| invalid(format!("no edge at {p:?}")))?;
+ if !edges.contains(&e) {
edges.push(e);
}
}
- let mut uses: HashMap<mt::VertexID, usize> = HashMap::new();
- for e in &edges {
- *uses.entry(e.front().id()).or_default() += 1;
- *uses.entry(e.back().id()).or_default() += 1;
+ let ends = |e: usize| r.edges.get(e).map(|x| x.vertices);
+ let mut uses: std::collections::HashMap<u32, usize> = std::collections::HashMap::new();
+ for &e in &edges {
+ for v in ends(e).ok_or_else(|| invalid("an edge reference"))? {
+ *uses.entry(v).or_default() += 1;
+ }
}
if uses.values().any(|n| *n > 2) {
- return Err(KernelError::Invalid("the edges branch: pick one chain".into()));
+ return Err(invalid("the edges branch: pick one chain"));
}
- let free = |v: &mt::Vertex| uses.get(&v.id()) == Some(&1);
- let open_end = edges.iter().find_map(|e| [e.front(), e.back()].into_iter().find(|v| free(v)).cloned());
+ let open_end = edges.iter().find_map(|&e| ends(e)?.into_iter().find(|v| uses.get(v) == Some(&1)));
let mut pool = edges;
- let (first, closed) = match &open_end {
+ let (first, closed) = match open_end {
Some(v) => {
- let k = pool.iter().position(|e| e.front().id() == v.id() || e.back().id() == v.id());
- let e = k.map(|k| pool.remove(k)).ok_or_else(|| KernelError::Invalid("no edges".into()))?;
- (if e.front().id() == v.id() { e } else { e.inverse() }, false)
+ let k = pool.iter().position(|&e| ends(e).is_some_and(|x| x.contains(&v))).ok_or_else(|| invalid("no edges"))?;
+ let e = pool.remove(k);
+ ((e, ends(e).is_some_and(|x| x[0] == v)), false)
}
- None => (pool.pop().ok_or_else(|| KernelError::Invalid("no edges".into()))?, true),
+ None => ((pool.pop().ok_or_else(|| invalid("no edges"))?, true), true),
};
- let start = first.front().id();
- let mut at_v = first.back().clone();
+ let head = |(e, forward): (usize, bool)| ends(e).map(|x| if forward { x[1] } else { x[0] });
+ let start = ends(first.0).map(|x| if first.1 { x[0] } else { x[1] });
+ let mut at_v = head(first);
let mut chain = vec![first];
- while !(closed && at_v.id() == start) {
- let Some(k) = pool.iter().position(|e| e.front().id() == at_v.id() || e.back().id() == at_v.id()) else { break };
+ while !(closed && at_v == start) {
+ let Some(v) = at_v else { break };
+ let Some(k) = pool.iter().position(|&e| ends(e).is_some_and(|x| x.contains(&v))) else { break };
let e = pool.remove(k);
- let e = if e.front().id() == at_v.id() { e } else { e.inverse() };
- at_v = e.back().clone();
- chain.push(e);
+ let link = (e, ends(e).is_some_and(|x| x[0] == v));
+ at_v = head(link);
+ chain.push(link);
}
if !pool.is_empty() {
let what = if closed { "the edges form more than one loop" } else { "the edges form more than one chain" };
- return Err(KernelError::Invalid(what.into()));
+ return Err(invalid(what));
}
Ok((chain, closed))
}
-/// Faces of a body copied out as a surface body (faces picked by points on them). Its history is
-/// over `[body]`: the faces and their edges are the body's.
-pub fn copy_faces(body: &Body, at: &[Vec3]) -> Result<Body> {
- body.require_brep("copy faces")?;
- let faces: Vec<&mt::Face> = body.solid.face_iter().collect();
- let mut chosen = Vec::new();
- for p in at {
- // The face whose mesh passes nearest the point.
- let i = nearest_face(body, *p)?;
- if !chosen.contains(&i) {
- chosen.push(i);
+// ---- Faces of a body --------------------------------------------------------------------
+
+/// Index of the face nearest a point (over its mesh triangles).
+pub(crate) fn nearest_face(body: &Body, p: Vec3) -> Result<usize> {
+ let m = body.mesh(&crate::MeshTolerance::chord(body.size() * 2e-3))?;
+ let mut best: Option<(f64, u32)> = None;
+ for (t, f) in m.triangles.iter().zip(&m.tri_face) {
+ let Some([a, b, c]) = m.tri(t) else { continue };
+ let d = ((a + b + c) / 3.0).dist(p).min(a.dist(p)).min(b.dist(p)).min(c.dist(p));
+ if best.is_none_or(|(x, _)| d < x) {
+ best = Some((d, *f));
}
}
- let copied = surface_body(chosen.into_iter().filter_map(|i| faces.get(i).map(|f| (*f).clone())).collect());
- Ok(rebuilt_body(copied, &[&body.solid], &Rebuild::default()))
+ best.map(|(_, f)| f as usize).ok_or_else(|| invalid("no face there"))
}
-/// The faces picked by points on them (each once, in the order picked); every face when no
-/// point is given.
+/// The faces picked by points on them (each once, in the order picked); every face when no point
+/// is given.
fn picked_faces(body: &Body, at: &[Vec3]) -> Result<Vec<usize>> {
if at.len() > 10_000 {
- return Err(KernelError::Invalid("too many faces picked".into()));
+ return Err(invalid("too many faces picked"));
}
if at.is_empty() {
return Ok((0..body.face_count()).collect());
@@ -542,663 +630,825 @@ fn picked_faces(body: &Body, at: &[Vec3]) -> Result<Vec<usize>> {
Ok(chosen)
}
-/// A body's faces taken apart: each picked face (by points on it; every face when none are
-/// given) its own surface body, and the faces left, if any, one surface body. A solid comes
-/// apart into surfaces. Histories are over `[body]`: each face is the body's.
+/// Faces of a body copied out as a surface body (faces picked by points on them). Its history is
+/// over `[body]`: the faces and their edges are the body's.
+pub fn copy_faces(body: &Body, at: &[Vec3]) -> Result<Body> {
+ body.require_brep("copy faces")?;
+ if at.is_empty() {
+ return Err(invalid("pick the faces to copy"));
+ }
+ let chosen = picked_faces(body, at)?;
+ let r = crate::native::brep_record(body)?;
+ taken(body, &r, &chosen.into_iter().map(|f| (f, false)).collect::<Vec<_>>())
+}
+
+/// A body's faces taken apart: each picked face (by points on it; every face when none are given)
+/// its own surface body, and the faces left, if any, one surface body. A solid comes apart into
+/// surfaces. Histories are over `[body]`: each face is the body's.
pub fn unstitch(body: &Body, at: &[Vec3]) -> Result<(Vec<Body>, Option<Body>)> {
body.require_brep("unstitch")?;
+ let r = crate::native::brep_record(body)?;
+ if r.faces.len() < 2 {
+ return Err(invalid("the body has one face: nothing to unstitch"));
+ }
let chosen = picked_faces(body, at)?;
- let faces: Vec<&mt::Face> = body.solid.face_iter().collect();
- if faces.len() < 2 {
- return Err(KernelError::Invalid("the body has one face: nothing to unstitch".into()));
- }
- let piece = |picked: Vec<mt::Face>| rebuilt_body(surface_body(picked), &[&body.solid], &Rebuild::default());
- let pieces: Vec<Body> = chosen.iter().filter_map(|i| faces.get(*i)).map(|f| piece(vec![(*f).clone()])).collect();
- let rest: Vec<mt::Face> = faces.iter().enumerate().filter(|(i, _)| !chosen.contains(i)).map(|(_, f)| (*f).clone()).collect();
- Ok((pieces, (!rest.is_empty()).then(|| piece(rest))))
+ let pieces = chosen.iter().map(|f| taken(body, &r, &[(*f, false)])).collect::<Result<Vec<_>>>()?;
+ let rest: Vec<(usize, bool)> = (0..r.faces.len()).filter(|f| !chosen.contains(f)).map(|f| (f, false)).collect();
+ let rest = if rest.is_empty() { None } else { Some(taken(body, &r, &rest)?) };
+ Ok((pieces, rest))
}
-/// A surface body with the picked faces (by points on them; every face when none are given)
-/// turned over: their normals point the other way. A solid is refused (its faces face out).
-/// The history is over `[body]`: each face is the body's, turned over or not.
+/// A surface body with the picked faces (by points on them; every face when none are given) turned
+/// over: their normals point the other way. A solid is refused (its faces face out). The history
+/// is over `[body]`: each face is the body's, turned over or not.
pub fn reverse_faces(body: &Body, at: &[Vec3]) -> Result<Body> {
body.require_brep("reverse normal")?;
if !body.is_surface() {
- return Err(KernelError::Invalid("a solid's faces face out: unstitch it into surfaces first".into()));
+ return Err(invalid("a solid's faces face out: unstitch it into surfaces first"));
}
let chosen = picked_faces(body, at)?;
- let mut rec = Rebuild::default();
- let faces: Vec<mt::Face> = body
- .solid
- .face_iter()
- .enumerate()
- .map(|(i, f)| {
- if !chosen.contains(&i) {
- return f.clone();
- }
- let turned = f.inverse();
- rec.whole(&turned, f);
- turned
- })
- .collect();
- Ok(rebuilt_body(surface_body(faces), &[&body.solid], &rec))
+ let r = crate::native::brep_record(body)?;
+ taken(body, &r, &(0..r.faces.len()).map(|f| (f, chosen.contains(&f))).collect::<Vec<_>>())
}
-/// A body with some of its faces (indices in its face order) taken away and the gap left open:
-/// a surface body of the faces left. Deleting every face is refused. The history is over
-/// `[body]`: each face left is the body's.
+/// A body with some of its faces (indices in its face order) taken away and the gap left open: a
+/// surface body of the faces left. Deleting every face is refused. The history is over `[body]`:
+/// each face left is the body's.
pub fn remove_faces(body: &Body, faces: &[usize]) -> Result<Body> {
body.require_brep("Delete Face")?;
if faces.is_empty() {
- return Err(KernelError::Invalid("no faces given".into()));
+ return Err(invalid("no faces given"));
}
- let left: Vec<mt::Face> = body.solid.face_iter().enumerate().filter(|(i, _)| !faces.contains(i)).map(|(_, f)| f.clone()).collect();
+ let r = crate::native::brep_record(body)?;
+ let left: Vec<(usize, bool)> = (0..r.faces.len()).filter(|f| !faces.contains(f)).map(|f| (f, false)).collect();
if left.is_empty() {
- return Err(KernelError::Invalid("that would delete every face of the body".into()));
+ return Err(invalid("that would delete every face of the body"));
}
- Ok(rebuilt_body(surface_body(left), &[&body.solid], &Rebuild::default()))
+ taken(body, &r, &left)
}
-/// Index of the face nearest a point (over its mesh triangles).
-pub(crate) fn nearest_face(body: &Body, p: Vec3) -> Result<usize> {
- let m = body.mesh(&crate::MeshTolerance::chord(body.size() * 2e-3))?;
- let mut best: Option<(f64, u32)> = None;
- for (t, f) in m.triangles.iter().zip(&m.tri_face) {
- let Some([a, b, c]) = m.tri(t) else { continue };
- let d = ((a + b + c) / 3.0).dist(p).min(a.dist(p)).min(b.dist(p)).min(c.dist(p));
- if best.is_none_or(|(x, _)| d < x) {
- best = Some((d, *f));
+/// `h`, a history over one record whose faces and edges came from the parts `c` numbers, carried
+/// to the records `offsets` took them from: each face origin through `face`, each edge origin to
+/// the record edge it was (`None` where an origin has no record behind it).
+fn carried(h: &History, c: &Canonical, offsets: &Offsets, operands: usize, face: impl Fn(usize, usize) -> FaceOrigin) -> Option<History> {
+ let back = |o: FaceOrigin| -> std::result::Result<FaceOrigin, ()> {
+ match o {
+ FaceOrigin::Face { face: f, .. } => c.faces.get(f).and_then(|p| owner(offsets, *p, 0)).map(|(k, i)| face(k, i)).ok_or(()),
+ other => Ok(other),
}
- }
- best.map(|(_, f)| f as usize).ok_or_else(|| KernelError::Invalid("no face there".into()))
+ };
+ let faces = h
+ .faces
+ .iter()
+ .map(|f| Some(FaceProv { origins: f.origins.iter().map(|o| back(*o).ok()).collect::<Option<_>>()?, change: f.change }))
+ .collect::<Option<Vec<_>>>()?;
+ let edges = h
+ .edges
+ .iter()
+ .map(|e| {
+ let origins = e
+ .origins
+ .iter()
+ .map(|o| match o {
+ EdgeOrigin::Edge { edge, .. } => {
+ let (operand, edge) = c.edges.get(*edge).and_then(|p| owner(offsets, *p, 1))?;
+ Some(EdgeOrigin::Edge { operand, edge })
+ }
+ EdgeOrigin::Meet { a, b } => Some(EdgeOrigin::Meet { a: a.try_map(back).ok()?, b: b.try_map(back).ok()? }),
+ })
+ .collect::<Option<_>>()?;
+ Some(EdgeProv { faces: e.faces.clone(), origins })
+ })
+ .collect::<Option<Vec<_>>>()?;
+ Some(History { operands, faces, edges })
}
-/// Sew surface bodies along edges that coincide (within `tol`): one body, a solid when the
-/// faces close up. Faces are turned so that neighbours agree. The result's history is over
-/// `bodies`: each face the one it was sewn from, each edge the edges sewn into it.
+/// Sew surface bodies along edges that coincide (within `tol`; the bodies' working tolerance when
+/// not positive): one body, a solid when the faces close up. SMLib turns the faces so that
+/// neighbours agree (outward on a solid). The result's history is over `bodies`: each face the one
+/// it was sewn from, each edge the edges sewn into it.
pub fn stitch(bodies: &[&Body], tol: f64) -> Result<Body> {
if bodies.is_empty() {
- return Err(KernelError::Invalid("nothing to stitch".into()));
+ return Err(invalid("nothing to stitch"));
}
for b in bodies {
b.require_brep("stitch")?;
}
let size = bodies.iter().map(|b| b.size()).fold(0.0, f64::max);
let tol = if tol.is_finite() && tol > 0.0 { tol } else { size * 1e-6 + 1e-6 };
- guard("stitch", || {
- let faces: Vec<mt::Face> = bodies.iter().flat_map(|b| b.solid.face_iter().cloned().collect::<Vec<_>>()).collect();
- // Shared vertices by position, shared edges by their ends and middle.
- let mut verts: Vec<mt::Vertex> = Vec::new();
- let mut vmap: HashMap<mt::VertexID, mt::Vertex> = HashMap::new();
- let mut canon = |v: &mt::Vertex, verts: &mut Vec<mt::Vertex>| -> mt::Vertex {
- if let Some(c) = vmap.get(&v.id()) {
- return c.clone();
- }
- let p = v.point();
- let c = match verts.iter().find(|u| u.point().distance(p) <= tol) {
- Some(u) => u.clone(),
- None => {
- verts.push(v.clone());
- v.clone()
- }
- };
- vmap.insert(v.id(), c.clone());
- c
- };
- let mut edges: Vec<(mt::Edge, mt::Point3)> = Vec::new();
- let mut out = Vec::with_capacity(faces.len());
- let mut rec = Rebuild::default();
- for f in &faces {
- let mut wires = Vec::new();
- for w in f.absolute_boundaries() {
- let mut nw = Vec::new();
- for e in w.edge_iter() {
- let abs = if e.orientation() { e.clone() } else { e.inverse() };
- let (a, b) = (canon(abs.front(), &mut verts), canon(abs.back(), &mut verts));
- let c = abs.curve();
- let (t0, t1) = c.range_tuple();
- let mid = c.subs(0.5 * (t0 + t1));
- let found = edges.iter().find_map(|(x, m)| {
- if m.distance(mid) > tol * 10.0 {
- return None;
- }
- if x.front().id() == a.id() && x.back().id() == b.id() {
- Some(x.clone())
- } else if x.front().id() == b.id() && x.back().id() == a.id() {
- Some(x.inverse())
- } else {
- None
- }
- });
- let ne = match found {
- Some(x) => x,
- None => {
- let x = mt::Edge::new_unchecked(&a, &b, c);
- edges.push((x.clone(), mid));
- x
- }
- };
- rec.piece(&ne, &abs);
- nw.push(if e.orientation() { ne } else { ne.inverse() });
- }
- wires.push(mt::Wire::from(nw));
- }
- let mut nf = mt::Face::new_unchecked(wires, f.surface());
- if !f.orientation() {
- nf.invert();
- }
- rec.whole(&nf, f);
- out.push(nf);
+ let records = bodies.iter().map(|b| crate::native::brep_record(b)).collect::<Result<Vec<_>>>()?;
+ let (parts, offsets) = Parts::joined(&records.iter().collect::<Vec<_>>())?;
+ let c = parts.canonical()?;
+ let (body, h) = imp::stitched(&c.brep, tol)?;
+ let h = h.and_then(|h| carried(&h, &c, &offsets, bodies.len(), |operand, face| FaceOrigin::Face { operand, face }));
+ Ok(body.with_checked_history(h, &record::counts(bodies)))
+}
+
+/// A surface body thickened into a solid: offset along the faces' normals by `thickness`
+/// (negative: against them), or by half each way when `symmetric`, by SMLib's thicken
+/// ([`crate::offset_backend::thicken`]).
+pub fn thicken(body: &Body, thickness: f64, symmetric: bool) -> Result<Body> {
+ body.require_brep("thicken")?;
+ imp::thicken(body, thickness, symmetric)
+}
+
+/// The faces `picked` of `body` (indices in its face order) offset one by one by SMLib, each onto
+/// its surface's offset by `distance` along its normal, and stitched where their offsets meet
+/// within `tolerance` (neighbours meeting smoothly stay joined; across a sharp edge they come
+/// apart): see [`crate::offset_surface`]. A distance of zero copies the faces. Each face is the
+/// offset of the one it came from.
+pub(crate) fn offset_faces(body: &Body, picked: &[usize], distance: f64, tolerance: f64) -> Result<Body> {
+ let r = crate::native::brep_record(body)?;
+ if distance == 0.0 {
+ return taken(body, &r, &picked.iter().map(|f| (*f, false)).collect::<Vec<_>>());
+ }
+ let moved = picked.iter().map(|f| imp::offset_face(&r, *f, distance)).collect::<Result<Vec<_>>>()?;
+ let (parts, offsets) = Parts::joined(&moved.iter().collect::<Vec<_>>())?;
+ let c = parts.canonical()?;
+ let (result, h) = imp::stitched(&c.brep, tolerance.max(c.brep.tolerance))?;
+ let offset = |k: usize, _: usize| FaceOrigin::Offset { operand: 0, face: picked.get(k).copied().unwrap_or(0) };
+ let faces = h
+ .and_then(|h| carried(&h, &c, &offsets, 1, offset))
+ .map(|h| h.faces.into_iter().map(|f| FaceProv { change: Change::Generated, ..f }).collect::<Vec<_>>());
+ let rec = crate::native::brep_record(&result)?;
+ let h = faces.map(|faces| record_history(&rec, 1, faces, |_, between, faces| record::meeting(between, faces)));
+ Ok(result.with_checked_history(h, &record::counts(&[body])))
+}
+
+/// A planar surface extended: the chosen straight edges (picked by points on them) move outward in
+/// the face's plane by `distance`, their neighbours lengthened to meet them. The result's history
+/// is over `[body]`: the face is the body's face rebuilt, each edge the one it was moved from.
+pub fn extend(body: &Body, at: &[Vec3], distance: f64) -> Result<Body> {
+ body.require_brep("extend")?;
+ if !(distance.is_finite() && distance > 0.0) {
+ return Err(invalid("the extension distance must be positive"));
+ }
+ let r = crate::native::brep_record(body)?;
+ let [face] = r.faces.as_slice() else { return Err(invalid("not supported yet: extending a surface of more than one face")) };
+ let (origin, du, dv) = match face.surface {
+ b::Surface::Plane { origin, u_axis, v_axis } => (v3(origin), v3(u_axis), v3(v_axis)),
+ b::Surface::PlaneThrough { origin, u_point, v_point } => (v3(origin), v3(u_point) - v3(origin), v3(v_point) - v3(origin)),
+ _ => return Err(invalid("not supported yet: extending a surface that is not planar")),
+ };
+ // The outer loop runs counter-clockwise about the surface's natural normal.
+ let n = du.cross(dv).normalized().ok_or_else(|| invalid("a planar face with no normal"))?;
+ let [b::Loop::Edges { edges: rim }] = face.loops.as_slice() else { return Err(invalid("not supported yet: extending a surface with holes")) };
+ let chosen: Vec<usize> = at.iter().map(|p| edge_near(body, *p).ok_or_else(|| invalid(format!("no edge at {p:?}")))).collect::<Result<_>>()?;
+ let m = rim.len();
+ // Each edge as a line (point, direction along the loop), moved outward when chosen.
+ let mut lines = Vec::with_capacity(m);
+ for u in rim {
+ let e = r.edges.get(u.edge as usize).ok_or_else(|| invalid("an edge reference"))?;
+ let b::Curve::Line { start, end } = e.curve else { return Err(invalid("not supported yet: extending a surface with curved edges")) };
+ let at_t = |t: f64| v3(start) + (v3(end) - v3(start)) * t;
+ let (a, z) = if u.forward { (at_t(e.interval[0]), at_t(e.interval[1])) } else { (at_t(e.interval[1]), at_t(e.interval[0])) };
+ let d = (z - a).normalized().ok_or_else(|| invalid("a zero-length edge"))?;
+ // Outward: right of the edge seen along the normal (the face is on its left).
+ let shift = if chosen.contains(&(u.edge as usize)) { distance } else { 0.0 };
+ lines.push((a + d.cross(n) * shift, d));
+ }
+ // Corners: where consecutive lines meet.
+ let meet = |(p, d): (Vec3, Vec3), (q, e): (Vec3, Vec3)| -> Option<Vec3> {
+ let c = d.cross(e);
+ let cc = c.dot(c);
+ (cc >= 1e-24).then(|| p + d * ((q - p).cross(e).dot(c) / cc))
+ };
+ let mut parts = Parts { tolerance: r.tolerance, ..Parts::default() };
+ for i in 0..m {
+ let (Some(prev), Some(cur)) = (lines.get((i + m - 1) % m), lines.get(i)) else { continue };
+ parts.vertices.push(b::Vertex { point: a3(meet(*prev, *cur).unwrap_or(cur.0)), tolerance: r.tolerance });
+ }
+ for i in 0..m {
+ let (Some(a), Some(z)) = (parts.vertices.get(i), parts.vertices.get((i + 1) % m)) else { continue };
+ let curve = b::Curve::Line { start: a.point, end: z.point };
+ parts.edges.push(b::Edge {
+ curve,
+ interval: [0.0, 1.0],
+ vertices: [index(i)?, index((i + 1) % m)?],
+ tolerance: r.tolerance,
+ uses: Vec::new(),
+ });
+ }
+ let uses = parts
+ .edges
+ .iter()
+ .enumerate()
+ .map(|(i, e)| {
+ Ok(b::pcurve::EdgeUse { edge: index(i)?, curve: &e.curve, interval: e.interval, forward: true, tolerance: e.tolerance, given: None })
+ })
+ .collect::<Result<Vec<_>>>()?;
+ let surface = b::Surface::Plane { origin: a3(origin), u_axis: a3(du), v_axis: a3(dv) };
+ let pcurves = b::pcurve::pcurves(&surface, &[uses], r.tolerance).map_err(|e| failed(format!("extend: {e}")))?;
+ let edges = pcurves
+ .into_iter()
+ .flatten()
+ .enumerate()
+ .map(|(i, pcurve)| Ok(b::OrientedEdge { edge: index(i)?, forward: true, pcurve }))
+ .collect::<Result<Vec<_>>>()?;
+ let loops = vec![b::Loop::Edges { edges }];
+ let domain = uv_box(&loops).ok_or_else(|| invalid("the extended face has no area"))?;
+ let forward = face_sides(&r).first().copied().unwrap_or(true);
+ parts.faces.push((b::Face { surface, domain, loops }, forward));
+ let c = parts.canonical()?;
+ let h = record_history(&c.brep, 1, vec![record::from_face(0, 0, Change::Modified)], |e, _, _| {
+ c.edges.get(e).and_then(|p| rim.get(*p)).map(|u| EdgeOrigin::Edge { operand: 0, edge: u.edge as usize }).into_iter().collect()
+ });
+ let (result, same) = record_body(&c.brep)?;
+ with_history(result, same, h, &record::counts(&[body]))
+}
+
+// ---- Sheets swept from sketch curves ------------------------------------------------------
+
+/// Most curve chains one surface sweep takes.
+const MAX_CHAINS: usize = 10_000;
+
+/// A sketch segment with its number across all the chains (chain after chain).
+type Numbered = (Seg2, usize);
+
+/// The chains' segments, numbered on across the chains.
+fn numbered(chains: &[Vec<Seg2>]) -> Vec<Vec<Numbered>> {
+ let mut next = 0;
+ chains
+ .iter()
+ .map(|c| {
+ c.iter()
+ .map(|s| {
+ next += 1;
+ (*s, next - 1)
+ })
+ .collect()
+ })
+ .collect()
+}
+
+fn check_chains(chains: &[Vec<Seg2>], what: &str) -> Result<()> {
+ if chains.is_empty() || chains.len() > MAX_CHAINS {
+ return Err(invalid(format!("pick the curves or profiles to {what}")));
+ }
+ for c in chains {
+ if c.is_empty() || c.len() > 4096 {
+ return Err(invalid("a curve chain has no curves, or too many"));
}
- // Neighbours run their shared edges opposite ways.
- let mut uses: HashMap<mt::EdgeID, Vec<(usize, bool)>> = HashMap::new();
- for (i, f) in out.iter().enumerate() {
- for e in f.boundaries().iter().flat_map(|w| w.edge_iter()) {
- uses.entry(e.id()).or_default().push((i, e.orientation()));
- }
+ if c.iter().any(|s| !(s.start().is_finite() && s.end().is_finite())) {
+ return Err(invalid("a curve chain is not finite"));
}
- let mut flip: Vec<Option<bool>> = vec![None; out.len()];
- for s in 0..out.len() {
- if flip[s].is_some() {
- continue;
- }
- flip[s] = Some(false);
- let mut stack = vec![s];
- while let Some(i) = stack.pop() {
- let fl = flip[i].unwrap_or(false);
- let Some(f) = out.get(i) else { continue };
- for e in f.boundaries().iter().flat_map(|w| w.edge_iter()) {
- let d = e.orientation() != fl;
- for &(j, dj) in uses.get(&e.id()).into_iter().flatten() {
- if j != i && flip[j].is_none() {
- flip[j] = Some(dj == d);
- stack.push(j);
- }
+ if c.windows(2).any(|w| w[0].end().dist(w[1].start()) > 1e-6) {
+ return Err(invalid("a curve chain has a gap: its curves must run end to end"));
+ }
+ }
+ Ok(())
+}
+
+/// The faces of the sheet `r` swept from `pieces` that start on `start`: each face comes from the
+/// pieces its edges lying in `start` run along (the edges' middles on the pieces' curves), none
+/// where no edge does.
+fn swept_from(r: &Brep, start: &Plane, pieces: &[Numbered]) -> Vec<FaceProv> {
+ let mut from: Vec<BTreeSet<usize>> = vec![BTreeSet::new(); r.faces.len()];
+ for e in &r.edges {
+ let Some(mid) = CurveEval::new(&e.curve).ok().and_then(|c| c.point(0.5 * (e.interval[0] + e.interval[1]))) else { continue };
+ let near = 4.0 * e.tolerance.max(r.tolerance);
+ if start.height(mid).abs() > near {
+ continue;
+ }
+ let o = mid - start.origin;
+ let q = Vec2::new(o.dot(start.x), o.dot(start.y));
+ for (s, number) in pieces {
+ if s.point_at(s.closest_param(q)).dist(q) <= near {
+ for u in &e.uses {
+ if let Some(set) = from.get_mut(u.face as usize) {
+ set.insert(*number);
}
}
}
}
- let out: Vec<mt::Face> = out.into_iter().zip(flip).map(|(f, fl)| if fl == Some(true) { f.inverse() } else { f }).collect();
- let operands: Vec<&mt::Solid> = bodies.iter().map(|b| &*b.solid).collect();
- body_of(out, &operands, &rec)
- })
+ }
+ from.iter().map(|set| if set.is_empty() { record::generated(Vec::new()) } else { record::profile(set.iter()) }).collect()
}
-/// How a face moves along its normal: a plane slides, a circular cylinder changes radius.
-#[derive(Clone, Copy)]
-pub(crate) enum Offset {
- Plane { n: Vec3 },
- Cylinder { o: Vec3, axis: UnitVec3, r: f64, out: f64 },
+/// A sheet of SMLib's pieces (each a record with its faces' history), joined into one record and,
+/// with `stitch`, sewn where pieces share edges (at ten times the pieces' tolerance).
+fn sheet_of(pieces: Vec<(Brep, Vec<FaceProv>)>, stitch: bool) -> Result<Body> {
+ let records: Vec<&Brep> = pieces.iter().map(|(r, _)| r).collect();
+ let (parts, offsets) = Parts::joined(&records)?;
+ let c = parts.canonical()?;
+ let prov = |part: usize| owner(&offsets, part, 0).and_then(|(k, i)| pieces.get(k)?.1.get(i).cloned());
+ let faces: Option<Vec<FaceProv>> = c.faces.iter().map(|p| prov(*p)).collect();
+ if !stitch {
+ let (body, same) = record_body(&c.brep)?;
+ return record::attach(body, &[], faces.filter(|_| same), Default::default());
+ }
+ let (body, h) = imp::stitched(&c.brep, c.brep.tolerance * 10.0)?;
+ // A stitched face keeps the tag of the joined record's face it was.
+ let sewn = h.zip(faces).and_then(|(h, faces)| {
+ h.faces
+ .iter()
+ .map(|f| match f.origins.as_slice() {
+ [FaceOrigin::Face { face, .. }] => faces.get(*face).cloned(),
+ _ => None,
+ })
+ .collect::<Option<Vec<_>>>()
+ });
+ record::attach(body, &[], sewn, Default::default())
}
-impl Offset {
- pub(crate) fn of(f: &mt::Face) -> Option<Offset> {
- match crate::splitface::analytic_field(&f.oriented_surface())? {
- crate::splitface::Analytic::Plane { n } => Some(Offset::Plane { n }),
- crate::splitface::Analytic::Cylinder { o, axis, r, out } => Some(Offset::Cylinder { o, axis, r, out }),
- }
+/// A surface extruded from chains of sketch segments on `plane`: each chain (open, or closed such
+/// as a profile's boundary) moved straight from `start` to `end` along the plane normal (offsets in
+/// mm). The walls it sweeps form one surface body with no caps. Its history has no operands:
+/// every face is new, from the segments it was swept from.
+pub fn extrude_sheet(plane: &Plane, chains: &[Vec<Seg2>], start: f64, end: f64) -> Result<Body> {
+ if !crate::build::frame_ok(plane) {
+ return Err(invalid("extrude frame is not finite and orthonormal"));
}
- pub(crate) fn map(&self, p: Vec3, d: f64) -> Vec3 {
- match *self {
- Offset::Plane { n } => p + n * d,
- // Scaled about the axis (control points of a NURBS circle stay exact).
- Offset::Cylinder { o, axis, r, out } => {
- let v = p - o;
- let radial = v - axis * v.dot(axis);
- p + radial * (out * d / r)
- }
+ if !(start.is_finite() && end.is_finite() && start.abs() < 1e7 && end.abs() < 1e7) {
+ return Err(invalid("extrude distance is not finite"));
+ }
+ let (lo, hi) = if end >= start { (start, end) } else { (end, start) };
+ if hi - lo < 1e-6 {
+ return Err(invalid("extrude distance is zero"));
+ }
+ check_chains(chains, "extrude")?;
+ let base = plane.offset(lo);
+ let n = plane.normal().normalized().ok_or_else(|| invalid("extrude frame has no normal"))?;
+ let pieces = numbered(chains)
+ .into_iter()
+ .map(|chain| {
+ let r = imp::extruded(&base, &chain, n, hi - lo)?;
+ let h = swept_from(&r, &base, &chain);
+ Ok((r, h))
+ })
+ .collect::<Result<Vec<_>>>()?;
+ sheet_of(pieces, false)
+}
+
+/// A surface revolved from chains of sketch segments on `plane` about the sketch line through
+/// `axis_origin` along `axis_dir`: each chain turned from `start` through `sweep` radians (a full
+/// turn at most), positive angles carrying it toward the sketch normal. A chain end on the axis
+/// stays put there (a cone's apex, a sphere's pole). The walls form one surface body with no caps,
+/// or a solid where they close (a full turn of a closed curve, or of a curve from the axis back to
+/// it); its history has no operands: every face is new.
+pub fn revolve_sheet(plane: &Plane, chains: &[Vec<Seg2>], axis_origin: Vec2, axis_dir: Vec2, start: f64, sweep: f64) -> Result<Body> {
+ use std::f64::consts::TAU;
+ if !crate::build::frame_ok(plane) || !axis_origin.is_finite() || !axis_dir.is_finite() {
+ return Err(invalid("revolve frame is not finite and orthonormal"));
+ }
+ if !(start.is_finite() && sweep.is_finite() && start.abs() <= TAU && sweep.abs() <= TAU + 1e-9) {
+ return Err(invalid("revolve angles must be finite, a full turn at most"));
+ }
+ if sweep.abs() < 1e-6 {
+ return Err(invalid("revolve angle is zero"));
+ }
+ check_chains(chains, "revolve")?;
+ let d = axis_dir.normalized().ok_or_else(|| invalid("revolve axis has no direction"))?;
+ let side = |p: Vec2| d.cross(p - axis_origin);
+ let on_axis = |p: Vec2| side(p).abs() < 1e-7;
+ let (origin, n) = (plane.to_world(axis_origin), plane.normal());
+ let axis = plane.dir_to_world(d).normalized().ok_or_else(|| invalid("revolve frame has no axis"))?;
+ let mut pieces = Vec::with_capacity(chains.len());
+ for chain in numbered(chains) {
+ // On one side of the axis; the point farthest from it fixes the turning sense.
+ let pts: Vec<Vec2> = chain.iter().flat_map(|(s, _)| s.polyline(1e-3)).collect();
+ if pts.iter().any(|p| side(*p) < -1e-7) && pts.iter().any(|p| side(*p) > 1e-7) {
+ return Err(invalid("the curves cross the revolve axis"));
+ }
+ let far = pts.iter().copied().max_by(|a, c| side(*a).abs().total_cmp(&side(*c).abs())).filter(|p| !on_axis(*p));
+ let Some(far) = far else { return Err(invalid("the curves lie on the revolve axis")) };
+ let a = if axis.cross(plane.to_world(far) - origin).dot(n) < 0.0 { axis * -1.0 } else { axis };
+ let (Some((first, _)), Some((last, _))) = (chain.first(), chain.last()) else { return Err(invalid("an empty curve chain")) };
+ if first.start().dist(last.end()) <= 1e-6 && pts.iter().any(|p| on_axis(*p)) {
+ return Err(invalid("not supported yet: a closed curve touching the revolve axis"));
}
+ // The chain starts `start` round: its sketch frame turned there.
+ let turn = |v: Vec3| crate::build::rotate_about(v, Vec3::ZERO, a, start);
+ let turned = Plane { origin: crate::build::rotate_about(plane.origin, origin, a, start), x: turn(plane.x), y: turn(plane.y) };
+ let (k, angle) = if sweep < 0.0 { (a * -1.0, -sweep) } else { (a, sweep) };
+ let r = imp::revolved(&turned, &chain, origin, k, angle.min(TAU))?;
+ let h = swept_from(&r, &turned, &chain);
+ pieces.push((r, h));
}
+ sheet_of(pieces, false)
}
-fn map_pt(off: &Offset, p: mt::Point3, d: f64) -> mt::Point3 {
- p3(off.map(from_p3(p), d))
+/// A surface swept from chains of sketch segments on `plane` along a path that starts near them,
+/// turning with it (SMLib's curve sweep: along lines an extrusion, round arcs about one axis a
+/// revolution, exactly). A path whose direction jumps at a joint (a corner) is not supported yet.
+/// The walls form one surface body with no caps; its history has no operands: every face is new.
+pub fn sweep_sheet(plane: &Plane, chains: &[Vec<Seg2>], path: &[crate::PathSeg]) -> Result<Body> {
+ sweep_sheet_with(plane, chains, path, &crate::SweepControl::default())
}
-/// A curve moved by an offset (control points mapped; exact for lines, and for circles square
-/// to a cylinder's axis or in a plane).
-pub(crate) fn map_curve(off: &Offset, c: &mt::Curve, d: f64) -> Result<mt::Curve> {
- if let Some(moved) = map_control_points(c, |p| off.map(p, d)) {
- return Ok(moved);
+/// [`sweep_sheet`] with sweep options: orientation, twist, end scale and guide rails place the
+/// chains at stations along the path by [`crate::sweep_path`]'s laws (each section the chain's
+/// exact image) for SMLib to skin the walls through.
+pub fn sweep_sheet_with(plane: &Plane, chains: &[Vec<Seg2>], path: &[crate::PathSeg], ctl: &crate::SweepControl) -> Result<Body> {
+ ctl.check()?;
+ if !crate::build::frame_ok(plane) {
+ return Err(invalid("sweep frame is not finite and orthonormal"));
}
- // Anything else: a cubic through moved samples.
- let (t0, t1) = c.range_tuple();
- let pts: Vec<Vec3> = (0..=32).map(|k| off.map(from_p3(c.subs(t0 + (t1 - t0) * k as f64 / 32.0)), d)).collect();
- Ok(mt::Curve::BSplineCurve(crate::build::interpolate_cubic(&pts).ok_or_else(|| KernelError::Failed("offset edge".into()))?))
+ check_chains(chains, "sweep")?;
+ if path.is_empty() || path.len() > 1000 {
+ return Err(invalid("the path needs 1…1000 segments"));
+ }
+ let ends: Vec<(Vec3, Vec3)> =
+ path.iter().map(crate::PathSeg::tangents).collect::<Option<_>>().ok_or_else(|| invalid("a path segment has no direction"))?;
+ if ends.windows(2).any(|w| w[0].1.dot(w[1].0) < (1e-3f64).cos()) {
+ return Err(imp::refuse("surface sweep along a path with corners"));
+ }
+ let pieces = numbered(chains)
+ .into_iter()
+ .map(|chain| {
+ let r = if ctl.is_default() { imp::swept(plane, &chain, path)? } else { imp::swept_stations(plane, &chain, path, ctl)? };
+ let h = swept_from(&r, plane, &chain);
+ Ok((r, h))
+ })
+ .collect::<Result<Vec<_>>>()?;
+ sheet_of(pieces, false)
}
-/// A line, B-spline or NURBS curve with its control points mapped by `f` (the exact image of
-/// the curve under an affine `f`); `None` for a curve without control points (an
-/// intersection curve).
-pub(crate) fn map_control_points(c: &mt::Curve, f: impl Fn(Vec3) -> Vec3) -> Option<mt::Curve> {
- let map = |p: mt::Point3| p3(f(from_p3(p)));
- Some(match c {
- mt::Curve::Line(l) => mt::Curve::Line(mt::Line(map(l.0), map(l.1))),
- mt::Curve::BSplineCurve(b) => {
- let pts: Vec<mt::Point3> = b.control_points().iter().map(|p| map(*p)).collect();
- mt::Curve::BSplineCurve(mt::BSplineCurve::new(b.knot_vec().clone(), pts))
- }
- mt::Curve::NurbsCurve(n) => {
- let nb = n.non_rationalized();
- let pts: Vec<mt::Vector4> = nb
- .control_points()
- .iter()
- .map(|h| {
- let w = h.w;
- let q = map(mt::Point3::new(h.x / w, h.y / w, h.z / w));
- mt::Vector4::new(q.x * w, q.y * w, q.z * w, w)
- })
- .collect();
- mt::Curve::NurbsCurve(mt::NurbsCurve::new(mt::BSplineCurve::new(nb.knot_vec().clone(), pts)))
- }
- mt::Curve::IntersectionCurve(_) => return None,
- })
+/// A surface swept from chains of sketch segments on `plane` along a 3D polyline path: along the
+/// lines between its points, as [`sweep_sheet`] sweeps them.
+pub fn sweep_sheet_points(plane: &Plane, chains: &[Vec<Seg2>], path: &[Vec3]) -> Result<Body> {
+ sweep_sheet_points_with(plane, chains, path, &crate::SweepControl::default())
+}
+
+/// [`sweep_sheet_points`] with sweep options (see [`sweep_sheet_with`]).
+pub fn sweep_sheet_points_with(plane: &Plane, chains: &[Vec<Seg2>], path: &[Vec3], ctl: &crate::SweepControl) -> Result<Body> {
+ let pts = crate::sweep_path::clean(path)?;
+ let segs: Vec<crate::PathSeg> = pts.windows(2).map(|w| crate::PathSeg::Line { a: w[0], b: w[1] }).collect();
+ sweep_sheet_with(plane, chains, &segs, ctl)
}
-/// A surface moved by an offset (control points mapped; exact for planes and NURBS cylinders).
-pub(crate) fn map_surface(off: &Offset, s: &mt::Surface, d: f64) -> Result<mt::Surface> {
- Ok(match s {
- mt::Surface::Plane(pl) => {
- let (o, a, b) = (pl.origin(), pl.u_axis(), pl.v_axis());
- let o2 = map_pt(off, o, d);
- mt::Surface::Plane(mt::Plane::new(o2, o2 + a, o2 + b))
+/// A surface lofted through two or more sections, each a chain of sketch segments on its plane,
+/// all open or all closed: ruled between two sections, smooth through three or more. Closed
+/// sections are matched as the solid loft matches them; open ones are split to the same number of
+/// segments (longest first) and each turned to run the way the one before it does. Walls only, no
+/// caps; the history has no operands: every face is new.
+pub fn loft_sheet(sections: &[(Plane, Vec<Seg2>)]) -> Result<Body> {
+ loft_sheet_with_rails(sections, &[], crate::RailFit::Scale)
+}
+
+/// [`loft_sheet`] following one or two guide rails (polylines from the first section to the last,
+/// through every section's curve; see [`crate::loft_rails`]), `fit` saying how they reshape the
+/// sections between. Without rails, the plain sheet loft.
+///
+/// The k-th segments of every section make a column: SMLib lofts each column on its own (one wall
+/// from the column's segments), and the columns are stitched along the edges they share.
+pub fn loft_sheet_with_rails(sections: &[(Plane, Vec<Seg2>)], rails: &[Vec<Vec3>], fit: crate::RailFit) -> Result<Body> {
+ if sections.len() < 2 || sections.len() > 50 {
+ return Err(invalid("a loft needs 2…50 sections"));
+ }
+ let closed: Vec<bool> = sections
+ .iter()
+ .map(|(_, c)| match (c.first(), c.last()) {
+ (Some(f), Some(l)) if c.len() <= 4096 => Ok(l.end().dist(f.start()) <= 1e-6),
+ _ => Err(invalid("a loft section has no curves, or too many")),
+ })
+ .collect::<Result<_>>()?;
+ let all_closed = closed.iter().all(|c| *c);
+ if !all_closed && closed.iter().any(|c| *c) {
+ return Err(invalid("the loft sections must be all open or all closed"));
+ }
+ for (plane, chain) in sections {
+ if !crate::build::frame_ok(plane) {
+ return Err(invalid("a loft section's frame is not finite and orthonormal"));
}
- mt::Surface::BSplineSurface(b) => {
- let rows: Vec<Vec<mt::Point3>> = b.control_points().iter().map(|r| r.iter().map(|p| map_pt(off, *p, d)).collect()).collect();
- mt::Surface::BSplineSurface(mt::BSplineSurface::new((b.uknot_vec().clone(), b.vknot_vec().clone()), rows))
+ check_chains(std::slice::from_ref(chain), "loft")?;
+ }
+ let matched = if all_closed { closed_sections(sections)? } else { open_sections(sections)? };
+ let lofted = crate::loft_rails::railed(&matched, all_closed, rails, fit)?;
+ let count = matched.first().map_or(0, |s| s.curves.len());
+ let pieces = (0..count)
+ .map(|k| {
+ let column: Vec<&solidcraft_geom::bspline::CurveN<4>> = lofted.iter().filter_map(|s| s.get(k)).collect();
+ let r = imp::lofted(&column)?;
+ let numbers: BTreeSet<usize> = matched.iter().filter_map(|s| s.numbers.get(k)).flatten().copied().collect();
+ let h = vec![record::profile(numbers.iter()); r.faces.len()];
+ Ok((r, h))
+ })
+ .collect::<Result<Vec<_>>>()?;
+ sheet_of(pieces, true)
+}
+
+/// Closed sections matched as the solid loft matches them ([`crate::build::loft_numbered_loops`]),
+/// in loft order.
+fn closed_sections(sections: &[(Plane, Vec<Seg2>)]) -> Result<Vec<crate::loft_rails::Section>> {
+ let loops: Vec<(Plane, solidcraft_geom::Loop2)> = sections.iter().map(|(p, c)| (*p, solidcraft_geom::Loop2 { segs: c.clone() })).collect();
+ let reversed = crate::build::loft_reversed(&loops)?;
+ let numbered = loops.iter().map(|(p, _)| *p).zip(crate::numbered::number_loops(loops.iter().map(|(_, l)| l))).collect::<Vec<_>>();
+ crate::build::loft_numbered_loops(&numbered, reversed)?
+ .iter()
+ .map(|(plane, l)| crate::loft_rails::Section::of(plane, &l.lp.segs, (0..l.lp.segs.len()).map(|i| l.numbers(i).to_vec()).collect()))
+ .collect()
+}
+
+/// Open sections split to the same number of segments (the longest in half until the counts
+/// match), each turned to run the way the one before it does.
+fn open_sections(sections: &[(Plane, Vec<Seg2>)]) -> Result<Vec<crate::loft_rails::Section>> {
+ let n = sections.iter().map(|(_, c)| c.len()).max().unwrap_or(0);
+ let mut out = Vec::with_capacity(sections.len());
+ let mut prev: Option<(Vec3, Vec3)> = None;
+ let mut offset = 0;
+ for (plane, chain) in sections {
+ // Each piece with the segment it is (part of).
+ let mut segs: Vec<(Seg2, usize)> = chain.iter().enumerate().map(|(i, s)| (*s, offset + i)).collect();
+ offset += chain.len();
+ while segs.len() < n {
+ let Some(i) = segs.iter().enumerate().max_by(|a, c| a.1.0.length().total_cmp(&c.1.0.length())).map(|(i, _)| i) else { break };
+ let Some(&(s, k)) = segs.get(i) else { break };
+ let (a, c) = s.split_half();
+ segs.splice(i..=i, [(a, k), (c, k)]);
}
- mt::Surface::NurbsSurface(n) => {
- let nb = n.non_rationalized();
- let rows: Vec<Vec<mt::Vector4>> = nb
- .control_points()
- .iter()
- .map(|r| {
- r.iter()
- .map(|h| {
- let w = h.w;
- let q = map_pt(off, mt::Point3::new(h.x / w, h.y / w, h.z / w), d);
- mt::Vector4::new(q.x * w, q.y * w, q.z * w, w)
- })
- .collect()
- })
- .collect();
- mt::Surface::NurbsSurface(mt::NurbsSurface::new(mt::BSplineSurface::new((nb.uknot_vec().clone(), nb.vknot_vec().clone()), rows)))
+ let ends = |c: &[(Seg2, usize)]| c.first().zip(c.last()).map(|(f, l)| (plane.to_world(f.0.start()), plane.to_world(l.0.end())));
+ if let (Some((ps, pe)), Some((s, e))) = (prev, ends(&segs))
+ && s.dist(ps) + e.dist(pe) > s.dist(pe) + e.dist(ps)
+ {
+ segs = segs.iter().rev().map(|(s, k)| (s.reversed(), *k)).collect();
}
- _ => return Err(KernelError::Invalid("not supported yet: thickening this kind of surface".into())),
- })
+ prev = ends(&segs);
+ let pieces: Vec<Seg2> = segs.iter().map(|(s, _)| *s).collect();
+ out.push(crate::loft_rails::Section::of(plane, &pieces, segs.iter().map(|(_, k)| vec![*k]).collect())?);
+ }
+ Ok(out)
}
-/// How far Thicken's fitted faces may stray from the true offset (mm).
-const THICKEN_TOLERANCE: f64 = 0.01;
+/// SMLib's side of this module.
+#[cfg(feature = "smlib")]
+mod imp {
+ use solidcraft_smlib::sweeps::{Affine, Curve, Ends, SweepFrame};
+ use solidcraft_smlib::{Brep as SmBrep, CheckLevel};
-/// A surface body thickened into a solid: offset along the faces' normals by `thickness`
-/// (negative: against them), or by half each way when `symmetric`. Planes and circular
-/// cylinders move exactly, other faces onto fitted surfaces (see `surface_offset`); a thickness
-/// that would fold a face over is refused. Neighbouring faces must meet smoothly (their offsets
-/// agree).
-pub fn thicken(body: &Body, thickness: f64, symmetric: bool) -> Result<Body> {
- body.require_brep("thicken")?;
- #[cfg(feature = "smlib")]
- if crate::backend()? == crate::Backend::Smlib {
- return crate::offset_backend::thicken(body, thickness, symmetric);
- }
- if !(thickness.is_finite() && thickness.abs() > 1e-9) {
- return Err(KernelError::Invalid("thickness must be non-zero".into()));
- }
- let (d0, d1) = if symmetric { (-thickness / 2.0, thickness / 2.0) } else { (0.0, thickness) };
- let (lo, hi) = (d0.min(d1), d0.max(d1));
- let size = body.size();
- let tol = size * 1e-7 + 1e-9;
- guard("thicken", || {
- let faces: Vec<mt::Face> = body.solid.face_iter().cloned().collect();
- if faces.is_empty() {
- return Err(KernelError::Invalid("nothing to thicken".into()));
- }
- // Planes and circular cylinders move exactly; other faces onto surfaces fitted within the
- // offset tolerance (Offset Surface's).
- let offs: Vec<crate::surface_offset::FaceMover> =
- faces.iter().map(|f| crate::surface_offset::FaceMover::new(f, &[lo, hi], THICKEN_TOLERANCE)).collect::<Result<_>>()?;
- let near = |a: Vec3, b: Vec3| a.dist(b) <= tol * 1e3;
- // Each side's copies of every vertex and edge. Faces that move one to the same place share
- // the copy (they meet smoothly there); across a sharp edge each face has its own.
- let mut vcopies: [HashMap<mt::VertexID, Vec<mt::Vertex>>; 2] = [HashMap::new(), HashMap::new()];
- let mut ecopies: [HashMap<mt::EdgeID, Vec<mt::Edge>>; 2] = [HashMap::new(), HashMap::new()];
- // Each face's copies, by side: (face, vertex) → vertex, (face, edge) → edge.
- let mut vof: [HashMap<(usize, mt::VertexID), mt::Vertex>; 2] = [HashMap::new(), HashMap::new()];
- let mut eof: [HashMap<(usize, mt::EdgeID), mt::Edge>; 2] = [HashMap::new(), HashMap::new()];
- // The faces using each edge, in order.
- let mut users: HashMap<mt::EdgeID, Vec<usize>> = HashMap::new();
- let mut abs_edges: HashMap<mt::EdgeID, mt::Edge> = HashMap::new();
- for (fi, (f, off)) in faces.iter().zip(&offs).enumerate() {
- for e in f.absolute_boundaries().iter().flat_map(|w| w.edge_iter()) {
- let abs = if e.orientation() { e.clone() } else { e.inverse() };
- let list = users.entry(abs.id()).or_default();
- if !list.contains(&fi) {
- list.push(fi);
- }
- abs_edges.entry(abs.id()).or_insert_with(|| abs.clone());
- for (side, d) in [lo, hi].into_iter().enumerate() {
- for v in [abs.front(), abs.back()] {
- if vof[side].contains_key(&(fi, v.id())) {
- continue;
- }
- let at = off.point(from_p3(v.point()), d)?;
- let list = vcopies[side].entry(v.id()).or_default();
- let copy = match list.iter().find(|c| near(from_p3(c.point()), at)) {
- Some(c) => c.clone(),
- None => {
- let c = mt::Vertex::new(p3(at));
- list.push(c.clone());
- c
- }
- };
- vof[side].insert((fi, v.id()), copy);
- }
- let (Some(a), Some(b)) = (vof[side].get(&(fi, abs.front().id())).cloned(), vof[side].get(&(fi, abs.back().id())).cloned()) else {
- continue;
- };
- let c = abs.curve();
- let (t0, t1) = c.range_tuple();
- let mid = off.point(from_p3(c.subs(0.5 * (t0 + t1))), d)?;
- let list = ecopies[side].entry(abs.id()).or_default();
- let shared = list.iter().find(|m| {
- m.front().id() == a.id() && m.back().id() == b.id() && {
- let mc = m.curve();
- let (s0, s1) = mc.range_tuple();
- near(from_p3(mc.subs(0.5 * (s0 + s1))), mid)
- }
- });
- let copy = match shared {
- Some(m) => m.clone(),
- None => {
- let m = mt::Edge::new_unchecked(&a, &b, off.curve(&c, d)?);
- list.push(m.clone());
- m
- }
- };
- eof[side].insert((fi, abs.id()), copy);
- }
- }
+ use super::*;
+
+ fn sm(what: &'static str) -> impl Fn(solidcraft_smlib::Error) -> KernelError {
+ move |e| failed(format!("SMLib {what}: {e}"))
+ }
+
+ pub(super) fn refuse(what: &str) -> KernelError {
+ crate::smlib_sweeps::refuse(what)
+ }
+
+ /// A result SMLib's own check accepts, as its record.
+ fn checked(r: &SmBrep, what: &'static str) -> Result<Brep> {
+ let check = r.check(CheckLevel::All).map_err(sm(what))?;
+ if !check.is_valid() {
+ return Err(failed(format!("SMLib {what}: SMLib's check refuses the result: {check}")));
}
- // Lines joining a vertex's copy on one side to its copy on the other, once each.
- let mut risers: HashMap<(mt::VertexID, mt::VertexID), mt::Edge> = HashMap::new();
- let mut riser = |a: &mt::Vertex, b: &mt::Vertex| -> mt::Edge {
- risers.entry((a.id(), b.id())).or_insert_with(|| mt::Edge::new_unchecked(a, b, mt::Curve::Line(mt::Line(a.point(), b.point())))).clone()
- };
- let moved_face = |fi: usize, f: &mt::Face, off: &crate::surface_offset::FaceMover, side: usize, d: f64| -> Result<mt::Face> {
- let wires: Vec<mt::Wire> = f
- .absolute_boundaries()
- .iter()
- .map(|w| {
- w.edge_iter()
- .filter_map(|e| {
- let abs_id = if e.orientation() { e.id() } else { e.inverse().id() };
- let m = eof[side].get(&(fi, abs_id))?.clone();
- Some(if e.orientation() { m } else { m.inverse() })
- })
- .collect::<Vec<_>>()
- .into()
- })
- .collect();
- let mut nf = mt::Face::new_unchecked(wires, off.surface(d)?);
- if !f.orientation() {
- nf.invert();
- }
- Ok(nf)
+ r.to_native().map_err(|e| failed(format!("SMLib {what}: {e}")))
+ }
+
+ pub(super) fn record_body(r: &Brep) -> Result<(Body, bool)> {
+ let (brep, order) = crate::native::smlib_record_ordered(r)?;
+ let (body, kept) = crate::native::body_from_smlib_ordered(&brep)?;
+ Ok((body, order.is_some() && kept.is_some()))
+ }
+
+ /// The record `r` sewn by SMLib at `tol` (`smlib_stitch`), with its history over `[r]` (faces
+ /// and edges by their index in `r`); none where the orders cannot be matched.
+ pub(super) fn stitched(r: &Brep, tol: f64) -> Result<(Body, Option<History>)> {
+ let (brep, order) = crate::native::smlib_record_ordered(r)?;
+ let tagged = brep.tagged(0).map_err(sm("stitch"))?;
+ let (sewn, _closed) = tagged.stitch(tol).map_err(sm("stitch"))?;
+ checked(&sewn, "stitch")?;
+ let (body, kept) = crate::native::body_from_smlib_ordered(&sewn)?;
+ let h = match (order, kept) {
+ (Some(o), Some(k)) => sewn.history().ok().and_then(|raw| raw.history(&[o], &k).ok()),
+ _ => None,
};
- let mut out = Vec::new();
- // History (one operand, the surface): a copy at no distance is the face itself, a copy
- // further out its offset, a wall is made along the edge it stands on, a corner patch from
- // the sharp edges that meet at its corner.
- let operand = crate::record::Operand::new(body);
- let edge_index = &operand.edges;
- let mut history = Vec::new();
- let copy = |i: usize, d: f64| {
- if d == 0.0 {
- crate::record::from_face(0, i, Change::Kept)
- } else {
- crate::record::generated(vec![FaceOrigin::Offset { operand: 0, face: i }])
+ Ok((body, h))
+ }
+
+ pub(super) fn thicken(body: &Body, thickness: f64, symmetric: bool) -> Result<Body> {
+ crate::offset_backend::thicken(body, thickness, symmetric)
+ }
+
+ /// The face `f` of `r` alone, offset by `d` along its normal (`smlib_offset_sheet`).
+ pub(super) fn offset_face(r: &Brep, f: usize, d: f64) -> Result<Brep> {
+ let one = Parts::of(r, &[(f, false)])?.canonical()?;
+ let sheet = SmBrep::from_record(&one.brep, true).map_err(sm("offset"))?;
+ checked(&sheet.offset_sheet(d).map_err(sm("offset"))?, "offset")
+ }
+
+ /// A sketch segment on `plane` as SMLib's curve: an arc as SMLib's own circle, anything else
+ /// as its exact record curve.
+ fn curve(plane: &Plane, s: &Seg2) -> Result<Curve> {
+ if let Seg2::Arc { center, radius, start, sweep } = *s {
+ let n = plane.normal().normalized().ok_or_else(|| invalid("profile plane"))?;
+ // Clockwise in the plane is counter-clockwise about the other normal.
+ let (axis, a0) = if sweep >= 0.0 { (n, start) } else { (n * -1.0, -start) };
+ let turn = sweep.abs().min(std::f64::consts::TAU);
+ return Ok(Curve::Arc { center: a3(plane.to_world(center)), axis: a3(axis), reference: a3(plane.x), radius, start: a0, end: a0 + turn });
+ }
+ record_curve(&crate::freeform::segment(plane, s)?.0)
+ }
+
+ /// A record line or (rational) B-spline as SMLib's curve.
+ fn record_curve(c: &b::Curve) -> Result<Curve> {
+ let degree = |knots: &[f64], n: usize| knots.len().checked_sub(n + 1).ok_or_else(|| invalid("spline degree"));
+ Ok(match c {
+ b::Curve::Line { start, end } => Curve::Line { start: *start, end: *end },
+ b::Curve::Spline { knots, points } => Curve::Nurbs {
+ degree: degree(knots, points.len())?,
+ points: points.iter().map(|p| [p[0], p[1], p[2], 1.0]).collect(),
+ knots: knots.clone(),
+ },
+ b::Curve::RationalSpline { knots, homogeneous } => Curve::Nurbs {
+ degree: degree(knots, homogeneous.len())?,
+ points: homogeneous.iter().map(|h| [h[0] / h[3], h[1] / h[3], h[2] / h[3], h[3]]).collect(),
+ knots: knots.clone(),
+ },
+ _ => return Err(invalid("a profile curve SMLib's sweeps do not take")),
+ })
+ }
+
+ fn curves(plane: &Plane, chain: &[Numbered]) -> Result<Vec<Curve>> {
+ chain.iter().map(|(s, _)| curve(plane, s)).collect()
+ }
+
+ pub(super) fn extruded(base: &Plane, chain: &[Numbered], n: Vec3, distance: f64) -> Result<Brep> {
+ checked(&SmBrep::extrude(&curves(base, chain)?, a3(n), distance, 0.0, false).map_err(sm("surface extrude"))?, "surface extrude")
+ }
+
+ pub(super) fn revolved(plane: &Plane, chain: &[Numbered], origin: Vec3, axis: Vec3, angle: f64) -> Result<Brep> {
+ checked(&SmBrep::revolve(&curves(plane, chain)?, a3(origin), a3(axis), angle, false).map_err(sm("surface revolve"))?, "surface revolve")
+ }
+
+ /// A path segment as SMLib's curve.
+ fn path_curve(s: &crate::PathSeg) -> Result<Curve> {
+ Ok(match *s {
+ crate::PathSeg::Line { a, b } => Curve::Line { start: a3(a), end: a3(b) },
+ crate::PathSeg::Arc { a, center, axis, angle } => {
+ let k = axis.normalized().ok_or_else(|| invalid("a path arc has no axis"))?;
+ let (k, turn) = if angle < 0.0 { (k * -1.0, -angle) } else { (k, angle) };
+ let r = a - center;
+ let reference = r.normalized().ok_or_else(|| invalid("a path arc has no radius"))?;
+ Curve::Arc { center: a3(center), axis: a3(k), reference: a3(reference), radius: r.len(), start: 0.0, end: turn }
}
- };
- let edge_origin = |id: &mt::EdgeID| -> Result<FaceOrigin> {
- let edge = edge_index.get(id).copied().ok_or_else(|| KernelError::Failed("thicken: an edge outside the surface".into()))?;
- Ok(FaceOrigin::Edge { operand: 0, edge })
- };
- for (i, (f, off)) in faces.iter().zip(&offs).enumerate() {
- // The lower copy faces back, the upper one forward.
- out.push(moved_face(i, f, off, 0, lo)?.inverse());
- out.push(moved_face(i, f, off, 1, hi)?);
- history.extend([copy(i, lo), copy(i, hi)]);
- // Walls along free edges, outward across the edge.
- for w in f.boundaries() {
- for e in w.edge_iter() {
- let abs_id = if e.orientation() { e.id() } else { e.inverse().id() };
- if users.get(&abs_id).map_or(0, Vec::len) != 1 {
- continue;
- }
- let (Some(le), Some(he)) = (eof[0].get(&(i, abs_id)), eof[1].get(&(i, abs_id))) else { continue };
- let (le, he) = if e.orientation() { (le.clone(), he.clone()) } else { (le.inverse(), he.inverse()) };
- let (sa, sb) = (riser(le.front(), he.front()), riser(le.back(), he.back()));
- // A → B low, B → B' up, B' → A' high back, A' → A down.
- let wire: mt::Wire = vec![le.clone(), sb, he.inverse(), sa.inverse()].into();
- let ruled = mt::builder::homotopy(&le, &he);
- let surf = ruled.surface();
- // The wall's outward normal: across the edge, away from the face.
- let c = le.oriented_curve();
- let (t0, t1) = c.range_tuple();
- let tm = 0.5 * (t0 + t1);
- let p = c.subs(tm);
- let tangent = c.der(tm);
- let n =
- f.oriented_surface().search_nearest_parameter(p, None, 50).map(|(u, v)| f.oriented_surface().normal(u, v)).unwrap_or(tangent);
- let outward = tangent.cross(n);
- let sn = surf.search_nearest_parameter(p, None, 50).map(|(u, v)| surf.normal(u, v)).unwrap_or(outward);
- let wall = if sn.dot(outward) >= 0.0 {
- mt::Face::new_unchecked(vec![wire], surf)
- } else {
- let mut x = mt::Face::new_unchecked(vec![wire.inverse()], surf);
- x.invert();
- x
- };
- out.push(wall);
- history.push(crate::record::generated(vec![edge_origin(&abs_id)?]));
- }
+ crate::PathSeg::Curve { plane, seg } => curve(&plane, &seg)?,
+ crate::PathSeg::Cubic { p } => Curve::Nurbs {
+ degree: 3,
+ points: p.iter().map(|q| [q.x, q.y, q.z, 1.0]).collect(),
+ knots: vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0],
+ },
+ })
+ }
+
+ pub(super) fn swept(plane: &Plane, chain: &[Numbered], path: &[crate::PathSeg]) -> Result<Brep> {
+ let route = path.iter().map(path_curve).collect::<Result<Vec<_>>>()?;
+ checked(&SmBrep::sweep(&curves(plane, chain)?, &route, SweepFrame::Follow, false).map_err(sm("surface sweep"))?, "surface sweep")
+ }
+
+ /// Fewest and most stations of a sweep that twists, scales or follows rails.
+ const MIN_STATIONS: usize = 16;
+ const MAX_STATIONS: usize = 2048;
+
+ /// The chain carried through stations along `path` placed by [`crate::sweep_path`]'s laws for
+ /// `ctl` (a station per degree the path and the twist turn), SMLib skinning its walls through
+ /// the sections with open ends (`smlib_sweep_stations`).
+ pub(super) fn swept_stations(plane: &Plane, chain: &[Numbered], path: &[crate::PathSeg], ctl: &crate::SweepControl) -> Result<Brep> {
+ let turn: f64 = path.iter().map(turn_of).sum::<f64>() + ctl.twist.abs();
+ let rail_points = ctl.rails.iter().map(Vec::len).max().unwrap_or(0);
+ let n = ((turn / 1f64.to_radians()).ceil() as usize).max(rail_points.saturating_sub(1)).clamp(MIN_STATIONS, MAX_STATIONS);
+ let (pts, tangents) = samples(path, n)?;
+ let st = crate::sweep_path::controlled_stations(plane, &pts, &tangents, &[], ctl)?;
+ let s0 = st.first().map(|s| s.at).ok_or_else(|| invalid("sweep path"))?;
+ let maps: Vec<Affine> = st
+ .iter()
+ .map(|s| {
+ let [a, b, c] = s.m;
+ Affine { m: [a3(a), a3(b), a3(c)], t: a3(s.at - s.apply(s0)) }
+ })
+ .collect();
+ checked(&SmBrep::sweep_stations(&curves(plane, chain)?, &maps, Ends::Open).map_err(sm("surface sweep"))?, "surface sweep")
+ }
+
+ /// How far a path segment turns (radians).
+ fn turn_of(s: &crate::PathSeg) -> f64 {
+ match *s {
+ crate::PathSeg::Line { .. } => 0.0,
+ crate::PathSeg::Arc { angle, .. } => angle.abs(),
+ _ => {
+ let pts: Vec<Vec3> = std::iter::once(s.start()).chain(s.points_after_start(1e-3)).collect();
+ pts.windows(3)
+ .filter_map(|w| Some(((w[1] - w[0]).normalized()?, (w[2] - w[1]).normalized()?)))
+ .map(|(u, v)| u.cross(v).len().atan2(u.dot(v)))
+ .sum()
}
}
- // Sharp edges: where the two faces' copies of an edge part on a side, a wall closes the
- // gap; where they would cross (an inside corner on that side), refused.
- let mut sharp_at: HashMap<mt::VertexID, Vec<mt::EdgeID>> = HashMap::new();
- let mut gaps = Vec::new();
- for (id, fs) in &users {
- let [fa, fb] = fs.as_slice() else { continue };
- let Some(abs) = abs_edges.get(id) else { continue };
- for (side, d) in [lo, hi].into_iter().enumerate() {
- let (Some(ea), Some(eb)) = (eof[side].get(&(*fa, *id)), eof[side].get(&(*fb, *id))) else { continue };
- if ea.id() == eb.id() {
- continue;
- }
- // Which way the faces bend across the edge: each lies behind the other's normal
- // (convex toward the normals) or in front of it.
- let c = abs.curve();
- let (t0, t1) = c.range_tuple();
- let p = from_p3(c.subs(0.5 * (t0 + t1)));
- let normal = |fi: usize| -> Option<Vec3> {
- let s = faces.get(fi)?.oriented_surface();
- let (u, v) = s.search_nearest_parameter(p3(p), None, 50)?;
- Some(from_p3(mt::Point3::new(0.0, 0.0, 0.0) + s.normal(u, v)))
- };
- let centre = |fi: usize| -> Option<Vec3> {
- let pts: Vec<Vec3> =
- faces.get(fi)?.absolute_boundaries().iter().flat_map(|w| w.vertex_iter().map(|v| from_p3(v.point()))).collect();
- Some(pts.iter().fold(Vec3::ZERO, |a, q| a + *q) * (1.0 / pts.len().max(1) as f64))
- };
- let (Some(na), Some(ca), Some(cb)) = (normal(*fa), centre(*fa), centre(*fb)) else {
- return Err(KernelError::Failed("thicken: the faces at a sharp edge".into()));
- };
- // Convex toward the normals: the other face falls away behind this one's normal.
- let convex = na.dot(cb - p) < 0.0 && normal(*fb).is_some_and(|nb| nb.dot(ca - p) < 0.0);
- if convex != (d > 0.0) {
- return Err(KernelError::Invalid(
- "not supported yet: thickening into an inside corner across a sharp edge (try the other side, or symmetric off)".into(),
- ));
- }
- gaps.push((*id, side, ea.clone(), eb.clone()));
- for v in [abs.front(), abs.back()] {
- let list = sharp_at.entry(v.id()).or_default();
- if !list.contains(id) {
- list.push(*id);
- }
- }
- }
+ }
+
+ /// `n + 1` points spread along `path` (evenly by length from segment to segment, evenly in each
+ /// segment's parameter within it), with the path's unit tangent at each.
+ fn samples(path: &[crate::PathSeg], n: usize) -> Result<(Vec<Vec3>, Vec<Vec3>)> {
+ let bad = || invalid("a path segment has no direction");
+ let lengths: Vec<f64> = path.iter().map(length).collect();
+ let total: f64 = lengths.iter().sum();
+ if !(total > 1e-12) {
+ return Err(invalid("the sweep path has no length"));
}
- // Each gap wall runs along one face's copy of the edge and back along the other's, joined
- // at the ends by lines between the two copies of each end vertex. It is turned so that it
- // crosses the first face's copy the other way from that face.
- let mut links: HashMap<(mt::VertexID, mt::VertexID), mt::Edge> = HashMap::new();
- let mut link = |a: &mt::Vertex, b: &mt::Vertex| -> mt::Edge {
- if let Some(e) = links.get(&(b.id(), a.id())) {
- return e.inverse();
+ let (mut pts, mut tangents) = (Vec::with_capacity(n + 1), Vec::with_capacity(n + 1));
+ for i in 0..=n {
+ let mut s = total * i as f64 / n as f64;
+ let mut k = 0;
+ while k + 1 < path.len() && s > lengths.get(k).copied().unwrap_or(0.0) {
+ s -= lengths.get(k).copied().unwrap_or(0.0);
+ k += 1;
}
- links.entry((a.id(), b.id())).or_insert_with(|| mt::Edge::new_unchecked(a, b, mt::Curve::Line(mt::Line(a.point(), b.point())))).clone()
- };
- let used_forward = |faces: &[mt::Face], e: &mt::Edge| -> Option<bool> {
- faces
- .iter()
- .flat_map(|f| f.boundaries().into_iter().flat_map(|w| w.edge_iter().cloned().collect::<Vec<_>>()))
- .find(|x| x.id() == e.id())
- .map(|x| x.front().id() == e.front().id())
- };
- for (id, _side, ea, eb) in gaps {
- let wire: mt::Wire = vec![ea.clone(), link(ea.back(), eb.back()), eb.inverse(), link(eb.front(), ea.front())].into();
- let surf = mt::builder::homotopy(&ea, &eb).surface();
- let wall = mt::Face::new_unchecked(vec![wire], surf);
- let wall = if used_forward(&out, &ea).unwrap_or(false) { wall.inverse() } else { wall };
- out.push(wall);
- history.push(crate::record::generated(vec![edge_origin(&id)?]));
+ let f = (s / lengths.get(k).copied().unwrap_or(1.0).max(1e-300)).clamp(0.0, 1.0);
+ let (p, t) = path.get(k).and_then(|seg| at(seg, f)).ok_or_else(bad)?;
+ pts.push(p);
+ tangents.push(t);
}
- // Corners: whatever is left open is closed by plane patches (where three faces meet at a
- // sharp corner, a triangle), each from the sharp edges meeting there.
- let open = mt::Shell::from(out.clone()).extract_boundaries();
- for w in open {
- let patch = mt::builder::try_attach_plane(&[w.inverse()])
- .map_err(|_| KernelError::Invalid("not supported yet: thickening a corner where the gap does not close flat".into()))?;
- let mut origins = Vec::new();
- for v in w.vertex_iter() {
- for (vid, list) in &sharp_at {
- let at = vcopies.iter().flat_map(|m| m.get(vid).into_iter().flatten()).any(|c| c.id() == v.id());
- if at {
- for e in list {
- let o = edge_origin(e)?;
- if !origins.contains(&o) {
- origins.push(o);
- }
- }
- }
- }
- }
- if origins.is_empty() {
- return Err(KernelError::Failed("the thickened surface does not close".into()));
+ Ok((pts, tangents))
+ }
+
+ fn length(s: &crate::PathSeg) -> f64 {
+ match *s {
+ crate::PathSeg::Line { a, b } => a.dist(b),
+ crate::PathSeg::Arc { a, center, angle, .. } => a.dist(center) * angle.abs(),
+ _ => {
+ let pts: Vec<Vec3> = std::iter::once(s.start()).chain(s.points_after_start(1e-4)).collect();
+ pts.windows(2).map(|w| w[0].dist(w[1])).sum()
}
- out.push(patch);
- history.push(crate::record::generated(origins));
}
- let shell = mt::Shell::from(out);
- if shell.shell_condition() != mt::ShellCondition::Closed {
- return Err(KernelError::Failed("the thickened surface does not close".into()));
- }
- // The edges copied at no distance are the surface's own edges, rebuilt.
- let mut copies = HashMap::new();
- for (side, d) in [lo, hi].into_iter().enumerate() {
- if d != 0.0 {
- continue;
+ }
+
+ /// The point `f` (0…1) of the way along a segment's parameter and its unit tangent there.
+ fn at(s: &crate::PathSeg, f: f64) -> Option<(Vec3, Vec3)> {
+ match *s {
+ crate::PathSeg::Line { a, b } => Some((a.lerp(b, f), (b - a).normalized()?)),
+ crate::PathSeg::Arc { a, center, axis, angle } => {
+ let k = axis.normalized()?;
+ let p = crate::build::rotate_about(a, center, k, angle * f);
+ Some((p, (k.cross(p - center) * angle.signum()).normalized()?))
}
- for (id, list) in &ecopies[side] {
- if let Some(&edge) = edge_index.get(id) {
- for c in list {
- copies.insert(c.id(), EdgeOrigin::Edge { operand: 0, edge });
- }
- }
+ crate::PathSeg::Curve { plane, seg } => Some((plane.to_world(seg.point_at(f)), plane.dir_to_world(seg.derivative(f)).normalized()?)),
+ crate::PathSeg::Cubic { p: [p0, p1, p2, p3] } => {
+ let g = 1.0 - f;
+ let p = p0 * (g * g * g) + p1 * (3.0 * g * g * f) + p2 * (3.0 * g * f * f) + p3 * (f * f * f);
+ let d = (p1 - p0) * (3.0 * g * g) + (p2 - p1) * (6.0 * g * f) + (p3 - p2) * (3.0 * f * f);
+ Some((p, d.normalized()?))
}
}
- crate::record::attach(Body::new(mt::Solid::new_unchecked(vec![shell]))?, &[operand], Some(history), copies)
- })
+ }
+
+ /// One column of a loft: its curve in each section (and station) in loft order, skinned by
+ /// SMLib with no caps (`smlib_loft`), ruled between two, cubic through four or more.
+ pub(super) fn lofted(column: &[&solidcraft_geom::bspline::CurveN<4>]) -> Result<Brep> {
+ let sections: Vec<Vec<Curve>> = column
+ .iter()
+ .map(|c| {
+ let points = c.ctrl.iter().map(|h| [h[0] / h[3], h[1] / h[3], h[2] / h[3], h[3]]).collect();
+ vec![Curve::Nurbs { degree: c.degree, points, knots: c.knots.clone() }]
+ })
+ .collect();
+ let degree = u32::try_from(column.len().saturating_sub(1).clamp(1, 3)).unwrap_or(3);
+ checked(&SmBrep::loft(&sections, degree, false).map_err(sm("surface loft"))?, "surface loft")
+ }
}
-/// A planar surface extended: the chosen straight edges (picked by points on them) move
-/// outward in the face's plane by `distance`, their neighbours lengthened to meet them. The
-/// result's history is over `[body]`: the face and each edge the one it was moved from.
-pub fn extend(body: &Body, at: &[Vec3], distance: f64) -> Result<Body> {
- body.require_brep("extend")?;
- if !(distance.is_finite() && distance > 0.0) {
- return Err(KernelError::Invalid("the extension distance must be positive".into()));
+#[cfg(not(feature = "smlib"))]
+mod imp {
+ use super::*;
+
+ fn not_built() -> KernelError {
+ refuse("surfaces: this build has no SMLib (feature `smlib`)")
+ }
+ pub(super) fn refuse(what: &str) -> KernelError {
+ crate::smlib_sweeps::refuse(what)
+ }
+ pub(super) fn record_body(_: &Brep) -> Result<(Body, bool)> {
+ Err(not_built())
+ }
+ pub(super) fn stitched(_: &Brep, _: f64) -> Result<(Body, Option<History>)> {
+ Err(not_built())
+ }
+ pub(super) fn thicken(_: &Body, _: f64, _: bool) -> Result<Body> {
+ Err(not_built())
+ }
+ pub(super) fn offset_face(_: &Brep, _: usize, _: f64) -> Result<Brep> {
+ Err(not_built())
+ }
+ pub(super) fn extruded(_: &Plane, _: &[Numbered], _: Vec3, _: f64) -> Result<Brep> {
+ Err(not_built())
+ }
+ pub(super) fn revolved(_: &Plane, _: &[Numbered], _: Vec3, _: Vec3, _: f64) -> Result<Brep> {
+ Err(not_built())
+ }
+ pub(super) fn swept(_: &Plane, _: &[Numbered], _: &[crate::PathSeg]) -> Result<Brep> {
+ Err(not_built())
+ }
+ pub(super) fn swept_stations(_: &Plane, _: &[Numbered], _: &[crate::PathSeg], _: &crate::SweepControl) -> Result<Brep> {
+ Err(not_built())
+ }
+ pub(super) fn lofted(_: &[&solidcraft_geom::bspline::CurveN<4>]) -> Result<Brep> {
+ Err(not_built())
}
- let faces: Vec<mt::Face> = body.solid.face_iter().cloned().collect();
- let [face] = faces.as_slice() else { return Err(KernelError::Invalid("not supported yet: extending a surface of more than one face".into())) };
- let Some(crate::splitface::Analytic::Plane { n }) = crate::splitface::analytic_field(&face.oriented_surface()) else {
- return Err(KernelError::Invalid("not supported yet: extending a surface that is not planar".into()));
- };
- let chosen: Vec<mt::EdgeID> = at
- .iter()
- .map(|p| edge_near(body, *p).map(|e| e.id()).ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}"))))
- .collect::<Result<_>>()?;
- guard("extend", || {
- let bounds = face.boundaries();
- let [outer] = bounds.as_slice() else { return Err(KernelError::Invalid("not supported yet: extending a surface with holes".into())) };
- let edges: Vec<mt::Edge> = outer.edge_iter().cloned().collect();
- let m = edges.len();
- // Each edge as a line (point, direction) moved outward when chosen.
- let mut lines = Vec::with_capacity(m);
- for e in &edges {
- let (a, b) = (from_p3(e.front().point()), from_p3(e.back().point()));
- if !matches!(e.curve(), mt::Curve::Line(_)) {
- return Err(KernelError::Invalid("not supported yet: extending a surface with curved edges".into()));
- }
- let d = (b - a).normalized().ok_or_else(|| KernelError::Invalid("a zero-length edge".into()))?;
- // Outward: right of the edge seen along the normal (the face is on its left).
- let out = d.cross(n);
- let shift = if chosen.contains(&e.id()) || chosen.contains(&e.inverse().id()) { distance } else { 0.0 };
- lines.push((a + out * shift, d));
- }
- // Corners: where consecutive lines meet.
- let meet = |(p, d): (Vec3, Vec3), (q, e): (Vec3, Vec3)| -> Option<Vec3> {
- let w = q - p;
- let c = d.cross(e);
- let cc = c.dot(c);
- if cc < 1e-24 {
- return None;
- }
- Some(p + d * (w.cross(e).dot(c) / cc))
- };
- let mut corners = Vec::with_capacity(m);
- for i in 0..m {
- let (Some(prev), Some(cur)) = (lines.get((i + m - 1) % m), lines.get(i)) else { continue };
- let p = meet(*prev, *cur).unwrap_or(cur.0);
- corners.push(mt::Vertex::new(p3(p)));
- }
- let mut rec = Rebuild::default();
- let wire: mt::Wire = (0..m)
- .filter_map(|i| {
- let (a, b, old) = (corners.get(i)?, corners.get((i + 1) % m)?, edges.get(i)?);
- let e = mt::Edge::new_unchecked(a, b, mt::Curve::Line(mt::Line(a.point(), b.point())));
- rec.piece(&e, old);
- Some(e)
- })
- .collect::<Vec<_>>()
- .into();
- let mut f = mt::builder::try_attach_plane(&[wire]).map_err(|e| KernelError::Failed(format!("extend: {e}")))?;
- if f.oriented_surface().normal(0.0, 0.0).dot(crate::body::v3(n)) < 0.0 {
- f = f.inverse();
- }
- rec.face(&f, face);
- Ok(rebuilt_body(surface_body(vec![f]), &[&body.solid], &rec))
- })
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{box_solid, cylinder, measure, trim};
- use solidcraft_geom::{Loop2, Vec2};
+ use solidcraft_geom::Loop2;
fn rel(a: f64, b: f64) -> f64 {
(a - b).abs() / b.abs().max(1e-9)
@@ -1320,8 +1570,7 @@ mod tests {
let bent = vec![line[0], Seg2::Line { a: Vec2::new(10.0, 0.0), b: Vec2::new(10.0, 5.0) }];
let two = sweep_sheet_points(&Plane::XY, &[bent], &arc).unwrap();
assert_eq!(two.face_count(), 2);
- let edges: std::collections::HashSet<_> = two.solid.edge_iter().map(|e| e.id()).collect();
- assert_eq!(edges.len(), 7, "the walls share their seam");
+ assert_eq!(two.edge_count(), 7, "the walls share their seam");
}
#[test]
@@ -1494,7 +1743,7 @@ mod tests {
let want = 300.0 + 15.0 + 1.0 / 6.0;
let v = measure(&t).unwrap().volume;
assert!(rel(v, want) < 1e-9, "{v} vs {want}");
- assert!(Body::new(t.solid.as_ref().clone()).is_ok());
+ assert!(t.validity().is_empty(), "{:?}", t.validity());
assert!(thicken(&corner, -1.0, false).is_err());
assert!(thicken(&corner, 1.0, true).is_err(), "half of it goes into the inside corner");
}