SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 222/509: brep, step: the pcurve fit is gone (and 1 more)
jyviko51f0a9df43d0
diff --git a/crates/geom/src/brep/pcurve.rs b/crates/geom/src/brep/pcurve.rsindex 1bcfd88dbc..4cfd38c4d7 100644--- a/crates/geom/src/brep/pcurve.rs+++ b/crates/geom/src/brep/pcurve.rs@@ -57,12 +57,6 @@ pub struct EdgeUse<'a> {/// Knot spans a fitted pcurve may have (the schema takes 4096 control points).const MAX_SPANS: usize = 4000;-/// Refinement rounds of one fit.-const MAX_ROUNDS: usize = 40;-/// Samples per knot span when a fit starts.-const PER_SPAN: usize = 4;-/// Spans a fit starts from (more where the curve has its own knots).-const START_SPANS: usize = 4;/// Edge uses of one face.const MAX_USES: usize = 100_000;/// Lift checks of an exact pcurve: evenly spaced, plus one inside each of its spans up to this.@@ -170,6 +164,19 @@ fn cut(c: Curve2, [t0, t1]: [f64; 2]) -> Result<Curve2> {})}+/// What a curve record is, for a message.+fn curve_kind(c: &Curve) -> &'static str {+ match c {+ Curve::Line { .. } => "a line",+ Curve::Circle { .. } => "a circle",+ Curve::Ellipse { .. } => "an ellipse",+ Curve::Polyline { .. } => "a polyline",+ Curve::Spline { .. } => "a B-spline",+ Curve::RationalSpline { .. } => "a NURBS",+ _ => "a derived curve",+ }+}+/// A face's surface: its evaluator and parameter box, and the grid a point's parameters on it/// are searched from, made once for all the face's points.struct On {@@ -180,18 +187,6 @@ struct On {face: Option<[[f64; 2]; 2]>,}-/// A curve sample: its parameter, point, surface parameters (periodic ones unwrapped along the-/// curve), whether the surface is degenerate along each direction there (a pole), and the-/// curve's point halfway to the next sample once measured.-#[derive(Clone, Copy)]-struct Sample {- t: f64,- p: Vec3,- uv: [f64; 2],- pole: [bool; 2],- mid: Option<Vec3>,-}-impl On {fn new(s: &Surface) -> Result<Self> {let surface = SurfaceEval::new(s)?;@@ -199,6 +194,18 @@ impl On {Ok(On { surface, starts: uv::Starts::default(), dom, face: None })}+ /// What the surface is, for a message.+ fn surface_kind(&self) -> &'static str {+ match &self.surface {+ SurfaceEval::Eval(crate::tess::EvalSurface::Plane { .. }, _) => "a plane",+ SurfaceEval::Cylinder { .. } => "a cylinder",+ SurfaceEval::Cone { .. } => "a cone",+ SurfaceEval::Sphere { .. } => "a sphere",+ SurfaceEval::Torus { .. } => "a torus",+ _ => "a spline surface",+ }+ }+fn within(self, face: Option<[[f64; 2]; 2]>) -> Self {let face = face.filter(|f| f.iter().flatten().all(|x| x.is_finite()));On { face, ..self }@@ -210,7 +217,7 @@ impl On {{return Ok(pc);}- self.fit(record, curve, range, tol)+ Err(Error::Failed(format!("not supported yet: no exact pcurve of {} on {}", curve_kind(record), self.surface_kind())))}/// The closed-form pcurve where there is one (unchecked).@@ -355,12 +362,6 @@ impl On {Some(q)}- fn sample(&self, curve: &CurveEval, t: f64, near: Option<[f64; 2]>, accept: f64, reach: f64) -> Result<Sample> {- let p = curve.point(t).ok_or_else(|| Error::Failed(format!("the curve has no point at {t}")))?;- let uv = self.project(p, near, accept).ok_or_else(|| self.off(p, t, near))?;- Ok(Sample { t, p, uv, pole: self.pole(uv, reach), mid: None })- }-/// Whether `uv` is at a pole along each direction, or within `reach` of one: moving that/// parameter by half its period (or across its range) moves the point by no more than `reach`/// at its speed there. There the parameter is as free as at the pole itself.@@ -380,99 +381,6 @@ impl On {out}- /// The error for a curve point `p` (at `t`) farther than the fit allows from the surface.- fn off(&self, p: Vec3, t: f64, near: Option<[f64; 2]>) -> Error {- let d = self.project(p, near, f64::INFINITY).and_then(|q| self.surface.point(q)).map(|s| s.dist(p));- Error::Failed(format!("the curve at {t} lies {} mm off the surface", d.unwrap_or(f64::NAN)))- }-- /// A cubic B-spline in (u, v) on the curve's own parameter, through the parameters of the- /// curve's ends, least squares through samples between; spans whose lift misses the curve- /// by more than half the tolerance (at the samples and halfway between them) are halved and- /// sampled twice as densely until none does.- fn fit(&self, record: &Curve, curve: &CurveEval, [t0, t1]: [f64; 2], tol: f64) -> Result<Curve2> {- let (target, accept) = (0.5 * tol, 0.5 * tol);- // Samples this near a pole take their free parameter from a neighbour, which moves- // their lift by at most this (well inside the target).- let reach = 0.25 * tol;- // Interior knots: where the curve's own parameterisation is less smooth (a pcurve is no- // smoother than its curve), else even.- let mut inner = breaks(record, Some(curve), t0, t1);- if inner.len() + 1 > MAX_SPANS / 4 {- return Err(Error::TooLarge(format!("a pcurve of a curve with {} knots", inner.len())));- }- if inner.is_empty() {- inner = (1..START_SPANS).map(|k| (t0 + (t1 - t0) * k as f64 / START_SPANS as f64, 1)).collect();- }- let bounds =- |inner: &[(f64, usize)]| -> Vec<f64> { std::iter::once(t0).chain(inner.iter().map(|k| k.0)).chain(std::iter::once(t1)).collect() };- let mut samples: Vec<Sample> = Vec::new();- let mut near = None;- for w in bounds(&inner).windows(2) {- let (a, b) = (w.first().copied().unwrap_or(t0), w.get(1).copied().unwrap_or(t1));- for k in usize::from(!samples.is_empty())..=PER_SPAN {- let t = if k == PER_SPAN { b } else { a + (b - a) * k as f64 / PER_SPAN as f64 };- let s = self.sample(curve, t, near, accept, reach)?;- near = Some(s.uv);- samples.push(s);- }- }- for _ in 0..MAX_ROUNDS {- let knots: Vec<f64> = [t0; 4].into_iter().chain(inner.iter().flat_map(|&(k, m)| std::iter::repeat_n(k, m))).chain([t1; 4]).collect();- let points = least_squares(&knots, &fill_poles(&samples)).ok_or_else(|| Error::Failed("the pcurve fit is singular".into()))?;- let pc = Curve2::Spline { knots, points };- let miss = |t: f64, p: Vec3| pc.eval(t).and_then(|q| self.surface.point(q)).map_or(f64::INFINITY, |s| s.dist(p));- let spans = inner.len() + 1;- let span_of = |t: f64| inner.partition_point(|k| k.0 <= t).min(spans - 1);- let mut bad = vec![false; spans];- for i in 0..samples.len() {- let Some(s) = samples.get(i).copied() else { break };- let mid_t = samples.get(i + 1).map(|n| 0.5 * (s.t + n.t));- let mid = s.mid.or_else(|| mid_t.and_then(|t| curve.point(t)));- if let Some(slot) = samples.get_mut(i) {- slot.mid = mid;- }- let between = match (mid_t, mid) {- (Some(t), Some(m)) => miss(t, m),- (Some(_), None) => f64::INFINITY,- _ => 0.0,- };- if !(miss(s.t, s.p) <= target && between <= target)- && let Some(flag) = bad.get_mut(span_of(mid_t.unwrap_or(s.t)))- {- *flag = true;- }- }- if !bad.contains(&true) {- return Ok(pc);- }- // Halve the failing spans and sample them twice as densely.- let split: Vec<(f64, f64)> =- bounds(&inner).windows(2).zip(&bad).filter(|(_, b)| **b).filter_map(|(w, _)| Some((*w.first()?, *w.get(1)?))).collect();- if inner.iter().map(|k| k.1).sum::<usize>() + split.len() + 1 > MAX_SPANS {- break;- }- inner.extend(split.iter().map(|(a, b)| (0.5 * (a + b), 1)));- inner.sort_by(|a, b| a.0.total_cmp(&b.0));- let inside = |t: f64| split.iter().any(|&(a, b)| t >= a && t < b);- let mut dense = Vec::with_capacity(samples.len() * 2);- for i in 0..samples.len() {- let Some(s) = samples.get(i).copied() else { break };- match (inside(s.t), samples.get(i + 1), s.mid) {- (true, Some(n), Some(m)) => {- let t = 0.5 * (s.t + n.t);- let uv = self.project(m, Some(s.uv), accept).ok_or_else(|| self.off(m, t, Some(s.uv)))?;- dense.push(Sample { mid: None, ..s });- dense.push(Sample { t, p: m, uv, pole: self.pole(uv, reach), mid: None });- }- _ => dense.push(s),- }- }- samples = dense;- }- Err(Error::Failed(format!("no pcurve within {tol} mm in {MAX_SPANS} spans")))- }-/// The loop's uses moved by whole periods so each starts where the one before it ends (in/// loop order and direction), then all together into the surface's base period where the/// loop's lowest point allows. Where uses meet at a pole (within `tol`) the periodic@@ -570,59 +478,6 @@ impl On {}}-/// The interior parameters where `curve` is less than twice continuously differentiable, with-/// the knot multiplicity a cubic needs there: a spline's knots by their multiplicity, and the-/// vertices of a polyline or an intersection curve's leader polyline (its parameter turns there).-/// A knot that leaves a spline only continuous by its multiplicity, where the spline's-/// derivative is the same either side (`eval`, the curve's own evaluator), is once-/// differentiable and gets a pcurve with a tangent there: two pieces fitted apart would meet at-/// an angle, sharp in (u, v) where the surface's parameters run at very different speeds (a-/// thread's flank, hundreds of mm per unit along the helix and one across it).-fn breaks(curve: &Curve, eval: Option<&CurveEval>, t0: f64, t1: f64) -> Vec<(f64, usize)> {- let spline = |knots: &[f64], count: usize| -> Vec<(f64, usize)> {- let degree = knots.len().saturating_sub(count + 1);- let mut out: Vec<(f64, usize)> = Vec::new();- for &k in knots.iter().filter(|&&k| k > t0 && k < t1) {- match out.last_mut() {- Some(last) if last.0 == k => last.1 += 1,- _ => out.push((k, 1)),- }- }- out.into_iter()- .map(|(k, m)| {- let mut smooth = degree.saturating_sub(m);- if m == degree && eval.is_some_and(|e| differentiable_at(e, k)) {- smooth = 1;- }- (k, (3 - smooth.min(2)).clamp(1, 3))- })- .collect()- };- let corners = |n: usize| (1..n.saturating_sub(1)).map(|i| (i as f64, 3)).filter(|k| k.0 > t0 && k.0 < t1).collect();- match curve {- Curve::Line { .. } | Curve::Circle { .. } | Curve::Ellipse { .. } => Vec::new(),- Curve::Polyline { points } => corners(points.len()),- Curve::Spline { knots, points } => spline(knots, points.len()),- Curve::RationalSpline { knots, homogeneous } => spline(knots, homogeneous.len()),- Curve::SurfaceIntersection { leader, .. } => match &**leader {- Curve::Polyline { points } => corners(points.len()),- other => breaks(other, None, t0, t1),- },- }-}--/// Relative difference of a spline's derivatives either side of a knot within which it is-/// differentiable there (rounding of derivatives made equal).-const SAME_DERIVATIVE: f64 = 1e-9;--/// Whether the spline `eval` has one derivative at its knot `k` (the same from either side).-fn differentiable_at(eval: &CurveEval, k: f64) -> bool {- let CurveEval::Spline(c) = eval else { return false };- let Some((l, r)) = c.sides(k) else { return false };- let size = l.len().max(r.len());- size > 0.0 && (l - r).len() <= SAME_DERIVATIVE * size-}-/// Signed area in (u, v) of the loop with its uses moved by `shift` along `d`.fn area(uses: &[(Curve2, bool)], shift: &[f64], d: usize) -> f64 {let mut ring: Vec<[f64; 2]> = Vec::new();@@ -643,127 +498,6 @@ fn area(uses: &[(Curve2, bool)], shift: &[f64], d: usize) -> f64 {(0..n).filter_map(|i| Some((ring.get(i)?, ring.get((i + 1) % n)?))).map(|(p, q)| p[0] * q[1] - q[0] * p[1]).sum::<f64>() * 0.5}-/// The samples' parameters, where a pole leaves one undefined taken from the nearest sample-/// where it is defined (so the pcurve runs straight into the pole, never across to another-/// angle).-fn fill_poles(samples: &[Sample]) -> Vec<(f64, [f64; 2])> {- let mut out: Vec<(f64, [f64; 2])> = samples.iter().map(|s| (s.t, s.uv)).collect();- for d in 0..2 {- // Where the surface collapses along `d`, the parameter `d` says nothing.- let free = |s: &Sample| s.pole.get(d).copied().unwrap_or(false);- if samples.iter().all(free) {- continue;- }- for (i, s) in samples.iter().enumerate() {- if !free(s) {- continue;- }- let left = samples.get(..i).and_then(|l| l.iter().rposition(|x| !free(x)));- let right = samples.get(i + 1..).and_then(|r| r.iter().position(|x| !free(x))).map(|k| k + i + 1);- let dt = |k: usize| samples.get(k).map_or(f64::INFINITY, |x| (x.t - s.t).abs());- let pick = match (left, right) {- (Some(l), Some(r)) => Some(if dt(l) <= dt(r) { l } else { r }),- (a, b) => a.or(b),- };- if let (Some(src), Some(slot)) = (pick.and_then(|k| samples.get(k)), out.get_mut(i))- && let (Some(x), Some(v)) = (slot.1.get_mut(d), src.uv.get(d))- {- *x = *v;- }- }- }- out-}--/// Cubic control points on `knots` through the first and last data points, least squares-/// through the rest (banded normal equations, Cholesky).-fn least_squares(knots: &[f64], data: &[(f64, [f64; 2])]) -> Option<Vec<[f64; 2]>> {- const P: usize = 3;- let n = knots.len().checked_sub(P + 1)?;- let (first, last) = (data.first()?.1, data.last()?.1);- let m = n.checked_sub(2)?;- // Normal equations, upper band: ata[j][k] = A(j, j + k) over the free points 1..n−1.- let mut ata = vec![[0.0f64; P + 1]; m];- let mut atb = vec![[0.0f64; 2]; m];- for &(t, q) in data {- let span = crate::bspline::find_span(knots, P, n, t)?;- let nb = crate::tess::basis_ders(knots, span, P, t)?;- let nb = nb.first()?.get(..=P)?;- let mut r = q;- for (j, w) in nb.iter().enumerate() {- let i = span + j - P;- let fixed = if i == 0 {- Some(first)- } else if i + 1 == n {- Some(last)- } else {- None- };- if let Some(f) = fixed {- r = [r[0] - w * f[0], r[1] - w * f[1]];- }- }- for (j, wj) in nb.iter().enumerate() {- let Some(row) = (span + j - P).checked_sub(1).filter(|&r| r < m) else { continue };- if let Some(b) = atb.get_mut(row) {- b[0] += wj * r[0];- b[1] += wj * r[1];- }- for (k, wk) in nb.iter().enumerate().skip(j) {- let Some(col) = (span + k - P).checked_sub(1).filter(|&c| c < m) else { continue };- if let Some(x) = ata.get_mut(row).and_then(|a| a.get_mut(col - row)) {- *x += wj * wk;- }- }- }- }- // A = Rᵀ R with R upper of the same band: r[j][k] = R(j, j + k).- let at = |r: &[[f64; P + 1]], j: usize, k: usize| r.get(j).and_then(|x| x.get(k)).copied().unwrap_or(0.0);- let scale = ata.iter().map(|a| a[0]).fold(0.0, f64::max);- let mut r = vec![[0.0f64; P + 1]; m];- for j in 0..m {- let mut diag = at(&ata, j, 0);- for l in 1..=P.min(j) {- diag -= at(&r, j - l, l).powi(2);- }- if !(diag > 1e-14 * scale) {- return None;- }- let diag = diag.sqrt();- let mut row = [diag, 0.0, 0.0, 0.0];- for (k, x) in row.iter_mut().enumerate().skip(1).take_while(|(k, _)| j + k < m) {- let mut v = at(&ata, j, k);- for l in 1..=(P - k).min(j) {- v -= at(&r, j - l, l) * at(&r, j - l, l + k);- }- *x = v / diag;- }- *r.get_mut(j)? = row;- }- let mut y = vec![[0.0f64; 2]; m];- for j in 0..m {- let mut v = *atb.get(j)?;- for l in 1..=P.min(j) {- let (c, yl) = (at(&r, j - l, l), *y.get(j - l)?);- v = [v[0] - c * yl[0], v[1] - c * yl[1]];- }- let d = at(&r, j, 0);- *y.get_mut(j)? = [v[0] / d, v[1] / d];- }- let mut x = vec![[0.0f64; 2]; m];- for j in (0..m).rev() {- let mut v = *y.get(j)?;- for k in (1..=P).take_while(|k| j + k < m) {- let (c, xk) = (at(&r, j, k), *x.get(j + k)?);- v = [v[0] - c * xk[0], v[1] - c * xk[1]];- }- let d = at(&r, j, 0);- *x.get_mut(j)? = [v[0] / d, v[1] / d];- }- let out: Vec<[f64; 2]> = std::iter::once(first).chain(x).chain(std::iter::once(last)).collect();- out.iter().flatten().all(|v| v.is_finite()).then_some(out)-}-/// The control points of `c` in (u, v).fn points(c: &Curve2) -> Vec<[f64; 2]> {match c {diff --git a/crates/step/src/topology.rs b/crates/step/src/topology.rsindex d5d3dbe78e..0683b24b3c 100644--- a/crates/step/src/topology.rs+++ b/crates/step/src/topology.rs@@ -694,17 +694,14 @@ impl<'b, 'a> Builder<'b, 'a> {let mut face_forms: Vec<Option<BSurface>> = Vec::with_capacity(self.faces.len());let mut domains = Vec::with_capacity(self.faces.len());let mut turned = vec![false; self.faces.len()];- let (mut failed, mut first_failure, mut loosened) = (0usize, None, 0usize);+ let (mut failed, mut first_failure) = (0usize, None);for fi in 0..self.faces.len() {match self.face_pcurves(fi) {- Ok((pc, domain, flipped, tol, form)) => {+ Ok((pc, domain, flipped, form)) => {face_forms.push(form);if flipped && let Some(t) = turned.get_mut(fi) {*t = true;}- if tol > self.tol {- loosened += 1;- }pcs.push(pc);domains.push(domain);}@@ -724,9 +721,6 @@ impl<'b, 'a> Builder<'b, 'a> {if flipped > 0 {notes.push(format!("{flipped} faces turned over: their loops disagree with their same_sense"));}- if loosened > 0 {- notes.push(format!("{loosened} faces have their pcurves fitted looser than {} mm", self.tol));- }let shells: Vec<Vec<(u32, bool)>> = shells.into_iter().map(|s| s.into_iter().map(|(f, fwd)| (f, if turned.get(f as usize).copied().unwrap_or(false) { !fwd } else { fwd })).collect())@@ -953,11 +947,11 @@ impl<'b, 'a> Builder<'b, 'a> {}/// The pcurves of a face's edge loops (in its edge-loop order), its domain, whether it was- /// turned over, and the tolerance they were fitted at. Picks the outer loop when the file+ /// turned over, and its NURBS form. Picks the outer loop when the file/// marks none (or marks one that another loop encloses), and turns the face over when its/// outer loop runs clockwise about the natural normal on a surface where that cannot be a/// face's outer boundary.- fn face_pcurves(&mut self, fi: usize) -> R<(Vec<Vec<Curve2>>, [[f64; 2]; 2], bool, f64, Option<BSurface>)> {+ fn face_pcurves(&mut self, fi: usize) -> R<(Vec<Vec<Curve2>>, [[f64; 2]; 2], bool, Option<BSurface>)> {let face = self.faces.get(fi).ok_or("face reference")?;let label = face.surface.clone();let edge_loops: Vec<Vec<(u32, bool)>> = face@@ -970,52 +964,35 @@ impl<'b, 'a> Builder<'b, 'a> {.collect();// Which loop index in `face.loops` each edge loop is.let positions: Vec<usize> = face.loops.iter().enumerate().filter(|(_, l)| matches!(l, LoopB::Edges(_))).map(|(i, _)| i).collect();- let mut tol = self.tol;+ let tol = self.tol;// The face's pcurves on `on`, each edge on its NURBS form when `formed`.- let pcurves_on = |on: &BSurface, formed: bool, tol: &mut f64| -> R<Vec<Vec<Curve2>>> {- loop {- let mut uses = Vec::with_capacity(edge_loops.len());- for l in &edge_loops {- let mut u = Vec::with_capacity(l.len());- for &(e, forward) in l {- let edge = self.edges.get(e as usize).ok_or("edge reference")?;- let (curve, interval) = match &edge.form {- Some((c, i)) if formed => (c, *i),- _ => (&edge.curve, edge.interval),- };- u.push(EdgeUse { edge: e, curve, interval, forward, tolerance: 0.0, given: None });- }- uses.push(u);- }- match pcurve::pcurves(on, &uses, *tol) {- Ok(p) => return Ok(p),- Err(pcurve::Error::Failed(m)) if !m.contains("not supported") && *tol * 10.0 <= MAX_FIT_TOLERANCE * (1.0 + 1e-9) => {- *tol *= 10.0;- }- Err(e) => return Err(e.to_string()),+ let pcurves_on = |on: &BSurface, formed: bool| -> R<Vec<Vec<Curve2>>> {+ let mut uses = Vec::with_capacity(edge_loops.len());+ for l in &edge_loops {+ let mut u = Vec::with_capacity(l.len());+ for &(e, forward) in l {+ let edge = self.edges.get(e as usize).ok_or("edge reference")?;+ let (curve, interval) = match &edge.form {+ Some((c, i)) if formed => (c, *i),+ _ => (&edge.curve, edge.interval),+ };+ u.push(EdgeUse { edge: e, curve, interval, forward, tolerance: 0.0, given: None });}+ uses.push(u);}+ pcurve::pcurves(on, &uses, tol).map_err(|e| e.to_string())};// A cylinder, cone, sphere or torus on its NURBS form, over the extent its label's pcurves// give; then every pcurve on the forms.let form = match brep::form::frame_of(&label) {Some(_) => {- let extent = face_domain(&label, &pcurves_on(&label, false, &mut tol)?)?;+ let extent = face_domain(&label, &pcurves_on(&label, false)?)?;Some(brep::form::surface(&label, extent).ok_or_else(|| unsupported("a face of more than one turn"))?.0)}None => None,};let surface = form.clone().unwrap_or(label);- let pcs = pcurves_on(&surface, true, &mut tol)?;- if tol > self.tol {- for l in &edge_loops {- for &(e, _) in l {- if let Some(edge) = self.edges.get_mut(e as usize) {- edge.tolerance = edge.tolerance.max(tol);- }- }- }- }+ let pcs = pcurves_on(&surface, true)?;// Signed areas of the loops that close in (u, v).let periods = natural_periods(&surface);// Each use starts near where the one before it ends, along a bounded direction that@@ -1077,7 +1054,7 @@ impl<'b, 'a> Builder<'b, 'a> {}let pcs: Vec<Vec<Curve2>> = if flip { pcs.into_iter().map(|l| l.into_iter().rev().collect()).collect() } else { pcs };let domain = face_domain(&surface, &pcs)?;- Ok((pcs, domain, flip, tol, form))+ Ok((pcs, domain, flip, form))}}diff --git a/crates/step/src/topology/swept.rs b/crates/step/src/topology/swept.rsindex b043aff467..3ff7441b3c 100644--- a/crates/step/src/topology/swept.rs+++ b/crates/step/src/topology/swept.rs@@ -24,8 +24,6 @@ use crate::geom::{Axis1, Curve, P3, Placement, Surface};/// Margin around a face's parameters on a profile, as a fraction of their span.const MARGIN: f64 = 0.1;-/// Most sweep of one rational quadratic conic piece.-const CONIC_PIECE: f64 = FRAC_PI_2;/// Most parameter step of one rational quadratic hyperbola piece (its weight `cosh(step / 2)`/// stays near 1).const HYPERBOLA_STEP: f64 = 1.0;@@ -45,31 +43,6 @@ fn p3(v: Vec3) -> P3 {[v.x, v.y, v.z]}-/// The ellipse of `radii` in `p` from angle `t0` over `sweep` > 0 as rational quadratic pieces-/// whose knots are the pieces' end angles.-pub(super) fn conic_spline(p: &Placement, radii: [f64; 2], t0: f64, sweep: f64) -> BCurve {- let n = ((sweep / CONIC_PIECE).ceil() as usize).clamp(1, 8);- let dt = sweep / n as f64;- let w = (0.5 * dt).cos();- let at = |c: f64, s: f64| p.at(radii[0] * c, radii[1] * s, 0.0);- let mut knots = vec![t0; 3];- let first = at(t0.cos(), t0.sin());- let mut homogeneous = vec![[first[0], first[1], first[2], 1.0]];- for i in 0..n {- let ta = t0 + dt * i as f64;- let (tm, tb) = (ta + 0.5 * dt, ta + dt);- // The meeting point of the end tangents, weighted cos of the half sweep.- let m = at(tm.cos() / w, tm.sin() / w);- homogeneous.push([m[0] * w, m[1] * w, m[2] * w, w]);- let b = at(tb.cos(), tb.sin());- homogeneous.push([b[0], b[1], b[2], 1.0]);- let k = if i + 1 == n { t0 + sweep } else { tb };- knots.extend([k, k]);- }- knots.push(t0 + sweep);- BCurve::RationalSpline { knots, homogeneous }-}-/// The hyperbola branch `a cosh t X + b sinh t Y` from `t0` to `t1` (t0 < t1) as rational/// quadratic pieces whose knots are the pieces' end parameters.pub(super) fn hyperbola_spline(p: &Placement, a: f64, b: f64, t0: f64, t1: f64) -> BCurve {@@ -212,6 +185,11 @@ fn span(ts: &[f64], seam: &[f64], closed: bool) -> R<Span> {Ok(Span::Open { inner: (lo, hi), outer: (lo - m, hi + m) })}+/// A conic's NURBS form over `[lo, hi]` in angle.+fn form(c: BCurve, lo: f64, hi: f64) -> R<BCurve> {+ Ok(solidcraft_geom::brep::form::curve(&c, [lo, hi]).ok_or_else(|| unsupported("a conic profile of more than one turn"))?.0)+}+/// The profile over its span as an exact spline (B-spline and polyline profiles whole).fn bounded(c: &Curve, s: Span) -> R<BCurve> {let (lo, hi) = match s {@@ -223,8 +201,12 @@ fn bounded(c: &Curve, s: Span) -> R<BCurve> {}Ok(match c {Curve::Line { origin, direction, magnitude } => line_spline(*origin, *direction, *magnitude, lo, hi),- Curve::Circle { position, radius } => conic_spline(position, [*radius; 2], lo, hi - lo),- Curve::Ellipse { position, semi_axis_1, semi_axis_2 } => conic_spline(position, [*semi_axis_1, *semi_axis_2], lo, hi - lo),+ // A circle or ellipse as its NURBS form (`form::curve`), the one its edges carry: the swept+ // surface's parameter along the profile is then theirs, and their pcurves are straight.+ Curve::Circle { position, radius } => form(BCurve::Circle { frame: super::frame(position), radius: *radius }, lo, hi)?,+ Curve::Ellipse { position, semi_axis_1, semi_axis_2 } => {+ form(BCurve::Ellipse { frame: super::frame(position), radii: [*semi_axis_1, *semi_axis_2] }, lo, hi)?+ }Curve::Hyperbola { position, semi_axis, semi_imag_axis } => {if hi - lo > HYPERBOLA_STEP * MAX_PIECES as f64 {return Err(unsupported("a hyperbola profile that long"));