Skip to content

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

Wave 174/509: kernel: surface sweeps mitre at corners, as the solid sweep does (and 1 more)

jyviko2e39a45145e3
diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rs
index 2aedd93d8f..f9d5bf9931 100644
--- a/crates/kernel/src/smlib_sweeps.rs
+++ b/crates/kernel/src/smlib_sweeps.rs
@@ -71,7 +71,9 @@ pub(crate) struct Draft {
}
#[cfg(feature = "smlib")]
-pub(crate) use imp::{body_from_record, curve, extrude, loft, loft_rails, loft_to_point, revolve, screw, sphere, sweep, sweep_controlled};
+pub(crate) use imp::{
+ body_from_record, curve, extrude, loft, loft_rails, loft_to_point, path_curve, revolve, screw, sphere, sweep, sweep_controlled,
+};
/// The error of an SMLib operation in a build without SMLib.
#[cfg(not(feature = "smlib"))]
@@ -478,7 +480,8 @@ mod imp {
with_history(body, &roles, &walls)
}
- fn path_curve(s: &crate::PathSeg) -> Result<Curve> {
+ /// 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 } => {
@@ -894,278 +897,35 @@ mod imp {
with_history(body, &roles, &columns)
}
- /// A curve as a NURBS net: degree, control points (x, y, z) and weights, clamped knots. A line
- /// is of degree 1; an arc is rational quadratic, one span per quarter turn or less.
- struct Net {
- degree: usize,
- points: Vec<Vec3>,
- weights: Vec<f64>,
- knots: Vec<f64>,
- }
-
- impl Net {
- fn of(c: &Curve) -> Option<Net> {
- let v = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]);
- Some(match c {
- Curve::Line { start, end } => {
- Net { degree: 1, points: vec![v(*start), v(*end)], weights: vec![1.0; 2], knots: vec![0.0, 0.0, 1.0, 1.0] }
- }
- Curve::Arc { center, axis, reference, radius, start, end } => {
- let (c, k, x) = (v(*center), v(*axis), v(*reference));
- let y = k.cross(x);
- let sweep = end - start;
- let m = (sweep / (std::f64::consts::PI / 2.0) - 1e-9).ceil().max(1.0) as usize;
- let d = sweep / m as f64;
- let at = |a: f64, r: f64| c + (x * a.cos() + y * a.sin()) * r;
- let (mut points, mut weights, mut knots) = (vec![at(*start, *radius)], vec![1.0], vec![0.0; 3]);
- for j in 0..m {
- let a0 = start + d * j as f64;
- points.push(at(a0 + d / 2.0, radius / (d / 2.0).cos()));
- weights.push((d / 2.0).cos());
- points.push(at(a0 + d, *radius));
- weights.push(1.0);
- let u = (j + 1) as f64 / m as f64;
- knots.extend(if j + 1 < m { vec![u, u] } else { vec![1.0; 3] });
- }
- Net { degree: 2, points, weights, knots }
- }
- Curve::Nurbs { degree, points, knots } => Net {
- degree: *degree,
- points: points.iter().map(|q| Vec3::new(q[0], q[1], q[2])).collect(),
- weights: points.iter().map(|q| q[3]).collect(),
- knots: knots.clone(),
- },
- })
- }
-
- /// The same curve with other control points.
- fn with(&self, points: Vec<Vec3>) -> Net {
- Net { degree: self.degree, points, weights: self.weights.clone(), knots: self.knots.clone() }
- }
-
- /// Whether `o` has the same degree, knots and weights (its control points pair up).
- fn pairs_with(&self, o: &Net) -> bool {
- let near = |a: &[f64], b: &[f64]| a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() <= 1e-9 * (1.0 + x.abs()));
- self.degree == o.degree && self.points.len() == o.points.len() && near(&self.knots, &o.knots) && near(&self.weights, &o.weights)
- }
-
- fn curve(&self) -> Curve {
- let points = self.points.iter().zip(&self.weights).map(|(q, w)| [q.x, q.y, q.z, *w]).collect();
- Curve::Nurbs { degree: self.degree, points, knots: self.knots.clone() }
- }
-
- /// The point `f` (0…1) of the way along the parameter range.
- fn at(&self, f: f64) -> Option<Vec3> {
- let ctrl = self.points.iter().zip(&self.weights).map(|(q, w)| [q.x * w, q.y * w, q.z * w, *w]).collect();
- let c = solidcraft_geom::bspline::CurveN::<4> { degree: self.degree, knots: self.knots.clone(), ctrl };
- let (t0, t1) = (*self.knots.first()?, *self.knots.last()?);
- let ([x, y, z, w], _) = c.eval(t0 + (t1 - t0) * f.clamp(0.0, 1.0))?;
- (w.abs() > 1e-300).then(|| Vec3::new(x / w, y / w, z / w))
- }
- }
-
- /// The point of a section (its curves' nets) nearest `p`: as a wire parameter (the curve's
- /// index plus how far along its parameter range), the point, and how far it is.
- fn nearest_on(section: &[Net], p: Vec3) -> Option<(f64, Vec3, f64)> {
- const SAMPLES: usize = 256;
- let mut best: Option<(f64, Vec3, f64)> = None;
- for (k, c) in section.iter().enumerate() {
- let d = |f: f64| c.at(f).map_or(f64::INFINITY, |q| q.dist(p));
- let Some(i) = (0..=SAMPLES).min_by(|a, b| d(*a as f64 / SAMPLES as f64).total_cmp(&d(*b as f64 / SAMPLES as f64))) else { continue };
- // Golden-section search about the nearest sample.
- let (mut lo, mut hi) = ((i as f64 - 1.0).max(0.0) / SAMPLES as f64, (i as f64 + 1.0).min(SAMPLES as f64) / SAMPLES as f64);
- let g = 0.5 * (5f64.sqrt() - 1.0);
- for _ in 0..80 {
- let (a, b) = (hi - g * (hi - lo), lo + g * (hi - lo));
- if d(a) < d(b) {
- hi = b;
- } else {
- lo = a;
- }
- }
- let f = 0.5 * (lo + hi);
- let q = c.at(f)?;
- if best.as_ref().is_none_or(|b| q.dist(p) < b.2) {
- best = Some((k as f64 + f, q, q.dist(p)));
- }
- }
- best
- }
-
- /// The point at wire parameter `g` of a section.
- fn wire_point(section: &[Net], g: f64) -> Result<Vec3> {
- let k = (g.floor().max(0.0) as usize).min(section.len().saturating_sub(1));
- section.get(k).and_then(|c| c.at(g - k as f64)).ok_or_else(|| KernelError::Failed("loft rails: section".into()))
- }
-
- fn centroid(section: &[Net]) -> Vec3 {
- let (sum, n) = section.iter().flat_map(|c| &c.points).fold((Vec3::ZERO, 0usize), |(s, n), q| (s + *q, n + 1));
- sum * (1.0 / n.max(1) as f64)
- }
-
/// 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`] gives a loft's rails: between each two sections stations are the
- /// plain loft there (the sections' control points straight between two, the cubic through
- /// them across more) 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).
+ /// [`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 fail = |m: &str| KernelError::Failed(format!("loft rails: {m}"));
- let count = sections.len();
- if count < 2 {
- return Err(fail("sections"));
- }
- let curves: Vec<Vec<Curve>> = sections.iter().map(|(pl, ps)| curves(pl, ps)).collect::<Result<_>>()?;
- let nets: Vec<Vec<Net>> = curves
+ let matched = sections
.iter()
- .map(|cs| cs.iter().map(Net::of).collect::<Option<Vec<_>>>())
- .collect::<Option<_>>()
- .ok_or_else(|| fail("section curves"))?;
- let lead = nets.first().ok_or_else(|| fail("sections"))?;
- let n = lead.len();
- if n == 0 || nets.iter().any(|s| s.len() != n || s.iter().zip(lead).any(|(a, b)| !a.pairs_with(b))) {
- return Err(refuse("loft along guide rails between sections whose curves differ in kind (a line against an arc)"));
- }
- let mut bounds = solidcraft_geom::Aabb3::EMPTY;
- for q in nets.iter().flatten().flat_map(|c| &c.points) {
- bounds.add(*q);
- }
- let size = bounds.diagonal();
- let tol = (size * 1e-4).max(1e-6);
- // The sections' parameters along the loft: in proportion to the mean distance between
- // their curves' starts.
- let mut along = vec![0.0];
- for w in nets.windows(2) {
- let step = w[0].iter().zip(&w[1]).filter_map(|(a, b)| Some(a.points.first()?.dist(*b.points.first()?))).sum::<f64>() / n as f64;
- along.push(along.last().copied().unwrap_or(0.0) + step);
- }
- let total = along.last().copied().unwrap_or(0.0);
- if !(total > 1e-9) || along.windows(2).any(|w| !(w[1] - w[0] > 1e-9 * total)) {
- return Err(KernelError::Invalid("two loft sections sit on top of each other".into()));
- }
- along.iter_mut().for_each(|u| *u /= total);
- // The plain loft at v: each control point straight between two sections, the cubic (or
- // quadratic) through them across more.
- let degree_across = (count - 1).min(3);
- let across: Vec<Vec<solidcraft_geom::bspline::CurveN<3>>> = if count == 2 {
- Vec::new()
- } else {
- (0..n)
- .map(|k| {
- (0..lead.get(k).map_or(0, |c| c.points.len()))
- .map(|j| {
- let pts: Vec<[f64; 3]> = nets.iter().filter_map(|s| s.get(k)?.points.get(j).map(|q| [q.x, q.y, q.z])).collect();
- solidcraft_geom::bspline::CurveN::interpolate(&along, &pts, degree_across).map_err(|e| fail(&e.to_string()))
- })
- .collect::<Result<Vec<_>>>()
- })
- .collect::<Result<_>>()?
- };
- let plain = |v: f64| -> Result<Vec<Net>> {
- let (Some(a), Some(b)) = (nets.first(), nets.last()) else { return Err(fail("sections")) };
- if count == 2 {
- return Ok(a.iter().zip(b).map(|(ca, cb)| ca.with(ca.points.iter().zip(&cb.points).map(|(p, q)| p.lerp(*q, v)).collect())).collect());
- }
- a.iter()
- .zip(&across)
- .map(|(c, cs)| {
- let pts = cs.iter().map(|x| x.eval(v).map(|([px, py, pz], _)| Vec3::new(px, py, pz))).collect::<Option<Vec<_>>>();
- pts.map(|p| c.with(p)).ok_or_else(|| fail("the plain loft"))
- })
- .collect()
- };
- // The plain loft's middle and its direction there.
- let middle = |v: f64| -> Result<(Vec3, Vec3)> {
- let h = 1e-4;
- let (a, b) = ((v - h).max(0.0), (v + h).min(1.0));
- let d = centroid(&plain(b)?) - centroid(&plain(a)?);
- let d = d.normalized().ok_or_else(|| KernelError::Invalid("two loft sections sit on top of each other".into()))?;
- Ok((centroid(&plain(v)?), d))
- };
- // Each rail from its end nearer the first section's middle, and where it meets each
- // section: the guided point (wire parameter), that point, the nudge onto it from the
- // crossing, and how far along the rail the crossing is.
- let start = centroid(lead);
- type Anchor = (f64, Vec3, Vec3, (usize, f64));
- let mut guided: Vec<(Vec<Vec3>, Vec<Anchor>)> = Vec::with_capacity(rails.len());
- for r in rails {
- let mut pts =
- crate::sweep_path::clean(r).map_err(|_| KernelError::Invalid("a guide rail needs 2…100000 finite points along its length".into()))?;
- if let (Some(a), Some(b)) = (pts.first(), pts.last())
- && b.dist(start) < a.dist(start)
- {
- pts.reverse();
- }
- let mut cursor = (0usize, 0.0f64);
- let mut anchors = Vec::with_capacity(count);
- for (i, ((plane, _), section)) in sections.iter().zip(&nets).enumerate() {
- let Some((hit, at)) = crate::sweep_path::rail_crossing(&pts, plane.origin, plane.normal(), cursor, tol) else {
- return Err(KernelError::Invalid(format!(
- "a guide rail does not reach section {}: a rail has to run from the first section to the last, through every one",
- i + 1
- )));
- };
- cursor = at;
- let (g, on, d) = nearest_on(section, hit).ok_or_else(|| fail("section"))?;
- if d > tol {
- return Err(KernelError::Invalid(format!(
- "a guide rail crosses section {}'s plane {d:.3} mm from its curves: a rail has to pass through every section",
- i + 1
- )));
- }
- anchors.push((g, on, on - hit, at));
- }
- guided.push((pts, anchors));
- }
- if let [a, b] = &guided[..]
- && a.1.iter().zip(&b.1).any(|(p, q)| p.1.dist(q.1) <= tol)
- {
- return Err(KernelError::Invalid("the two guide rails meet a section at the same point".into()));
- }
- // The sections' normals, turned to agree with the first's.
- let mut normals: Vec<Vec3> = Vec::with_capacity(count);
- for (p, _) in sections {
- let nn = p.normal();
- let prev = normals.last().copied().unwrap_or(nn);
- normals.push(if nn.dot(prev) < 0.0 { nn * -1.0 } else { nn });
- }
- let spans = count - 1;
- let per = (crate::loft_rails::MAX_WIRES.saturating_sub(count) / spans).clamp(1, crate::loft_rails::MAX_PER_SPAN);
- let mut all: Vec<Vec<Curve>> = Vec::with_capacity(count + spans * per);
- for i in 0..spans {
- all.push(nets.get(i).ok_or_else(|| fail("sections"))?.iter().map(Net::curve).collect());
- let (Some(&v0), Some(&v1), Some(&n0), Some(&n1)) = (along.get(i), along.get(i + 1), normals.get(i), normals.get(i + 1)) else {
- return Err(fail("sections"));
- };
- let mut cursors: Vec<(usize, f64)> = guided.iter().map(|(_, a)| a.get(i).map_or((0, 0.0), |x| x.3)).collect();
- for q in 1..=per {
- let f = q as f64 / (per + 1) as f64;
- let v = v0 + f * (v1 - v0);
- let station = plain(v)?;
- let (mid, dir) = middle(v)?;
- let normal = n0.lerp(n1, f).normalized().ok_or_else(|| fail("section planes"))?;
- let mut pairs = Vec::with_capacity(guided.len());
- for ((pts, anchors), cursor) in guided.iter().zip(cursors.iter_mut()) {
- let (Some(a0), Some(a1)) = (anchors.get(i), anchors.get(i + 1)) else { return Err(fail("rail")) };
- let anchor = wire_point(&station, crate::loft_rails::interpolate_g(a0.0, a1.0, f, n, true))?;
- let Some((hit, at)) = crate::sweep_path::rail_crossing(pts, anchor, normal, *cursor, tol) else {
- return Err(KernelError::Invalid(format!(
- "a guide rail turns back between sections {} and {}: it has to run on from one section to the next",
- i + 1,
- i + 2
- )));
- };
- *cursor = at;
- pairs.push((anchor, hit + a0.2 * (1.0 - f) + a1.2 * f));
- }
- let map = crate::loft_rails::station_map(&pairs, mid, dir, fit, size)?;
- all.push(station.iter().map(|c| c.with(c.points.iter().map(|q| map.apply(*q)).collect()).curve()).collect());
- }
- }
- all.push(nets.last().ok_or_else(|| fail("sections"))?.iter().map(Net::curve).collect());
+ .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)
}
diff --git a/crates/kernel/src/surfaces.rs b/crates/kernel/src/surfaces.rs
index 1991747eff..344d47ee1a 100644
--- a/crates/kernel/src/surfaces.rs
+++ b/crates/kernel/src/surfaces.rs
@@ -1023,8 +1023,8 @@ pub fn revolve_sheet(plane: &Plane, chains: &[Vec<Seg2>], axis_origin: Vec2, axi
/// 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.
+/// revolution, exactly); at a corner the walls meet in a mitre, as the solid sweep's do. 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())
}
@@ -1041,20 +1041,40 @@ pub fn sweep_sheet_with(plane: &Plane, chains: &[Vec<Seg2>], path: &[crate::Path
if path.is_empty() || path.len() > 1000 {
return Err(invalid("the path needs 1…1000 segments"));
}
+ let runs = smooth_runs(path)?;
+ let controlled = ctl.varies() || matches!(ctl.orientation, crate::SweepOrientation::Direction(_));
+ if controlled && runs.len() > 1 {
+ return Err(imp::refuse("sweep with a twist, an end scale, guide rails or an orientation direction along a path with corners"));
+ }
+ let translate = ctl.orientation == crate::SweepOrientation::Parallel;
+ let mut pieces = Vec::with_capacity(chains.len());
+ for chain in numbered(chains) {
+ if runs.len() > 1 {
+ pieces.extend(imp::cornered(plane, &chain, path, &runs, translate)?);
+ continue;
+ }
+ let r = if controlled { imp::swept_stations(plane, &chain, path, ctl)? } else { imp::swept(plane, &chain, path, translate)? };
+ let h = swept_from(&r, plane, &chain);
+ pieces.push((r, h));
+ }
+ sheet_of(pieces, runs.len() > 1)
+}
+
+/// 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(|| 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 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;
+ }
}
- 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)
+ runs.push(from..path.len());
+ Ok(runs)
}
/// A surface swept from chains of sketch segments on `plane` along a 3D polyline path: along the
@@ -1232,40 +1252,8 @@ mod imp {
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()
+ chain.iter().map(|(s, _)| crate::smlib_sweeps::curve(plane, s)).collect()
}
pub(super) fn extruded(base: &Plane, chain: &[Numbered], n: Vec3, distance: f64) -> Result<Brep> {
@@ -1276,29 +1264,171 @@ mod imp {
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 }
- }
- 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],
- },
- })
+ fn route(path: &[crate::PathSeg]) -> Result<Vec<Curve>> {
+ path.iter().map(crate::smlib_sweeps::path_curve).collect()
+ }
+
+ fn frame(translate: bool) -> SweepFrame {
+ if translate { SweepFrame::Translate } else { SweepFrame::Follow }
+ }
+
+ /// The chain swept along the smooth `path`, turning with it, or only moving along it when
+ /// `translate`.
+ pub(super) fn swept(plane: &Plane, chain: &[Numbered], path: &[crate::PathSeg], translate: bool) -> Result<Brep> {
+ checked(&SmBrep::sweep(&curves(plane, chain)?, &route(path)?, frame(translate), false).map_err(sm("surface sweep"))?, "surface sweep")
+ }
+
+ /// `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| v3(*c));
+ col(0) * q.x + col(1) * q.y + col(2) * q.z + v3(a.t)
}
- 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")
+ /// `pl` carried by the rigid motion `a`.
+ 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 bisector of a corner from direction `t1` to `t2` (unit, the way the path runs) and the
+ /// turn there; a corner that turns the path back on itself is refused.
+ fn mitre(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(invalid("the path turns back on itself at a corner"));
+ }
+ Ok(((t1 + t2).normalized().ok_or_else(|| invalid("path corner"))?, turn))
+ }
+
+ /// A tool of square planar faces, one in each plane `cuts` (a point and its normal), `size`
+ /// across: what a run is imprinted with at its corners.
+ fn cutting_planes(cuts: &[(Vec3, Vec3)], size: f64) -> Result<SmBrep> {
+ let mut parts = Parts { tolerance: (size * 1e-9).max(1e-6), ..Parts::default() };
+ let h = size * 0.5;
+ let square = [Vec2::new(-h, -h), Vec2::new(h, -h), Vec2::new(h, h), Vec2::new(-h, h)];
+ let segs: Vec<Seg2> = (0..4).map(|i| Seg2::Line { a: square[i], b: square[(i + 1) % 4] }).collect();
+ for &(at, n) in cuts {
+ let u = n.cross(if n.x.abs() < 0.9 { Vec3::X } else { Vec3::Y }).normalized().ok_or_else(|| invalid("mitre plane"))?;
+ let pl = Plane { origin: at, x: u, y: n.cross(u) };
+ let lp = sketch_loop(&mut parts, &pl, &segs)?;
+ let domain = uv_box(std::slice::from_ref(&lp)).ok_or_else(|| invalid("mitre plane"))?;
+ parts.faces.push((b::Face { surface: crate::freeform::plane_surface(&pl), domain, loops: vec![lp] }, true));
+ }
+ SmBrep::from_record(&parts.canonical()?.brep, true).map_err(sm("sweep mitre"))
+ }
+
+ /// The faces of `sheet` (a run's walls, each from what `prov` says, in its record's order)
+ /// imprinted with `cuts` and kept where every cut's `keep` holds of a point inside them: the
+ /// piece between a run's mitres, each face from what its uncut face came from.
+ fn cut_back(sheet: &SmBrep, prov: &[FaceProv], cuts: &[(Vec3, Vec3)], size: f64) -> Result<(Brep, Vec<FaceProv>)> {
+ let (_, order) = sheet.to_native_ordered().map_err(|e| failed(format!("SMLib sweep mitre: {e}")))?;
+ let tagged = sheet.tagged(0).map_err(sm("sweep mitre"))?;
+ let Some(cut) = tagged.imprint(&cutting_planes(cuts, size)?).map_err(sm("sweep mitre"))? else {
+ return Ok((checked(sheet, "sweep mitre")?, prov.to_vec()));
+ };
+ let (record, kept_order) = cut.to_native_ordered().map_err(|e| failed(format!("SMLib sweep mitre: {e}")))?;
+ let h = cut.history().map_err(sm("sweep mitre"))?.history(&[order], &kept_order).map_err(|e| failed(format!("SMLib sweep mitre: {e}")))?;
+ // A point inside each face, from SMLib's face order to the record's.
+ let points = cut.face_points().map_err(sm("sweep mitre"))?;
+ let mut inside = vec![Vec3::ZERO; record.faces.len()];
+ for (i, p) in points.iter().enumerate() {
+ let k = if kept_order.faces.is_empty() { i } else { kept_order.faces.get(i).copied().unwrap_or(i) };
+ if let Some(slot) = inside.get_mut(k) {
+ *slot = v3(*p);
+ }
+ }
+ let keep: Vec<(usize, bool)> = (0..record.faces.len())
+ .filter(|f| inside.get(*f).is_some_and(|p| cuts.iter().all(|(at, n)| (*p - *at).dot(*n) < 0.0)))
+ .map(|f| (f, false))
+ .collect();
+ let c = Parts::of(&record, &keep)?.canonical()?;
+ let faces = c
+ .faces
+ .iter()
+ .map(|p| {
+ let f = keep.get(*p).map_or(0, |(f, _)| *f);
+ match h.faces.get(f).map(|x| x.origins.as_slice()) {
+ Some([FaceOrigin::Face { face, .. }]) => prov.get(*face).cloned().unwrap_or_else(|| record::generated(Vec::new())),
+ _ => record::generated(Vec::new()),
+ }
+ })
+ .collect();
+ Ok((c.brep, faces))
+ }
+
+ /// A sheet swept along a path with corners, by the solid sweep's corner model with open ends:
+ /// each smooth run swept on its own, turning with the path, carried on straight past each
+ /// corner (by the profile's reach times the tangent of half the turn, and a little more) and
+ /// cut back to the plane halving the corner, where the next run, cut back the same way, meets
+ /// it; the profile turns at a corner about the line square to both directions. Each run's
+ /// walls come from the segments they are swept from, found where the run starts; the runs are
+ /// stitched by the caller. Only moving along the path (`translate`), the profile is the same at
+ /// a corner in both runs, which meet there as they are.
+ pub(super) fn cornered(
+ plane: &Plane,
+ chain: &[Numbered],
+ path: &[crate::PathSeg],
+ runs: &[std::ops::Range<usize>],
+ translate: bool,
+ ) -> Result<Vec<(Brep, Vec<FaceProv>)>> {
+ let bad = || invalid("a path segment has no direction");
+ let start = path.first().map(crate::PathSeg::start).ok_or_else(|| invalid("empty path"))?;
+ let end = path.last().map(crate::PathSeg::end).ok_or_else(|| invalid("empty path"))?;
+ let reach = chain
+ .iter()
+ .flat_map(|(s, _)| (0..=8).map(move |i| s.point_at(f64::from(i) / 8.0)))
+ .map(|q| plane.to_world(q).dist(start))
+ .fold(0.0f64, f64::max);
+ let size = 4.0 * (path.iter().map(length).sum::<f64>() + reach) + 1.0;
+ let (first_t, _) = path.first().and_then(crate::PathSeg::tangents).ok_or_else(bad)?;
+ let (_, last_t) = path.last().and_then(crate::PathSeg::tangents).ok_or_else(bad)?;
+ // A closed path ends where it starts; at a corner there the last run meets the first in a
+ // mitre too.
+ let closing = (end.dist(start) <= 1e-6 && last_t.dot(first_t) < (1e-3f64).cos()).then_some(first_t);
+ let over = |turn: f64| if translate { 0.0 } else { reach * (turn * 0.5).tan() * 1.1 + reach * 1e-3 + 1e-6 };
+ let mut pose = *plane;
+ // The mitre the next run starts from: its point, its normal (along the run) and the turn.
+ let mut entry = closing.filter(|_| !translate).map(|t| mitre(last_t, t).map(|(m, turn)| (start, m, turn))).transpose()?;
+ let mut pieces = Vec::with_capacity(runs.len());
+ for (ri, run) in runs.iter().enumerate() {
+ let segs = path.get(run.clone()).ok_or_else(|| invalid("path run"))?;
+ let (Some(first), Some(last)) = (segs.first(), segs.last()) else { return Err(invalid("path run")) };
+ let ((t0, _), (_, t1)) = (first.tangents().ok_or_else(bad)?, last.tangents().ok_or_else(bad)?);
+ let (a0, b1) = (first.start(), last.end());
+ let next = match runs.get(ri + 1).and_then(|r| path.get(r.start)) {
+ Some(s) => Some(s.tangents().ok_or_else(bad)?.0),
+ None => closing,
+ };
+ let exit = next.filter(|_| !translate).map(|t2| mitre(t1, t2)).transpose()?;
+ let pre = entry.map_or(0.0, |(_, _, turn)| over(turn));
+ let post = exit.map_or(0.0, |(_, turn)| over(turn));
+ let mut along = Vec::with_capacity(segs.len() + 2);
+ if pre > 0.0 {
+ along.push(crate::PathSeg::Line { a: a0 - t0 * pre, b: a0 });
+ }
+ along.extend_from_slice(segs);
+ if post > 0.0 {
+ along.push(crate::PathSeg::Line { a: b1, b: b1 + t1 * post });
+ }
+ let from = Plane { origin: pose.origin - t0 * pre, ..pose };
+ let (sheet, [_, _, at_last]) =
+ SmBrep::sweep_placed(&curves(&from, chain)?, &route(&along)?, frame(translate), false).map_err(sm("surface sweep"))?;
+ let prov = swept_from(&sheet.to_native().map_err(|e| failed(format!("SMLib surface sweep: {e}")))?, &from, chain);
+ // Kept: after the entry mitre, before the exit one.
+ let cuts: Vec<(Vec3, Vec3)> = entry.map(|(at, m, _)| (at, m * -1.0)).into_iter().chain(exit.map(|(m, _)| (b1, m))).collect();
+ pieces.push(cut_back(&sheet, &prov, &cuts, size)?);
+ // The profile at the run's end, turned through the corner onto the next run.
+ let at_end = placed(&from, &at_last);
+ pose = Plane { origin: at_end.origin - t1 * post, ..at_end };
+ entry = None;
+ if let (Some(t2), Some((m, turn))) = (next, exit) {
+ let k = t1.cross(t2).normalized().ok_or_else(|| invalid("path corner"))?;
+ let turn_v = |v: Vec3| crate::build::rotate_about(v, Vec3::ZERO, k, turn);
+ pose = Plane { origin: crate::build::rotate_about(pose.origin, b1, k, turn), x: turn_v(pose.x), y: turn_v(pose.y) };
+ entry = Some((b1, m, turn));
+ }
+ }
+ Ok(pieces)
}
/// Fewest and most stations of a sweep that twists, scales or follows rails.
@@ -1325,18 +1455,21 @@ mod imp {
checked(&SmBrep::sweep_stations(&curves(plane, chain)?, &maps, Ends::Open).map_err(sm("surface sweep"))?, "surface sweep")
}
- /// How far a path segment turns (radians).
+ /// Samples of a segment's parameter its turn and length are read from.
+ const TURN_SAMPLES: usize = 64;
+
+ /// How far a path segment turns (radians): its tangent's turn through even steps of its
+ /// parameter.
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()
- }
+ _ => (0..=TURN_SAMPLES)
+ .filter_map(|i| at(s, i as f64 / TURN_SAMPLES as f64).map(|(_, t)| t))
+ .collect::<Vec<_>>()
+ .windows(2)
+ .map(|w| w[0].cross(w[1]).len().atan2(w[0].dot(w[1])))
+ .sum(),
}
}
@@ -1365,33 +1498,27 @@ mod imp {
Ok((pts, tangents))
}
+ /// A path segment's length (an arc's exactly; a free-form one's by its spans' own lengths).
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()
- }
+ match s {
+ crate::PathSeg::Line { a, b } => a.dist(*b),
+ crate::PathSeg::Arc { a, center, angle, .. } => a.dist(*center) * angle.abs(),
+ crate::PathSeg::Curve { seg, .. } => seg.length(),
+ crate::PathSeg::Bezier(b) => b.length().unwrap_or(0.0),
}
}
/// 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()?)),
+ 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()?))
+ let p = crate::build::rotate_about(*a, *center, k, angle * f);
+ Some((p, (k.cross(p - *center) * angle.signum()).normalized()?))
}
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::PathSeg::Bezier(b) => Some((b.point(f)?, b.derivative(f)?.normalized()?)),
}
}
@@ -1435,7 +1562,16 @@ mod imp {
pub(super) fn revolved(_: &Plane, _: &[Numbered], _: Vec3, _: Vec3, _: f64) -> Result<Brep> {
Err(not_built())
}
- pub(super) fn swept(_: &Plane, _: &[Numbered], _: &[crate::PathSeg]) -> Result<Brep> {
+ pub(super) fn swept(_: &Plane, _: &[Numbered], _: &[crate::PathSeg], _: bool) -> Result<Brep> {
+ Err(not_built())
+ }
+ pub(super) fn cornered(
+ _: &Plane,
+ _: &[Numbered],
+ _: &[crate::PathSeg],
+ _: &[std::ops::Range<usize>],
+ _: bool,
+ ) -> Result<Vec<(Brep, Vec<FaceProv>)>> {
Err(not_built())
}
pub(super) fn swept_stations(_: &Plane, _: &[Numbered], _: &[crate::PathSeg], _: &crate::SweepControl) -> Result<Brep> {