OneCAD/crates/geom/src/network.rs

//! Surfaces through curve networks (Surface › Boundary): one non-rational B-spline surface
//! through curves in one direction (a loft that skins them), or through curves in two
//! directions that cross each other (a Gordon surface; with two curves each way, the bilinearly
//! blended Coons patch). A boundary curve may carry a continuity condition with a neighbouring
//! face ([`CrossFace`]): G1, the surface leaves that face tangent to it, or G2, with its normal
//! curvature as well.
//!
//! Method:
//! - Each curve is measured by (normalised) arc length. Where curves of the two directions cross
//!   ([`closest`]: refused when they miss by more than the crossing tolerance, or cross twice),
//!   the crossing positions give the network's parameters: `ū_j` (where v-curve `j` crosses the
//!   u-curves) and `v̄_i` the other way, averages of the relative positions over the curves.
//!   With curves in one direction only, `v̄_i` is the mean distance between neighbours (chord
//!   length, NURBS Book §9.2.1 applied across).
//! - Each curve is reparameterised onto the network parameter by a monotone cubic through its
//!   crossings, so that every u-curve passes crossing `j` at `ū_j`; the small gap at a crossing
//!   (within tolerance) is closed by moving each curve onto the crossing's mid-point, the move
//!   spread linearly between crossings.
//! - All curves of one direction, and the cross-boundary derivative functions, are fitted in one
//!   common cubic spline space whose breaks include every crossing parameter (refined until each
//!   is within tolerance): so they are compatible from the start and pass exactly through the
//!   crossing points.
//! - The surface is Gordon's `S = P_u + P_v − P_uv` (W. J. Gordon, "Spline-blended surface
//!   interpolation through curve networks", 1969; the NURBS Book, ch. 10, interpolation of a
//!   bidirectional curve network): `P_u` interpolates the u-curves across v (skinning: the same
//!   interpolation applied to every column of control points), `P_v` the v-curves across u, and
//!   `P_uv` the crossing points both ways, by the same two interpolation operators. `S` then
//!   reproduces every curve. Two curves each way and linear operators give the bilinearly blended
//!   Coons patch (S. A. Coons, 1967); curves in one direction only give `S = P_u`.
//! - A continuity condition enters the across-v operator as Hermite end conditions (NURBS Book
//!   §9.2.2): the surface's first (G1) and second (G2) v-derivatives along the boundary curve.
//!   The first lies in the face's tangent plane, pointing away from the face (or into it at the
//!   far end); the second has the normal component `II(T, T)` that matches the face's normal
//!   curvature in that direction (the face's second fundamental form). A curve that crosses
//!   such a boundary is part of the surface, so it must already leave the face tangent to it
//!   (G1) and with its curvature (G2), within tolerance; otherwise the network is refused,
//!   naming the curve.
//! - The three surfaces are brought into one space ([`crate::spline_space::embed`]: Bézier degree
//!   elevation and knot insertion) and summed.
//!
//! - A side may collapse to a point ([`PointCurve`]: the apex of a three-sided patch, where the
//!   two sides beside it meet). The curves through it cross it at the point itself, so the side
//!   stays one point; the surface is singular there, as a three-sided tensor patch must be.
//!
//! Continuity conditions may sit on curves of one direction only (on two boundaries that meet
//! at a corner the cross derivatives would also have to agree on the twist there: not supported
//! yet), and only on the first and last curves of that direction. Closed curves are not
//! supported yet.
//!
//! Input is hostile: sizes are capped, every evaluation is checked, and failures are
//! [`SplineError`]s naming the curves; nothing here panics.

use crate::Vec3;
use crate::bspline::{NurbsSurface, SplineError, SplineResult, invalid};
use crate::spline_space::{Cond, Interpolant, Linear, Monotone, Space, embed};

/// Most curves in one direction of a network.
pub const MAX_NETWORK_CURVES: usize = 32;
/// Most spans of the common fitting space in one direction.
const MAX_SPANS: usize = 512;
/// Fewest spans the fitting starts with in one direction.
const MIN_SPANS: usize = 8;
/// Samples of a curve's arc-length table.
const TABLE: usize = 256;
/// How far a curve that crosses a G1 or G2 boundary may lean out of the face's tangent plane
/// there (radians, about 1°).
const TANGENT_TOL: f64 = 0.0175;
/// How much a curve that crosses a G2 boundary may differ from the face's normal curvature in
/// its direction there, relative to that curvature (or to one over the network's size, when
/// larger).
const CURVATURE_TOL: f64 = 0.02;

/// A curve of a network: its points along a parameter running over `[0, 1]` (any regular
/// parameterisation; the network measures its arc length).
pub trait NetCurve {
    fn point(&mut self, t: f64) -> Option<Vec3>;

    /// A side collapsed to a point (a three-sided patch: the apex where two sides meet). Any
    /// other curve of no length is refused.
    fn is_point(&self) -> bool {
        false
    }
}

/// A side of a network collapsed to one point: the apex of a three-sided patch, where the two
/// sides beside it meet.
pub struct PointCurve(pub Vec3);

impl NetCurve for PointCurve {
    fn point(&mut self, _: f64) -> Option<Vec3> {
        Some(self.0)
    }

    fn is_point(&self) -> bool {
        true
    }
}

/// A face along a boundary curve, seen from a point of the curve.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FaceFrame {
    /// The face's unit normal there.
    pub normal: Vec3,
    /// A unit vector in the face's tangent plane, square to the curve, pointing away from the
    /// face (out across its edge).
    pub outward: Vec3,
    /// The face's second fundamental form against `normal` (`II(w, w)`: the normal component of
    /// the second derivative of a curve on the face with first derivative `w`), in the
    /// orthonormal basis of the tangent asked about `t` (made unit in the tangent plane, running
    /// the way it was given) and `outward` `b`: `[II(t, t), II(t, b), II(b, b)]`.
    pub form: [f64; 3],
}

/// The face a boundary curve runs along: its frame at a point of the curve (`tangent`: the
/// curve's direction there, either way).
pub trait CrossFace {
    fn frame(&mut self, at: Vec3, tangent: Vec3) -> Option<FaceFrame>;
}

/// How smoothly a surface meets a neighbouring face across a boundary curve.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Continuity {
    /// Position only.
    #[default]
    G0,
    /// Tangent: the same tangent plane along the curve.
    G1,
    /// Curvature: the same tangent plane and normal curvature along the curve.
    G2,
}

impl Continuity {
    /// The number of cross-boundary derivatives it fixes.
    pub fn order(self) -> usize {
        match self {
            Continuity::G0 => 0,
            Continuity::G1 => 1,
            Continuity::G2 => 2,
        }
    }
}

/// One curve of a network: a name for messages, the curve, and its continuity with a face.
pub struct NetworkCurve<'a> {
    pub label: String,
    pub curve: Box<dyn NetCurve + 'a>,
    pub condition: Option<(Continuity, Box<dyn CrossFace + 'a>)>,
}

/// The tolerances of a network (mm): how close curves must come to cross, and how far the fitted
/// curves may stray from the given ones.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Tolerances {
    pub cross: f64,
    pub fit: f64,
}

/// A curve measured by arc length: `point(s)` with `s` in `[0, 1]` (reversed when `flipped`).
struct Track<'a> {
    label: String,
    curve: Box<dyn NetCurve + 'a>,
    /// Normalised arc length and curve parameter at each table sample.
    s: Vec<f64>,
    t: Vec<f64>,
    pts: Vec<Vec3>,
    length: f64,
    flipped: bool,
    /// A side collapsed to a point ([`PointCurve`]).
    point: bool,
    /// The finite-difference step of [`Track::ders`]: a quarter of the smallest table cell.
    step: f64,
    condition: Option<(Continuity, Box<dyn CrossFace + 'a>)>,
}

impl<'a> Track<'a> {
    fn new(c: NetworkCurve<'a>) -> SplineResult<Track<'a>> {
        let NetworkCurve { label, mut curve, condition } = c;
        let mut pts = Vec::with_capacity(TABLE + 1);
        let mut t = Vec::with_capacity(TABLE + 1);
        for k in 0..=TABLE {
            let tk = k as f64 / TABLE as f64;
            let p = curve.point(tk).filter(|p| p.is_finite()).ok_or_else(|| SplineError::Invalid(format!("{label} can't be evaluated")))?;
            pts.push(p);
            t.push(tk);
        }
        let mut s = vec![0.0];
        let mut acc = 0.0;
        for w in pts.windows(2) {
            acc += w[0].dist(w[1]);
            s.push(acc);
        }
        let point = curve.is_point();
        if point {
            // Its parameter runs evenly: every value is the same point.
            if acc > 1e-9 || !acc.is_finite() {
                return invalid(format!("{label} is meant to be a point but moves"));
            }
            if condition.as_ref().is_some_and(|(g, _)| *g != Continuity::G0) {
                return invalid(format!("{label} is a point: a continuity condition needs a curve"));
            }
            let step = step(&t);
            return Ok(Track { label, curve, s: t.clone(), t, pts, length: 0.0, flipped: false, point, step, condition: None });
        }
        if !(acc > 1e-9 && acc.is_finite()) {
            return invalid(format!("{label} has no length"));
        }
        for x in &mut s {
            *x /= acc;
        }
        let condition = condition.filter(|(g, _)| *g != Continuity::G0);
        let step = step(&s);
        Ok(Track { label, curve, s, t, pts, length: acc, flipped: false, point, step, condition })
    }

    fn continuity(&self) -> Continuity {
        self.condition.as_ref().map_or(Continuity::G0, |(g, _)| *g)
    }

    /// The point at normalised arc length `s` (clamped to `[0, 1]`).
    fn point(&mut self, s: f64) -> SplineResult<Vec3> {
        let s = if self.flipped { 1.0 - s } else { s }.clamp(0.0, 1.0);
        let k = self.s.partition_point(|x| *x <= s).saturating_sub(1).min(TABLE - 1);
        let (s0, s1, t0, t1) = (self.s[k], self.s[k + 1], self.t[k], self.t[k + 1]);
        let t = if s1 > s0 { t0 + (t1 - t0) * (s - s0) / (s1 - s0) } else { t0 };
        self.curve.point(t).filter(|p| p.is_finite()).ok_or_else(|| SplineError::Invalid(format!("{} can't be evaluated", self.label)))
    }

    /// The table's points in the curve's current direction.
    fn polyline(&self) -> Vec<Vec3> {
        if self.flipped { self.pts.iter().rev().copied().collect() } else { self.pts.clone() }
    }

    /// The first two derivatives by `s` at `s` (one-sided at the ends), by finite differences
    /// within one table cell.
    fn ders(&mut self, s: f64) -> SplineResult<(Vec3, Vec3)> {
        let h = self.step;
        if s - 2.0 * h < 0.0 {
            let f: Vec<Vec3> = (0..4).map(|k| self.point(s + k as f64 * h)).collect::<SplineResult<_>>()?;
            Ok(((f[0] * -3.0 + f[1] * 4.0 - f[2]) / (2.0 * h), (f[0] * 2.0 - f[1] * 5.0 + f[2] * 4.0 - f[3]) / (h * h)))
        } else if s + 2.0 * h > 1.0 {
            let f: Vec<Vec3> = (0..4).map(|k| self.point(s - k as f64 * h)).collect::<SplineResult<_>>()?;
            Ok(((f[0] * 3.0 - f[1] * 4.0 + f[2]) / (2.0 * h), (f[0] * 2.0 - f[1] * 5.0 + f[2] * 4.0 - f[3]) / (h * h)))
        } else {
            let (a, b, c) = (self.point(s - h)?, self.point(s)?, self.point(s + h)?);
            Ok(((c - a) / (2.0 * h), (a - b * 2.0 + c) / (h * h)))
        }
    }
}

/// The finite-difference step along a table of parameters: a quarter of its smallest cell, at
/// most 1e-3.
fn step(s: &[f64]) -> f64 {
    let cell = s.windows(2).map(|w| w[1] - w[0]).filter(|d| *d > 0.0).fold(f64::INFINITY, f64::min);
    (cell / 4.0).min(1e-3)
}

/// Where two curves cross: the arc-length positions on each and the mid-point between them.
#[derive(Clone, Copy, Debug)]
struct Crossing {
    s: f64,
    r: f64,
    at: Vec3,
}

/// The one place where `a` and `b` come within `tol` of each other. Refused when they don't, or
/// do at two places.
fn closest(a: &mut Track, b: &mut Track, tol: f64) -> SplineResult<Crossing> {
    let (pa, pb) = (a.polyline(), b.polyline());
    let longest = |p: &[Vec3]| p.windows(2).map(|w| w[0].dist(w[1])).fold(0.0, f64::max);
    let near = tol + longest(&pa) + longest(&pb);
    // Distance from each sample of `a` to the polyline of `b`, and the nearest segment.
    let mut d = Vec::with_capacity(pa.len());
    for p in &pa {
        let mut best = (f64::INFINITY, 0usize);
        for (k, w) in pb.windows(2).enumerate() {
            let x = p.dist_to_segment(w[0], w[1]);
            if x < best.0 {
                best = (x, k);
            }
        }
        d.push(best);
    }
    // Runs of samples near `b`: one candidate crossing each, refined from its nearest sample.
    let n = d.len();
    let mut starts = Vec::new();
    let mut k = 0;
    while k < n {
        if d[k].0 > near {
            k += 1;
            continue;
        }
        let mut m = k;
        while k < n && d[k].0 <= near {
            if d[k].0 < d[m].0 {
                m = k;
            }
            k += 1;
        }
        starts.push(m);
    }
    if starts.is_empty() {
        starts.push((0..n).min_by(|x, y| d[*x].0.total_cmp(&d[*y].0)).unwrap_or(0));
    }
    let mut found: Vec<Crossing> = Vec::new();
    let mut miss: Option<(f64, Vec3)> = None;
    for m in starts {
        let c = refine(a, b, m as f64 / TABLE as f64, (d[m].1 as f64 + 0.5) / TABLE as f64)?;
        let gap = a.point(c.s)?.dist(b.point(c.r)?);
        if gap <= tol {
            if !found.iter().any(|f| (f.s - c.s).abs() < 1e-6 && (f.r - c.r).abs() < 1e-6) {
                found.push(c);
            }
        } else if miss.is_none_or(|(g, _)| gap < g) {
            miss = Some((gap, c.at));
        }
    }
    match found.as_slice() {
        [c] => Ok(*c),
        [] => {
            let (gap, at) = miss.unwrap_or((f64::INFINITY, Vec3::ZERO));
            invalid(format!(
                "{} and {} don't meet: they pass {gap:.4} mm apart near ({:.3}, {:.3}, {:.3}) (the crossing tolerance is {tol} mm)",
                a.label, b.label, at.x, at.y, at.z
            ))
        }
        _ => invalid(format!("{} and {} cross more than once", a.label, b.label)),
    }
}

/// The closest points of `a` and `b` near `(s, r)`: Gauss–Newton on `|a(s) − b(r)|²`, the
/// parameters kept in `[0, 1]`.
fn refine(a: &mut Track, b: &mut Track, mut s: f64, mut r: f64) -> SplineResult<Crossing> {
    let h = 1e-7;
    let slope = |t: &mut Track, x: f64| -> SplineResult<Vec3> {
        let (x0, x1) = ((x - h).max(0.0), (x + h).min(1.0));
        Ok((t.point(x1)? - t.point(x0)?) / (x1 - x0))
    };
    for _ in 0..40 {
        let (pa, pb) = (a.point(s)?, b.point(r)?);
        let (da, db) = (slope(a, s)?, slope(b, r)?);
        let e = pa - pb;
        // Normal equations of the 3×2 system [da, −db]·(Δs, Δr) = −e.
        let (m11, m12, m22) = (da.dot(da), -da.dot(db), db.dot(db));
        let (g1, g2) = (-da.dot(e), db.dot(e));
        let det = m11 * m22 - m12 * m12;
        let (ds, dr) = if det.abs() > 1e-14 * (m11 * m22).max(1e-300) {
            ((g1 * m22 - m12 * g2) / det, (m11 * g2 - m12 * g1) / det)
        } else {
            // Parallel there: a plain step along the gradient.
            (g1 / m11.max(1e-300), g2 / m22.max(1e-300))
        };
        let (ns, nr) = ((s + ds).clamp(0.0, 1.0), (r + dr).clamp(0.0, 1.0));
        let done = (ns - s).abs() < 1e-13 && (nr - r).abs() < 1e-13;
        (s, r) = (ns, nr);
        if done {
            break;
        }
    }
    let (pa, pb) = (a.point(s)?, b.point(r)?);
    Ok(Crossing { s, r, at: (pa + pb) * 0.5 })
}

/// What an interpolation condition across the network is matched with: curve `i`'s value, the
/// `order`-th cross derivative at the first (`end` 0) or last (`end` 1) curve, or zero (the
/// slope that holds a single curve's value constant).
#[derive(Clone, Copy, Debug, PartialEq)]
enum Datum {
    Curve(usize),
    Der { end: usize, order: usize },
    Zero,
}

/// An interpolation operator across a direction: values at `params`, cross derivatives of the
/// orders in `ders` at the first and last, on `[0, 1]`.
struct Across {
    interp: Interpolant,
    data: Vec<Datum>,
}

impl Across {
    fn new(params: &[f64], ders: [usize; 2]) -> SplineResult<Across> {
        let mut conds = Vec::new();
        let mut data = Vec::new();
        for (i, &t) in params.iter().enumerate() {
            conds.push(Cond { t, der: 0 });
            data.push(Datum::Curve(i));
        }
        for (end, &count) in ders.iter().enumerate() {
            let t = if end == 0 { params.first() } else { params.last() };
            let Some(&t) = t else { return invalid("no curves") };
            for order in 1..=count {
                conds.push(Cond { t, der: order });
                data.push(Datum::Der { end, order });
            }
        }
        let interp = Interpolant::lowest(conds, 0.0, 1.0)?;
        // A lone value gets a zero slope to hold it constant.
        data.resize(interp.conds().len(), Datum::Zero);
        Ok(Across { interp, data })
    }

    /// Interpolation of values given by `datum` (one per condition).
    fn fit<T: Linear>(&self, mut datum: impl FnMut(Datum) -> SplineResult<T>) -> SplineResult<Vec<T>> {
        let values: Vec<T> = self.data.iter().map(|d| if *d == Datum::Zero { Ok(T::zero()) } else { datum(*d) }).collect::<SplineResult<_>>()?;
        self.interp.fit(&values)
    }

    fn space(&self) -> &Space {
        self.interp.space()
    }

    /// The interpolant's interior knots (the fitting space must contain them).
    fn knots(&self) -> Vec<f64> {
        let [a, b] = self.space().domain();
        self.space().knots().iter().copied().filter(|k| *k > a && *k < b).collect()
    }
}

/// A function along one direction that is fitted: its values (and, at the ends, derivatives) and
/// how close the fit must come.
struct Target<'f> {
    label: String,
    value: Box<dyn FnMut(f64) -> SplineResult<Vec3> + 'f>,
    /// Derivatives (orders 1, 2, …) at the first and last parameter.
    ders: [Vec<Vec3>; 2],
    tol: f64,
}

/// The common cubic space of a direction and each target's control points in it: breaks at
/// `base` (increasing, from 0 to 1) each split into equal parts, refined until every target is
/// within its tolerance at the quarter points of every span. A G2 end gets one more knot in its
/// end span, room for its second derivative.
fn fit_direction(base: &[f64], ders: [usize; 2], targets: &mut [Target]) -> SplineResult<(Space, Vec<Vec<Vec3>>)> {
    let intervals = base.len().saturating_sub(1).max(1);
    let mut m = MIN_SPANS.div_ceil(intervals);
    loop {
        let mut breaks = Vec::with_capacity(intervals * m + 1);
        for w in base.windows(2) {
            for k in 0..m {
                breaks.push(if k == 0 { w[0] } else { w[0] + (w[1] - w[0]) * k as f64 / m as f64 });
            }
        }
        if let Some(&last) = base.last() {
            breaks.push(last);
        }
        let spans = breaks.len() - 1;
        let mut space = Space::with_breaks(3, &breaks)?;
        let mid = |k: usize| (breaks[k] + breaks[k + 1]) / 2.0;
        let mut extra = Vec::new();
        if ders[0] >= 2 {
            extra.push(mid(0));
        }
        if ders[1] >= 2 {
            extra.push(mid(spans - 1));
        }
        space = space.refined(&extra)?;
        // Values at the breaks, the end derivatives, and a value mid-span at an end without one.
        let mut conds: Vec<Cond> = breaks.iter().map(|&t| Cond { t, der: 0 }).collect();
        let mut kinds: Vec<(usize, usize)> = breaks.iter().map(|_| (0, 0)).collect();
        for (end, &count) in ders.iter().enumerate() {
            let t = if end == 0 { 0.0 } else { 1.0 };
            for order in 1..=count {
                conds.push(Cond { t, der: order });
                kinds.push((end, order));
            }
            if count == 0 {
                conds.push(Cond { t: mid(if end == 0 { 0 } else { spans - 1 }), der: 0 });
                kinds.push((0, 0));
            }
        }
        let interp = Interpolant::new(space.clone(), conds.clone())?;
        let mut ctrls = Vec::with_capacity(targets.len());
        let mut worst: Option<(f64, String)> = None;
        for tg in targets.iter_mut() {
            let data: Vec<Vec3> = conds
                .iter()
                .zip(&kinds)
                .map(|(c, (end, order))| match order {
                    0 => (tg.value)(c.t),
                    o => tg.ders.get(*end).and_then(|d| d.get(o - 1)).copied().ok_or_else(|| SplineError::Invalid("a derivative is missing".into())),
                })
                .collect::<SplineResult<_>>()?;
            let ctrl = interp.fit(&data)?;
            for k in 0..spans {
                for q in [0.25, 0.75] {
                    let t = breaks[k] + (breaks[k + 1] - breaks[k]) * q;
                    let off = space.eval(&ctrl, t, 0)?.dist((tg.value)(t)?);
                    if off > tg.tol && worst.as_ref().is_none_or(|(w, _)| off / tg.tol > *w) {
                        worst = Some((off / tg.tol, format!("{} (off by {off:.2e} at the best fit)", tg.label)));
                    }
                }
            }
            ctrls.push(ctrl);
        }
        match worst {
            None => return Ok((space, ctrls)),
            Some((_, what)) if spans * 2 > MAX_SPANS => {
                return Err(SplineError::Unsupported(format!(
                    "{what} can't be fitted closely enough: a curve with a sharp corner, or one that turns very sharply, can't be part of a boundary surface"
                )));
            }
            Some(_) => m *= 2,
        }
    }
}

/// Linear interpolation at `x` of `values` given at the increasing parameters `xs` (held
/// constant beyond the first and last; a lone value everywhere).
fn lerp_between<T: Linear>(xs: &[f64], values: &[T], x: f64) -> T {
    match (xs.len(), values.len()) {
        (0, _) | (_, 0) => T::zero(),
        (1, _) | (_, 1) => values[0],
        (n, _) => {
            let k = xs.partition_point(|t| *t <= x).saturating_sub(1).min(n - 2);
            let (x0, x1) = (xs[k], xs[k + 1]);
            let w = if x1 > x0 { ((x - x0) / (x1 - x0)).clamp(0.0, 1.0) } else { 0.0 };
            values[k].times(1.0 - w).plus(values.get(k + 1).copied().unwrap_or(values[k]).times(w))
        }
    }
}

/// How a curve runs over the network parameter: its arc-length position at network parameter
/// `x`, and the shift that puts it through the crossing points exactly.
struct Placement {
    map: Monotone,
    /// The network parameters of the crossings and each crossing's shift.
    at: Vec<f64>,
    shift: Vec<Vec3>,
}

impl Placement {
    fn point(&self, track: &mut Track, x: f64) -> SplineResult<Vec3> {
        Ok(track.point(self.map.eval(x)[0])? + lerp_between(&self.at, &self.shift, x))
    }

    /// The first two derivatives by the network parameter at `x`.
    fn ders(&self, track: &mut Track, x: f64) -> SplineResult<(Vec3, Vec3)> {
        let [s, ds, dds] = self.map.eval(x);
        let (p1, p2) = track.ders(s)?;
        // The shift is linear between crossings: its slope on the span at x.
        let slope = match self.at.len() {
            0 | 1 => Vec3::ZERO,
            n => {
                let k = self.at.partition_point(|t| *t <= x).saturating_sub(1).min(n - 2);
                let (x0, x1) = (self.at[k], self.at[k + 1]);
                if x1 > x0 { (self.shift[k + 1] - self.shift[k]) / (x1 - x0) } else { Vec3::ZERO }
            }
        };
        Ok((p1 * ds + slope, p2 * (ds * ds) + p1 * dds))
    }
}

/// A placement through `nodes` (network parameter, arc-length position), with the shifts that
/// take the curve onto `targets` at the crossings `(x, s)` it was measured at.
fn placement(track: &mut Track, nodes: &[(f64, f64)], crossings: &[(f64, f64, Vec3)]) -> SplineResult<Placement> {
    let map = Monotone::new(nodes.iter().map(|n| n.0).collect(), nodes.iter().map(|n| n.1).collect())
        .map_err(|_| SplineError::Invalid(format!("{} is crossed out of order", track.label)))?;
    let mut at = Vec::with_capacity(crossings.len());
    let mut shift = Vec::with_capacity(crossings.len());
    for &(x, s, q) in crossings {
        at.push(x);
        shift.push(q - track.point(s)?);
    }
    Ok(Placement { map, at, shift })
}

/// The frame of the face along conditioned curve `e`, with the tangent and outward directions
/// made orthonormal in its tangent plane.
struct Frame {
    n: Vec3,
    t: Vec3,
    b: Vec3,
    form: [f64; 3],
}

impl Frame {
    /// `II(w, w)` for `w = a·b + c·t`.
    fn second(&self, a: f64, c: f64) -> f64 {
        let [tt, tb, bb] = self.form;
        c * c * tt + 2.0 * a * c * tb + a * a * bb
    }
}

/// A surface through a curve network (see the module documentation): curves `u` in one
/// direction, `v` (possibly none) in the other.
pub fn network_surface(u: Vec<NetworkCurve>, v: Vec<NetworkCurve>, tol: Tolerances) -> SplineResult<NurbsSurface> {
    if !(tol.cross > 0.0 && tol.cross.is_finite() && tol.fit > 0.0 && tol.fit.is_finite()) {
        return invalid("the tolerances must be positive");
    }
    if u.len() > MAX_NETWORK_CURVES || v.len() > MAX_NETWORK_CURVES {
        return Err(SplineError::TooLarge(format!("more than {MAX_NETWORK_CURVES} curves in one direction")));
    }
    let mut us: Vec<Track> = u.into_iter().map(Track::new).collect::<SplineResult<_>>()?;
    let mut vs: Vec<Track> = v.into_iter().map(Track::new).collect::<SplineResult<_>>()?;
    for t in us.iter().chain(&vs).filter(|t| !t.point) {
        if t.pts.first().zip(t.pts.last()).is_some_and(|(a, b)| a.dist(*b) <= tol.cross) {
            return Err(SplineError::Unsupported(format!("{} is closed: closed curves in a boundary surface", t.label)));
        }
    }
    let conditioned = |ts: &[Track]| ts.iter().any(|t| t.condition.is_some());
    if conditioned(&us) && conditioned(&vs) {
        return Err(SplineError::Unsupported("continuity conditions on curves of both directions (on two boundaries that meet at a corner)".into()));
    }
    // Conditions go on the u-curves, and there are two u-curves where possible.
    if conditioned(&vs) || (us.len() < 2 && vs.len() >= 2 && !conditioned(&us)) {
        std::mem::swap(&mut us, &mut vs);
    }
    let size = us
        .iter()
        .chain(&vs)
        .flat_map(|t| t.pts.iter())
        .fold(None, |acc: Option<(Vec3, Vec3)>, p| Some(acc.map_or((*p, *p), |(lo, hi)| (lo.min(*p), hi.max(*p)))));
    let size = size.map_or(0.0, |(lo, hi)| lo.dist(hi));
    match (us.len(), vs.len()) {
        (0, _) | (1, 0) => return invalid("a boundary surface needs two curves in one direction, or crossing curves"),
        (1, _) if !conditioned(&us) => return invalid("a boundary surface needs two curves in one direction"),
        _ => {}
    }
    let (nu, nv) = (us.len(), vs.len());
    // A side collapsed to a point: one at most, with another curve beside it in its own direction,
    // and the curves the other way (if any) running from it to the far side.
    let points = |ts: &[Track]| ts.iter().filter(|t| t.point).count();
    match (points(&us), points(&vs)) {
        (0, 0) => {}
        (1, 0) if nu >= 2 && nv != 1 => {}
        (0, 1) if nv >= 2 && nu >= 2 => {}
        _ => return invalid("a point can stand for one side of the patch only, with curves running from it to the side across"),
    }

    // Crossings: x[i][j] where u-curve i meets v-curve j (s along u-curve i, r along v-curve j).
    // Where one of them is a point, the crossing is that point itself, so that every curve
    // through it is moved onto it and the side stays collapsed.
    let mut x: Vec<Vec<Crossing>> = Vec::with_capacity(nu);
    for a in us.iter_mut() {
        let mut row = Vec::with_capacity(nv);
        for b in vs.iter_mut() {
            let mut c = closest(a, b, tol.cross)?;
            if a.point {
                c.at = a.point(0.0)?;
            } else if b.point {
                c.at = b.point(0.0)?;
            }
            row.push(c);
        }
        x.push(row);
    }
    // The first curve of a direction that is not a point (orders are read along it).
    let first_curve = |ts: &[Track]| ts.iter().position(|t| !t.point).unwrap_or(0);

    // Order and orient: the u-curves in their order along the first v-curve, each v-curve running
    // from the first u-curve to the last; likewise the v-curves along the first u-curve.
    if nv >= 1 && nu >= 2 {
        let mut order: Vec<usize> = (0..nu).collect();
        let j0 = first_curve(&vs);
        order.sort_by(|a, b| x[*a][j0].r.total_cmp(&x[*b][j0].r));
        us = reorder(us, &order);
        x = reorder(x, &order);
        for j in 0..nv {
            // A point runs no way: nothing to orient.
            if vs[j].point {
                continue;
            }
            let rs: Vec<f64> = x.iter().map(|row| row[j].r).collect();
            match direction(&rs) {
                Some(true) => {}
                Some(false) => {
                    vs[j].flipped = !vs[j].flipped;
                    for row in x.iter_mut() {
                        row[j].r = 1.0 - row[j].r;
                    }
                }
                None => return invalid(format!("{} crosses the other curves out of order (or two of them at one point)", vs[j].label)),
            }
        }
    } else if nv >= 1 {
        // One conditioned u-curve: each v-curve starts on it.
        for j in 0..nv {
            if x[0][j].r > 0.5 {
                vs[j].flipped = !vs[j].flipped;
                x[0][j].r = 1.0 - x[0][j].r;
            }
        }
    }
    if nv >= 2 {
        let mut order: Vec<usize> = (0..nv).collect();
        let i0 = first_curve(&us);
        order.sort_by(|a, b| x[i0][*a].s.total_cmp(&x[i0][*b].s));
        vs = reorder(vs, &order);
        for row in x.iter_mut() {
            *row = reorder(std::mem::take(row), &order);
        }
        for (i, row) in x.iter_mut().enumerate() {
            if us[i].point {
                continue;
            }
            let ss: Vec<f64> = row.iter().map(|c| c.s).collect();
            match direction(&ss) {
                Some(true) => {}
                Some(false) => {
                    us[i].flipped = !us[i].flipped;
                    for c in row.iter_mut() {
                        c.s = 1.0 - c.s;
                    }
                }
                None => return invalid(format!("{} crosses the other curves out of order (or two of them at one point)", us[i].label)),
            }
        }
    } else {
        // No order along the u-curves: each runs the way the one before it does.
        for i in 1..nu {
            if us[i].point || us[i - 1].point {
                continue;
            }
            let (ps, pe) = (us[i - 1].point(0.0)?, us[i - 1].point(1.0)?);
            let (s, e) = (us[i].point(0.0)?, us[i].point(1.0)?);
            if s.dist(ps) + e.dist(pe) > s.dist(pe) + e.dist(ps) {
                us[i].flipped = !us[i].flipped;
                for c in x[i].iter_mut() {
                    c.s = 1.0 - c.s;
                }
            }
        }
    }

    // A point is a side: the first or last curve of its direction.
    for ts in [&us, &vs] {
        for (i, t) in ts.iter().enumerate() {
            if t.point && i != 0 && i + 1 != ts.len() {
                return invalid(format!("{} lies inside the network: a point can only stand for a side", t.label));
            }
        }
    }
    // Conditions only on the first and last u-curve.
    for (i, t) in us.iter().enumerate() {
        if t.condition.is_some() && i != 0 && i + 1 != nu {
            return invalid(format!("{} lies inside the network: continuity applies only to a boundary curve", t.label));
        }
    }
    let end_order = [us.first().map_or(0, |t| t.continuity().order()), if nu >= 2 { us.last().map_or(0, |t| t.continuity().order()) } else { 0 }];

    // Network parameters (a point has no positions along it to average).
    let rows: Vec<Vec<f64>> = x.iter().zip(&us).filter(|(_, t)| !t.point).map(|(row, _)| row.iter().map(|c| c.s).collect()).collect();
    let ubar = network_params(&rows, nv)?;
    let vbar: Vec<f64> = if nv == 0 {
        chord_params(&mut us)?
    } else if nu >= 2 {
        let cols: Vec<Vec<f64>> = (0..nv).filter(|j| !vs[*j].point).map(|j| x.iter().map(|row| row[j].r).collect()).collect();
        network_params(&cols, nu)?
    } else {
        // One conditioned curve, crossed at the start of every v-curve.
        for j in 0..nv {
            if x[0][j].r * vs[j].length > tol.cross {
                return invalid(format!("{} must start on {}: it crosses it partway along", vs[j].label, us[0].label));
            }
        }
        vec![0.0]
    };

    // A point is placed evenly: its crossings sit at the network parameters themselves.
    for (i, row) in x.iter_mut().enumerate() {
        for (j, c) in row.iter_mut().enumerate() {
            if us.get(i).is_some_and(|t| t.point) {
                c.s = ubar.get(j).copied().unwrap_or(c.s);
            }
            if vs.get(j).is_some_and(|t| t.point) {
                c.r = vbar.get(i).copied().unwrap_or(c.r);
            }
        }
    }

    // Placements: each curve through its crossings at the network parameters.
    let mut up = Vec::with_capacity(nu);
    for (i, t) in us.iter_mut().enumerate() {
        let cross: Vec<(f64, f64, Vec3)> = (0..nv).map(|j| (ubar[j], x[i][j].s, x[i][j].at)).collect();
        let nodes = place_nodes(&cross, nv);
        up.push(placement(t, &nodes, &cross)?);
    }
    let mut vp = Vec::with_capacity(nv);
    for (j, t) in vs.iter_mut().enumerate() {
        let cross: Vec<(f64, f64, Vec3)> = (0..nu).map(|i| (vbar[i], x[i][j].r, x[i][j].at)).collect();
        let nodes = place_nodes(&cross, nu);
        vp.push(placement(t, &nodes, &cross)?);
    }

    // The operators across: Π_v over the u-curves (with the end conditions), Π_u over the v-curves.
    let across_v = Across::new(&vbar, end_order)?;
    let across_u = if nv >= 1 { Some(Across::new(&ubar, [0, 0])?) } else { None };

    // Cross-boundary conditions: for each conditioned end, the frame along it, the natural
    // derivatives, and the corrections that make them agree with the v-curves at the crossings.
    let mut ends: Vec<Option<EndCondition>> = vec![None, None];
    for end in 0..2 {
        if end_order[end] == 0 {
            continue;
        }
        let i = if end == 0 { 0 } else { nu - 1 };
        let mut cond = EndCondition { end, curve: i, order: end_order[end], neighbour: None, at: Vec::new(), corr: [None, None, None, None] };
        if nu >= 2 {
            let k = if end == 0 { 1 } else { nu - 2 };
            cond.neighbour = Some((k, (vbar[k] - vbar[i]).abs()));
        }
        // The v-curves where they meet this boundary: their derivatives, checked against the face.
        let mut values: Vec<[f64; 4]> = Vec::with_capacity(nv);
        for j in 0..nv {
            let xj = ubar[j];
            let frame = end_frame(&mut us, &up, i, xj)?;
            let (d1, d2) = vp[j].ders(&mut vs[j], vbar[i])?;
            let (vl, ul) = (vs[j].label.clone(), us[i].label.clone());
            let len = d1.len();
            if !(len > 0.0) {
                return invalid(format!("{vl} has no direction where it meets {ul}"));
            }
            if d1.dot(frame.n).abs() > TANGENT_TOL.sin() * len {
                let deg = (d1.dot(frame.n).abs() / len).clamp(0.0, 1.0).asin().to_degrees();
                return invalid(format!(
                    "{vl} meets the {} boundary {ul} at {deg:.2}° to its face: it must leave the face tangent to it there",
                    if end_order[end] == 1 { "G1" } else { "G2" }
                ));
            }
            let a = d1.dot(frame.b);
            let outward = if end == 0 { a } else { -a };
            if outward <= TANGENT_TOL.sin() * len {
                return invalid(format!("{vl} turns back over the face of {ul} where it meets it"));
            }
            let c = d1.dot(frame.t);
            let (mut kb, mut kt) = (0.0, 0.0);
            if end_order[end] >= 2 {
                let tproj = frame.b * a + frame.t * c;
                let want = frame.second(a, c) / tproj.len2();
                let got = d2.dot(frame.n) / d1.len2();
                let scale = want.abs().max(1.0 / size.max(1e-9));
                if (got - want).abs() > CURVATURE_TOL * scale {
                    return invalid(format!(
                        "{vl} meets the G2 boundary {ul} with a normal curvature of {got:.5} /mm where the face has {want:.5} /mm: it must follow the face's curvature there"
                    ));
                }
                kb = d2.dot(frame.b);
                kt = d2.dot(frame.t);
            }
            values.push([a, c, kb, kt]);
        }
        cond.at = values;
        ends[end] = Some(cond);
    }
    // Corrections: Π_u through (crossing value − natural value), so each function hits the
    // v-curves' own derivatives at the crossings.
    if let Some(au) = &across_u {
        for slot in ends.iter_mut() {
            let Some(mut cond) = slot.take() else { continue };
            let mut diffs: [Vec<f64>; 4] = [Vec::new(), Vec::new(), Vec::new(), Vec::new()];
            for (&xj, at) in ubar.iter().zip(&cond.at) {
                let frame = end_frame(&mut us, &up, cond.curve, xj)?;
                let natural = cond.natural(&mut us, &up, &frame, xj)?;
                for (k, d) in diffs.iter_mut().enumerate() {
                    d.push(at[k] - natural[k]);
                }
            }
            for (k, d) in diffs.iter().enumerate() {
                let ctrl = au.fit(|datum| match datum {
                    Datum::Curve(j) => d.get(j).copied().ok_or_else(|| SplineError::Invalid("crossing".into())),
                    _ => Ok(0.0),
                })?;
                cond.corr[k] = Some(ctrl);
            }
            *slot = Some(cond);
        }
    }

    // Fit the u-direction: the u-curves, then each condition's first and second derivatives.
    let mut base_u: Vec<f64> = vec![0.0, 1.0];
    base_u.extend(ubar.iter().copied());
    if let Some(au) = &across_u {
        base_u.extend(au.knots());
    }
    let base_u = sorted_breaks(base_u);
    let (u_space, u_ctrl) = {
        let us_cell = std::cell::RefCell::new(&mut us);
        let up_ref = &up;
        let mut targets: Vec<Target> = Vec::new();
        for i in 0..nu {
            let label = us_cell.borrow()[i].label.clone();
            let cell = &us_cell;
            targets.push(Target {
                label,
                value: Box::new(move |t| {
                    let mut tracks = cell.borrow_mut();
                    up_ref[i].point(&mut tracks[i], t)
                }),
                ders: [Vec::new(), Vec::new()],
                tol: tol.fit,
            });
        }
        for cond in ends.iter().flatten() {
            let label = format!("the cross-boundary tangent along {}", us_cell.borrow()[cond.curve].label);
            let scale = cond.scale(&mut us_cell.borrow_mut(), up_ref, across_u.as_ref())?;
            for order in 1..=cond.order {
                let cell = &us_cell;
                let au = across_u.as_ref();
                targets.push(Target {
                    label: label.clone(),
                    value: Box::new(move |t| {
                        let mut tracks = cell.borrow_mut();
                        let (d1, d2) = cond.derivatives(&mut tracks, up_ref, au, t)?;
                        Ok(if order == 1 { d1 } else { d2 })
                    }),
                    ders: [Vec::new(), Vec::new()],
                    tol: scale[order - 1] * 1e-4,
                });
            }
        }
        fit_direction(&base_u, [0, 0], &mut targets)?
    };
    // Which fitted function is which: the u-curves, then per conditioned end its derivatives.
    let mut der_index: [[Option<usize>; 2]; 2] = [[None; 2]; 2];
    let mut next = nu;
    for cond in ends.iter().flatten() {
        for order in 1..=cond.order {
            der_index[cond.end][order - 1] = Some(next);
            next += 1;
        }
    }
    let u_fn = |d: Datum, a: usize| -> SplineResult<Vec3> {
        let k = match d {
            Datum::Curve(i) => Some(i),
            Datum::Der { end, order } => der_index.get(end).and_then(|e| e.get(order.wrapping_sub(1))).copied().flatten(),
            Datum::Zero => None,
        };
        Ok(k.and_then(|k| u_ctrl.get(k)).and_then(|c| c.get(a)).copied().unwrap_or(Vec3::ZERO))
    };
    // P_u: across v, column by column of the u-direction control points.
    let nu_ctrl = u_space.count();
    let mut pu: Vec<Vec<Vec3>> = Vec::with_capacity(nu_ctrl);
    for a in 0..nu_ctrl {
        pu.push(across_v.fit(|d| u_fn(d, a))?);
    }
    let v_op_space = across_v.space().clone();
    let Some(across_u) = across_u else {
        // Curves in one direction only: the skinned surface.
        return surface(&u_space, &v_op_space, &pu);
    };

    // The derivative data at each crossing of a conditioned boundary, exactly as the fitted
    // functions take them there.
    let mut cross_ders: Vec<[[Vec3; 2]; 2]> = vec![[[Vec3::ZERO; 2]; 2]; nv];
    for cond in ends.iter().flatten() {
        for (j, cd) in cross_ders.iter_mut().enumerate() {
            let (d1, d2) = cond.derivatives(&mut us, &up, Some(&across_u), ubar[j])?;
            cd[cond.end] = [d1, d2];
        }
    }

    // Fit the v-direction: the v-curves, with the conditioned ends' derivatives.
    let mut base_v: Vec<f64> = vec![0.0, 1.0];
    base_v.extend(vbar.iter().copied());
    base_v.extend(across_v.knots());
    let base_v = sorted_breaks(base_v);
    let (v_space, v_ctrl) = {
        let vs_cell = std::cell::RefCell::new(&mut vs);
        let vp_ref = &vp;
        let mut targets: Vec<Target> = Vec::new();
        for (j, cd) in cross_ders.iter().enumerate() {
            let label = vs_cell.borrow()[j].label.clone();
            let cell = &vs_cell;
            let ders = [cd[0][..end_order[0]].to_vec(), cd[1][..end_order[1]].to_vec()];
            targets.push(Target {
                label,
                value: Box::new(move |t| {
                    let mut tracks = cell.borrow_mut();
                    vp_ref[j].point(&mut tracks[j], t)
                }),
                ders,
                tol: tol.fit,
            });
        }
        fit_direction(&base_v, end_order, &mut targets)?
    };
    let nv_ctrl = v_space.count();
    // P_v: across u, row by row of the v-direction control points.
    let mut pv_rows: Vec<Vec<Vec3>> = Vec::with_capacity(nv_ctrl);
    for b in 0..nv_ctrl {
        pv_rows.push(across_u.fit(|d| match d {
            Datum::Curve(j) => v_ctrl.get(j).and_then(|c| c.get(b)).copied().ok_or_else(|| SplineError::Invalid("v-curve".into())),
            _ => Ok(Vec3::ZERO),
        })?);
    }
    // P_uv: the crossing points (and cross derivatives) across v, then across u.
    let mut cols: Vec<Vec<Vec3>> = Vec::with_capacity(nv);
    for (j, cd) in cross_ders.iter().enumerate() {
        cols.push(across_v.fit(|d| match d {
            Datum::Curve(i) => x.get(i).and_then(|row| row.get(j)).map(|c| c.at).ok_or_else(|| SplineError::Invalid("crossing".into())),
            Datum::Der { end, order } => Ok(cd.get(end).and_then(|e| e.get(order.wrapping_sub(1))).copied().unwrap_or(Vec3::ZERO)),
            Datum::Zero => Ok(Vec3::ZERO),
        })?);
    }
    let nvop = v_op_space.count();
    let mut puv_rows: Vec<Vec<Vec3>> = Vec::with_capacity(nvop);
    for b in 0..nvop {
        puv_rows.push(across_u.fit(|d| match d {
            Datum::Curve(j) => cols.get(j).and_then(|c| c.get(b)).copied().ok_or_else(|| SplineError::Invalid("crossing".into())),
            _ => Ok(Vec3::ZERO),
        })?);
    }
    // Into the common space KU × KV and summed.
    let u_op_space = across_u.space().clone();
    let pu_full: Vec<Vec<Vec3>> = pu.iter().map(|col| embed(&v_op_space, col, &v_space)).collect::<SplineResult<_>>()?;
    let pv_cols = transpose(&pv_rows.iter().map(|row| embed(&u_op_space, row, &u_space)).collect::<SplineResult<Vec<_>>>()?);
    let puv_rows_u: Vec<Vec<Vec3>> = puv_rows.iter().map(|row| embed(&u_op_space, row, &u_space)).collect::<SplineResult<_>>()?;
    let puv_cols: Vec<Vec<Vec3>> = transpose(&puv_rows_u).iter().map(|col| embed(&v_op_space, col, &v_space)).collect::<SplineResult<_>>()?;
    let mut net = Vec::with_capacity(nu_ctrl);
    for a in 0..nu_ctrl {
        let col: Vec<Vec3> = (0..nv_ctrl)
            .map(|b| {
                let get = |m: &Vec<Vec<Vec3>>| m.get(a).and_then(|c| c.get(b)).copied().unwrap_or(Vec3::ZERO);
                get(&pu_full) + get(&pv_cols) - get(&puv_cols)
            })
            .collect();
        net.push(col);
    }
    surface(&u_space, &v_space, &net)
}

/// A conditioned end of the u-direction: which curve, the derivative orders, its neighbouring
/// curve (and the parameter gap to it) for the natural tangent, the scalar values the v-curves
/// give at each crossing (`[a, c, kb, kt]`: the tangent's outward and along-curve components, the
/// second derivative's), and the corrections to the natural values (control values across u).
struct EndCondition {
    end: usize,
    curve: usize,
    order: usize,
    neighbour: Option<(usize, f64)>,
    at: Vec<[f64; 4]>,
    corr: [Option<Vec<f64>>; 4],
}

impl EndCondition {
    /// The natural `[a, c, kb, kt]` at `x`: the tangent as long as the step to the neighbouring
    /// curve, outward from the face (into it at the far end), sheared along the curve as that
    /// step is; no tangential second derivative.
    fn natural(&self, us: &mut [Track], up: &[Placement], frame: &Frame, x: f64) -> SplineResult<[f64; 4]> {
        let Some((k, gap)) = self.neighbour else { return Ok([0.0; 4]) };
        let p = up.get(self.curve).ok_or_else(|| SplineError::Invalid("curve".into()))?.point(track(us, self.curve)?, x)?;
        let q = up.get(k).ok_or_else(|| SplineError::Invalid("curve".into()))?.point(track(us, k)?, x)?;
        let step = if self.end == 0 { q - p } else { p - q };
        let gap = gap.max(1e-12);
        let a = step.len() / gap * if self.end == 0 { 1.0 } else { -1.0 };
        Ok([a, step.dot(frame.t) / gap, 0.0, 0.0])
    }

    /// The first and second v-derivatives of the surface along this boundary at `x`.
    fn derivatives(&self, us: &mut [Track], up: &[Placement], across_u: Option<&Across>, x: f64) -> SplineResult<(Vec3, Vec3)> {
        self.derivatives_framed(us, up, across_u, x).map(|(d1, d2, _)| (d1, d2))
    }

    /// [`EndCondition::derivatives`] with the face's frame there (projecting onto the face is
    /// the costly part: it is done once).
    fn derivatives_framed(&self, us: &mut [Track], up: &[Placement], across_u: Option<&Across>, x: f64) -> SplineResult<(Vec3, Vec3, Frame)> {
        let frame = end_frame(us, up, self.curve, x)?;
        let mut v = self.natural(us, up, &frame, x)?;
        if let Some(au) = across_u {
            for (k, c) in self.corr.iter().enumerate() {
                if let Some(c) = c {
                    v[k] += au.space().eval(c, x, 0)?;
                }
            }
        }
        let [a, c, kb, kt] = v;
        let d1 = frame.b * a + frame.t * c;
        let d2 = frame.n * frame.second(a, c) + frame.b * kb + frame.t * kt;
        Ok((d1, d2, frame))
    }

    /// Typical sizes of the first and second derivatives along the boundary (for fitting
    /// tolerances), checking that the tangent never turns back along it.
    fn scale(&self, us: &mut [Track], up: &[Placement], across_u: Option<&Across>) -> SplineResult<[f64; 2]> {
        let mut big = [0.0f64; 2];
        for k in 0..=32 {
            let x = k as f64 / 32.0;
            let (d1, d2, frame) = self.derivatives_framed(us, up, across_u, x)?;
            let out = d1.dot(frame.b) * if self.end == 0 { 1.0 } else { -1.0 };
            if !(out > 0.0) {
                let label = us.get(self.curve).map(|t| t.label.clone()).unwrap_or_default();
                return invalid(format!("the surface's tangent across {label} would turn back over its face"));
            }
            big = [big[0].max(d1.len()), big[1].max(d2.len())];
        }
        Ok([big[0].max(1e-9), big[1].max(big[0] * 1e-3).max(1e-9)])
    }
}

fn track<'t, 'a>(us: &'t mut [Track<'a>], i: usize) -> SplineResult<&'t mut Track<'a>> {
    us.get_mut(i).ok_or_else(|| SplineError::Invalid("curve".into()))
}

/// The face's frame along conditioned u-curve `i` at network parameter `x`.
fn end_frame(us: &mut [Track], up: &[Placement], i: usize, x: f64) -> SplineResult<Frame> {
    let place = up.get(i).ok_or_else(|| SplineError::Invalid("curve".into()))?;
    let t = track(us, i)?;
    let p = place.point(t, x)?;
    let (d1, _) = place.ders(t, x)?;
    let label = t.label.clone();
    let face = t.condition.as_mut().map(|(_, f)| f).ok_or_else(|| SplineError::Invalid(format!("{label} has no face")))?;
    let f = face
        .frame(p, d1)
        .ok_or_else(|| SplineError::Invalid(format!("the face along {label} can't be evaluated at ({:.3}, {:.3}, {:.3})", p.x, p.y, p.z)))?;
    let n = f.normal.normalized().ok_or_else(|| SplineError::Invalid(format!("the face along {label} has no normal")))?;
    let t = (d1 - n * d1.dot(n)).normalized().ok_or_else(|| SplineError::Invalid(format!("{label} runs along its face's normal")))?;
    let mut b = f.outward - n * f.outward.dot(n);
    b = (b - t * b.dot(t)).normalized().ok_or_else(|| SplineError::Invalid(format!("the face along {label} has no outward direction")))?;
    Ok(Frame { n, t, b, form: f.form })
}

/// `true` when `xs` increase strictly, `false` when they decrease strictly, `None` otherwise.
fn direction(xs: &[f64]) -> Option<bool> {
    let gap = 1e-9;
    if xs.windows(2).all(|w| w[1] - w[0] > gap) {
        Some(true)
    } else if xs.windows(2).all(|w| w[0] - w[1] > gap) {
        Some(false)
    } else {
        None
    }
}

fn reorder<T>(items: Vec<T>, order: &[usize]) -> Vec<T> {
    let mut slots: Vec<Option<T>> = items.into_iter().map(Some).collect();
    order.iter().filter_map(|&k| slots.get_mut(k).and_then(Option::take)).collect()
}

fn transpose(m: &[Vec<Vec3>]) -> Vec<Vec<Vec3>> {
    let cols = m.first().map_or(0, Vec::len);
    (0..cols).map(|c| m.iter().map(|row| row.get(c).copied().unwrap_or(Vec3::ZERO)).collect()).collect()
}

fn sorted_breaks(mut b: Vec<f64>) -> Vec<f64> {
    b.retain(|x| x.is_finite() && (0.0..=1.0).contains(x));
    b.sort_by(f64::total_cmp);
    b.dedup_by(|a, b| (*a - *b).abs() < 1e-12);
    b
}

/// The network parameters of the crossings along one direction: `rows[i][j]` is where curve `j`
/// of the other direction crosses curve `i` (arc length). With two crossings or more each curve
/// runs from its first to its last crossing; the parameters are the relative positions,
/// averaged over the curves. With one, it is its mean position along the whole curves.
fn network_params(rows: &[Vec<f64>], count: usize) -> SplineResult<Vec<f64>> {
    let n = rows.len().max(1) as f64;
    match count {
        0 => Ok(Vec::new()),
        1 => {
            let firsts: Vec<f64> = rows.iter().filter_map(|r| r.first().copied()).collect();
            let at_end = |x: f64| x <= 1e-9 || x >= 1.0 - 1e-9;
            if firsts.iter().any(|x| at_end(*x)) && !firsts.iter().all(|x| at_end(*x)) {
                return invalid("a curve crosses the others at the end of some and partway along others");
            }
            Ok(vec![firsts.iter().sum::<f64>() / n])
        }
        _ => {
            let mut out = vec![0.0; count];
            for r in rows {
                let (Some(&a), Some(&b)) = (r.first(), r.last()) else { return invalid("crossings") };
                if !(b - a > 1e-12) {
                    return invalid("the curves cross out of order");
                }
                for (o, x) in out.iter_mut().zip(r) {
                    *o += (x - a) / (b - a) / n;
                }
            }
            out[0] = 0.0;
            out[count - 1] = 1.0;
            if out.windows(2).any(|w| !(w[1] - w[0] > 1e-9)) {
                return invalid("two curves cross the others at the same place");
            }
            Ok(out)
        }
    }
}

/// Lofting parameters of curves in one direction only: cumulative mean distances between
/// neighbouring curves, from 0 to 1.
fn chord_params(us: &mut [Track]) -> SplineResult<Vec<f64>> {
    let mut out = vec![0.0];
    let mut acc = 0.0;
    for i in 1..us.len() {
        let mut d = 0.0;
        for k in 0..=32 {
            let s = k as f64 / 32.0;
            let p = track(us, i - 1)?.point(s)?;
            let q = track(us, i)?.point(s)?;
            d += p.dist(q) / 33.0;
        }
        if !(d > 1e-9) {
            let (a, b) = (us[i - 1].label.clone(), us[i].label.clone());
            return invalid(format!("{a} and {b} lie on each other"));
        }
        acc += d;
        out.push(acc);
    }
    Ok(out.into_iter().map(|x| x / acc).collect())
}

/// The nodes `(network parameter, arc length)` a curve is placed through: its crossings, and
/// with fewer than two the curve's ends at 0 and 1 (a crossing at an end standing for that end).
fn place_nodes(cross: &[(f64, f64, Vec3)], count: usize) -> Vec<(f64, f64)> {
    if count >= 2 {
        return cross.iter().map(|c| (c.0, c.1)).collect();
    }
    let mut nodes = vec![(0.0, 0.0)];
    if let Some(&(x, s, _)) = cross.first()
        && x > 1e-9
        && x < 1.0 - 1e-9
        && s > 1e-9
        && s < 1.0 - 1e-9
    {
        nodes.push((x, s));
    }
    nodes.push((1.0, 1.0));
    nodes
}

/// The tensor surface of a net of control points (`net[a][b]`: a along u).
fn surface(su: &Space, sv: &Space, net: &[Vec<Vec3>]) -> SplineResult<NurbsSurface> {
    let (nu, nv) = (su.count(), sv.count());
    if net.len() != nu || net.iter().any(|c| c.len() != nv) {
        return invalid("control net size");
    }
    let mut pts = Vec::with_capacity(nu * nv);
    for b in 0..nv {
        for col in net {
            pts.push(col[b]);
        }
    }
    let weights = vec![1.0; pts.len()];
    NurbsSurface::new([su.degree(), sv.degree()], [su.knots().to_vec(), sv.knots().to_vec()], &pts, &weights)
}

#[cfg(test)]
mod tests {
    use super::*;

    /// A curve given by a function of its parameter.
    struct F<G: FnMut(f64) -> Vec3>(G);
    impl<G: FnMut(f64) -> Vec3> NetCurve for F<G> {
        fn point(&mut self, t: f64) -> Option<Vec3> {
            Some((self.0)(t))
        }
    }

    fn curve<'a>(label: &str, f: impl FnMut(f64) -> Vec3 + 'a) -> NetworkCurve<'a> {
        NetworkCurve { label: label.into(), curve: Box::new(F(f)), condition: None }
    }

    fn line<'a>(label: &str, a: Vec3, b: Vec3) -> NetworkCurve<'a> {
        curve(label, move |t| a.lerp(b, t))
    }

    const TOL: Tolerances = Tolerances { cross: 1e-3, fit: 1e-5 };

    fn grid(s: &NurbsSurface, n: usize) -> Vec<Vec3> {
        let [du, dv] = s.domain();
        let mut out = Vec::new();
        for i in 0..=n {
            for j in 0..=n {
                let (u, v) = (du[0] + (du[1] - du[0]) * i as f64 / n as f64, dv[0] + (dv[1] - dv[0]) * j as f64 / n as f64);
                out.push(s.eval(u, v).unwrap());
            }
        }
        out
    }

    /// Distance from `p` to the polyline of `f` sampled finely.
    fn dist_to(p: Vec3, f: &dyn Fn(f64) -> Vec3) -> f64 {
        (0..2000).map(|k| p.dist_to_segment(f(k as f64 / 2000.0), f((k + 1) as f64 / 2000.0))).fold(f64::INFINITY, f64::min)
    }

    /// The bilinearly blended Coons patch of four straight lines reproduces the hyperbolic
    /// paraboloid z = x·y they bound, exactly; four coplanar curves (two arcs, two lines) give a
    /// patch in their plane.
    #[test]
    fn coons_patch_reproduces_a_hyperbolic_paraboloid_and_a_plane() {
        let p = |x: f64, y: f64| Vec3::new(x, y, x * y);
        let s = network_surface(
            vec![line("u0", p(0.0, 0.0), p(4.0, 0.0)), line("u1", p(0.0, 3.0), p(4.0, 3.0))],
            vec![line("v0", p(0.0, 0.0), p(0.0, 3.0)), line("v1", p(4.0, 3.0), p(4.0, 0.0))],
            TOL,
        )
        .unwrap();
        for q in grid(&s, 20) {
            assert!((q.z - q.x * q.y).abs() < 1e-9, "{q:?} off z = xy by {}", q.z - q.x * q.y);
        }
        assert!(s.eval(0.5, 0.5).unwrap().dist(p(2.0, 1.5)) < 1e-9, "the middle of the patch");
        // A plane z = 0.3x + 0.2y + 1 bounded by two arcs bulging out and two lines.
        let on = |x: f64, y: f64| Vec3::new(x, y, 0.3 * x + 0.2 * y + 1.0);
        let arc = |y: f64, sign: f64| move |t: f64| on(10.0 * t, y + sign * 2.0 * (std::f64::consts::PI * t).sin());
        let s = network_surface(
            vec![curve("bottom", arc(0.0, -1.0)), curve("top", arc(8.0, 1.0))],
            vec![line("left", on(0.0, 0.0), on(0.0, 8.0)), line("right", on(10.0, 0.0), on(10.0, 8.0))],
            TOL,
        )
        .unwrap();
        for q in grid(&s, 20) {
            assert!((q.z - (0.3 * q.x + 0.2 * q.y + 1.0)).abs() < 1e-9, "{q:?} off the plane");
        }
    }

    /// Area of a surface over its whole domain: |S_u × S_v| by central differences on an n × n grid
    /// of cell centres.
    fn area(s: &NurbsSurface, n: usize) -> f64 {
        let [du, dv] = s.domain();
        let (hu, hv) = ((du[1] - du[0]) / n as f64, (dv[1] - dv[0]) / n as f64);
        let mut a = 0.0;
        for i in 0..n {
            for j in 0..n {
                let (u, v) = (du[0] + hu * (i as f64 + 0.5), dv[0] + hv * (j as f64 + 0.5));
                let su = (s.eval(u + hu * 0.25, v).unwrap() - s.eval(u - hu * 0.25, v).unwrap()) / (hu * 0.5);
                let sv = (s.eval(u, v + hv * 0.25).unwrap() - s.eval(u, v - hv * 0.25).unwrap()) / (hv * 0.5);
                a += su.cross(sv).len() * hu * hv;
            }
        }
        a
    }

    fn apex<'a>(label: &str, p: Vec3) -> NetworkCurve<'a> {
        NetworkCurve { label: label.into(), curve: Box::new(PointCurve(p)), condition: None }
    }

    /// Three sides: one of them a point. A triangle of lines and a quarter disc (two radii and the
    /// arc, the apex at the centre) are filled flat, the whole patch on their plane, every point of
    /// the collapsed side at the apex, with the area of the triangle and of the quarter disc.
    #[test]
    fn three_sides_collapse_one_to_a_point() {
        let (a, b, c) = (Vec3::new(0.0, 0.0, 2.0), Vec3::new(10.0, 0.0, 2.0), Vec3::new(4.0, 8.0, 2.0));
        let s = network_surface(vec![line("ab", a, b), apex("c", c)], vec![line("ac", a, c), line("cb", c, b)], TOL).unwrap();
        for q in grid(&s, 20) {
            assert!((q.z - 2.0).abs() < 1e-9, "{q:?} off the plane");
        }
        let [du, dv] = s.domain();
        let collapsed = [s.eval(du[0], dv[0]).unwrap(), s.eval(du[1], dv[0]).unwrap(), s.eval(du[0], dv[1]).unwrap(), s.eval(du[1], dv[1]).unwrap()];
        assert!(collapsed.iter().filter(|p| p.dist(c) < 1e-12).count() == 2, "two corners at the apex: {collapsed:?}");
        let tri = area(&s, 200);
        assert!((tri - 40.0).abs() < 1e-3, "triangle area {tri}");
        // The quarter disc of radius 10 about the origin.
        let r = 10.0;
        let arc = move |t: f64| Vec3::new(r * (std::f64::consts::FRAC_PI_2 * t).cos(), r * (std::f64::consts::FRAC_PI_2 * t).sin(), 0.0);
        let s = network_surface(
            vec![curve("arc", arc), apex("centre", Vec3::ZERO)],
            vec![line("x", Vec3::ZERO, Vec3::X * r), line("y", Vec3::Y * r, Vec3::ZERO)],
            TOL,
        )
        .unwrap();
        for q in grid(&s, 20) {
            assert!(q.z.abs() < 1e-9 && q.len() <= r + 1e-4, "{q:?} off the quarter disc");
        }
        let quarter = area(&s, 200);
        let want = std::f64::consts::PI * r * r / 4.0;
        assert!((quarter - want).abs() < 2e-3 * want, "quarter disc area {quarter} vs {want}");
        // A point given as a v-curve is the same patch.
        let s2 = network_surface(
            vec![line("x", Vec3::ZERO, Vec3::X * r), line("y", Vec3::Y * r, Vec3::ZERO)],
            vec![curve("arc", arc), apex("centre", Vec3::ZERO)],
            TOL,
        )
        .unwrap();
        assert!((area(&s2, 200) - quarter).abs() < 1e-6);
    }

    /// Points where a patch has no side for them, a point that moves, and a point with a
    /// continuity condition are refused, never a panic.
    #[test]
    fn misplaced_points_are_refused() {
        let (a, b, c) = (Vec3::ZERO, Vec3::new(10.0, 0.0, 0.0), Vec3::new(4.0, 8.0, 0.0));
        let two = network_surface(vec![apex("p", a), apex("q", c)], vec![], TOL).unwrap_err();
        assert!(two.to_string().contains("point"), "{two}");
        let both = network_surface(vec![line("ab", a, b), apex("c", c)], vec![apex("a", a), line("cb", c, b)], TOL).unwrap_err();
        assert!(both.to_string().contains("point"), "{both}");
        let lone = network_surface(vec![apex("c", c)], vec![line("ac", a, c), line("cb", c, b)], TOL);
        assert!(lone.is_err());
        let one_across = network_surface(vec![line("ab", a, b), apex("c", c)], vec![line("ac", a, c)], TOL).unwrap_err();
        assert!(one_across.to_string().contains("point"), "{one_across}");
        // A point between two curves of its direction.
        let mid = network_surface(
            vec![line("low", a, b), apex("mid", Vec3::new(5.0, 4.0, 0.0)), line("high", Vec3::new(0.0, 8.0, 0.0), Vec3::new(10.0, 8.0, 0.0))],
            vec![],
            TOL,
        )
        .unwrap_err();
        assert!(mid.to_string().contains("inside"), "{mid}");
        struct Moving;
        impl NetCurve for Moving {
            fn point(&mut self, t: f64) -> Option<Vec3> {
                Some(Vec3::new(t, 0.0, 0.0))
            }
            fn is_point(&self) -> bool {
                true
            }
        }
        let moving = NetworkCurve { label: "m".into(), curve: Box::new(Moving), condition: None };
        let e = network_surface(vec![line("ab", a, b), moving], vec![], TOL).unwrap_err();
        assert!(e.to_string().contains("moves"), "{e}");
        let with_g1 = NetworkCurve { label: "g".into(), curve: Box::new(PointCurve(c)), condition: Some((Continuity::G1, Box::new(Plane))) };
        let e = network_surface(vec![line("ab", a, b), with_g1], vec![], TOL).unwrap_err();
        assert!(e.to_string().contains("point"), "{e}");
    }

    /// Two curves loft straight between them; three or more pass smoothly through all; curves
    /// given running opposite ways are turned to agree.
    #[test]
    fn curves_one_way_are_lofted() {
        let ruled =
            network_surface(vec![line("a", Vec3::ZERO, Vec3::X * 10.0), line("b", Vec3::new(10.0, 5.0, 2.0), Vec3::new(0.0, 5.0, 2.0))], vec![], TOL)
                .unwrap();
        assert_eq!(ruled.degree()[1], 1, "ruled between two curves");
        for q in grid(&ruled, 10) {
            assert!((q.z - 0.4 * q.y).abs() < 1e-9, "{q:?}: a flat strip, not twisted");
        }
        let arc = |z: f64, r: f64| move |t: f64| Vec3::new(r * (std::f64::consts::PI * t).cos(), r * (std::f64::consts::PI * t).sin(), z);
        let fs: Vec<(f64, f64)> = vec![(0.0, 5.0), (4.0, 6.0), (8.0, 5.5), (12.0, 7.0)];
        let s = network_surface(fs.iter().enumerate().map(|(k, &(z, r))| curve(&format!("c{k}"), arc(z, r))).collect(), vec![], TOL).unwrap();
        // Every section lies on the surface: its iso-curve at the section's parameter is close.
        let pts = grid(&s, 60);
        for &(z, r) in &fs {
            let f = arc(z, r);
            for k in 0..=10 {
                let p = f(k as f64 / 10.0);
                let d = pts.iter().map(|q| q.dist(p)).fold(f64::INFINITY, f64::min);
                assert!(d < 0.3, "section at z = {z} is {d} from the surface's samples");
            }
        }
    }

    /// A 3 × 3 network: the Gordon surface passes through all six curves (within the fit
    /// tolerance), the interior ones included.
    #[test]
    fn gordon_surface_passes_through_every_curve() {
        let z = |x: f64, y: f64| 0.05 * x * x - 0.03 * y * y + 0.02 * x * y;
        let ux: Vec<f64> = vec![0.0, 4.0, 10.0];
        let vy: Vec<f64> = vec![0.0, 3.0, 8.0];
        let ucurve = |y: f64| move |t: f64| Vec3::new(10.0 * t, y, z(10.0 * t, y));
        let vcurve = |x: f64| move |t: f64| Vec3::new(x, 8.0 * t, z(x, 8.0 * t));
        let s = network_surface(
            vy.iter().map(|&y| curve(&format!("y={y}"), ucurve(y))).collect(),
            ux.iter().rev().map(|&x| curve(&format!("x={x}"), vcurve(x))).collect(),
            TOL,
        )
        .unwrap();
        // The surface's iso-curves at the crossing parameters are the given curves.
        let [du, dv] = s.domain();
        for &y in &vy {
            let f = ucurve(y);
            // Find the v of this curve by its start point.
            let start = f(0.0);
            let off = |v: f64| s.eval(du[0], v).unwrap().dist(start);
            let mut v = (0..=1000).map(|k| dv[0] + (dv[1] - dv[0]) * k as f64 / 1000.0).min_by(|a, b| off(*a).total_cmp(&off(*b))).unwrap();
            let (mut lo, mut hi) = ((v - 0.002).max(dv[0]), (v + 0.002).min(dv[1]));
            for _ in 0..100 {
                let (a, b) = (lo + (hi - lo) / 3.0, hi - (hi - lo) / 3.0);
                if off(a) < off(b) { hi = b } else { lo = a }
            }
            v = (lo + hi) / 2.0;
            for k in 0..=20 {
                let q = s.eval(du[0] + (du[1] - du[0]) * k as f64 / 20.0, v).unwrap();
                assert!(dist_to(q, &f) < 1e-4, "y = {y}: {q:?} is {} off", dist_to(q, &f));
            }
        }
        for q in grid(&s, 10) {
            assert!((q.z - z(q.x, q.y)).abs() < 0.05, "{q:?} strays from the network's surface");
        }
    }

    /// A plane face along the x axis (normal +z, the face on the −y side): a frame for G1 and G2.
    struct Plane;
    impl CrossFace for Plane {
        fn frame(&mut self, _: Vec3, _: Vec3) -> Option<FaceFrame> {
            Some(FaceFrame { normal: Vec3::Z, outward: Vec3::Y, form: [0.0; 3] })
        }
    }

    /// A cylinder of radius R about the x axis, the face below its edge at (y = R, z = 0): it
    /// leaves the edge straight up (+z), bending toward the axis.
    struct Cylinder(f64);
    impl CrossFace for Cylinder {
        fn frame(&mut self, at: Vec3, tangent: Vec3) -> Option<FaceFrame> {
            let n = Vec3::new(0.0, at.y, at.z).normalized()?;
            let _ = tangent;
            // Outward normal n; curvature −1/R in the direction around the axis, none along it.
            Some(FaceFrame { normal: n, outward: Vec3::Z, form: [0.0, 0.0, -1.0 / self.0] })
        }
    }

    fn deriv_v(s: &NurbsSurface, u: f64, h: f64) -> (Vec3, Vec3) {
        let f: Vec<Vec3> = (0..4).map(|k| s.eval(u, k as f64 * h).unwrap()).collect();
        ((f[0] * -3.0 + f[1] * 4.0 - f[2]) / (2.0 * h), (f[0] * 2.0 - f[1] * 5.0 + f[2] * 4.0 - f[3]) / (h * h))
    }

    /// G1: the surface leaves a plane edge tangent to the plane. G2 against a cylinder: the
    /// surface's normal curvature across the edge is the cylinder's, 1/R; with G1 only it is
    /// not.
    #[test]
    fn g1_and_g2_conditions_meet_the_face() {
        let edge = |c: Box<dyn CrossFace>, g| NetworkCurve {
            label: "edge".into(),
            curve: Box::new(F(|t: f64| Vec3::new(10.0 * t, 0.0, 0.0))),
            condition: Some((g, c)),
        };
        let s = network_surface(
            vec![edge(Box::new(Plane), Continuity::G1), line("far", Vec3::new(0.0, 10.0, 5.0), Vec3::new(10.0, 10.0, 5.0))],
            vec![],
            TOL,
        )
        .unwrap();
        for k in 0..=10 {
            let u = k as f64 / 10.0;
            let (d1, _) = deriv_v(&s, u, 1e-5);
            let angle = (d1.z / d1.len()).asin().to_degrees().abs();
            assert!(angle < 1e-3 && d1.y > 0.0, "u = {u}: leaves the plane at {angle}°");
        }
        let r = 10.0;
        let cyl = |g| {
            let edge = NetworkCurve {
                label: "rim".into(),
                curve: Box::new(F(move |t: f64| Vec3::new(10.0 * t, r, 0.0))),
                condition: Some((g, Box::new(Cylinder(r)) as Box<dyn CrossFace>)),
            };
            network_surface(vec![edge, line("top", Vec3::new(0.0, 3.0, 12.0), Vec3::new(10.0, 3.0, 12.0))], vec![], TOL).unwrap()
        };
        let curvature = |s: &NurbsSurface, u: f64| {
            let (d1, d2) = deriv_v(s, u, 1e-4);
            // Curvature of the v-curve: |d1 × d2| / |d1|³, toward the axis (−y).
            (d1.cross(d2).len() / d1.len().powi(3), d2.y)
        };
        let g2 = cyl(Continuity::G2);
        for k in 0..=4 {
            let (kappa, _) = curvature(&g2, k as f64 / 4.0);
            assert!((kappa - 1.0 / r).abs() < 1e-3 / r, "G2: curvature {kappa} vs {}", 1.0 / r);
        }
        let g1 = cyl(Continuity::G1);
        let (kappa, _) = curvature(&g1, 0.5);
        assert!((kappa - 1.0 / r).abs() > 0.1 / r, "G1 alone does not match the curvature: {kappa}");
    }

    /// A Coons patch with a G1 edge: the side curves leave the plane tangent to it (arcs), so the
    /// patch does too; a side curve that leaves it at an angle is refused, named.
    #[test]
    fn crossing_curves_must_agree_with_a_g1_face() {
        let edge = || NetworkCurve {
            label: "edge".into(),
            curve: Box::new(F(|t: f64| Vec3::new(10.0 * t, 0.0, 0.0))),
            condition: Some((Continuity::G1, Box::new(Plane) as Box<dyn CrossFace>)),
        };
        // Arcs in x = const from (y, z) = (0, 0), tangent to +y, to (10, 5): centre (0, 12.5).
        let side = |x: f64| {
            move |t: f64| {
                let a = -std::f64::consts::FRAC_PI_2 + t * 0.927_295_218_001_612_2;
                Vec3::new(x, 12.5 * a.cos(), 12.5 + 12.5 * a.sin())
            }
        };
        let far = line("far", Vec3::new(0.0, 10.0, 5.0), Vec3::new(10.0, 10.0, 5.0));
        let s = network_surface(vec![edge(), far], vec![curve("left", side(0.0)), curve("right", side(10.0))], TOL).unwrap();
        for k in 0..=10 {
            let (d1, _) = deriv_v(&s, k as f64 / 10.0, 1e-5);
            let angle = (d1.z / d1.len()).asin().to_degrees().abs();
            assert!(angle < 0.01, "leaves the plane at {angle}°");
        }
        let far = line("far", Vec3::new(0.0, 10.0, 5.0), Vec3::new(10.0, 10.0, 5.0));
        let steep = line("steep", Vec3::new(0.0, 0.0, 0.0), Vec3::new(0.0, 10.0, 5.0));
        let err = network_surface(vec![edge(), far], vec![steep, curve("right", side(10.0))], TOL).unwrap_err();
        assert!(err.to_string().contains("steep") && err.to_string().contains("tangent"), "{err}");
    }

    /// Networks that can't be built are refused, naming the curves; none panics.
    #[test]
    fn bad_networks_are_refused() {
        let l = |n: &str, a: [f64; 3], b: [f64; 3]| line(n, Vec3::from(a), Vec3::from(b));
        let miss = network_surface(
            vec![l("a", [0.0, 0.0, 0.0], [10.0, 0.0, 0.0]), l("b", [0.0, 5.0, 0.0], [10.0, 5.0, 0.0])],
            vec![l("c", [0.0, 0.0, 0.0], [0.0, 5.0, 0.0]), l("d", [10.0, 0.0, 1.0], [10.0, 5.0, 1.0])],
            TOL,
        )
        .unwrap_err();
        assert!(miss.to_string().contains("a and d") || miss.to_string().contains("b and d"), "{miss}");
        assert!(miss.to_string().contains("don't meet"), "{miss}");
        let one = network_surface(vec![l("a", [0.0, 0.0, 0.0], [1.0, 0.0, 0.0])], vec![], TOL);
        assert!(one.is_err());
        assert!(network_surface(vec![], vec![], TOL).is_err());
        let circle = curve("ring", |t: f64| Vec3::new((6.3 * t).cos(), (6.3 * t).sin(), 0.0).lerp(Vec3::X, if t >= 1.0 { 1.0 } else { 0.0 }));
        let closed = network_surface(vec![circle, l("b", [0.0, 0.0, 1.0], [1.0, 0.0, 1.0])], vec![], TOL).unwrap_err();
        assert!(closed.to_string().contains("closed"), "{closed}");
        let zero = network_surface(vec![l("a", [0.0; 3], [0.0; 3]), l("b", [0.0, 0.0, 1.0], [1.0, 0.0, 1.0])], vec![], TOL).unwrap_err();
        assert!(zero.to_string().contains("no length"), "{zero}");
        let nan = network_surface(vec![l("a", [f64::NAN, 0.0, 0.0], [1.0, 0.0, 0.0]), l("b", [0.0, 0.0, 1.0], [1.0, 0.0, 1.0])], vec![], TOL);
        assert!(nan.is_err());
        // A parabola crossing a line twice.
        let wave = curve("wave", |t: f64| Vec3::new(10.0 * t, 4.0 * (2.0 * t - 1.0).powi(2) - 1.0, 0.0));
        let twice = network_surface(
            vec![l("a", [0.0, 0.0, 0.0], [10.0, 0.0, 0.0]), l("b", [0.0, 5.0, 0.0], [10.0, 5.0, 0.0])],
            vec![l("c", [0.0, 0.0, 0.0], [0.0, 5.0, 0.0]), wave],
            TOL,
        )
        .unwrap_err();
        assert!(twice.to_string().contains("more than once"), "{twice}");
        // Conditions on both directions.
        let cond = |n: &str, a: [f64; 3], b: [f64; 3]| {
            let (a, b) = (Vec3::from(a), Vec3::from(b));
            NetworkCurve {
                label: n.into(),
                curve: Box::new(F(move |t: f64| a.lerp(b, t))),
                condition: Some((Continuity::G1, Box::new(Plane) as Box<dyn CrossFace>)),
            }
        };
        let both = network_surface(
            vec![cond("a", [0.0, 0.0, 0.0], [10.0, 0.0, 0.0]), l("b", [0.0, 5.0, 0.0], [10.0, 5.0, 0.0])],
            vec![cond("c", [0.0, 0.0, 0.0], [0.0, 5.0, 0.0]), l("d", [10.0, 0.0, 0.0], [10.0, 5.0, 0.0])],
            TOL,
        )
        .unwrap_err();
        assert!(matches!(both, SplineError::Unsupported(_)), "{both}");
        let bad_tol = network_surface(
            vec![l("a", [0.0; 3], [1.0, 0.0, 0.0]), l("b", [0.0, 1.0, 0.0], [1.0, 1.0, 0.0])],
            vec![],
            Tolerances { cross: f64::NAN, fit: 1.0 },
        );
        assert!(bad_tol.is_err());
    }
}