Wave 326/509: geom: patches about a fill's centre are solved by blocks, their banded interiors eliminated onto what they share (and 3 more)

4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.

- 6a8753443 jyviko: Fill: the height-field fill tries grids up to 64 spans
- dc3d504ba jyviko: geom: a fill patch folds where its normal reverses between neighbours, not where it turns past the middle's
- bac6674ab jyviko: geom: patches about a fill's centre run in the spaces of their own sides, not one space of every edge's breaks
- ea6500559 jyviko: geom: patches about a fill's centre are solved by blocks, their banded interiors eliminated onto what they share

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
jyviko
2026-10-29 01:32:12 -04:00
parent e71d2e2844
commit 21582b66e9
3 changed files with 308 additions and 47 deletions
+2 -2
View File
@@ -16,7 +16,7 @@ use crate::bspline::{Dir, HPoint, NurbsSurface, Side, SplineError, SplineResult,
/// Most loop points a fill takes.
pub const MAX_LOOP_POINTS: usize = 8192;
/// Most spans of the height field in each direction.
pub const MAX_FILL_SPANS: usize = 32;
pub const MAX_FILL_SPANS: usize = 64;
/// How full a patch's middle may be made (`crown`): 0 the least-bending fill, positive fuller,
/// negative flatter, in fractions of the loop's size. Outside this range the value is refused.
pub const MIN_CROWN: f64 = -0.9;
@@ -89,7 +89,7 @@ pub struct LoopFill {
/// is free to turn at the rim (it is not the surface that made the rim). It does not depend
/// on the grid's directions. `λ = 10⁻⁷ ·` (fitted points) `/` (control points): just enough
/// to fix the inside, small enough not to pull the surface off the loop.
/// - Grids of 4, 8, 16, 32 spans across the box's longer side are tried, with as many across
/// - Grids of 4, 8, 16, 32, 64 spans across the box's longer side are tried, with as many across
/// the shorter side as keep the cells about square; a grid whose cells are under twice the
/// fitted points' largest step in a direction (cells between points would be left to the
/// energy alone) waits for denser sampling. The first grid within `tol` of every sampled
+292 -44
View File
@@ -71,7 +71,8 @@
//! has too few rows for the conditions from opposite sides to stay apart, the spans that way are
//! halved (both ways where a point is missed, a patch folds, or the patches share one space),
//! up to [`MAX_ISO_SPANS`] and the free points one solve takes ([`MAX_BANDED_POINTS`] for one
//! patch, whose system is banded, [`MAX_UNKNOWN_POINTS`] about a centre, whose is dense). A
//! patch, whose system is banded, and about a centre, whose patches' banded interiors are
//! eliminated onto the unknowns they share, at most [`MAX_SHARED_UNKNOWNS`]). A
//! fill that then still misses the angle tolerance or a point, or folds, is refused; one that
//! misses only an order above G1 is the closest the finest space holds, its jumps reported
//! ([`Achieved::jumps`]).
@@ -91,11 +92,14 @@ use crate::spline_space::{Cond, Interpolant, Space};
pub const MAX_ISO_SPANS: usize = 64;
/// Most edges of a loop.
pub const MAX_ISO_EDGES: usize = 16;
/// Most free control points of patches about a centre (their system is solved dense: the
/// spokes and the centre couple every patch).
const MAX_UNKNOWN_POINTS: usize = 500;
/// Most free control points of one patch (its system is banded: see [`Quilt::new`]).
/// Most free control points of one solve: of one patch (its system is banded: see
/// [`Quilt::new`]), or of the patches about a centre (each patch's interior banded, eliminated
/// onto the unknowns the patches share: [`BlockNormal`]).
const MAX_BANDED_POINTS: usize = 6000;
/// Most unknowns (coordinates) the patches about a centre share once their interiors are
/// eliminated: the spokes, the centre and the points beside the spokes that rows across them
/// couple. Their system is dense: 4000² values, 128 MB.
const MAX_SHARED_UNKNOWNS: usize = 4000;
/// Stations per span of a side where conditions are asked and checked.
const STATIONS_PER_SPAN: usize = 6;
/// Stations per control point of a row.
@@ -562,8 +566,9 @@ fn corner_scales(edges: &[IsoEdge]) -> SplineResult<Vec<f64>> {
impl Quilt {
/// The fill's patches over the loop's sides at degree `degree` (at least) in spaces refined
/// by `extra` breaks (along u and v). One patch has a space each way, each holding the two
/// sides that run that way; patches about a centre share one space both ways, which each
/// spoke, a row of two patches, runs in.
/// sides that run that way; about a centre, the space along each spoke is the two patches'
/// either side of it (one's along v, the other's along u), holding the spoke and the two edge
/// halves it meets those patches beside.
fn new(edges: &[IsoEdge], extra: &[Vec<f64>; 2], degree: usize) -> SplineResult<Quilt> {
let n = edges.len();
let scales = corner_scales(edges)?;
@@ -613,16 +618,48 @@ impl Quilt {
for m in &middle {
curves.push(line(*m, HPoint::weighted(centre, 1.0))?);
}
let refs: Vec<&Curve> = curves.iter().collect();
let (space, rows) = compatible(&refs, &extra[0], degree)?;
let c = space.count();
let row = |r: usize| rows.get(r).cloned().ok_or_else(|| SplineError::Invalid("rows".into()));
// Space k runs along spoke k: it is patch k's along v (its sides edge k − 1's second half
// and spoke k) and patch k + 1's along u (edge k + 1's first half and spoke k), so it
// holds those three curves' breaks only, not every edge's.
let mut spaces: Vec<Space> = Vec::with_capacity(n);
// Each curve carried into the space it runs in: [first half, second half] per edge, and
// each spoke.
let mut first_half: Vec<Option<Vec<HPoint>>> = vec![None; n];
let mut second_half: Vec<Option<Vec<HPoint>>> = vec![None; n];
let mut spoke_rows: Vec<Vec<HPoint>> = Vec::with_capacity(n);
for k in 0..n {
let (prev, next) = ((k + n - 1) % n, (k + 1) % n);
let refs = [
curves.get(2 * prev + 1).ok_or_else(|| SplineError::Invalid("curves".into()))?,
curves.get(2 * next).ok_or_else(|| SplineError::Invalid("curves".into()))?,
curves.get(2 * n + k).ok_or_else(|| SplineError::Invalid("curves".into()))?,
];
let (space, mut rows) = compatible(&refs, &extra[0], degree)?;
let spoke = rows.pop().ok_or_else(|| SplineError::Invalid("rows".into()))?;
let first = rows.pop().ok_or_else(|| SplineError::Invalid("rows".into()))?;
let second = rows.pop().ok_or_else(|| SplineError::Invalid("rows".into()))?;
second_half[prev] = Some(second);
first_half[next] = Some(first);
spoke_rows.push(spoke);
spaces.push(space);
}
let got = |v: &[Option<Vec<HPoint>>], k: usize| v.get(k).cloned().flatten().ok_or_else(|| SplineError::Invalid("rows".into()));
let space = |k: usize| spaces.get(k).cloned().ok_or_else(|| SplineError::Invalid("spaces".into()));
let spoke_row = |k: usize| spoke_rows.get(k).cloned().ok_or_else(|| SplineError::Invalid("rows".into()));
let mut patches = Vec::with_capacity(n);
for k in 0..n {
let prev = (k + n - 1) % n;
// v = 0: edge k's first half; u = 0: edge k − 1's second half, from V_k up to M_{k−1};
// u = 1: spoke k; v = 1: spoke k − 1, from M_{k−1} to C.
patches.push(coons([space.clone(), space.clone()], &row(2 * k)?, &row(2 * n + prev)?, &row(2 * prev + 1)?, &row(2 * n + k)?, false)?);
// Along u, space k − 1: v = 0 edge k's first half, v = 1 spoke k − 1 (from M_{k−1} to
// C); along v, space k: u = 0 edge k − 1's second half (from V_k up to M_{k−1}),
// u = 1 spoke k.
patches.push(coons(
[space(prev)?, space(k)?],
&got(&first_half, k)?,
&spoke_row(prev)?,
&got(&second_half, prev)?,
&spoke_row(k)?,
false,
)?);
}
// The spokes are shared rows: their weights the same in both patches (the Coons blends
// agree on them), and so are their points once solved.
@@ -634,20 +671,21 @@ impl Quilt {
unknowns - 1
};
let centre_id = next();
let spoke_ids: Vec<Vec<usize>> = (0..n).map(|_| (1..c - 1).map(|_| next()).collect()).collect();
let spoke_ids: Vec<Vec<usize>> = spaces.iter().map(|sp| (1..sp.count().saturating_sub(1)).map(|_| next()).collect()).collect();
let mut slots = Vec::with_capacity(n);
for k in 0..n {
let prev = (k + n - 1) % n;
let mut s = vec![None; c * c];
for j in 1..c {
for i in 1..c {
let id = match (i == c - 1, j == c - 1) {
let [cu, cv] = patches.get(k).map(Patch::counts).ok_or_else(|| SplineError::Invalid("patch".into()))?;
let mut s = vec![None; cu * cv];
for j in 1..cv {
for i in 1..cu {
let id = match (i == cu - 1, j == cv - 1) {
(true, true) => centre_id,
(true, false) => *spoke_ids.get(k).and_then(|x| x.get(j - 1)).ok_or_else(|| SplineError::Invalid("spoke".into()))?,
(false, true) => *spoke_ids.get(prev).and_then(|x| x.get(i - 1)).ok_or_else(|| SplineError::Invalid("spoke".into()))?,
(false, false) => next(),
};
if let Some(slot) = s.get_mut(i + c * j) {
if let Some(slot) = s.get_mut(i + cu * j) {
*slot = Some(id);
}
}
@@ -664,10 +702,10 @@ impl Quilt {
Ok(Quilt { patches, slots, unknowns, pieces, spokes })
}
/// Most free control points one solve takes: about a centre (`shared` spaces) the system is
/// dense, for one patch banded.
/// Most free control points one solve takes, one patch or several about a centre.
fn most_unknowns(shared: bool) -> usize {
if shared { MAX_UNKNOWN_POINTS } else { MAX_BANDED_POINTS }
let _ = shared;
MAX_BANDED_POINTS
}
/// Write the unknowns' values into every patch that holds them.
@@ -988,8 +1026,10 @@ pub fn iso_fill(
let stations = stations(edges, &quilt, &mut *across, &corners)?;
let spaces = quilt.patches.first().map(|p| p.spaces.clone()).ok_or_else(|| SplineError::Invalid("no patch".into()))?;
let shared = !quilt.spokes.is_empty();
// Rows enough for the conditions from opposite sides not to share control points.
let cramped = spaces.clone().map(|s| s.count() < 2 * (order + 1));
// Rows enough for the conditions from opposite sides not to share control points, in
// every patch.
let fewest = |d: usize| quilt.patches.iter().filter_map(|p| p.spaces.get(d).map(Space::count)).min().unwrap_or(0);
let cramped = [fewest(0), fewest(1)].map(|c| c < 2 * (order + 1));
if cramped.iter().any(|c| *c) && refinable(&spans, cramped, shared, quilt.unknowns) {
halve(&mut extra, &mut spans, &spaces, cramped, shared);
continue;
@@ -1032,10 +1072,19 @@ fn refinable(spans: &[usize; 2], wanted: [bool; 2], shared: bool, unknowns: usiz
spans_ok && unknowns.saturating_mul(2usize.pow(grows)) <= Quilt::most_unknowns(shared)
}
/// Halve every span of the spaces in the `wanted` directions (both when the patches share one
/// space): the breaks that do it added to `extra`.
/// Halve every span of the spaces in the `wanted` directions: the breaks that do it added to
/// `extra`. About a centre, every spoke's space takes the middles of a uniform grid as fine as
/// the refinement has reached.
fn halve(extra: &mut [Vec<f64>; 2], spans: &mut [usize; 2], spaces: &[Space; 2], wanted: [bool; 2], shared: bool) {
let wanted = if shared { [true; 2] } else { wanted };
if shared {
// Each spoke's space has the breaks of its own sides: every one of them gets the same
// further breaks, the middles of the uniform grid at the level reached so far.
let n = spans[0];
extra[0].extend((0..n).map(|i| (2 * i + 1) as f64 / (2 * n) as f64));
spans[0] *= 2;
spans[1] *= 2;
return;
}
for (((e, n), s), w) in extra.iter_mut().zip(spans.iter_mut()).zip(spaces).zip(wanted) {
if w {
e.extend(breaks(s).windows(2).map(|w| 0.5 * (w[0] + w[1])));
@@ -1157,10 +1206,10 @@ fn solve(mut quilt: Quilt, stations: &[Station], spec: &IsoSpec) -> SplineResult
let mut located: Vec<(usize, [f64; 2])> = Vec::new();
let mut report = Achieved::default();
let mut along = Along::default();
let spoke_count = quilt.patches.first().map_or(0, |p| station_count(&p.spaces[0]));
let spoke_count = quilt.patches.iter().map(|p| station_count(&p.spaces[0])).max().unwrap_or(0);
let top = stations.iter().map(Station::order).max().unwrap_or(1);
// The mean span of each space (the same in every patch).
let span = quilt.patches.first().map_or([1.0; 2], |p| p.spaces.clone().map(|s| 1.0 / breaks(&s).len().saturating_sub(1).max(1) as f64));
// The mean span of each space of a patch.
let span = |p: &Patch| p.spaces.clone().map(|s| 1.0 / breaks(&s).len().saturating_sub(1).max(1) as f64);
let rounds = if top >= 2 { ROUNDS_PER_ORDER * top } else { ROUNDS };
let smooth = knot_line_rows(&quilt, spec.angle_tol)?;
for round in 0..rounds {
@@ -1168,7 +1217,7 @@ fn solve(mut quilt: Quilt, stations: &[Station], spec: &IsoSpec) -> SplineResult
for s in stations {
let Some(patch) = quilt.patches.get(s.patch) else { continue };
// The span across the side: of v for sides 0 and 2, of u for 1 and 3.
linkage_rows(&mut rows, patch, s, span.get(1 - s.side % 2).copied().unwrap_or(1.0))?;
linkage_rows(&mut rows, patch, s, span(patch).get(1 - s.side % 2).copied().unwrap_or(1.0))?;
}
// Across each spoke the two patches' derivatives away from it are opposed.
for &(left, right) in &quilt.spokes {
@@ -1365,7 +1414,7 @@ fn gram(s: &Space, m: usize) -> SplineResult<Vec<Vec<Vec<f64>>>> {
fn least_squares(quilt: &Quilt, rows: &[Row], energy: &[Vec<(usize, usize, f64)>]) -> SplineResult<Vec<Vec3>> {
let dim = 3 * quilt.unknowns;
let slot = |p: usize, flat: usize| quilt.slots.get(p).and_then(|s| s.get(flat)).copied().flatten();
let mut a = Normal::new(dim, bandwidth(quilt, rows, energy));
let mut a = if quilt.spokes.is_empty() { Normal::new(dim, bandwidth(quilt, rows, energy)) } else { Normal::Blocks(BlockNormal::new(quilt)) };
let mut b = vec![0.0; dim];
let value = |p: usize, flat: usize| quilt.patches.get(p).and_then(|x| x.net.get(flat)).copied().unwrap_or(Vec3::ZERO);
let mut condition_trace = 0.0;
@@ -1454,6 +1503,7 @@ fn bandwidth(quilt: &Quilt, rows: &[Row], energy: &[Vec<(usize, usize, f64)>]) -
enum Normal {
Band(crate::fill::Band),
Dense(Vec<f64>, usize),
Blocks(BlockNormal),
}
impl Normal {
@@ -1470,6 +1520,7 @@ impl Normal {
*x += v;
}
}
Normal::Blocks(m) => m.add(r, s, v),
}
}
@@ -1477,10 +1528,189 @@ impl Normal {
match self {
Normal::Band(m) => m.factor_rows()?.substitute(b),
Normal::Dense(a, n) => cholesky(a, b, n),
Normal::Blocks(m) => m.solve(b),
}
}
}
/// The normal equations of patches about a centre, solved by blocks: each patch's interior
/// unknowns (coordinates of control points only that patch holds, coupled to no other patch's)
/// form a banded block, eliminated exactly onto the shared unknowns (the spokes', the centre's,
/// and any a row couples across patches) by their Schur complement, which is solved dense; the
/// interiors then follow by back substitution. Entries are kept sparse until the blocks are
/// known (callers add both halves of the symmetric matrix).
struct BlockNormal {
/// Each coordinate's patch when only one patch holds its point, else `None`.
owner: Vec<Option<usize>>,
entries: std::collections::HashMap<(usize, usize), f64>,
}
impl BlockNormal {
fn new(quilt: &Quilt) -> BlockNormal {
let mut holders: Vec<Vec<usize>> = vec![Vec::new(); quilt.unknowns];
for (p, slots) in quilt.slots.iter().enumerate() {
for id in slots.iter().flatten() {
if let Some(h) = holders.get_mut(*id)
&& !h.contains(&p)
{
h.push(p);
}
}
}
let owner = holders.iter().flat_map(|h| {
let o = if let [p] = h.as_slice() { Some(*p) } else { None };
[o; 3]
});
BlockNormal { owner: owner.collect(), entries: std::collections::HashMap::new() }
}
fn add(&mut self, r: usize, s: usize, v: f64) {
if v != 0.0 {
*self.entries.entry((r, s)).or_insert(0.0) += v;
}
}
fn solve(mut self, b: Vec<f64>) -> SplineResult<Vec<f64>> {
let n = b.len();
// A coordinate coupled to another patch's interior is shared too.
let coupled: Vec<usize> = self
.entries
.keys()
.filter(|(r, c)| matches!((self.owner.get(*r).copied().flatten(), self.owner.get(*c).copied().flatten()), (Some(a), Some(b)) if a != b))
.flat_map(|(r, c)| [*r, *c])
.collect();
for x in coupled {
if let Some(o) = self.owner.get_mut(x) {
*o = None;
}
}
let shared: Vec<usize> = (0..n).filter(|x| self.owner.get(*x).copied().flatten().is_none()).collect();
if shared.len() > MAX_SHARED_UNKNOWNS {
return Err(SplineError::TooLarge(format!(
"{} unknowns shared by the patches about the centre (at most {MAX_SHARED_UNKNOWNS})",
shared.len()
)));
}
let mut place = vec![usize::MAX; n];
for (i, x) in shared.iter().enumerate() {
if let Some(slot) = place.get_mut(*x) {
*slot = i;
}
}
let patches = self.owner.iter().flatten().copied().max().map_or(0, |m| m + 1);
let mut interior: Vec<Vec<usize>> = vec![Vec::new(); patches];
for (x, o) in self.owner.iter().enumerate() {
if let Some(p) = o
&& let Some(list) = interior.get_mut(*p)
{
if let Some(slot) = place.get_mut(x) {
*slot = list.len();
}
list.push(x);
}
}
let m = shared.len();
// The shared block, and per patch its block, its coupling to the shared unknowns.
let mut s_mat = vec![0.0; m * m];
let mut blocks: Vec<std::collections::HashMap<(usize, usize), f64>> = vec![std::collections::HashMap::new(); patches];
let mut couple: Vec<std::collections::HashMap<(usize, usize), f64>> = vec![std::collections::HashMap::new(); patches];
for ((r, c), v) in std::mem::take(&mut self.entries) {
let (or, oc) = (self.owner.get(r).copied().flatten(), self.owner.get(c).copied().flatten());
let (pr, pc) = (place.get(r).copied().unwrap_or(0), place.get(c).copied().unwrap_or(0));
match (or, oc) {
(None, None) => {
if let Some(x) = s_mat.get_mut(pr * m + pc) {
*x += v;
}
}
(Some(p), Some(_)) => {
if let Some(blk) = blocks.get_mut(p) {
*blk.entry((pr, pc)).or_insert(0.0) += v;
}
}
// Interior row, shared column (the transposed entry is its mirror).
(Some(p), None) => {
if let Some(cp) = couple.get_mut(p) {
*cp.entry((pr, pc)).or_insert(0.0) += v;
}
}
(None, Some(_)) => {}
}
}
let mut rhs: Vec<f64> = shared.iter().map(|x| b.get(*x).copied().unwrap_or(0.0)).collect();
let mut solved_parts: Vec<(crate::fill::Band, Vec<f64>, Vec<(usize, Vec<f64>)>)> = Vec::with_capacity(patches);
for p in 0..patches {
let ids = interior.get(p).map(Vec::as_slice).unwrap_or(&[]);
let k = ids.len();
let blk = blocks.get(p).cloned().unwrap_or_default();
let bw = blk.keys().map(|(r, c)| r.abs_diff(*c)).max().unwrap_or(0);
let mut band = crate::fill::Band::new(k.max(1), bw);
for (&(r, c), &v) in &blk {
band.add(r, c, v);
}
if k == 0 {
solved_parts.push((band, Vec::new(), Vec::new()));
continue;
}
let band = band.factor_rows()?;
// g = A_kk⁻¹ b_k; per shared column j coupled to this patch, z_j = A_kk⁻¹ A_k,j.
let bk: Vec<f64> = ids.iter().map(|x| b.get(*x).copied().unwrap_or(0.0)).collect();
let g = band.substitute(bk)?;
let mut columns: std::collections::BTreeMap<usize, Vec<f64>> = std::collections::BTreeMap::new();
for (&(r, j), &v) in couple.get(p).into_iter().flatten() {
if let Some(cell) = columns.entry(j).or_insert_with(|| vec![0.0; k]).get_mut(r) {
*cell += v;
}
}
let mut z: Vec<(usize, Vec<f64>)> = Vec::with_capacity(columns.len());
for (j, col) in columns {
z.push((j, band.substitute(col)?));
}
// S −= A_Bk·Z, rhs −= A_Bk·g, A_Bk the transpose of the coupling.
let coupling = couple.get(p).cloned().unwrap_or_default();
let mut by_column: std::collections::BTreeMap<usize, Vec<(usize, f64)>> = std::collections::BTreeMap::new();
for (&(r, j), &v) in &coupling {
by_column.entry(j).or_default().push((r, v));
}
for (i, entries) in &by_column {
let dot = |w: &[f64]| entries.iter().map(|(r, v)| v * w.get(*r).copied().unwrap_or(0.0)).sum::<f64>();
if let Some(x) = rhs.get_mut(*i) {
*x -= dot(&g);
}
for (j, zj) in &z {
if let Some(x) = s_mat.get_mut(i * m + j) {
*x -= dot(zj);
}
}
}
solved_parts.push((band, g, z));
}
let xs = if m > 0 { cholesky(s_mat, rhs, m)? } else { Vec::new() };
let mut x = vec![0.0; n];
for (i, id) in shared.iter().enumerate() {
if let Some(slot) = x.get_mut(*id) {
*slot = xs.get(i).copied().unwrap_or(0.0);
}
}
for (p, (_, g, z)) in solved_parts.iter().enumerate() {
let ids = interior.get(p).map(Vec::as_slice).unwrap_or(&[]);
for (r, id) in ids.iter().enumerate() {
let mut v = g.get(r).copied().unwrap_or(0.0);
for (j, zj) in z {
v -= zj.get(r).copied().unwrap_or(0.0) * xs.get(*j).copied().unwrap_or(0.0);
}
if let Some(slot) = x.get_mut(*id) {
*slot = v;
}
}
}
if x.iter().any(|v| !v.is_finite()) {
return invalid("the patches' equations have no finite solution");
}
Ok(x)
}
}
/// Solve the symmetric positive definite `a·x = b` (dense, `n × n`).
fn cholesky(mut a: Vec<f64>, mut b: Vec<f64>, n: usize) -> SplineResult<Vec<f64>> {
let at = |a: &[f64], r: usize, c: usize| a.get(r * n + c).copied().unwrap_or(0.0);
@@ -1648,19 +1878,37 @@ fn nearest(quilt: &Quilt, p: Vec3) -> (usize, [f64; 2]) {
(k, [u, v])
}
/// Whether a patch folds back on itself: its normal turns against the middle's somewhere on a
/// grid (clear of a three-sided patch's pole at u = 0, where the normal is undefined).
/// Whether a patch folds back on itself: on a grid of its parameters, its normal reverses between
/// neighbouring points (the surface turns back over itself), or vanishes inside it. A patch may
/// turn its normal through more than a right angle overall (a dome meeting a tube's wall, a
/// window round more than half a cylinder): only a reversal between neighbours is a fold. The
/// normal may vanish at a corner (where two sides run on straight, as on a closed loop's pieces)
/// and on a three-sided patch's pole at u = 0.
fn folds(patch: &Patch) -> bool {
let Some(mid) = patch.normal(0.5, 0.5) else { return true };
for i in 0..=FOLD_SAMPLES {
if patch.pole && i == 0 {
continue;
let n = FOLD_SAMPLES;
if patch.normal(0.5, 0.5).is_none() {
return true;
}
let at = |i: usize, j: usize| patch.normal(i as f64 / n as f64, j as f64 / n as f64);
let mut grid: Vec<Option<Vec3>> = Vec::with_capacity((n + 1) * (n + 1));
for i in 0..=n {
for j in 0..=n {
let normal = at(i, j);
let excused = (patch.pole && i == 0) || ((i == 0 || i == n) && (j == 0 || j == n));
if normal.is_none() && !excused {
return true;
}
grid.push(normal);
}
for j in 0..=FOLD_SAMPLES {
let (u, v) = (i as f64 / FOLD_SAMPLES as f64, j as f64 / FOLD_SAMPLES as f64);
match patch.normal(u, v) {
Some(n) if n.dot(mid) > 0.0 => {}
_ => return true,
}
let get = |i: usize, j: usize| grid.get(i * (n + 1) + j).copied().flatten();
for i in 0..=n {
for j in 0..=n {
let Some(a) = get(i, j) else { continue };
for (k, l) in [(i + 1, j), (i, j + 1)] {
if k <= n && l <= n && get(k, l).is_some_and(|b| a.dot(b) <= 0.0) {
return true;
}
}
}
}
+14 -1
View File
@@ -164,8 +164,21 @@ fn check_face(name: &str, open: &Body, fill: &Body) -> f64 {
assert!(fill.is_surface());
assert!(fill.face_count() >= 1, "{name}: a face");
let (own, made) = (open.record(), fill.record());
// The same kind of curve on the same curve it is parameterised on, to rounding (SMLib makes a
// conic's frame and NURBS form again on a round trip, the last bit of a coordinate apart).
let close = |p: &[f64], q: &[f64]| p.len() == q.len() && p.iter().zip(q).all(|(x, y)| (x - y).abs() <= 1e-12 * (1.0 + x.abs().max(y.abs())));
let same = |c: &b::Curve, d: &b::Curve| match (c, d) {
(b::Curve::Spline { knots: k, points: p }, b::Curve::Spline { knots: l, points: q }) => {
k == l && p.len() == q.len() && p.iter().zip(q).all(|(x, y)| close(x, y))
}
(b::Curve::RationalSpline { knots: k, homogeneous: p }, b::Curve::RationalSpline { knots: l, homogeneous: q }) => {
k == l && p.len() == q.len() && p.iter().zip(q).all(|(x, y)| close(x, y))
}
_ => c == d,
};
let kind = |e: &b::Edge| std::mem::discriminant(&e.curve);
for e in made.edges.iter().filter(|e| e.uses.len() == 1) {
assert!(own.edges.iter().any(|o| o.curve == e.curve), "{name}: an edge that is not the body's");
assert!(own.edges.iter().any(|o| kind(o) == kind(e) && same(o.parameters(), e.parameters())), "{name}: an edge that is not the body's");
}
let faces = Faces::of(fill);
let tol = face_tolerance(open);