Skip to content

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

Wave 19/509: brep: a seam from pole to pole gets pcurves a period apart (and 1 more)

jyvikoc72062a96a92
diff --git a/crates/geom/src/brep/pcurve.rs b/crates/geom/src/brep/pcurve.rs
index a788702bad..d6912301fb 100644
--- a/crates/geom/src/brep/pcurve.rs
+++ b/crates/geom/src/brep/pcurve.rs
@@ -101,7 +101,7 @@ pub fn pcurves(surface_record: &Surface, loops: &[Vec<EdgeUse<'_>>], tolerance:
};
fitted.push((pc, u.forward));
}
- on.close(&mut fitted)?;
+ on.close(&mut fitted, tolerance)?;
out.push(fitted.into_iter().map(|(c, _)| c).collect());
}
Ok(out)
@@ -254,10 +254,29 @@ impl On {
Some(q)
}
- fn sample(&self, curve: &CurveEval, t: f64, near: Option<[f64; 2]>, accept: f64) -> Result<Sample> {
+ 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.surface.pole(uv), mid: None })
+ 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.
+ fn pole(&self, uv: [f64; 2], reach: f64) -> [bool; 2] {
+ let mut out = self.surface.pole(uv);
+ let Some((_, su, sv)) = self.surface.derivs(uv[0], uv[1]) else { return out };
+ for (d, speed) in [su.len(), sv.len()].into_iter().enumerate() {
+ let span = match (self.dom.period.get(d).copied().flatten(), self.dom.range.get(d).copied().flatten()) {
+ (Some(period), _) => 0.5 * period,
+ (None, Some((a, b))) => (b - a).abs(),
+ (None, None) => continue,
+ };
+ if let Some(flag) = out.get_mut(d) {
+ *flag |= speed * span <= reach;
+ }
+ }
+ out
}
/// The error for a curve point `p` (at `t`) farther than the fit allows from the surface.
@@ -272,6 +291,9 @@ impl On {
/// 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, t0, t1);
@@ -289,7 +311,7 @@ impl On {
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)?;
+ let s = self.sample(curve, t, near, accept, reach)?;
near = Some(s.uv);
samples.push(s);
}
@@ -340,7 +362,7 @@ impl On {
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.surface.pole(uv), mid: None });
+ dense.push(Sample { t, p: m, uv, pole: self.pole(uv, reach), mid: None });
}
_ => dense.push(s),
}
@@ -352,10 +374,11 @@ impl On {
/// 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 the periodic parameter is free:
- /// there the offsets that turn the loop counter-clockwise in (u, v) (a face boundary seen
- /// from the natural normal) are taken, else the nearest.
- fn close(&self, uses: &mut [(Curve2, bool)]) -> Result<()> {
+ /// loop's lowest point allows. Where uses meet at a pole (within `tol`) the periodic
+ /// parameter is free: there the offsets that turn the loop counter-clockwise in (u, v) (a
+ /// face boundary seen from the natural normal) by more than rounding are taken, else the
+ /// nearest. A seam used twice from pole to pole thus encloses its face, never nothing.
+ fn close(&self, uses: &mut [(Curve2, bool)], tol: f64) -> Result<()> {
let n = uses.len();
let mut ends = Vec::with_capacity(n);
for (c, fwd) in uses.iter() {
@@ -367,7 +390,7 @@ impl On {
let Some(period) = self.dom.period.get(d).copied().flatten().filter(|p| *p > 0.0) else { continue };
// Start after a pole junction if there is one: from there continuity fixes the
// offsets up to the next pole.
- let at_pole: Vec<bool> = ends.iter().map(|(s, _)| self.surface.pole(*s).get(d).copied().unwrap_or(false)).collect();
+ let at_pole: Vec<bool> = ends.iter().map(|(s, _)| self.pole(*s, tol).get(d).copied().unwrap_or(false)).collect();
let first = at_pole.iter().position(|&p| p).unwrap_or(0);
let order: Vec<usize> = (0..n).map(|k| (first + k) % n).collect();
let mut shift = vec![0.0; n];
@@ -384,6 +407,11 @@ impl On {
// After each later pole one period less, none or more: the right turn, then the
// fewest moves.
if !free.is_empty() && free.len() <= 6 {
+ // Less than this is rounding: a loop that encloses nothing (a seam's two uses
+ // on one line) has no turn, whatever the sign of its area.
+ let other = uses.iter().flat_map(|(c, _)| points(c).into_iter().filter_map(|q| q.get(1 - d).copied()));
+ let (lo, hi) = other.fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), x| (a.min(x), b.max(x)));
+ let flat = if hi >= lo { 1e-9 * period * (hi - lo) } else { 0.0 };
let mut best: Option<(bool, usize, Vec<f64>)> = None;
for combo in 0..3usize.pow(free.len() as u32) {
let (mut code, mut moved, mut add) = (combo, 0, 0.0);
@@ -399,7 +427,7 @@ impl On {
*slot += add;
}
}
- let right = area(uses, &extra, d) > 0.0;
+ let right = area(uses, &extra, d) > flat;
if best.as_ref().is_none_or(|(r, m, _)| (right && !r) || (right == *r && moved < *m)) {
best = Some((right, moved, extra));
}
diff --git a/crates/geom/src/brep/pcurve_tests.rs b/crates/geom/src/brep/pcurve_tests.rs
index 5688cdac50..4b934daef9 100644
--- a/crates/geom/src/brep/pcurve_tests.rs
+++ b/crates/geom/src/brep/pcurve_tests.rs
@@ -234,6 +234,93 @@ fn meridians_run_straight_into_the_poles() {
}
}
+/// A whole sphere bounded only by its seam (one meridian from pole to pole, used twice), in
+/// frames where rounding leaves the loop with the uses on one line a tiny positive area: the
+/// two uses come out a period apart and the loop turns counter-clockwise around the whole
+/// (u, v) box, in either loop order, for a circle or a NURBS meridian, with its ends at the
+/// poles or within a tenth of the tolerance of them.
+#[test]
+fn a_seam_from_pole_to_pole_encloses_the_whole_sphere() {
+ let w = std::f64::consts::FRAC_1_SQRT_2;
+ let tol = 1e-7;
+ let frames = [
+ about_z([0.; 3], false),
+ about_z([1., -2., 3.], true),
+ frame([1., 2., 3.], [0., 0.6, 0.8], [0., -0.8, 0.6]),
+ frame([-4., 0.5, 2.], [0.36, 0.48, 0.8], [-0.8, 0.6, 0.]),
+ ];
+ for sf in frames {
+ let sphere = Surface::Sphere { frame: sf.clone(), radius: 6. };
+ let ax = crate::brep::eval::Axes::new(&sf);
+ for turn in [0f64, 2.1, -0.7] {
+ let x = ax.x * turn.cos() + ax.y * turn.sin();
+ let p = |v: Vec3| [v.x, v.y, v.z];
+ let (o, r, z) = (ax.o, x * 6., ax.z * 6.);
+ let circle = Curve::Circle { frame: Frame { origin: p(o), x_axis: p(x), y_axis: p(ax.z) }, radius: 6. };
+ for off in [0., 0.1 * tol] {
+ // South pole to north pole through the equator, as two rational quarter arcs,
+ // the ends `off` to the side of the poles.
+ let h = |v: Vec3, wt: f64| [v.x * wt, v.y * wt, v.z * wt, wt];
+ let side = ax.y * off;
+ let nurbs = Curve::RationalSpline {
+ knots: vec![0., 0., 0., 0.5, 0.5, 1., 1., 1.],
+ homogeneous: vec![h(o - z + side, 1.), h(o - z + r, w), h(o + r, 1.), h(o + z + r, w), h(o + z - side, 1.)],
+ };
+ for (seam, iv) in [(&circle, [-FRAC_PI_2, FRAC_PI_2]), (&nurbs, [0., 1.])] {
+ for order in [[true, false], [false, true]] {
+ let l: Vec<EdgeUse> = order.iter().map(|&forward| EdgeUse { edge: 0, curve: seam, interval: iv, forward }).collect();
+ let pcs = &pcurves(&sphere, std::slice::from_ref(&l), tol).unwrap()[0];
+ let what = format!("{sf:?} {turn} {off} {seam:?} {order:?}");
+ for pc in pcs {
+ assert!(lift_error(&sphere, seam, iv, pc) <= tol, "{what}");
+ }
+ let mid = 0.5 * (iv[0] + iv[1]);
+ let (a, b) = (pcs[0].eval(mid).unwrap(), pcs[1].eval(mid).unwrap());
+ assert!(((a[0] - b[0]).abs() - TAU).abs() < 1e-6 && (a[1] - b[1]).abs() < 1e-12, "a period apart: {a:?} {b:?} {what}");
+ let (ends, area) = walk(&l, pcs);
+ for k in 0..2 {
+ assert!((ends[k].1[1] - ends[(k + 1) % 2].0[1]).abs() < 1e-6, "closed in v: {ends:?} {what}");
+ }
+ // The box less the corners `walk` cuts (it joins each use's 16th
+ // sample to the next use's start): about 15/16 of it.
+ assert!((area / (TAU * PI * 15. / 16.) - 1.).abs() < 1e-2, "counter-clockwise around the box: {area} {what}");
+ }
+ }
+ }
+ }
+ }
+}
+
+/// A whole torus bounded only by its two seams (a circle about the axis and a circle around
+/// the tube, each used twice): no pole, continuity alone puts each seam's uses a period apart
+/// and the loop around the whole (u, v) box.
+#[test]
+fn a_torus_bounded_by_its_seams_spans_both_periods() {
+ let frames = [about_z([0.; 3], false), frame([1., 2., 3.], [0., 0.6, 0.8], [0., -0.8, 0.6])];
+ for sf in frames {
+ let torus = Surface::Torus { frame: sf.clone(), major_radius: 10., minor_radius: 2. };
+ let ax = crate::brep::eval::Axes::new(&sf);
+ let p = |v: Vec3| [v.x, v.y, v.z];
+ // The outer equator (v = 0, u from 0) and the tube circle at u = 0 (v from 0, upwards).
+ let around = Curve::Circle { frame: sf.clone(), radius: 12. };
+ let tube = Curve::Circle { frame: Frame { origin: p(ax.o + ax.x * 10.), x_axis: p(ax.x), y_axis: p(ax.z) }, radius: 2. };
+ let full = [0., TAU];
+ let l = vec![
+ EdgeUse { edge: 0, curve: &around, interval: full, forward: true },
+ EdgeUse { edge: 1, curve: &tube, interval: full, forward: true },
+ EdgeUse { edge: 0, curve: &around, interval: full, forward: false },
+ EdgeUse { edge: 1, curve: &tube, interval: full, forward: false },
+ ];
+ let pcs = &pcurves(&torus, std::slice::from_ref(&l), 1e-9).unwrap()[0];
+ let (ends, area) = walk(&l, pcs);
+ for k in 0..4 {
+ let (end, start) = (ends[k].1, ends[(k + 1) % 4].0);
+ assert!((end[0] - start[0]).abs() < 1e-12 && (end[1] - start[1]).abs() < 1e-12, "{k}: {end:?} {start:?}");
+ }
+ assert!((area / (TAU * TAU) - 1.).abs() < 1e-12, "counter-clockwise around the box: {area}");
+ }
+}
+
/// An intersection record evaluates to the point of both surfaces in the leader's normal
/// plane, and its pcurves on either surface fit.
#[test]