Skip to content

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

Wave 146/509: kernel: path segments hold any rational Bézier span, and edges as paths

jyvikoc302f6cbb359
diff --git a/crates/kernel/src/build.rs b/crates/kernel/src/build.rs
index 807ee4e119..eab371781a 100644
--- a/crates/kernel/src/build.rs
+++ b/crates/kernel/src/build.rs
@@ -1288,7 +1288,7 @@ pub(crate) fn smooth_loft_faces(wires: &[mt::Wire], numbers: &[Vec<Vec<usize>>],
}
/// A 3D path segment for sweeps.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PathSeg {
Line {
a: Vec3,
@@ -1306,11 +1306,9 @@ pub enum PathSeg {
plane: Plane,
seg: Seg2,
},
- /// A cubic Bézier in space with control points `p`: a span of a drawn 3D sketch spline
- /// ([`crate::PathPiece::Spline`]).
- Cubic {
- p: [Vec3; 4],
- },
+ /// A rational Bézier span in space: a span of a drawn 3D sketch spline
+ /// ([`crate::PathPiece::Spline`]) or of an edge's curve ([`crate::edge_path`]).
+ Bezier(crate::point_path::SpaceBezier),
}
impl PathSeg {
@@ -1319,7 +1317,7 @@ impl PathSeg {
match *self {
PathSeg::Line { a, .. } | PathSeg::Arc { a, .. } => a,
PathSeg::Curve { plane, seg } => plane.to_world(seg.start()),
- PathSeg::Cubic { p } => p[0],
+ PathSeg::Bezier(b) => b.start(),
}
}
@@ -1329,7 +1327,7 @@ impl PathSeg {
PathSeg::Line { b, .. } => b,
PathSeg::Arc { a, center, axis, angle } => axis.normalized().map_or(a, |k| rotate_about(a, center, k, angle)),
PathSeg::Curve { plane, seg } => plane.to_world(seg.end()),
- PathSeg::Cubic { p } => p[3],
+ PathSeg::Bezier(b) => b.end(),
}
}
@@ -1348,9 +1346,39 @@ impl PathSeg {
PathSeg::Curve { plane, seg } => {
Some((plane.dir_to_world(seg.start_tangent()).normalized()?, plane.dir_to_world(seg.end_tangent()).normalized()?))
}
- PathSeg::Cubic { p } => {
- Some((crate::point_path::cubic_derivative(&p, 0.0).normalized()?, crate::point_path::cubic_derivative(&p, 1.0).normalized()?))
- }
+ PathSeg::Bezier(b) => Some((b.derivative(0.0)?.normalized()?, b.derivative(1.0)?.normalized()?)),
+ }
+ }
+
+ /// The segment the other way round.
+ pub fn reversed(&self) -> PathSeg {
+ match *self {
+ PathSeg::Line { a, b } => PathSeg::Line { a: b, b: a },
+ PathSeg::Arc { center, axis, angle, .. } => PathSeg::Arc { a: self.end(), center, axis: axis * -1.0, angle },
+ PathSeg::Curve { plane, seg } => PathSeg::Curve { plane, seg: seg.reversed() },
+ PathSeg::Bezier(b) => PathSeg::Bezier(b.reversed()),
+ }
+ }
+
+ /// The segment carried by the rigid motion `point` of points and `vector` of directions
+ /// (a placement); `None` where a carried span no longer evaluates.
+ pub fn mapped(&self, point: impl Fn(Vec3) -> Vec3, vector: impl Fn(Vec3) -> Vec3) -> Option<PathSeg> {
+ Some(match *self {
+ PathSeg::Line { a, b } => PathSeg::Line { a: point(a), b: point(b) },
+ PathSeg::Arc { a, center, axis, angle } => PathSeg::Arc { a: point(a), center: point(center), axis: vector(axis), angle },
+ PathSeg::Curve { plane, seg } => PathSeg::Curve { plane: Plane::new(point(plane.origin), vector(plane.x), vector(plane.y))?, seg },
+ PathSeg::Bezier(b) => PathSeg::Bezier(b.mapped(point)?),
+ })
+ }
+
+ /// A sketch segment on `plane` as the path segment that is the same curve: a line, an arc
+ /// about the plane's normal, or the free curve on its plane.
+ pub fn of_sketch(plane: &Plane, s: &Seg2) -> PathSeg {
+ let w = |p: Vec2| plane.to_world(p);
+ match *s {
+ Seg2::Line { a, b } => PathSeg::Line { a: w(a), b: w(b) },
+ Seg2::Arc { center, sweep, .. } => PathSeg::Arc { a: w(s.start()), center: w(center), axis: plane.normal() * sweep.signum(), angle: sweep.abs() },
+ Seg2::Cubic { .. } | Seg2::Conic { .. } | Seg2::Bezier { .. } => PathSeg::Curve { plane: *plane, seg: *s },
}
}
@@ -1372,7 +1400,7 @@ impl PathSeg {
match *self {
PathSeg::Line { b, .. } => vec![b],
PathSeg::Curve { plane, seg } => seg.polyline(tol).into_iter().skip(1).map(|q| plane.to_world(q)).collect(),
- PathSeg::Cubic { p } => crate::point_path::cubic_polyline(&p, tol),
+ PathSeg::Bezier(b) => b.polyline(tol),
PathSeg::Arc { a, center, axis, angle } => {
let Some(k) = axis.normalized() else { return vec![a] };
let r = (a - center).len();
diff --git a/crates/kernel/src/point_path.rs b/crates/kernel/src/point_path.rs
index 955bc628e1..db763a6150 100644
--- a/crates/kernel/src/point_path.rs
+++ b/crates/kernel/src/point_path.rs
@@ -1,12 +1,15 @@
-//! Sweep paths through 3D sketch curves ([`PointPath`]): polylines (linked, projected and
-//! included curves, which reach the kernel as their points) and drawn 3D splines, which it gets
-//! as their fit points and so exactly ([`solidcraft_geom::catmull_rom`]). SMLib follows the
-//! path's segments ([`PointPath::segs`]), each spline span exactly as a [`PathSeg::Cubic`];
-//! [`PointPath::points`] is its polyline, for what takes points (rails, curve networks).
+//! Sweep paths through 3D sketch curves ([`PointPath`]): drawn 3D splines, which the kernel gets
+//! as their fit points and so exactly ([`solidcraft_geom::catmull_rom`]); curves it holds
+//! exactly as path segments (sketch curves, body edges: [`edge_path`]); and polylines (curves
+//! that reach it only as points: projected onto a face, intersection and iso curves). SMLib
+//! follows the path's segments ([`PointPath::segs`]), each free-form span exactly as a
+//! [`PathSeg::Bezier`] ([`SpaceBezier`]); [`PointPath::points`] is its polyline, for what takes
+//! points (rails, curve networks).
-use solidcraft_geom::bspline::{ArcLength, CurveN};
+use solidcraft_geom::brep;
+use solidcraft_geom::bspline::{HPoint, bezier_point, segment};
use solidcraft_geom::catmull_rom;
-use solidcraft_geom::{Plane, Region2, Vec3};
+use solidcraft_geom::{MAX_BEZIER_CTRL, MAX_BEZIER_DEGREE, Plane, Region2, Vec3};
use crate::body::Body;
use crate::{KernelError, PathSeg, Result, SweepControl};
@@ -19,6 +22,9 @@ pub enum PathPiece {
/// A drawn 3D spline: the centripetal Catmull–Rom spline through `fit`, from its last fit
/// point back to its first when `reversed`.
Spline { fit: Vec<Vec3>, reversed: bool },
+ /// A curve the kernel holds exactly as path segments end to end: a sketch curve
+ /// ([`PathSeg::of_sketch`]) or a body edge ([`edge_path`]).
+ Segs(Vec<PathSeg>),
}
impl PathPiece {
@@ -34,6 +40,13 @@ impl PathPiece {
}
pts
}
+ PathPiece::Segs(segs) => {
+ let mut pts: Vec<Vec3> = segs.first().map(PathSeg::start).into_iter().collect();
+ for s in segs {
+ pts.extend(s.points_after_start(1e-2));
+ }
+ pts
+ }
}
}
@@ -45,23 +58,28 @@ impl PathPiece {
PathPiece::Polyline(pts)
}
PathPiece::Spline { fit, reversed } => PathPiece::Spline { fit, reversed: !reversed },
+ PathPiece::Segs(segs) => PathPiece::Segs(segs.iter().rev().map(PathSeg::reversed).collect()),
}
}
- /// A spline of three or more fit points as its exact spans ([`PathSeg::Cubic`]), in the
- /// direction of travel; `None` for a polyline (and a spline of one or two points, a point or
- /// a line).
+ /// The piece's exact segments in the direction of travel: a spline of three or more fit
+ /// points as its spans ([`PathSeg::Bezier`]), a curve held exactly as its segments; `None`
+ /// for a polyline (and a spline of one or two points, a point or a line).
pub(crate) fn spans(&self) -> Result<Option<Vec<PathSeg>>> {
- let PathPiece::Spline { fit, reversed } = self else { return Ok(None) };
+ let (fit, reversed) = match self {
+ PathPiece::Spline { fit, reversed } => (fit, reversed),
+ PathPiece::Segs(segs) => return Ok(Some(segs.clone())),
+ PathPiece::Polyline(_) => return Ok(None),
+ };
let spans = catmull_rom::beziers(fit).ok_or_else(|| KernelError::Invalid("the 3D sketch spline is not finite".into()))?;
if spans.is_empty() {
return Ok(None);
}
- let seg = |p: [Vec3; 4]| PathSeg::Cubic { p };
+ let seg = |p: [Vec3; 4]| SpaceBezier::cubic(p).map(PathSeg::Bezier).ok_or_else(|| KernelError::Invalid("the 3D sketch spline is not finite".into()));
Ok(Some(if *reversed {
- spans.into_iter().rev().map(|[a, b, c, d]| seg([d, c, b, a])).collect()
+ spans.into_iter().rev().map(|[a, b, c, d]| seg([d, c, b, a])).collect::<Result<_>>()?
} else {
- spans.into_iter().map(seg).collect()
+ spans.into_iter().map(seg).collect::<Result<_>>()?
}))
}
}
@@ -94,7 +112,7 @@ impl PointPath {
chain
}
- /// The path as segments: each spline span exactly ([`PathSeg::Cubic`]), each polyline as the
+ /// The path as segments: each spline span exactly ([`PathSeg::Bezier`]), each polyline as the
/// lines between its points, starting where the piece before it ended (as [`Self::points`]
/// chains them).
pub(crate) fn segs(&self) -> Result<Vec<PathSeg>> {
@@ -121,43 +139,255 @@ pub fn sweep_point_path_with(plane: &Plane, region: &Region2, path: &PointPath,
crate::sweep_path::smlib_sweep_points(plane, region, path, ctl)
}
-/// A cubic Bézier in space (a [`PathSeg::Cubic`]): its point at `x` (0…1).
-pub(crate) fn cubic_at(p: &[Vec3; 4], x: f64) -> Vec3 {
- let y = 1.0 - x;
- p[0] * (y * y * y) + p[1] * (3.0 * x * y * y) + p[2] * (3.0 * x * x * y) + p[3] * (x * x * x)
-}
+/// Most segments one edge's curve may give a path.
+const MAX_EDGE_SEGS: usize = 1000;
-/// Its derivative at `x`.
-pub(crate) fn cubic_derivative(p: &[Vec3; 4], x: f64) -> Vec3 {
- let y = 1.0 - x;
- (p[1] - p[0]) * (3.0 * y * y) + (p[2] - p[1]) * (6.0 * x * y) + (p[3] - p[2]) * (3.0 * x * x)
+/// Edge `edge` of `body` (its index in the body's edge order) as the path segments that are its
+/// curve exactly, from its start vertex to its end: a line, an arc, rational quadratic spans of
+/// an ellipse, the lines of a polyline, the Bézier spans of a B-spline between its knots. An
+/// intersection curve, which the record holds only as its surfaces and a leader near it, is
+/// refused.
+pub fn edge_path(body: &Body, edge: usize) -> Result<Vec<PathSeg>> {
+ let record = crate::native::brep_record(body)?;
+ let e = record.edges.get(edge).ok_or_else(|| KernelError::Invalid(format!("the body has no edge {edge}")))?;
+ curve_path(&e.curve, e.interval)
}
-#[cfg_attr(not(feature = "smlib"), allow(dead_code))]
-fn cubic_curve(p: &[Vec3; 4]) -> CurveN<3> {
- CurveN { degree: 3, knots: vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], ctrl: p.iter().map(|q| [q.x, q.y, q.z]).collect() }
+/// The record curve `c` on `[t0, t1]` as path segments ([`edge_path`]).
+pub(crate) fn curve_path(c: &brep::Curve, [t0, t1]: [f64; 2]) -> Result<Vec<PathSeg>> {
+ let bad = |what: &str| KernelError::Invalid(format!("the edge's {what} does not evaluate"));
+ if !(t0.is_finite() && t1.is_finite() && t0 < t1) {
+ return Err(bad("interval"));
+ }
+ let v = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]);
+ let out = match c {
+ brep::Curve::Line { start, end } => {
+ let (s, e) = (v(*start), v(*end));
+ vec![PathSeg::Line { a: s + (e - s) * t0, b: s + (e - s) * t1 }]
+ }
+ brep::Curve::Circle { frame, radius } => {
+ let (o, x, y) = (v(frame.origin), v(frame.x_axis), v(frame.y_axis));
+ vec![PathSeg::Arc { a: o + (x * t0.cos() + y * t0.sin()) * *radius, center: o, axis: x.cross(y), angle: t1 - t0 }]
+ }
+ brep::Curve::Ellipse { frame, radii } => {
+ // Each span of at most a quarter turn the affine image of a circular arc's rational
+ // quadratic: ends on the ellipse, the middle point at the tangents' meeting, weight
+ // cos(half the span).
+ let (o, x, y) = (v(frame.origin), v(frame.x_axis) * radii[0], v(frame.y_axis) * radii[1]);
+ let at = |t: f64, r: f64| o + (x * t.cos() + y * t.sin()) * r;
+ let m = ((t1 - t0) / std::f64::consts::FRAC_PI_2 - 1e-9).ceil().max(1.0) as usize;
+ if m > MAX_EDGE_SEGS {
+ return Err(bad("ellipse"));
+ }
+ let d = (t1 - t0) / m as f64;
+ (0..m)
+ .map(|i| {
+ let a = t0 + d * i as f64;
+ let w = (d / 2.0).cos();
+ let ctrl = [HPoint::weighted(at(a, 1.0), 1.0), HPoint::weighted(at(a + d / 2.0, 1.0 / w), w), HPoint::weighted(at(a + d, 1.0), 1.0)];
+ SpaceBezier::new(&ctrl).map(PathSeg::Bezier).ok_or_else(|| bad("ellipse"))
+ })
+ .collect::<Result<_>>()?
+ }
+ brep::Curve::Polyline { points } => {
+ let at = |t: f64| -> Option<Vec3> {
+ let i = (t.floor().max(0.0) as usize).min(points.len().saturating_sub(2));
+ let (a, b) = (v(*points.get(i)?), v(*points.get(i + 1)?));
+ Some(a + (b - a) * (t - i as f64))
+ };
+ let mut ts = vec![t0];
+ ts.extend((t0.floor() as i64 + 1..=t1.ceil() as i64 - 1).map(|k| k as f64).filter(|k| *k > t0 && *k < t1));
+ ts.push(t1);
+ if ts.len() > MAX_EDGE_SEGS {
+ return Err(bad("polyline"));
+ }
+ ts.windows(2).map(|w| Some(PathSeg::Line { a: at(w[0])?, b: at(w[1])? })).collect::<Option<_>>().ok_or_else(|| bad("polyline"))?
+ }
+ brep::Curve::Spline { knots, points } => {
+ let ctrl: Vec<HPoint> = points.iter().map(|q| HPoint::weighted(v(*q), 1.0)).collect();
+ spline_spans(knots, &ctrl, t0, t1)?
+ }
+ brep::Curve::RationalSpline { knots, homogeneous } => {
+ let ctrl: Vec<HPoint> = homogeneous.iter().map(|q| HPoint { x: q[0], y: q[1], z: q[2], w: q[3] }).collect();
+ spline_spans(knots, &ctrl, t0, t1)?
+ }
+ brep::Curve::SurfaceIntersection { .. } => {
+ return Err(KernelError::Failed("not supported yet: a path along an intersection curve (the record holds no exact curve for it)".into()));
+ }
+ };
+ Ok(out)
}
-/// Its length (`None` for a cubic that does not evaluate).
-#[cfg_attr(not(feature = "smlib"), allow(dead_code))]
-pub(crate) fn cubic_length(p: &[Vec3; 4]) -> Option<f64> {
- ArcLength::of(&cubic_curve(p)).map(|a| a.total())
+/// The B-spline (homogeneous `ctrl` on `knots`) on `[t0, t1]` as its Bézier spans, one per knot
+/// span: each the piece of the spline between two neighbouring knots ([`segment`]), exactly.
+fn spline_spans(knots: &[f64], ctrl: &[HPoint], t0: f64, t1: f64) -> Result<Vec<PathSeg>> {
+ let bad = || KernelError::Invalid("the edge's B-spline does not evaluate".into());
+ let p = knots.len().checked_sub(ctrl.len() + 1).ok_or_else(bad)?;
+ if !(1..=MAX_BEZIER_DEGREE).contains(&p) {
+ return Err(KernelError::Failed(format!("not supported yet: a path along a B-spline of degree {p}")));
+ }
+ let mut cuts = vec![t0];
+ cuts.extend(knots.iter().copied().filter(|k| *k > t0 && *k < t1));
+ cuts.push(t1);
+ cuts.dedup();
+ if cuts.len() > MAX_EDGE_SEGS {
+ return Err(KernelError::Failed("not supported yet: a path along an edge of more than 1000 spans".into()));
+ }
+ cuts.windows(2)
+ .map(|w| {
+ let (_, piece) = segment(p, knots, ctrl, w[0], w[1]).map_err(|e| KernelError::Invalid(format!("the edge's B-spline: {e}")))?;
+ SpaceBezier::new(&piece).map(PathSeg::Bezier).ok_or_else(bad)
+ })
+ .collect()
}
-/// The point `f` (0…1) of the way along the cubic by length, and the unit direction there.
-#[cfg_attr(not(feature = "smlib"), allow(dead_code))]
-pub(crate) fn cubic_along(p: &[Vec3; 4], f: f64) -> Option<(Vec3, Vec3)> {
- let c = cubic_curve(p);
- let arc = ArcLength::of(&c)?;
- let x = arc.param_at(&c, f * arc.total())?;
- Some((cubic_at(p, x), cubic_derivative(p, x).normalized()?))
+/// A rational Bézier span in space (a [`PathSeg::Bezier`]): degree 1…[`MAX_BEZIER_DEGREE`],
+/// homogeneous control points `(x·w, y·w, z·w, w)` with positive weights, on 0…1. A drawn 3D
+/// spline's spans are cubics of weight one; an edge's NURBS curve and an ellipse are spans of
+/// their degree, exactly.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SpaceBezier {
+ n: u8,
+ p: [HPoint; MAX_BEZIER_CTRL],
}
-/// Points along the cubic, without its start, the chords within `tol` of it (by the bound on
-/// its second derivative, 6 max |P(i) - 2 P(i+1) + P(i+2)|: a chord of a piece `h` long in the
-/// parameter is within h^2/8 of that of the curve).
-pub(crate) fn cubic_polyline(p: &[Vec3; 4], tol: f64) -> Vec<Vec3> {
- let bend = (p[0] - p[1] * 2.0 + p[2]).len().max((p[1] - p[2] * 2.0 + p[3]).len()) * 6.0;
- let n = ((bend / (8.0 * tol.max(1e-9))).sqrt().ceil() as usize).clamp(1, 512);
- (1..=n).map(|i| cubic_at(p, i as f64 / n as f64)).collect()
+/// Pieces a span's length is integrated over (8-point Gauss–Legendre on each).
+const LENGTH_PIECES: usize = 16;
+
+/// Nodes and weights of the 8-point Gauss–Legendre rule on [-1, 1].
+const GAUSS_8: [(f64, f64); 8] = [
+ (-0.960_289_856_497_536_2, 0.101_228_536_290_376_26),
+ (-0.796_666_477_413_626_7, 0.222_381_034_453_374_47),
+ (-0.525_532_409_916_329, 0.313_706_645_877_887_3),
+ (-0.183_434_642_495_649_8, 0.362_683_783_378_362),
+ (0.183_434_642_495_649_8, 0.362_683_783_378_362),
+ (0.525_532_409_916_329, 0.313_706_645_877_887_3),
+ (0.796_666_477_413_626_7, 0.222_381_034_453_374_47),
+ (0.960_289_856_497_536_2, 0.101_228_536_290_376_26),
+];
+
+impl SpaceBezier {
+ /// The span over `ctrl` (2…[`MAX_BEZIER_CTRL`] finite homogeneous points, positive weights).
+ pub fn new(ctrl: &[HPoint]) -> Option<SpaceBezier> {
+ let n = u8::try_from(ctrl.len().checked_sub(1)?).ok()?;
+ if !(1..=MAX_BEZIER_DEGREE as u8).contains(&n) || ctrl.iter().any(|q| !q.is_finite() || !(q.w > 0.0)) {
+ return None;
+ }
+ let mut p = [HPoint::ZERO; MAX_BEZIER_CTRL];
+ p.get_mut(..ctrl.len())?.copy_from_slice(ctrl);
+ Some(SpaceBezier { n, p })
+ }
+
+ /// The cubic over `p` (weights one).
+ pub fn cubic(p: [Vec3; 4]) -> Option<SpaceBezier> {
+ SpaceBezier::new(&p.map(|q| HPoint::weighted(q, 1.0)))
+ }
+
+ pub fn degree(&self) -> usize {
+ usize::from(self.n)
+ }
+
+ /// The homogeneous control points.
+ pub fn ctrl(&self) -> &[HPoint] {
+ self.p.get(..=self.degree()).unwrap_or(&[])
+ }
+
+ /// The point at `x` (0…1).
+ pub fn point(&self, x: f64) -> Option<Vec3> {
+ bezier_point(self.ctrl(), x).project()
+ }
+
+ pub fn start(&self) -> Vec3 {
+ self.ctrl().first().and_then(|q| q.project()).unwrap_or_default()
+ }
+
+ pub fn end(&self) -> Vec3 {
+ self.ctrl().last().and_then(|q| q.project()).unwrap_or_default()
+ }
+
+ /// The derivative at `x`: the quotient rule on the homogeneous curve and its hodograph.
+ pub fn derivative(&self, x: f64) -> Option<Vec3> {
+ let c = self.ctrl();
+ let n = self.degree() as f64;
+ let hodograph: Vec<HPoint> = c.windows(2).map(|w| (w[1] - w[0]) * n).collect();
+ let (h, d) = (bezier_point(c, x), bezier_point(&hodograph, x));
+ (h.w.abs() > f64::MIN_POSITIVE).then(|| (d.xyz() * h.w - h.xyz() * d.w) * (1.0 / (h.w * h.w))).filter(|v| v.is_finite())
+ }
+
+ /// The span the other way round.
+ pub fn reversed(&self) -> SpaceBezier {
+ let mut r = *self;
+ if let Some(c) = r.p.get_mut(..=self.degree()) {
+ c.reverse();
+ }
+ r
+ }
+
+ /// The span carried by the affine map `f` of points (weights kept: an affine image of a
+ /// rational Bézier is the Bézier of the images of its control points).
+ pub fn mapped(&self, f: impl Fn(Vec3) -> Vec3) -> Option<SpaceBezier> {
+ let ctrl: Vec<HPoint> = self.ctrl().iter().map(|q| q.project().map(|p| HPoint::weighted(f(p), q.w))).collect::<Option<_>>()?;
+ SpaceBezier::new(&ctrl)
+ }
+
+ /// The control points as SMLib takes them: (x, y, z, weight).
+ pub(crate) fn weighted_points(&self) -> Option<Vec<[f64; 4]>> {
+ self.ctrl().iter().map(|q| q.project().map(|p| [p.x, p.y, p.z, q.w])).collect()
+ }
+
+ fn speed(&self, x: f64) -> Option<f64> {
+ self.derivative(x).map(Vec3::len)
+ }
+
+ /// The length from `a` to `b` (8-point Gauss–Legendre).
+ fn length_between(&self, a: f64, b: f64) -> Option<f64> {
+ let (mid, half) = (0.5 * (a + b), 0.5 * (b - a));
+ GAUSS_8.iter().try_fold(0.0, |sum, (x, w)| Some(sum + w * half * self.speed(mid + half * x)?))
+ }
+
+ /// The length before each of the [`LENGTH_PIECES`] pieces, and the whole length last.
+ fn lengths(&self) -> Option<Vec<f64>> {
+ let mut out = vec![0.0];
+ for i in 0..LENGTH_PIECES {
+ let (a, b) = (i as f64 / LENGTH_PIECES as f64, (i + 1) as f64 / LENGTH_PIECES as f64);
+ out.push(out.last().copied().unwrap_or(0.0) + self.length_between(a, b)?);
+ }
+ out.last().is_some_and(|t| t.is_finite()).then_some(out)
+ }
+
+ /// Its length (`None` for a span that does not evaluate).
+ pub fn length(&self) -> Option<f64> {
+ self.lengths()?.last().copied()
+ }
+
+ /// The point `f` (0…1) of the way along the span by length, and the unit direction there.
+ pub fn along(&self, f: f64) -> Option<(Vec3, Vec3)> {
+ let table = self.lengths()?;
+ let want = table.last()? * f.clamp(0.0, 1.0);
+ let k = table.partition_point(|l| *l <= want).saturating_sub(1).min(LENGTH_PIECES - 1);
+ let (a, before) = (k as f64 / LENGTH_PIECES as f64, *table.get(k)?);
+ let (mut lo, mut hi) = (a, (k + 1) as f64 / LENGTH_PIECES as f64);
+ for _ in 0..60 {
+ let x = 0.5 * (lo + hi);
+ if before + self.length_between(a, x)? < want {
+ lo = x;
+ } else {
+ hi = x;
+ }
+ }
+ let x = 0.5 * (lo + hi);
+ Some((self.point(x)?, self.derivative(x)?.normalized()?))
+ }
+
+ /// Points along the span, without its start, every chord within `tol` of it (by the bound
+ /// on the homogeneous second differences, as for a polynomial span of weight one; a rational
+ /// span's homogeneous bound over its smallest weight).
+ pub fn polyline(&self, tol: f64) -> Vec<Vec3> {
+ let c = self.ctrl();
+ let n = self.degree() as f64;
+ let wmin = c.iter().map(|q| q.w).fold(f64::INFINITY, f64::min).max(1e-12);
+ let bend = c.windows(3).map(|w| (w[0] - w[1] * 2.0 + w[2]).xyz().len()).fold(0.0, f64::max) * n * (n - 1.0).max(1.0) / wmin;
+ let k = ((bend / (8.0 * tol.max(1e-9))).sqrt().ceil() as usize).clamp(1, 512);
+ (1..=k).filter_map(|i| self.point(i as f64 / k as f64)).collect()
+ }
}
diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rs
index 9fc38a002d..75158a6177 100644
--- a/crates/kernel/src/smlib_sweeps.rs
+++ b/crates/kernel/src/smlib_sweeps.rs
@@ -483,11 +483,11 @@ mod imp {
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::Cubic { p: ctrl } => Curve::Nurbs {
- degree: 3,
- points: ctrl.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],
- },
+ 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() }
+ }
})
}
@@ -564,7 +564,7 @@ mod imp {
(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::Cubic { p: ctrl } => (ctrl[0], ctrl[3]),
+ crate::PathSeg::Bezier(b) => (b.start(), b.end()),
})
}
@@ -608,7 +608,7 @@ mod imp {
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::Cubic { .. } => seg_len(s),
+ crate::PathSeg::Bezier(_) => seg_len(s),
crate::PathSeg::Line { .. } => 0.0,
});
}
@@ -712,7 +712,7 @@ mod imp {
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::Cubic { p: ctrl } => crate::point_path::cubic_length(&ctrl).unwrap_or(f64::NAN),
+ crate::PathSeg::Bezier(b) => b.length().unwrap_or(f64::NAN),
}
}
@@ -740,7 +740,7 @@ mod imp {
let t = 0.5 * (lo + hi);
Some((plane.to_world(seg.point_at(t)), plane.dir_to_world(seg.derivative(t)).normalized()?))
}
- crate::PathSeg::Cubic { p: ctrl } => crate::point_path::cubic_along(&ctrl, f),
+ crate::PathSeg::Bezier(b) => b.along(f),
}
}
@@ -782,8 +782,8 @@ mod imp {
.map(|(u, v)| u.cross(v).atan2(u.dot(v)).abs())
.sum()
}
- crate::PathSeg::Cubic { p: ctrl } => {
- let pts: Vec<Vec3> = std::iter::once(ctrl[0]).chain(crate::point_path::cubic_polyline(&ctrl, 1e-3)).collect();
+ 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)))
diff --git a/crates/kernel/src/surfaces.rs b/crates/kernel/src/surfaces.rs
index dfa45710a2..a204b94897 100644
--- a/crates/kernel/src/surfaces.rs
+++ b/crates/kernel/src/surfaces.rs
@@ -237,7 +237,7 @@ pub fn sweep_sheet(plane: &Plane, chains: &[Vec<Seg2>], path: &[crate::PathSeg])
(part, Box::new(move |p| crate::build::rotate_about(p, center, k, angle)))
}
// The path was flattened: no curves are left.
- PathSeg::Curve { .. } | PathSeg::Cubic { .. } => return Err(KernelError::Invalid("a free-form path curve".into())),
+ 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, &[]));