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:
@@ -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
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in New Issue
Block a user