Files
solidcraft/crates/kernel/src/smlib_sweeps.rs
T
2026-10-27 02:28:53 -04:00

1288 lines
67 KiB
Rust

//! Extrusions, revolutions, sweeps, lofts and screw sweeps through SMLib: the profile's
//! segments go to SMLib as 3D curves (lines, circular arcs, Béziers and conics as NURBS), SMLib
//! sweeps them, and the result comes back through its schema 4 record as a kernel body. A result
//! SMLib's own check refuses is an error, never a body. An option SMLib has no sweep for is "not
//! supported yet".
//!
//! A sweep that twists, scales, keeps an orientation direction or follows guide rails, and a
//! loft that follows guide rails, place the profile at stations by the laws the kernel's own
//! sweeps and lofts define ([`crate::sweep_path`], [`crate::loft_rails`]); each section is the
//! profile's exact image, and SMLib skins the walls through them.
//!
//! History is in the builders' vocabulary ([`FaceOrigin::Profile`], [`FaceOrigin::Cap`]), found
//! from the result's geometry ([`crate::provenance`] does the same for operations without exact
//! history): a wall comes from the profile segments whose curves its edge at the start runs
//! along (a wall SMLib makes over several tangent segments comes from all of them), and from
//! those whose middles it holds half-way along the sweep where that is known (extrusions,
//! revolutions); the face in the start plane is the start cap, the one in the end plane (or,
//! where the sweep has no end plane, the planar face left over) the end cap.
use solidcraft_geom::{Plane, Region2, Seg2, Vec3};
use crate::body::Body;
use crate::numbered::{NumberedLoop, NumberedRegion};
use crate::{KernelError, Result};
/// A profile segment as SMLib gets it, with the profile segments it stands for.
pub(crate) struct Piece {
pub seg: Seg2,
pub numbers: Vec<usize>,
/// The segment as drawn that names it: itself, or for collinear lines joined into one, the
/// first of them.
pub drawn: Seg2,
}
/// The segments of `loops` as pieces, loop after loop.
pub(crate) fn pieces<'a>(loops: impl IntoIterator<Item = &'a NumberedLoop>) -> Vec<Piece> {
loops.into_iter().flat_map(|l| l.lp.segs.iter().enumerate().map(|(i, s)| Piece { seg: *s, numbers: l.numbers(i).to_vec(), drawn: *s })).collect()
}
/// The pieces of `joined` (`drawn` with collinear lines joined): outer loop, then holes, each
/// joined line named by the first line drawn under it.
pub(crate) fn region_pieces(joined: &NumberedRegion, drawn: &NumberedRegion) -> Vec<Piece> {
let firsts: Vec<Seg2> = drawn.loops().flat_map(|l| l.lp.segs.iter().copied()).collect();
pieces(joined.loops())
.into_iter()
.map(|mut x| {
if x.numbers.len() > 1
&& let Some(first) = firsts.iter().find(|d| d.start() == x.seg.start())
{
x.drawn = *first;
}
x
})
.collect()
}
fn not_supported(what: &str) -> KernelError {
KernelError::Failed(format!("not supported yet: {what}"))
}
/// How an extrusion's walls lean.
#[derive(Clone, Copy, Debug)]
pub(crate) struct Draft {
/// Radians; positive grows the profile (as [`crate::extrude_tapered`] takes it).
pub taper: f64,
/// A height (less than the distance) the walls first stand straight for, before they slope
/// on to the same far end ([`crate::extrude_tapered_between`]'s foot).
pub foot: f64,
/// How the sharp corners close.
pub corner: crate::DraftCorner,
}
pub(crate) use imp::{
body_from_record, curve, extrude, face_section, loft, loft_rails, loft_to_point, path_curve, project_onto_face, revolve, screw, screw_radial,
sphere, sweep, sweep_controlled,
};
/// Refuses what no SMLib sweep does, before any work.
pub(crate) fn refuse(what: &str) -> KernelError {
not_supported(&format!("SMLib {what}"))
}
mod imp {
use std::collections::BTreeSet;
use solidcraft_smlib::sweeps::{Affine, Curve, DraftCorner, Ends, SweepFrame};
use solidcraft_smlib::{Brep, CheckLevel};
use solidcraft_geom::Vec2;
use super::*;
use crate::history::FaceProv;
use crate::provenance::{closest_on_tri, face_tris};
use crate::record;
fn failed(what: &str, e: impl std::fmt::Display) -> KernelError {
KernelError::Failed(format!("SMLib {what}: {e}"))
}
fn corner(c: crate::DraftCorner) -> DraftCorner {
match c {
crate::DraftCorner::PreserveCurvature => DraftCorner::Curvature,
crate::DraftCorner::Tangent => DraftCorner::Tangent,
crate::DraftCorner::Round => DraftCorner::Round,
}
}
fn p(v: Vec3) -> [f64; 3] {
[v.x, v.y, v.z]
}
/// The segment in 3D on `plane`, as SMLib's curve.
pub(crate) fn curve(plane: &Plane, s: &Seg2) -> Result<Curve> {
let w = |q: Vec2| p(plane.to_world(q));
let n = plane.x.cross(plane.y).normalized().ok_or_else(|| KernelError::Invalid("profile plane".into()))?;
let bezier = |pts: &[Vec2], weights: &[f64]| {
let degree = pts.len().saturating_sub(1);
let points = pts.iter().zip(weights).map(|(q, wt)| {
let [x, y, z] = w(*q);
[x, y, z, *wt]
});
let knots = std::iter::repeat_n(0.0, degree + 1).chain(std::iter::repeat_n(1.0, degree + 1)).collect();
Curve::Nurbs { degree, points: points.collect(), knots }
};
Ok(match *s {
Seg2::Line { a, b } => Curve::Line { start: w(a), end: w(b) },
Seg2::Arc { center, radius, start, sweep } => {
// A full circle re-split for a loft may come out a rounding over one turn.
if !(sweep.abs() <= std::f64::consts::TAU * (1.0 + 1e-9)) {
return Err(KernelError::Invalid("an arc turns more than once".into()));
}
let sweep = sweep.clamp(-std::f64::consts::TAU, std::f64::consts::TAU);
// Clockwise in the plane is counter-clockwise about the other normal, where a
// plane angle t is the angle -t.
let (axis, a0) = if sweep >= 0.0 { (n, start) } else { (-n, -start) };
Curve::Arc { center: w(center), axis: p(axis), reference: p(plane.x), radius, start: a0, end: a0 + sweep.abs() }
}
Seg2::Cubic { p0, p1, p2, p3 } => bezier(&[p0, p1, p2, p3], &[1.0; 4]),
Seg2::Conic { a, apex, b, w: wt } => bezier(&[a, apex, b], &[1.0, wt, 1.0]),
Seg2::Bezier { n: degree, p: pts } => {
let pts = pts.get(..=usize::from(degree)).ok_or_else(|| KernelError::Invalid("Bézier degree".into()))?;
bezier(pts, &vec![1.0; pts.len()])
}
})
}
fn curves(plane: &Plane, pieces: &[Piece]) -> Result<Vec<Curve>> {
pieces.iter().map(|x| curve(plane, &x.seg)).collect()
}
/// A chain of sketch segments on `plane` as SMLib's curves, one each, exactly (lines, arcs,
/// Béziers and conics as NURBS): what SMLib's sweeps take as a profile or a path.
#[allow(dead_code)] // For the sheet builders, which still build their own wires.
pub(crate) fn chain_curves(plane: &Plane, segs: &[Seg2]) -> Result<Vec<Curve>> {
segs.iter().map(|s| curve(plane, s)).collect()
}
/// The kernel body of an SMLib result SMLib's own check finds valid.
fn body_of(brep: &Brep, what: &str) -> Result<Body> {
let check = brep.check(CheckLevel::All).map_err(|e| failed(what, e))?;
if !check.is_valid() {
return Err(failed(what, format!("SMLib's check refuses the result: {check}")));
}
crate::native::body_from_smlib(brep)
}
/// The body (a solid or a sheet) a schema 4 record describes, taken by SMLib as a
/// modeller's own record (no healing) and checked there.
pub(crate) fn body_from_record(record: &solidcraft_geom::brep::Brep, what: &str) -> Result<Body> {
let brep = Brep::from_record(record, true).map_err(|e| failed(what, e))?;
body_of(&brep, what)
}
/// The sketch segments `segs` on `plane` projected along `direction` onto the face of
/// `body` at `face_at`: SMLib's projection (smlib_project_curves), each projected curve the
/// B-spline SMLib made, as a record curve on its interval, within a millionth of the body's
/// size of the true projection.
pub(crate) fn project_onto_face(
body: &Body,
face_at: Vec3,
plane: &Plane,
segs: &[Seg2],
direction: Vec3,
) -> Result<Vec<(solidcraft_geom::brep::Curve, [f64; 2])>> {
let c = segs.iter().map(|s| curve(plane, s)).collect::<Result<Vec<_>>>()?;
let out = body
.smlib()?
.project_curves(p(face_at), pick_reach(body), &c, p(direction), curve_tolerance(body))
.map_err(|e| curves_error("curve projection", e))?;
record_curves(out, "curve projection")
}
/// The face of `body` at `face_at` cut by the plane through `plane_point` square to `normal`,
/// SMLib's section curves on that face, as record curves on their intervals.
pub(crate) fn face_section(body: &Body, face_at: Vec3, plane_point: Vec3, normal: Vec3) -> Result<Vec<(solidcraft_geom::brep::Curve, [f64; 2])>> {
let out = body
.smlib()?
.face_section(p(face_at), pick_reach(body), p(plane_point), p(normal), curve_tolerance(body))
.map_err(|e| curves_error("face section", e))?;
record_curves(out, "face section")
}
/// How far a point may be from the face it picks: the kernel's picking reach.
fn pick_reach(body: &Body) -> f64 {
body.size().max(1e-9) * 1e-3 + 1e-6
}
/// How close a curve SMLib makes on a body's faces keeps to the true one: a millionth of the
/// body's size.
fn curve_tolerance(body: &Body) -> f64 {
(body.size() * 1e-6).max(1e-6)
}
fn curves_error(what: &str, e: solidcraft_smlib::Error) -> KernelError {
match e {
solidcraft_smlib::Error::Empty => KernelError::Invalid(format!("{what}: no curve on the face")),
solidcraft_smlib::Error::NoMatch { .. } => KernelError::Invalid(format!("{what}: no face of the body at the point")),
e => failed(what, e),
}
}
/// SMLib's NURBS curves as record curves (rational splines) on their intervals.
fn record_curves(out: Vec<(Curve, [f64; 2])>, what: &str) -> Result<Vec<(solidcraft_geom::brep::Curve, [f64; 2])>> {
out.into_iter()
.map(|(c, interval)| match c {
Curve::Nurbs { points, knots, .. } => {
let homogeneous = points.iter().map(|q| [q[0] * q[3], q[1] * q[3], q[2] * q[3], q[3]]).collect();
Ok((solidcraft_geom::brep::Curve::RationalSpline { knots, homogeneous }, interval))
}
_ => Err(failed(what, "a curve SMLib made is not a B-spline")),
})
.collect()
}
/// SMLib's sphere about `center`, each face swept from the arc (segment 0) of the half disc
/// a sphere revolves.
pub(crate) fn sphere(center: Vec3, radius: f64) -> Result<Body> {
let brep = Brep::make_sphere(p(center), radius).map_err(|e| failed("sphere", e))?;
let body = body_of(&brep, "sphere")?;
let faces = body.face_count();
Ok(record::attach(body, &[], Some(vec![record::profile(&[0usize]); faces]), &[]))
}
/// A point a wall is known by: on its edge in the start plane, or inside it; and the piece
/// (by index) that sweeps it.
struct Seed {
at: Vec3,
piece: usize,
}
fn seeds(plane: &Plane, pieces: &[Piece], to: impl Fn(Vec3) -> Vec3) -> Vec<Seed> {
pieces.iter().enumerate().map(|(piece, x)| Seed { at: to(plane.to_world(x.seg.point_at(0.5))), piece }).collect()
}
/// What a face of a swept body is.
#[derive(Clone, Debug, PartialEq)]
enum Role {
Start,
End,
/// A wall, swept from these pieces.
Wall(BTreeSet<usize>),
Unknown,
}
/// The role of each face of `body` swept from the profile in `start` (see the module notes):
/// `edges` lie on the walls' edges in the start plane, `inside` inside the walls; the face in
/// `end` (or, with `end` unset and `rest_is_end`, a planar face nothing else claims) is the
/// end cap.
fn roles(body: &Body, start: &Plane, end: Option<&Plane>, edges: &[Seed], inside: &[Seed], rest_is_end: bool) -> Result<Vec<Role>> {
let size = body.size().max(1e-9);
let mesh_tol = (size * 2e-4).max(1e-6);
let m = body.mesh(&crate::MeshTolerance::chord(mesh_tol))?;
let faces = face_tris(&m);
let n = body.face_count();
let flat_tol = size * 1e-5 + 1e-9;
let near = 3.0 * mesh_tol + flat_tol;
let flat = |f: usize, pl: &Plane| {
faces.get(f).is_some_and(|ft| !ft.tris.is_empty() && ft.tris.iter().all(|(t, _)| t.iter().all(|q| pl.height(*q).abs() <= flat_tol)))
};
let planar =
|f: usize| faces.get(f).is_some_and(|ft| ft.tris.first().is_some_and(|(_, n0)| ft.tris.iter().all(|(_, nn)| nn.dot(*n0) > 1.0 - 1e-6)));
// A face in the start plane is the start cap where the profile bounds it (a screw's far
// end after whole turns lies in the same plane, elsewhere).
let touches = |f: usize| {
edges.is_empty()
|| faces.get(f).is_some_and(|ft| edges.iter().any(|s| ft.tris.iter().any(|(t, _)| closest_on_tri(s.at, *t).dist(s.at) <= near)))
};
let start_cap: Vec<bool> = (0..n).map(|f| flat(f, start) && touches(f)).collect();
let end_cap: Vec<bool> = (0..n).map(|f| end.is_some_and(|e| flat(f, e))).collect();
let cap = |f: usize| start_cap.get(f).copied().unwrap_or(false) || end_cap.get(f).copied().unwrap_or(false);
let mut swept: Vec<BTreeSet<usize>> = vec![BTreeSet::new(); n];
for (poly, fs) in m.edges.iter().zip(&m.edge_faces) {
if poly.len() < 2 || !poly.iter().all(|q| start.height(*q).abs() <= flat_tol) {
continue;
}
for s in edges {
if poly.windows(2).any(|w| s.at.dist_to_segment(w[0], w[1]) <= near) {
for f in fs.iter().map(|f| *f as usize).filter(|f| !cap(*f)) {
if let Some(set) = swept.get_mut(f) {
set.insert(s.piece);
}
}
}
}
}
// Inside the walls: the face nearest each point (bounded work).
let tris: usize = faces.iter().map(|f| f.tris.len()).sum();
if tris.saturating_mul(inside.len()) <= 50_000_000 {
for s in inside {
let mut best = (f64::INFINITY, usize::MAX);
for (fi, ft) in faces.iter().enumerate() {
if !ft.bounds.inflated(best.0.min(size)).contains(s.at) {
continue;
}
for (t, _) in &ft.tris {
let d = closest_on_tri(s.at, *t).dist(s.at);
if d < best.0 {
best = (d, fi);
}
}
}
if best.0 <= 5.0 * near
&& !cap(best.1)
&& let Some(set) = swept.get_mut(best.1)
{
set.insert(s.piece);
}
}
}
Ok(swept
.into_iter()
.enumerate()
.map(|(f, set)| {
if start_cap.get(f).copied().unwrap_or(false) {
Role::Start
} else if end_cap.get(f).copied().unwrap_or(false) {
Role::End
} else if !set.is_empty() {
Role::Wall(set)
} else if end.is_none() && rest_is_end && planar(f) {
Role::End
} else {
log::debug!(target: "smlib", "sweep history: face {f} comes from no profile segment");
Role::Unknown
}
})
.collect())
}
/// The history the roles give: caps, and walls from their pieces' profile segments.
fn history(roles: &[Role], pieces: &[Piece]) -> Vec<FaceProv> {
roles
.iter()
.map(|r| match r {
Role::Start => record::cap(false),
Role::End => record::cap(true),
Role::Wall(set) => record::profile(set.iter().filter_map(|i| pieces.get(*i)).flat_map(|x| x.numbers.iter())),
Role::Unknown => record::generated(Vec::new()),
})
.collect()
}
fn with_history(body: Body, roles: &[Role], pieces: &[Piece]) -> Result<Body> {
Ok(record::attach(body, &[], Some(history(roles, pieces)), &[]))
}
/// The profile `pieces` on `plane`, moved `from` along its normal, extruded `distance`
/// along `sign` (±1) times the normal, straight or drafted.
pub(crate) fn extrude(
plane: &Plane,
pieces: &[Piece],
region: Option<&Region2>,
from: f64,
distance: f64,
sign: f64,
draft: Option<Draft>,
) -> Result<Body> {
let base = plane.offset(from);
let n = plane.x.cross(plane.y).normalized().ok_or_else(|| KernelError::Invalid("profile plane".into()))?;
let dir = n * sign.signum();
let c = curves(&base, pieces)?;
let top = plane.offset(from + sign.signum() * distance);
let edges = seeds(&base, pieces, |q| q);
let foot = draft.map_or(0.0, |d| d.foot);
if let Some(d) = draft.filter(|d| d.foot > 0.0) {
// A straight foot, then the walls sloping from its top to the far end the taper gives
// from the base, joined face to face where they meet.
if !(foot < distance) {
return Err(KernelError::Invalid(format!("taper foot = {foot}")));
}
let knee = plane.offset(from + sign.signum() * foot);
let lean = -(distance * d.taper.tan() / (distance - foot)).atan();
let prism = Brep::extrude(&c, p(dir), foot, 0.0, DraftCorner::default(), true).map_err(|e| failed("extrude", e))?;
let slope =
Brep::extrude(&curves(&knee, pieces)?, p(dir), distance - foot, lean, corner(d.corner), true).map_err(|e| failed("extrude", e))?;
let brep = prism.boolean(&slope, solidcraft_smlib::BooleanOp::Union).map_err(|e| failed("extrude", e))?;
let brep = brep.ok_or_else(|| failed("extrude", "nothing is left"))?;
let body = body_of(&brep, "extrude")?;
// The caps and the foot's walls from the base; the sloping walls (and the foot's again)
// from the edges at the knee, which both stand on.
let low = roles(&body, &base, Some(&top), &edges, &[], false)?;
let high = roles(&body, &knee, Some(&top), &seeds(&knee, pieces, |q| q), &[], false)?;
let roles: Vec<Role> = low
.into_iter()
.zip(high)
.map(|(a, b)| match (a, b) {
(Role::Wall(mut x), Role::Wall(y)) => {
x.extend(y);
Role::Wall(x)
}
(Role::Unknown, w @ Role::Wall(_)) => w,
(a, _) => a,
})
.collect();
return with_history(body, &roles, pieces);
}
// SMLib's draft is positive inward; the kernel's taper grows the profile.
let lean = draft.map_or(0.0, |d| -d.taper);
let rule = draft.map_or(DraftCorner::default(), |d| corner(d.corner));
let brep = Brep::extrude(&c, p(dir), distance, lean, rule, true).map_err(|e| failed("extrude", e))?;
let body = body_of(&brep, "extrude")?;
// Half-way along a straight wall lies over its segment; a drafted one has moved.
let inside = if draft.is_none() { seeds(&base, pieces, |q| q + dir * (distance * 0.5)) } else { Vec::new() };
let roles = roles(&body, &base, Some(&top), &edges, &inside, false)?;
let sources = (draft.is_none() && sign > 0.0).then(|| extrude_sources(&roles, pieces, region, plane, &base, &top));
let body = body.with_face_sources(sources.map(std::sync::Arc::new));
with_history(body, &roles, pieces)
}
/// The construction sources of a straight extrusion's faces along the normal of `sketch`, as
/// [`crate::extrude`] gives them: each cap the region at its end (both caps found once
/// each), each wall swept from one piece that piece as drawn, a line's with the wall's plane.
fn extrude_sources(
roles: &[Role],
pieces: &[Piece],
region: Option<&Region2>,
sketch: &Plane,
base: &Plane,
top: &Plane,
) -> Vec<Option<crate::FaceSource>> {
let once = |role: &Role| roles.iter().filter(|r| *r == role).count() == 1;
let caps = region.filter(|r| once(&Role::Start) && once(&Role::End) && numbered_segments(r) <= 4096);
roles
.iter()
.map(|role| match role {
Role::Start => caps.map(|r| crate::FaceSource::ExtrudeCap {
high: false,
region: r.clone(),
plane: Plane { origin: base.origin, x: sketch.x, y: -sketch.y },
}),
Role::End => caps.map(|r| crate::FaceSource::ExtrudeCap { high: true, region: r.clone(), plane: *top }),
Role::Wall(set) if set.len() == 1 => set.first().and_then(|i| pieces.get(*i)).map(|x| {
let plane = match x.seg {
Seg2::Line { a, b } => (b - a).normalized().and_then(|d| {
let foot = a - d * a.dot(d);
Plane::new(sketch.to_world(foot), sketch.dir_to_world(d), sketch.normal())
}),
_ => None,
};
crate::FaceSource::ExtrudeSide { segment: x.drawn, plane, coalesced: false }
}),
_ => None,
})
.collect()
}
fn numbered_segments(r: &Region2) -> usize {
r.outer.segs.len() + r.holes.iter().map(|h| h.segs.len()).sum::<usize>()
}
/// `v` turned by `a` right-handed about the unit `k` (Rodrigues).
fn turned(v: Vec3, k: Vec3, a: f64) -> Vec3 {
v * a.cos() + k.cross(v) * a.sin() + k * (k.dot(v) * (1.0 - a.cos()))
}
/// The profile `pieces` on `plane` turned `angle` radians (signed, right-handed about `axis`)
/// about the axis through `origin` (both in the plane). Segments on the axis sweep nothing.
pub(crate) fn revolve(plane: &Plane, pieces: &[Piece], origin: Vec3, axis: Vec3, angle: f64) -> Result<Body> {
let k = axis.normalized().ok_or_else(|| KernelError::Invalid("revolve axis".into()))?;
let (k, turn) = if angle < 0.0 { (-k, -angle) } else { (k, angle) };
let turn = turn.min(std::f64::consts::TAU);
let c = curves(plane, pieces)?;
let brep = Brep::revolve(&c, p(origin), p(k), turn, true).map_err(|e| failed("revolve", e))?;
let body = body_of(&brep, "revolve")?;
let size = body.size().max(1e-9);
let off_axis = |q: Vec3| {
let w = q - origin;
(w - k * w.dot(k)).len() > size * 1e-7
};
let walls: Vec<Piece> = pieces
.iter()
.filter(|x| [0.0, 0.5, 1.0].iter().any(|t| off_axis(plane.to_world(x.seg.point_at(*t)))))
.map(|x| Piece { seg: x.seg, numbers: x.numbers.clone(), drawn: x.drawn })
.collect();
let about = |q: Vec3, a: f64| origin + turned(q - origin, k, a);
let full = turn >= std::f64::consts::TAU - 1e-9;
let edges = seeds(plane, &walls, |q| q);
let inside = seeds(plane, &walls, |q| about(q, turn * 0.5));
let end = (!full).then(|| Plane { origin: about(plane.origin, turn), x: turned(plane.x, k, turn), y: turned(plane.y, k, turn) });
// A full turn has no caps, and its profile plane holds seams only.
let roles = if full {
roles(&body, &plane.offset(size * 10.0), None, &[], &inside, false)?
} else {
roles(&body, plane, end.as_ref(), &edges, &inside, false)?
};
with_history(body, &roles, &walls)
}
/// A path segment as SMLib's curve, exactly.
pub(crate) fn path_curve(s: &crate::PathSeg) -> Result<Curve> {
Ok(match *s {
crate::PathSeg::Line { a, b } => Curve::Line { start: p(a), end: p(b) },
crate::PathSeg::Arc { a, center, axis, angle } => {
let k = axis.normalized().ok_or_else(|| KernelError::Invalid("path arc axis".into()))?;
let (k, turn) = if angle < 0.0 { (-k, -angle) } else { (k, angle) };
let r = a - center;
let radius = r.len();
let reference = r.normalized().ok_or_else(|| KernelError::Invalid("path arc radius".into()))?;
Curve::Arc { center: p(center), axis: p(k), reference: p(reference), radius, start: 0.0, end: turn }
}
crate::PathSeg::Curve { plane, seg } => curve(&plane, &seg)?,
crate::PathSeg::Bezier(b) => {
let degree = b.degree();
let points = b.weighted_points().ok_or_else(|| KernelError::Invalid("a path span does not evaluate".into()))?;
Curve::Nurbs { degree, points, knots: std::iter::repeat_n(0.0, degree + 1).chain(std::iter::repeat_n(1.0, degree + 1)).collect() }
}
})
}
/// The profile `pieces` on `plane` swept along `path`, turning with it, or only moving along
/// it when `translate`. SMLib's sweep follows a smooth path; at a corner (the direction
/// jumping) the path is swept piece by piece ([`cornered`]).
pub(crate) fn sweep(plane: &Plane, pieces: &[Piece], path: &[crate::PathSeg], translate: bool) -> Result<Body> {
let runs = smooth_runs(path)?;
if runs.len() > 1 {
return cornered(plane, pieces, path, &runs, translate);
}
let (brep, _) = swept(plane, pieces, path, translate)?;
let body = body_of(&brep, "sweep")?;
let roles = roles(&body, plane, None, &seeds(plane, pieces, |q| q), &[], true)?;
with_history(body, &roles, pieces)
}
/// The sweep of the profile on `plane` along `path`, with the rigid motions SMLib reports
/// carrying the profile onto its first, middle and last sections.
fn swept(plane: &Plane, pieces: &[Piece], path: &[crate::PathSeg], translate: bool) -> Result<(Brep, [Affine; 3])> {
let c = curves(plane, pieces)?;
let route = path.iter().map(path_curve).collect::<Result<Vec<_>>>()?;
let frame = if translate { SweepFrame::Translate } else { SweepFrame::Follow };
Brep::sweep_placed(&c, &route, frame, true).map_err(|e| failed("sweep", e))
}
/// `q` moved by the motion `a`.
fn apply(a: &Affine, q: Vec3) -> Vec3 {
let col = |i: usize| a.m.get(i).map_or(Vec3::ZERO, |c| Vec3::new(c[0], c[1], c[2]));
col(0) * q.x + col(1) * q.y + col(2) * q.z + Vec3::new(a.t[0], a.t[1], a.t[2])
}
/// `pl` carried by the motion `a` (a rigid motion: its directions turn with it).
fn placed(pl: &Plane, a: &Affine) -> Plane {
let o = apply(a, Vec3::ZERO);
Plane { origin: apply(a, pl.origin), x: apply(a, pl.x) - o, y: apply(a, pl.y) - o }
}
/// The path's segments in runs along which its direction carries on (within a thousandth of
/// a radian across each joint): a new run starts at each corner.
fn smooth_runs(path: &[crate::PathSeg]) -> Result<Vec<std::ops::Range<usize>>> {
let ends: Vec<(Vec3, Vec3)> = path
.iter()
.map(crate::PathSeg::tangents)
.collect::<Option<_>>()
.ok_or_else(|| KernelError::Invalid("a path segment has no direction".into()))?;
let mut runs = Vec::new();
let mut from = 0;
for (i, w) in ends.windows(2).enumerate() {
if w[0].1.dot(w[1].0) < (1e-3f64).cos() {
runs.push(from..i + 1);
from = i + 1;
}
}
runs.push(from..path.len());
Ok(runs)
}
/// `pl` carried rigidly by a turn of `angle` about the unit `k` through `center`.
fn turned_plane(pl: &Plane, center: Vec3, k: Vec3, angle: f64) -> Plane {
Plane { origin: center + turned(pl.origin - center, k, angle), x: turned(pl.x, k, angle), y: turned(pl.y, k, angle) }
}
fn moved_plane(pl: &Plane, by: Vec3) -> Plane {
Plane { origin: pl.origin + by, ..*pl }
}
/// Where `s` starts and ends.
fn seg_ends(s: &crate::PathSeg) -> Result<(Vec3, Vec3)> {
Ok(match *s {
crate::PathSeg::Line { a, b } => (a, b),
crate::PathSeg::Arc { a, center, axis, angle } => {
let k = axis.normalized().ok_or_else(|| KernelError::Invalid("path arc axis".into()))?;
(a, crate::build::rotate_about(a, center, k, angle))
}
crate::PathSeg::Curve { plane, seg } => (plane.to_world(seg.start()), plane.to_world(seg.end())),
crate::PathSeg::Bezier(b) => (b.start(), b.end()),
})
}
/// A box on one side of the plane through `at` square to the unit `normal`: a `size` square
/// in the plane, `size` deep along `normal`.
fn half_space(at: Vec3, normal: Vec3, size: f64) -> Result<Brep> {
let u = if normal.x.abs() < 0.9 { Vec3::X } else { Vec3::Y };
let u = normal.cross(u).normalized().ok_or_else(|| KernelError::Invalid("mitre plane".into()))?;
let v = normal.cross(u);
let h = size * 0.5;
let c = [at + (u + v) * h, at + (v - u) * h, at - (u + v) * h, at + (u - v) * h];
let square: Vec<Curve> = (0..4).map(|i| Curve::Line { start: p(c[i]), end: p(c[(i + 1) % 4]) }).collect();
Brep::extrude(&square, p(normal), size, 0.0, DraftCorner::default(), true).map_err(|e| failed("mitre", e))
}
fn combined(a: &Brep, b: &Brep, op: solidcraft_smlib::BooleanOp, what: &str) -> Result<Brep> {
a.boolean(b, op).map_err(|e| failed(what, e))?.ok_or_else(|| failed(what, "nothing is left"))
}
/// A sweep along a path with corners: each smooth run of it swept on its own, and the runs
/// joined at each corner. Turning with the path, the profile turns at a corner about the
/// line square to both directions, and the runs meet in a mitre: each run is swept on
/// straight past the corner (along its direction there) and cut back to the plane that halves
/// the corner, where the next run, cut back the same way, meets it face to face. Only moving
/// along the path, the profile is the same at the corner in both runs, which meet there.
///
/// History: the start cap is the face in the profile's plane, the end cap the face in its
/// plane at the path's end; each wall comes from the profile segment it is swept from, found
/// on the first run's start or half-way along each run.
fn cornered(plane: &Plane, pieces: &[Piece], path: &[crate::PathSeg], runs: &[std::ops::Range<usize>], translate: bool) -> Result<Body> {
let start = path.first().map(seg_ends).transpose()?.map(|(a, _)| a).ok_or_else(|| KernelError::Invalid("empty path".into()))?;
// How far the profile reaches from the path.
let reach = pieces
.iter()
.flat_map(|x| (0..=8).map(move |i| x.seg.point_at(f64::from(i) / 8.0)))
.map(|q| plane.to_world(q).dist(start))
.fold(0.0f64, f64::max);
let mut length = 0.0;
for s in path {
let (a, b) = seg_ends(s)?;
length += a.dist(b).max(match *s {
crate::PathSeg::Arc { a, center, angle, .. } => (a - center).len() * angle.abs(),
crate::PathSeg::Curve { seg, .. } => seg.length(),
crate::PathSeg::Bezier(_) => seg_len(s),
crate::PathSeg::Line { .. } => 0.0,
});
}
let size = 4.0 * (length + reach) + 1.0;
let tangent = |s: Option<&crate::PathSeg>| {
s.and_then(crate::PathSeg::tangents).ok_or_else(|| KernelError::Invalid("a path segment has no direction".into()))
};
let (first_t, _) = tangent(path.first())?;
let (_, last_t) = tangent(path.last())?;
let end = path.last().map(seg_ends).transpose()?.map(|(_, b)| b).ok_or_else(|| KernelError::Invalid("empty path".into()))?;
// A closed path ends where it starts, with no caps; at a corner there the last run and the
// first meet in a mitre too.
let closed = end.dist(start) <= 1e-6;
let closing = (closed && last_t.dot(first_t) < (1e-3f64).cos()).then_some(first_t);
let mut pose = *plane;
let mut body: Option<Brep> = None;
let mut inside = Vec::new();
// The mitre the next run starts from: its point, its normal (along the run) and the turn.
let mut entry: Option<(Vec3, Vec3, f64)> = match closing {
Some(_) if !translate => {
let (m, turn) = mitre_of(last_t, first_t)?;
Some((start, m, turn))
}
_ => None,
};
for (ri, run) in runs.iter().enumerate() {
let segs = path.get(run.clone()).ok_or_else(|| KernelError::Invalid("path run".into()))?;
let (Some(first), Some(last)) = (segs.first(), segs.last()) else { return Err(KernelError::Invalid("path run".into())) };
let (t0, _) = first.tangents().ok_or_else(|| KernelError::Invalid("a path segment has no direction".into()))?;
let (_, t1) = last.tangents().ok_or_else(|| KernelError::Invalid("a path segment has no direction".into()))?;
let (a0, _) = seg_ends(first)?;
let (_, b1) = seg_ends(last)?;
let next = match runs.get(ri + 1).and_then(|r| path.get(r.start)) {
Some(s) => Some(tangent(Some(s))?.0),
None => closing,
};
// The plane halving the corner at the run's end, and the turn there.
let exit = next.map(|t2| mitre_of(t1, t2)).transpose()?;
// Each piece's sweep says where it left the profile: half-way along it each wall lies
// over its piece, and at its end (less any straight lead-out past the corner) the
// profile is where the next run takes it on.
let (piece, at_end) = if translate {
let (piece, [_, middle, last]) = swept(&pose, pieces, segs, true)?;
inside.extend(seeds(&pose, pieces, |q| apply(&middle, q)));
(piece, placed(&pose, &last))
} else {
// On past each mitre: the profile's reach times the tangent of half the turn takes
// every point of it to the mitre's plane; a little further, so the cut back runs
// through the walls, never along the run's own end.
let over = |turn: f64| reach * (turn * 0.5).tan() * 1.1 + reach * 1e-3 + 1e-6;
let pre = entry.map_or(0.0, |(_, _, turn)| over(turn));
let post = exit.map(|(_, turn)| over(turn)).unwrap_or(0.0);
let mut route = Vec::with_capacity(segs.len() + 2);
if pre > 0.0 {
route.push(crate::PathSeg::Line { a: a0 - t0 * pre, b: a0 });
}
route.extend_from_slice(segs);
if post > 0.0 {
route.push(crate::PathSeg::Line { a: b1, b: b1 + t1 * post });
}
let from = moved_plane(&pose, t0 * -pre);
let (mut piece, [_, middle, last]) = swept(&from, pieces, &route, false)?;
inside.extend(seeds(&from, pieces, |q| apply(&middle, q)));
if let Some((at, toward, _)) = entry {
piece = combined(&piece, &half_space(at, -toward, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?;
}
if let Some((m, _)) = exit {
piece = combined(&piece, &half_space(b1, m, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?;
}
(piece, moved_plane(&placed(&from, &last), t1 * -post))
};
body = Some(match body {
None => piece,
Some(b) => combined(&b, &piece, solidcraft_smlib::BooleanOp::Union, "sweep corner")?,
});
// The profile at the run's end, then turned through the corner onto the next run.
pose = at_end;
entry = None;
if let (Some(t2), Some((m, turn)), false) = (next, exit, translate) {
let k = t1.cross(t2).normalized().ok_or_else(|| KernelError::Invalid("path corner".into()))?;
pose = turned_plane(&pose, b1, k, turn);
entry = Some((b1, m, turn));
}
}
let brep = body.ok_or_else(|| KernelError::Invalid("empty path".into()))?;
let body = body_of(&brep, "sweep")?;
let roles = roles(&body, plane, (!closed).then_some(&pose), &seeds(plane, pieces, |q| q), &inside, false)?;
with_history(body, &roles, pieces)
}
/// The length of a path segment.
fn seg_len(s: &crate::PathSeg) -> f64 {
match *s {
crate::PathSeg::Line { a, b } => a.dist(b),
crate::PathSeg::Arc { a, center, angle, .. } => angle.abs() * a.dist(center),
crate::PathSeg::Curve { seg, .. } => seg.length(),
crate::PathSeg::Bezier(b) => b.length().unwrap_or(f64::NAN),
}
}
/// The point `f` (0…1) of the way along a path segment, and the unit direction of travel there.
fn seg_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 q = crate::build::rotate_about(a, center, k, angle * f);
Some((q, (k.cross(q - center) * angle.signum()).normalized()?))
}
// The parameter whose length from the start is that share of the curve's.
crate::PathSeg::Curve { plane, seg } => {
let want = seg.length() * f;
let (mut lo, mut hi) = (0.0f64, 1.0f64);
for _ in 0..48 {
let t = 0.5 * (lo + hi);
if seg.split_at(t).0.length() < want {
lo = t;
} else {
hi = t;
}
}
let t = 0.5 * (lo + hi);
Some((plane.to_world(seg.point_at(t)), plane.dir_to_world(seg.derivative(t)).normalized()?))
}
crate::PathSeg::Bezier(b) => b.along(f),
}
}
/// `n + 1` points evenly spaced by length along `path` (exact on its lines and arcs), with the
/// unit directions of travel there.
fn path_samples(path: &[crate::PathSeg], n: usize) -> Result<(Vec<Vec3>, Vec<Vec3>)> {
let lens: Vec<f64> = path.iter().map(seg_len).collect();
let total: f64 = lens.iter().sum();
if !(total > 1e-9 && total.is_finite()) || n == 0 {
return Err(KernelError::Invalid("the sweep path has no length".into()));
}
let bad = || KernelError::Invalid("a path segment has no direction".into());
let (mut pts, mut tangents) = (Vec::with_capacity(n + 1), Vec::with_capacity(n + 1));
let (mut k, mut before) = (0usize, 0.0f64);
for i in 0..=n {
let at = total * i as f64 / n as f64;
while k + 1 < path.len() && lens.get(k).is_some_and(|l| before + l < at) {
before += lens.get(k).copied().unwrap_or(0.0);
k += 1;
}
let (seg, len) = path.get(k).zip(lens.get(k)).ok_or_else(bad)?;
let f = if *len > 0.0 { ((at - before) / len).clamp(0.0, 1.0) } else { 0.0 };
let (q, t) = seg_at(seg, f).ok_or_else(bad)?;
pts.push(q);
tangents.push(t);
}
Ok((pts, tangents))
}
/// How far the direction of travel turns along a path segment (radians, all told).
fn path_turn(s: &crate::PathSeg) -> f64 {
match *s {
crate::PathSeg::Line { .. } => 0.0,
crate::PathSeg::Arc { angle, .. } => angle.abs(),
crate::PathSeg::Curve { seg, .. } => {
let pts = seg.polyline(1e-3);
pts.windows(3)
.filter_map(|w| Some(((w[1] - w[0]).normalized()?, (w[2] - w[1]).normalized()?)))
.map(|(u, v)| u.cross(v).atan2(u.dot(v)).abs())
.sum()
}
crate::PathSeg::Bezier(b) => {
let pts: Vec<Vec3> = std::iter::once(b.start()).chain(b.polyline(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()
}
}
}
/// Fewest and most stations of a sweep that twists, scales or follows rails.
const MIN_STATIONS: usize = 16;
const MAX_STATIONS: usize = 2048;
/// The profile `region` on `plane` swept along the smooth `path` the way `ctl` asks: twisted,
/// scaled, kept at an orientation or guided by rails. The profile is placed at stations along
/// the path by [`crate::sweep_path`]'s laws (the same the polyline sweep uses), each section
/// exactly the profile's image, and SMLib skins the walls through them. Round a closed path the
/// last section has to land on the first, and the ends are joined.
pub(crate) fn sweep_controlled(plane: &Plane, region: &NumberedRegion, path: &[crate::PathSeg], ctl: &crate::SweepControl) -> Result<Body> {
let runs = smooth_runs(path)?;
if runs.len() > 1 {
return cornered_controlled(plane, region, path, &runs, ctl);
}
let pieces = pieces(region.loops());
let c = curves(plane, &pieces)?;
let start = path.first().map(crate::PathSeg::start).ok_or_else(|| KernelError::Invalid("the path needs 1…1000 segments".into()))?;
// Each point of the profile turns with the path and the twist, and SMLib's skin is a cubic
// interpolation through the stations with free ends, whose error near the ends falls only
// as the square of the step: a square of reach 7.1 twisted a quarter turn over 40 mm is
// 2e-7 off in volume at 1.4 degree steps and 2e-6 at 2.8 (measured against V = A L). A
// station per degree of turn.
let turn: f64 = path.iter().map(path_turn).sum::<f64>() + ctl.twist.abs();
let step = std::f64::consts::PI / 180.0;
let rail_points = ctl.rails.iter().map(Vec::len).max().unwrap_or(0);
let n = ((turn / step).ceil() as usize).max(rail_points.saturating_sub(1)).clamp(MIN_STATIONS, MAX_STATIONS);
let (pts, tangents) = path_samples(path, n)?;
let st = crate::sweep_path::controlled_stations(plane, &pts, &tangents, &[], ctl)?;
let (Some(first), Some(last)) = (st.first(), st.last()) else { return Err(KernelError::Invalid("sweep path".into())) };
let s0 = first.at;
let size = pts.windows(2).map(|w| w[0].dist(w[1])).sum::<f64>() + region.outer.lp.signed_area().abs().sqrt();
let closed = pts.last().is_some_and(|e| e.dist(start) <= 1e-7 * (1.0 + size));
if closed {
for l in region.loops() {
crate::sweep_path::closing_offset(plane, l, &st)?;
}
}
let maps: Vec<Affine> = st
.iter()
.map(|s| {
let [a, b, c] = s.m;
Affine { m: [p(a), p(b), p(c)], t: p(s.at - s.apply(s0)) }
})
.collect();
let brep = Brep::sweep_stations(&c, &maps, if closed { Ends::Joined } else { Ends::Capped }).map_err(|e| failed("sweep", e))?;
let body = body_of(&brep, "sweep")?;
let mid = st.get(st.len() / 2).copied().unwrap_or(*last);
let inside = seeds(plane, &pieces, |q| mid.at + mid.apply(q - s0));
let roles = if closed {
// Round a closed path there are no caps, and the start holds seams only.
roles(&body, &plane.offset(size * 10.0), None, &[], &inside, false)?
} else {
let end = Plane::new(last.at + last.apply(plane.origin - s0), last.apply(plane.x), last.apply(plane.y))
.ok_or_else(|| KernelError::Invalid("the sweep's end section is degenerate".into()))?;
roles(&body, plane, Some(&end), &seeds(plane, &pieces, |q| q), &inside, false)?
};
with_history(body, &roles, &pieces)
}
/// `x` moved by `a`.
fn affine_apply(a: &Affine, x: Vec3) -> Vec3 {
let [c0, c1, c2] = a.m;
let v = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]);
v(c0) * x.x + v(c1) * x.y + v(c2) * x.z + v(a.t)
}
/// `v` turned by `a`'s linear part.
fn affine_turn(a: &Affine, v: Vec3) -> Vec3 {
affine_apply(a, v) - affine_apply(a, Vec3::ZERO)
}
/// `a` after `b`: x goes to a(b(x)).
fn affine_after(a: &Affine, b: &Affine) -> Affine {
let col = |c: [f64; 3]| p(affine_turn(a, Vec3::new(c[0], c[1], c[2])));
Affine { m: [col(b.m[0]), col(b.m[1]), col(b.m[2])], t: p(affine_apply(a, Vec3::new(b.t[0], b.t[1], b.t[2]))) }
}
/// The rigid turn by `angle` about the unit `k` through `center`, as an affine map.
fn affine_turned(center: Vec3, k: Vec3, angle: f64) -> Affine {
let col = |e: Vec3| p(turned(e, k, angle));
Affine { m: [col(Vec3::X), col(Vec3::Y), col(Vec3::Z)], t: p(center - turned(center, k, angle)) }
}
fn affine_moved(a: &Affine, by: Vec3) -> Affine {
Affine { m: a.m, t: p(Vec3::new(a.t[0], a.t[1], a.t[2]) + by) }
}
const IDENTITY: Affine = Affine { m: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], t: [0.0; 3] };
/// A sweep that twists, scales, keeps an orientation direction or follows guide rails along
/// a path with corners, by the corner model of the plain sweep ([`cornered`]): each smooth run
/// of the path is swept through stations by the laws a smooth path has (the twist and the
/// scale running with the length along the whole path, each run going on from the section the
/// last one ended with), and the runs meet at each corner in a mitre. Turning with the path,
/// each run is carried on straight past its corners as a prism of its section there (the laws
/// hold still across a mitre: the two runs' sections meet on the plane halving the corner only
/// when both are the corner's section), cut back to that plane, and the section turned through
/// the corner about its binormal; only moving along the path, the runs meet at the corner's
/// section.
///
/// At a corner an orientation direction turns the section as the corner does, and along the
/// next run it turns back about the path to the direction's frame, evenly along the run's
/// length, as a twist. Guide rails must turn with the path: each rail has a corner of its own
/// at every corner of the path, in the plane halving it and by the same turn, where it is cut
/// into the runs' rails. Round a closed path the last section has to land on the first: a
/// twist where the profile maps onto itself; an end scale never does.
fn cornered_controlled(
plane: &Plane,
region: &NumberedRegion,
path: &[crate::PathSeg],
runs: &[std::ops::Range<usize>],
ctl: &crate::SweepControl,
) -> Result<Body> {
let translate = ctl.orientation == crate::SweepOrientation::Parallel;
let pieces = pieces(region.loops());
let c = curves(plane, &pieces)?;
let bad = || KernelError::Invalid("a path segment has no direction".into());
let start = path.first().map(crate::PathSeg::start).ok_or_else(|| KernelError::Invalid("empty path".into()))?;
let end = path.last().map(crate::PathSeg::end).ok_or_else(|| KernelError::Invalid("empty path".into()))?;
let lens: Vec<f64> = path.iter().map(seg_len).collect();
let total: f64 = lens.iter().sum();
if !(total > 1e-9 && total.is_finite()) {
return Err(KernelError::Invalid("the sweep path has no length".into()));
}
let tangent = |s: Option<&crate::PathSeg>| s.and_then(crate::PathSeg::tangents).ok_or_else(bad);
let (first_t, _) = tangent(path.first())?;
let (_, last_t) = tangent(path.last())?;
let closed = end.dist(start) <= 1e-6;
if closed && ctl.scale != 1.0 {
return Err(KernelError::Invalid(
"a sweep with an end scale can't go round a closed path: its last section would have to land on its first".into(),
));
}
let closing = (closed && last_t.dot(first_t) < (1e-3f64).cos()).then_some(first_t);
let reach = pieces
.iter()
.flat_map(|x| (0..=8).map(move |i| x.seg.point_at(f64::from(i) / 8.0)))
.map(|q| plane.to_world(q).dist(start) * ctl.scale.max(1.0))
.fold(0.0f64, f64::max);
let size = 4.0 * (total + reach) + 1.0;
let law = |u: f64| 1.0 + (ctl.scale - 1.0) * u;
let n0 = plane.normal().normalized().ok_or_else(|| KernelError::Invalid("profile plane".into()))?;
// Each run's rails, cut at the corners.
let rails = run_rails(path, runs, &ctl.rails, closing)?;
// The map carrying the profile as drawn onto the section where the next run starts, the
// mitre that run starts from (its point, its normal along the run, its turn) and how far
// along the path it starts.
let mut at_start = IDENTITY;
let mut entry: Option<(Vec3, Vec3, f64)> = match closing {
Some(_) if !translate => {
let (m, turn) = mitre_of(last_t, first_t)?;
Some((start, m, turn))
}
_ => None,
};
let mut before = 0.0f64;
let mut body: Option<Brep> = None;
let mut inside = Vec::new();
for (ri, run) in runs.iter().enumerate() {
let segs = path.get(run.clone()).ok_or_else(|| KernelError::Invalid("path run".into()))?;
let length: f64 = lens.get(run.clone()).ok_or_else(|| KernelError::Invalid("path run".into()))?.iter().sum();
let (u0, u1) = (before / total, (before + length) / total);
let (Some(first), Some(last)) = (segs.first(), segs.last()) else { return Err(KernelError::Invalid("path run".into())) };
let ((t0, _), (_, t1)) = (first.tangents().ok_or_else(bad)?, last.tangents().ok_or_else(bad)?);
let (a0, b1) = (first.start(), last.end());
let normal = affine_turn(&at_start, n0).normalized().ok_or_else(|| KernelError::Invalid("the sweep's section is degenerate".into()))?;
let pose = Plane::from_normal(a0, normal).ok_or_else(|| KernelError::Invalid("the sweep's section is degenerate".into()))?;
// The run's own laws on its section at the start: the twist over its length (less the
// turn back to the orientation direction after a corner), the scale from where the
// last run left it to where this one ends, the rails from corner to corner.
let back = match ctl.orientation {
crate::SweepOrientation::Direction(_) if ri > 0 => direction_offset(plane, start, first_t, a0, t0, u0, ctl, &at_start)?,
_ => 0.0,
};
let run_ctl = crate::SweepControl {
orientation: ctl.orientation,
twist: ctl.twist * (u1 - u0) - back,
scale: law(u1) / law(u0),
rails: rails.get(ri).cloned().unwrap_or_default(),
rail_fit: ctl.rail_fit,
};
// A station per degree the section turns, with the path and the twist.
let turn: f64 = segs.iter().map(path_turn).sum::<f64>() + run_ctl.twist.abs();
let n = ((turn / (std::f64::consts::PI / 180.0)).ceil() as usize).clamp(MIN_STATIONS, MAX_STATIONS);
let (pts, tangents) = path_samples(segs, n)?;
let st = crate::sweep_path::controlled_stations(&pose, &pts, &tangents, &[], &run_ctl)?;
let maps: Vec<Affine> = st
.iter()
.map(|s| {
let [a, b, cc] = s.m;
affine_after(&Affine { m: [p(a), p(b), p(cc)], t: p(s.at - s.apply(a0)) }, &at_start)
})
.collect();
let (Some(&first_map), Some(&end_map)) = (maps.first(), maps.last()) else { return Err(KernelError::Invalid("sweep path".into())) };
let mid = maps.get(maps.len() / 2).copied().unwrap_or(end_map);
inside.extend(seeds(plane, &pieces, |q| affine_apply(&mid, q)));
let mut piece = Brep::sweep_stations(&c, &maps, Ends::Capped).map_err(|e| failed("sweep", e))?;
let next = match runs.get(ri + 1).and_then(|r| path.get(r.start)) {
Some(s) => Some(tangent(Some(s))?.0),
None => closing,
};
let exit = next.map(|t2| mitre_of(t1, t2)).transpose()?;
if !translate {
// On past each mitre, the run's section there held still.
let over = |turn: f64| reach * (turn * 0.5).tan() * 1.1 + reach * 1e-3 + 1e-6;
let prism = |map: Affine, toward: Vec3, by: f64| -> Result<Brep> {
Brep::sweep_stations(&c, &[map, affine_moved(&map, toward * by)], Ends::Capped).map_err(|e| failed("sweep corner", e))
};
if let Some((at, m, turn)) = entry {
let lead = prism(affine_moved(&first_map, t0 * -over(turn)), t0, over(turn))?;
piece = combined(&piece, &lead, solidcraft_smlib::BooleanOp::Union, "sweep corner")?;
piece = combined(&piece, &half_space(at, -m, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?;
}
if let Some((m, turn)) = exit {
let tail = prism(end_map, t1, over(turn))?;
piece = combined(&piece, &tail, solidcraft_smlib::BooleanOp::Union, "sweep corner")?;
piece = combined(&piece, &half_space(b1, m, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?;
}
}
body = Some(match body {
None => piece,
Some(b) => combined(&b, &piece, solidcraft_smlib::BooleanOp::Union, "sweep corner")?,
});
// The section at the run's end, turned through the corner onto the next run.
at_start = end_map;
entry = None;
if let (Some(t2), Some((m, turn)), false) = (next, exit, translate) {
let k = t1.cross(t2).normalized().ok_or_else(|| KernelError::Invalid("path corner".into()))?;
at_start = affine_after(&affine_turned(b1, k, turn), &end_map);
entry = Some((b1, m, turn));
}
before += length;
}
let brep = body.ok_or_else(|| KernelError::Invalid("empty path".into()))?;
if closed {
// Back at the start, the section has to be the profile again (a whole number of its
// symmetries of twist).
let to_station = |a: &Affine| {
let v = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]);
crate::sweep_path::Station { at: affine_apply(a, start), m: [v(a.m[0]), v(a.m[1]), v(a.m[2])] }
};
for l in region.loops() {
crate::sweep_path::closing_offset(plane, l, &[to_station(&IDENTITY), to_station(&at_start)])?;
}
}
let body = body_of(&brep, "sweep")?;
let roles = if closed {
roles(&body, &plane.offset(size * 10.0), None, &[], &inside, false)?
} else {
let end_plane = Plane::new(affine_apply(&at_start, plane.origin), affine_turn(&at_start, plane.x), affine_turn(&at_start, plane.y))
.ok_or_else(|| KernelError::Invalid("the sweep's end section is degenerate".into()))?;
roles(&body, plane, Some(&end_plane), &seeds(plane, &pieces, |q| q), &inside, false)?
};
with_history(body, &roles, &pieces)
}
/// After a corner, how far the section at `a0` (the profile carried there by `at_start`) is
/// turned about its normal (toward the run's direction `t0`) from where the orientation direction's law puts it
/// (the law of a smooth path from `start`, leaving along `first_t`, `u0` of the way along):
/// the turn the next run takes back, as a twist. Radians, right-handed about `t0`.
#[allow(clippy::too_many_arguments)]
fn direction_offset(
plane: &Plane,
start: Vec3,
first_t: Vec3,
a0: Vec3,
t0: Vec3,
u0: f64,
ctl: &crate::SweepControl,
at_start: &Affine,
) -> Result<f64> {
let law = crate::SweepControl { twist: ctl.twist * u0, scale: 1.0 + (ctl.scale - 1.0) * u0, rails: Vec::new(), ..ctl.clone() };
// A two-station path from the start to here with the two directions: the law's section here.
let st = crate::sweep_path::controlled_stations(plane, &[start, a0], &[first_t, t0], &[], &law)?;
let want = st.last().map(|s| s.apply(plane.x)).ok_or_else(|| KernelError::Invalid("sweep path".into()))?;
let have = affine_turn(at_start, plane.x);
// About the section's normal, pointing the way the run leaves it (the twist's axis).
let n = affine_turn(at_start, plane.normal());
let axis = (if n.dot(t0) < 0.0 { n * -1.0 } else { n })
.normalized()
.ok_or_else(|| KernelError::Invalid("the sweep's section is degenerate".into()))?;
let flat = |v: Vec3| (v - axis * v.dot(axis)).normalized();
let (Some(w), Some(h)) = (flat(want), flat(have)) else {
return Err(KernelError::Invalid("the profile lies along the sweep path at a corner".into()));
};
Ok(w.cross(h).dot(axis).atan2(w.dot(h)))
}
/// The guide rails cut at the path's corners, one set per run: each rail must turn with the
/// path there, with a corner of its own in the plane halving the path's corner and by the
/// same turn about the same axis.
fn run_rails(
path: &[crate::PathSeg],
runs: &[std::ops::Range<usize>],
rails: &[Vec<Vec3>],
closing: Option<Vec3>,
) -> Result<Vec<Vec<Vec<Vec3>>>> {
if rails.is_empty() {
return Ok(vec![Vec::new(); runs.len()]);
}
if closing.is_some() {
return Err(KernelError::Invalid("guide rails can't follow a closed path with corners: a rail runs from the start to the end".into()));
}
let refused = |i: usize| {
KernelError::Invalid(format!(
"at corner {} of the path the guide rails have to turn with it: each rail needs a corner of its own there, in the plane halving the path's corner and by the same turn",
i + 1
))
};
let mut rest: Vec<Vec<Vec3>> = rails.iter().map(|r| crate::sweep_path::clean(r)).collect::<Result<_>>()?;
let mut out = Vec::with_capacity(runs.len());
for (ci, w) in runs.windows(2).enumerate() {
let (Some(a), Some(b)) = (w[0].end.checked_sub(1).and_then(|i| path.get(i)), path.get(w[1].start)) else { return Err(refused(ci)) };
let ((_, t1), (t2, _)) = (a.tangents().ok_or_else(|| refused(ci))?, b.tangents().ok_or_else(|| refused(ci))?);
let (m, turn) = mitre_of(t1, t2)?;
let at = a.end();
let k = t1.cross(t2).normalized().ok_or_else(|| refused(ci))?;
let mut here = Vec::with_capacity(rest.len());
for rail in &mut rest {
let size = rail.windows(2).map(|q| q[0].dist(q[1])).sum::<f64>().max(1e-9);
let tol = (size * 1e-6).max(1e-6);
let corner = (1..rail.len().saturating_sub(1)).find(|&j| {
let (Some(p), Some(q), Some(r)) = (rail.get(j - 1), rail.get(j), rail.get(j + 1)) else { return false };
let (Some(d1), Some(d2)) = ((*q - *p).normalized(), (*r - *q).normalized()) else { return false };
(*q - at).dot(m).abs() <= tol
&& (d1.dot(d2).clamp(-1.0, 1.0).acos() - turn).abs() <= 1e-3
&& d1.cross(d2).normalized().is_some_and(|kr| kr.dot(k) > 1.0 - 1e-6)
});
let j = corner.ok_or_else(|| refused(ci))?;
let tail = rail.split_off(j);
let mut head = std::mem::replace(rail, tail);
head.extend(rail.first().copied());
here.push(head);
}
out.push(here);
}
out.push(rest);
Ok(out)
}
/// The plane halving the corner from direction `t1` to `t2` (its unit normal) and the turn
/// there; a path that turns back on itself has none.
fn mitre_of(t1: Vec3, t2: Vec3) -> Result<(Vec3, f64)> {
let turn = t1.dot(t2).clamp(-1.0, 1.0).acos();
if turn > std::f64::consts::PI - 1e-3 {
return Err(KernelError::Invalid("the path turns back on itself at a corner".into()));
}
Ok(((t1 + t2).normalized().ok_or_else(|| KernelError::Invalid("path corner".into()))?, turn))
}
/// A loft through `sections` (each a closed loop of pieces, all re-split to the same count
/// and lined up), `first` the index of the section given first (its cap is the start cap).
pub(crate) fn loft(sections: &[(Plane, Vec<Piece>)], first: usize) -> Result<Body> {
let curves: Vec<Vec<Curve>> = sections.iter().map(|(pl, ps)| curves(pl, ps)).collect::<Result<_>>()?;
// Ruled between two sections, else smooth through them (cubic from four).
let degree = match sections.len() {
0..=2 => 1,
3 => 2,
_ => 3,
};
loft_through(sections, first, &curves, degree)
}
/// The loft skinned through `curves` (the sections', or with stations between them), `degree`
/// across them; `sections` and `first` as [`loft`] takes them name the faces.
fn loft_through(sections: &[(Plane, Vec<Piece>)], first: usize, curves: &[Vec<Curve>], degree: u32) -> Result<Body> {
let brep = Brep::loft(curves, degree, true).map_err(|e| failed("loft", e))?;
let body = body_of(&brep, "loft")?;
let (Some((start, lead)), Some(last)) = (sections.get(first), sections.get(if first == 0 { sections.len().saturating_sub(1) } else { 0 }))
else {
return Err(KernelError::Invalid("loft sections".into()));
};
// Each wall comes from its column's segments in every section.
let columns: Vec<Piece> = lead
.iter()
.enumerate()
.map(|(i, x)| {
let mut all: BTreeSet<usize> = BTreeSet::new();
for (_, ps) in sections {
if let Some(q) = ps.get(i) {
all.extend(q.numbers.iter().copied());
}
}
Piece { seg: x.seg, numbers: all.into_iter().collect(), drawn: x.drawn }
})
.collect();
let roles = roles(&body, start, Some(&last.0), &seeds(start, &columns, |q| q), &[], false)?;
with_history(body, &roles, &columns)
}
/// A loft through `sections` (as [`loft`] takes them) guided by one or two `rails` (polylines
/// from the first section to the last, through every section's curve), by the law
/// [`crate::loft_rails::railed`] gives a loft's rails: between each two sections stations are
/// the plain loft there moved so that the points the rails guide land on the rails. Each
/// section curve has to pair with the others' (the same kind, so their control points pair
/// up).
pub(crate) fn loft_rails(sections: &[(Plane, Vec<Piece>)], first: usize, rails: &[Vec<Vec3>], fit: crate::RailFit) -> Result<Body> {
if rails.is_empty() || rails.len() > 2 {
return Err(KernelError::Invalid("a loft takes one or two guide rails".into()));
}
let matched = sections
.iter()
.map(|(pl, ps)| {
let segs: Vec<Seg2> = ps.iter().map(|x| x.seg).collect();
crate::loft_rails::Section::of(pl, &segs, ps.iter().map(|x| x.numbers.clone()).collect())
})
.collect::<Result<Vec<_>>>()?;
let all: Vec<Vec<Curve>> = crate::loft_rails::railed(&matched, true, rails, fit)?
.iter()
.map(|section| {
section
.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();
Curve::Nurbs { degree: c.degree, points, knots: c.knots.clone() }
})
.collect()
})
.collect();
loft_through(sections, first, &all, 3)
}
/// A loft from the section `pieces` (lines) on `plane` to `apex`: the base is the start cap,
/// each triangle comes from the segment it stands on.
pub(crate) fn loft_to_point(plane: &Plane, pieces: &[Piece], apex: Vec3) -> Result<Body> {
let c = curves(plane, pieces)?;
let brep = Brep::loft_to_point(&c, p(apex)).map_err(|e| failed("loft to a point", e))?;
let body = body_of(&brep, "loft to a point")?;
let roles = roles(&body, plane, None, &seeds(plane, pieces, |q| q), &[], false)?;
with_history(body, &roles, pieces)
}
/// The profile `pieces` on `plane` carried by a screw motion about the axis through `origin`
/// along `axis`: `turns` right-handed turns, rising `pitch` per turn.
pub(crate) fn screw(plane: &Plane, pieces: &[Piece], origin: Vec3, axis: Vec3, pitch: f64, turns: f64) -> Result<Body> {
let c = curves(plane, pieces)?;
// Walls within a ten-thousandth of the pitch of the true screw surfaces.
let tolerance = (pitch.abs() * 1e-4).clamp(1e-6, 1e-2);
let brep = Brep::screw_sweep(&c, p(origin), p(axis), pitch, turns, tolerance).map_err(|e| failed("screw sweep", e))?;
let body = body_of(&brep, "screw sweep")?;
let roles = roles(&body, plane, None, &seeds(plane, pieces, |q| q), &[], true)?;
with_history(body, &roles, pieces)
}
/// [`screw`] with the profile moved `offset(t)` mm off the axis at turn t (negative: towards
/// it), piecewise linear through `law`'s (turn, offset) pairs: a groove fading over a runout.
pub(crate) fn screw_radial(
plane: &Plane,
pieces: &[Piece],
origin: Vec3,
axis: Vec3,
pitch: f64,
turns: f64,
law: &[(f64, f64)],
) -> Result<Body> {
let c = curves(plane, pieces)?;
let tolerance = (pitch.abs() * 1e-4).clamp(1e-6, 1e-2);
let brep =
Brep::screw_sweep_radial(&c, p(origin), p(axis), pitch, turns, law, tolerance).map_err(|e| failed("screw sweep with a radial law", e))?;
let body = body_of(&brep, "screw sweep")?;
let roles = roles(&body, plane, None, &seeds(plane, pieces, |q| q), &[], true)?;
with_history(body, &roles, pieces)
}
}