//! 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::brep; use solidcraft_geom::bspline::{HPoint, bezier_point, segment}; use solidcraft_geom::catmull_rom; use solidcraft_geom::{MAX_BEZIER_CTRL, MAX_BEZIER_DEGREE, Plane, Region2, Vec3}; use crate::body::Body; use crate::{KernelError, PathSeg, Result, SweepControl}; /// One curve of a [`PointPath`], in the path's direction of travel. #[derive(Clone, Debug, PartialEq)] pub enum PathPiece { /// Points joined by straight lines. Polyline(Vec), /// 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, 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), } impl PathPiece { /// The piece's points in its direction of travel: the polyline, or the spline's samples /// ([`catmull_rom::samples`]). pub fn points(&self) -> Vec { match self { PathPiece::Polyline(pts) => pts.clone(), PathPiece::Spline { fit, reversed } => { let mut pts = catmull_rom::samples(fit); if *reversed { pts.reverse(); } pts } PathPiece::Segs(segs) => { let mut pts: Vec = segs.first().map(PathSeg::start).into_iter().collect(); for s in segs { pts.extend(s.points_after_start(1e-2)); } pts } } } /// The piece the other way round. pub fn reversed(self) -> PathPiece { match self { PathPiece::Polyline(mut pts) => { pts.reverse(); PathPiece::Polyline(pts) } PathPiece::Spline { fit, reversed } => PathPiece::Spline { fit, reversed: !reversed }, PathPiece::Segs(segs) => PathPiece::Segs(segs.iter().rev().map(PathSeg::reversed).collect()), } } /// 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 fn spans(&self) -> Result>> { 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]| { 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::>()? } else { spans.into_iter().map(seg).collect::>()? })) } } /// A sweep path through 3D sketch curves: its pieces end to end, each starting where the one /// before it ended. #[derive(Clone, Debug, Default, PartialEq)] pub struct PointPath { pub pieces: Vec, } impl PointPath { /// A path of one polyline. pub fn polyline(pts: Vec) -> PointPath { PointPath { pieces: vec![PathPiece::Polyline(pts)] } } /// The path as one polyline: the first piece's points, then each next piece's after its /// first (where the one before ended). pub fn points(&self) -> Vec { let mut chain: Vec = Vec::new(); for p in &self.pieces { let pts = p.points(); if chain.is_empty() { chain = pts; } else { chain.extend(pts.into_iter().skip(1)); } } chain } /// 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> { let mut out: Vec = Vec::new(); for piece in &self.pieces { if let Some(spans) = piece.spans()? { out.extend(spans); continue; } let mut pts = piece.points(); if let (Some(end), Some(first)) = (out.last().map(PathSeg::end), pts.first_mut()) { *first = end; } out.extend(pts.windows(2).filter(|w| w[0].dist(w[1]) > 1e-9).map(|w| PathSeg::Line { a: w[0], b: w[1] })); } Ok(out) } } /// Sweep a planar region along a path through 3D sketch curves: its splines exactly, its /// polylines as lines (through SMLib). pub fn sweep_point_path_with(plane: &Plane, region: &Region2, path: &PointPath, ctl: &SweepControl) -> Result { ctl.check()?; crate::sweep_path::smlib_sweep_points(plane, region, path, ctl) } /// The point a fraction `t` of the way along `path` (its segments end to end) by arc length, and /// the unit direction of travel there: 0 is where the path starts, 1 where it ends. Each /// segment's length and its point at a length are exact ([`PathSeg::length`], /// [`PathSeg::along`]): closed forms for lines and arcs, the arc-length parameter of a free-form /// span. A `t` outside 0…1 is refused: the path does not go on past its ends. pub fn along_path(path: &[PathSeg], t: f64) -> Result<(Vec3, Vec3)> { if !(0.0..=1.0).contains(&t) { return Err(KernelError::Invalid(format!("t is {t}: a point along a path is 0 (its start) to 1 (its end) of the way along it"))); } let bad = || KernelError::Invalid("a segment of the path does not evaluate".into()); let lengths: Vec = path.iter().map(|s| s.length().ok_or_else(bad)).collect::>()?; let total: f64 = lengths.iter().sum(); if !(total > 0.0 && total.is_finite()) { return Err(KernelError::Invalid("the path has no length".into())); } let mut left = t * total; let live = || path.iter().zip(&lengths).filter(|(_, l)| **l > 0.0); let last = live().next_back().ok_or_else(bad)?; for (seg, &l) in live() { if left <= l || std::ptr::eq(seg, last.0) { return seg.along((left / l).min(1.0)).ok_or_else(bad); } left -= l; } Err(bad()) } /// Most segments one edge's curve may give a path. const MAX_EDGE_SEGS: usize = 1000; /// 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> { 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.parameters(), e.interval) } /// The sketch segments `segs` on `plane` projected along `direction` (pointing from them toward /// the face) onto the face of `body` at `face_at`, as the record curves SMLib's projection makes /// (one per piece of the projection that stays on the face), each on its interval. pub fn project_onto_face( body: &Body, face_at: Vec3, plane: &Plane, segs: &[solidcraft_geom::Seg2], direction: Vec3, ) -> Result> { if !(face_at.is_finite() && direction.is_finite() && direction.len() > 1e-12) || segs.is_empty() || segs.len() > 4096 { return Err(KernelError::Invalid("curve projection: a point, a direction and 1…4096 curves".into())); } crate::smlib_sweeps::project_onto_face(body, face_at, plane, segs, direction) } /// The face `face` of `body` through `at` cut along `along` by the plane through `at` that holds /// the face's normal there (its exact normal from the record) and `along`: SMLib's section curves /// on that face, as record curves on their intervals. pub fn face_section_along(body: &Body, face: usize, at: Vec3, along: Vec3) -> Result> { use solidcraft_geom::brep::eval::SurfaceEval; let f = body.record().faces.get(face).ok_or_else(|| KernelError::Invalid(format!("the body has no face {face}")))?; let eval = SurfaceEval::new(f.parameters()).map_err(|e| KernelError::Failed(format!("face section: {e}")))?; let [[u0, u1], [v0, v1]] = f.domain; let size = body.size().max(1e-9); let uv = eval .project(at, Some([0.5 * (u0 + u1), 0.5 * (v0 + v1)]), size * 1e-3 + 1e-6) .ok_or_else(|| KernelError::Invalid("face section: the point is not on the face".into()))?; let (_, du, dv) = eval.derivs(uv[0], uv[1]).ok_or_else(|| KernelError::Failed("face section: the surface does not evaluate there".into()))?; let normal = du .cross(dv) .cross(along) .normalized() .ok_or_else(|| KernelError::Invalid("face section: the direction runs along the face's normal".into()))?; crate::smlib_sweeps::face_section(body, at, at, normal) } /// Most control points a record curve given to [`curve_path`] may have. pub(crate) const MAX_CURVE_POINTS: usize = 100_000; /// The record curve `c` on `[t0, t1]` as path segments ([`edge_path`]); the numbers are checked /// first (they may come from a design file). pub fn curve_path(c: &brep::Curve, [t0, t1]: [f64; 2]) -> Result> { let bad = |what: &str| KernelError::Invalid(format!("the curve's {what} does not evaluate")); if !(t0.is_finite() && t1.is_finite() && t0 < t1 && t0.abs() < 1e9 && t1.abs() < 1e9) { return Err(bad("interval")); } let v = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]); let frame_ok = |f: &brep::Frame| { let (x, y) = (v(f.x_axis), v(f.y_axis)); v(f.origin).is_finite() && (x.len() - 1.0).abs() < 1e-6 && (y.len() - 1.0).abs() < 1e-6 && x.dot(y).abs() < 1e-6 }; let finite = |pts: &[[f64; 3]]| pts.len() <= MAX_CURVE_POINTS && pts.iter().all(|q| v(*q).is_finite()); match c { brep::Curve::Line { start, end } if !finite(&[*start, *end]) => return Err(bad("line")), brep::Curve::Circle { frame, radius } if !(frame_ok(frame) && radius.is_finite() && *radius > 0.0) => return Err(bad("circle")), brep::Curve::Ellipse { frame, radii } if !(frame_ok(frame) && radii.iter().all(|r| r.is_finite() && *r > 0.0)) => return Err(bad("ellipse")), brep::Curve::Polyline { points } | brep::Curve::Spline { points, .. } if !finite(points) => return Err(bad("points")), brep::Curve::RationalSpline { homogeneous, .. } if homogeneous.len() > MAX_CURVE_POINTS => return Err(bad("points")), _ => {} } 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::>()? } brep::Curve::Polyline { points } => { let at = |t: f64| -> Option { 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::>().ok_or_else(|| bad("polyline"))? } brep::Curve::Spline { knots, points } => { let ctrl: Vec = 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 = 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) } /// A sketch segment on `plane` as the record curve that is it, on its interval, running the /// segment's way: a line, a circle (an arc's; clockwise ones on the frame turned over), a cubic /// or Bézier as a spline of its degree, a conic as a rational quadratic. `None` for a segment /// with non-finite numbers. pub fn sketch_record_curve(plane: &Plane, s: &solidcraft_geom::Seg2) -> Option<(brep::Curve, [f64; 2])> { use solidcraft_geom::Seg2; let w = |p: solidcraft_geom::Vec2| { let q = plane.to_world(p); [q.x, q.y, q.z] }; let d = |v: Vec3| [v.x, v.y, v.z]; let bezier = |pts: &[solidcraft_geom::Vec2]| { let n = pts.len().checked_sub(1)?; let knots = std::iter::repeat_n(0.0, n + 1).chain(std::iter::repeat_n(1.0, n + 1)).collect(); Some((brep::Curve::Spline { knots, points: pts.iter().map(|p| w(*p)).collect() }, [0.0, 1.0])) }; let out = match *s { Seg2::Line { a, b } => (brep::Curve::Line { start: w(a), end: w(b) }, [0.0, 1.0]), Seg2::Arc { center, radius, start, sweep } => { let (y, t0) = if sweep >= 0.0 { (plane.y, start) } else { (plane.y * -1.0, -start) }; let frame = brep::Frame { origin: w(center), x_axis: d(plane.x), y_axis: d(y) }; (brep::Curve::Circle { frame, radius }, [t0, t0 + sweep.abs()]) } Seg2::Cubic { p0, p1, p2, p3 } => bezier(&[p0, p1, p2, p3])?, Seg2::Bezier { n, p } => bezier(p.get(..=usize::from(n))?)?, Seg2::Conic { a, apex, b, w: wt } => { let h = |p: solidcraft_geom::Vec2, k: f64| { let q = w(p); [q[0] * k, q[1] * k, q[2] * k, k] }; ( brep::Curve::RationalSpline { knots: vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0], homogeneous: vec![h(a, 1.0), h(apex, wt), h(b, 1.0)] }, [0.0, 1.0], ) } }; let finite = |q: &[f64]| q.iter().all(|x| x.is_finite()); let ok = match &out.0 { brep::Curve::Line { start, end } => finite(start) && finite(end), brep::Curve::Circle { frame, radius } => finite(&frame.origin) && radius.is_finite() && *radius > 0.0, brep::Curve::Spline { points, .. } => points.iter().all(|q| finite(q)), brep::Curve::RationalSpline { homogeneous, .. } => homogeneous.iter().all(|q| finite(q) && q[3] > 0.0), _ => false, }; (ok && out.1.iter().all(|t| t.is_finite())).then_some(out) } /// 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> { 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() } /// 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], } /// 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 { 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::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 { 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 { let c = self.ctrl(); let n = self.degree() as f64; let hodograph: Vec = 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 { let ctrl: Vec = self.ctrl().iter().map(|q| q.project().map(|p| HPoint::weighted(f(p), q.w))).collect::>()?; SpaceBezier::new(&ctrl) } /// The control points as SMLib takes them: (x, y, z, weight). pub(crate) fn weighted_points(&self) -> Option> { self.ctrl().iter().map(|q| q.project().map(|p| [p.x, p.y, p.z, q.w])).collect() } fn speed(&self, x: f64) -> Option { 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 { 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> { 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 { 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 { 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() } }