Skip to content

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

26.7 KB
Raw Blame
//! Repair Part (#8371): a part SMLib refuses, or an open part that should be a solid, made into
//! one SMLib takes, saying what changed face by face. In order:
//!
//! 1. A face SMLib refuses on its own is rebuilt from its own surface, its geometry unchanged: a
//!    cylinder, cone, sphere or torus face on a NURBS form SMLib rejects goes as the analytic
//!    surface it is, which SMLib parameterises on its own form (the form's control net is the
//!    import's construction; the surface it stands for is the label's, exactly).
//! 2. Free edges that pair up within `gap` (a sliver between two faces that should meet) are sewn
//!    by SMLib's stitch, which gives each edge it glues its own tolerance from that pair's gap
//!    (`SmBrep::GlueEdgesGeneral`: at least twice the gap); the body's tolerance, and every other
//!    edge's, stays as it was.
//! 3. A loop of free edges no pair explains is a missing face: Patch on that loop is offered (and
//!    made, and sewn in, when asked), planar only where the faces around it are that plane; where
//!    they are curved the patch meets them tangent (G1). Extending the neighbours is not done.
//!
//! Nothing is moved: a face rebuilt keeps its surface, a sewn edge keeps its curve (SMLib keeps
//! one of the pair), a patch is a new face. What was done comes back in [`RepairReport`].

use solidcore_record::Vec3;
use solidcore_record::brep::{self as b, Brep};
use solidcraft_geom::brep::eval::CurveEval;
use solidcraft_geom::prelude::*;

use crate::body::{Body, SurfaceKind};
use crate::{Continuity, KernelError, Result};

/// Most free edges paired against each other (each against every other near it).
const MAX_FREE_EDGES: usize = 20_000;
/// Most faces sent into SMLib one by one to find the ones it refuses.
const MAX_FACE_PROBES: usize = 20_000;
/// Points along an edge where its distance to its partner is measured.
const GAP_SAMPLES: usize = 16;
/// SMLib's check tests that bound an item's tolerance by the body's (`SmBrep::AssertValid` #5,
/// #6: face; #59: edge, under 1000 times the body's; #82: vertex). An edge sewn across a gap
/// carries that gap; the body's tolerance is not raised to cover it, so these may fail on sewn
/// items, as they already fail on an import's edges that lie off their faces by more.
const TOLERANCE_BOUND_TESTS: [u32; 4] = [5, 6, 59, 82];

/// What a repair may do.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RepairOptions {
    /// The widest gap between two free edges that is sewn, mm (> 0).
    pub gap: f64,
    /// Patch the loops of free edges no pair explains (missing faces), and sew the patches in.
    pub patch_holes: bool,
}

/// A face rebuilt so SMLib takes it.
#[derive(Clone, Debug, PartialEq)]
pub struct RebuiltFace {
    /// Its index in the body before the repair.
    pub face: usize,
    pub surface: SurfaceKind,
    /// Why SMLib refused it before.
    pub why: String,
}

/// A face SMLib refuses that the repair could not rebuild.
#[derive(Clone, Debug, PartialEq)]
pub struct RefusedFace {
    pub face: usize,
    pub surface: SurfaceKind,
    pub why: String,
}

/// Two free edges sewn into one.
#[derive(Clone, Debug, PartialEq)]
pub struct SewnGap {
    /// The faces on either side, by index before the repair.
    pub faces: [usize; 2],
    /// The widest distance between the two edges, mm.
    pub gap: f64,
    /// A point halfway along the first edge.
    pub at: Vec3,
}

/// A loop of free edges no pair explains: a face is missing there.
#[derive(Clone, Debug, PartialEq)]
pub struct Hole {
    /// The faces around it, by index before the repair.
    pub faces: Vec<usize>,
    /// A point halfway along each of its edges: Patch's `edges`.
    pub edges: Vec<Vec3>,
    /// How a patch meets the faces around it: G0 (the plane they lie in) or G1 (curved neighbours).
    pub continuity: Continuity,
    /// The patch was made and sewn in.
    pub patched: bool,
    /// Why it was not, when it was asked for.
    pub why: Option<String>,
}

/// What a repair did.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RepairReport {
    pub rebuilt: Vec<RebuiltFace>,
    pub refused: Vec<RefusedFace>,
    pub sewn: Vec<SewnGap>,
    pub holes: Vec<Hole>,
    /// Faces before and after.
    pub faces: [usize; 2],
    /// The largest edge tolerance before and after, mm.
    pub largest_edge_tolerance: [f64; 2],
    /// The result is a closed solid.
    pub closed: bool,
    /// Whether SMLib takes the result as it is.
    pub modelling: bool,
}

impl RepairReport {
    /// Whether the repair changed anything.
    pub fn changed(&self) -> bool {
        !self.rebuilt.is_empty() || !self.sewn.is_empty() || self.holes.iter().any(|h| h.patched)
    }
}

fn invalid(what: impl Into<String>) -> KernelError {
    KernelError::Invalid(what.into())
}

fn v3(p: [f64; 3]) -> Vec3 {
    Vec3::new(p[0], p[1], p[2])
}

/// `body` repaired as the module says, with what was done. Refused (with why) when nothing
/// applies: SMLib takes it and it has no free edges, or its only free edges bound holes and
/// `patch_holes` is off (the report's holes are then in the message).
pub fn repair(body: &Body, opts: &RepairOptions) -> Result<(Body, RepairReport)> {
    let _span = solidcraft_profile::span("kernel", "repair");
    body.require_brep("repair")?;
    if !(opts.gap.is_finite() && opts.gap > 0.0 && opts.gap <= 1.0) {
        return Err(invalid("the gap to sew must be more than 0 and at most 1 mm"));
    }
    let before = body.record();
    let mut report =
        RepairReport { faces: [before.faces.len(), 0], largest_edge_tolerance: [largest_tolerance(before), 0.0], ..RepairReport::default() };

    // 1. Faces SMLib refuses on their own, rebuilt from their surfaces.
    let mut record = before.clone();
    if body.smlib().is_err() {
        rebuild_refused(&mut record, &mut report)?;
    }
    let mut current = if report.rebuilt.is_empty() { body.clone() } else { Body::from_record(record)?.with_color(body.color()) };
    if !report.refused.is_empty() && current.smlib().is_err() {
        // SMLib still refuses the part: nothing can be sewn or patched (both are SMLib's). The
        // faces rebuilt are kept, and the report names the ones left.
        let list: Vec<String> = report.refused.iter().map(|r| format!("face {} ({:?}): {}", r.face + 1, r.surface, r.why)).collect();
        if report.rebuilt.is_empty() {
            return Err(KernelError::Failed(format!("SMLib refuses faces the repair cannot rebuild: {}", list.join("; "))));
        }
        let r = current.record();
        report.holes = loops_of(r, &free_edges(r)?).iter().map(|l| hole(r, l)).collect();
        report.faces[1] = r.faces.len();
        report.largest_edge_tolerance[1] = largest_tolerance(r);
        report.closed = false;
        report.modelling = false;
        return Ok((current, report));
    }

    // 2. and 3. The free edges: pairs within the gap, and loops of the rest.
    let free = free_edges(current.record())?;
    let pairs = pair_up(current.record(), &free, opts.gap);
    let paired: std::collections::HashSet<u32> = pairs.iter().flat_map(|p| [p.edges[0], p.edges[1]]).collect();
    let rest: Vec<u32> = free.iter().copied().filter(|e| !paired.contains(e)).collect();
    let loops = loops_of(current.record(), &rest);
    for l in &loops {
        report.holes.push(hole(current.record(), l));
    }
    for p in &pairs {
        report.sewn.push(SewnGap { faces: p.faces, gap: p.gap, at: p.at });
    }
    if !pairs.is_empty() {
        let widest = pairs.iter().map(|p| p.gap).fold(0.0, f64::max);
        // SMLib glues the lamina pairs within the stitch tolerance: just past the widest pair, so
        // each of them glues and nothing farther apart does.
        let tol = (widest * 1.05).max(current.record().tolerance * 2.0);
        current = crate::surfaces::stitch_no_worse(&[&current], tol, &TOLERANCE_BOUND_TESTS)?;
    }
    if opts.patch_holes && !report.holes.is_empty() {
        current = patch_holes(current, &mut report.holes)?;
    }
    if !report.changed() {
        let holes: Vec<String> = report
            .holes
            .iter()
            .map(|h| {
                format!(
                    "a loop of {} edges around faces {}",
                    h.edges.len(),
                    h.faces.iter().map(|f| (f + 1).to_string()).collect::<Vec<_>>().join(", ")
                )
            })
            .collect();
        return Err(invalid(if holes.is_empty() {
            "nothing to repair: SMLib takes the part and it has no gaps or holes".to_string()
        } else {
            format!("nothing sewn: the free edges bound holes ({}); patch them to close the part", holes.join("; "))
        }));
    }
    let after = current.record();
    report.faces[1] = after.faces.len();
    report.largest_edge_tolerance[1] = largest_tolerance(after);
    report.closed = !after.faces.is_empty() && after.edges.iter().all(|e| e.uses.len() >= 2);
    report.modelling = current.smlib().is_ok();
    Ok((current, report))
}

fn largest_tolerance(r: &Brep) -> f64 {
    r.edges.iter().map(|e| e.tolerance).fold(r.tolerance, f64::max)
}

// ---- 1. Faces SMLib refuses -------------------------------------------------------------

/// Whether SMLib takes face `f` of `r` on its own; `Err` with SMLib's reason when it does not.
fn alone(r: &Brep, f: usize) -> Result<std::result::Result<(), String>> {
    let one = crate::surfaces::Parts::of(r, &[(f, false)])?.canonical()?;
    Ok(solidcraft_smlib::Brep::from_record(&one.brep, true).map(|_| ()).map_err(|e| e.to_string()))
}

/// Every face of `record` SMLib refuses on its own, rebuilt where its surface allows (into
/// `report.rebuilt`), else listed (`report.refused`).
fn rebuild_refused(record: &mut Brep, report: &mut RepairReport) -> Result<()> {
    if record.faces.len() > MAX_FACE_PROBES {
        return Err(KernelError::TooLarge(format!("a part of {} faces (the repair looks at most {MAX_FACE_PROBES})", record.faces.len())));
    }
    for f in 0..record.faces.len() {
        let Err(why) = alone(record, f)? else { continue };
        let Some(face) = record.faces.get(f) else { continue };
        let surface = SurfaceKind::of(&face.surface);
        match rebuilt_face(record, f) {
            Ok(Some(face)) => {
                let mut trial = record.clone();
                if let Some(slot) = trial.faces.get_mut(f) {
                    *slot = face;
                }
                match alone(&trial, f)? {
                    Ok(()) => {
                        *record = trial;
                        report.rebuilt.push(RebuiltFace { face: f, surface, why });
                    }
                    Err(still) => {
                        report.refused.push(RefusedFace { face: f, surface, why: format!("{why}; rebuilt on its own surface, still: {still}") })
                    }
                }
            }
            Ok(None) => report.refused.push(RefusedFace { face: f, surface, why }),
            Err(e) => report.refused.push(RefusedFace { face: f, surface, why: format!("{why}; not rebuilt: {e}") }),
        }
    }
    Ok(())
}

/// Face `f` of `r` rebuilt on its own surface: a cylinder, cone, sphere or torus face on a
/// NURBS form of the surface laid on arcs from where the face starts
/// ([`solidcraft_geom::brep::form::surface_on_own_arcs`]) instead of its frame's quarter grid, the same surface
/// exactly, with SMLib's own trims of the face's edges on it (`SmlibTrims`, as the import makes the
/// trims it has no closed form for). The face's edges and loops stay as they were. `None` for a
/// face on another surface.
fn rebuilt_face(r: &Brep, f: usize) -> Result<Option<b::Face>> {
    use solidcraft_geom::brep::pcurve::{TrimEdge, TrimFace, TrimUse, Trims};
    let face = r.faces.get(f).ok_or_else(|| invalid(format!("no face {f}")))?;
    if !matches!(face.surface, b::Surface::Cylinder { .. } | b::Surface::Cone { .. } | b::Surface::Sphere { .. } | b::Surface::Torus { .. }) {
        return Ok(None);
    }
    // The face's edges and vertices, numbered here as the trim face takes them.
    let mut local: Vec<u32> = Vec::new();
    let mut vertices: Vec<u32> = Vec::new();
    let mut loops = Vec::with_capacity(face.loops.len());
    let mut boundary = Vec::with_capacity(face.loops.len());
    for l in &face.loops {
        let b::Loop::Edges { edges } = l else { return Ok(None) };
        let mut uses = Vec::with_capacity(edges.len());
        let mut lb = Vec::with_capacity(edges.len());
        for u in edges {
            let e = r.edges.get(u.edge as usize).ok_or_else(|| invalid(format!("no edge {}", u.edge)))?;
            let k = match local.iter().position(|&x| x == u.edge) {
                Some(k) => k,
                None => {
                    local.push(u.edge);
                    local.len() - 1
                }
            };
            uses.push(TrimUse { edge: u32::try_from(k).map_err(|_| invalid("too many edges"))?, forward: u.forward, pcurve: None });
            lb.push((&e.curve, e.interval, u.forward));
        }
        loops.push(uses);
        boundary.push(lb);
    }
    let mut edges = Vec::with_capacity(local.len());
    for &e in &local {
        let edge = r.edges.get(e as usize).ok_or_else(|| invalid(format!("no edge {e}")))?;
        let mut ends = [0u32; 2];
        for (end, v) in ends.iter_mut().zip(edge.vertices) {
            let k = match vertices.iter().position(|&x| x == v) {
                Some(k) => k,
                None => {
                    vertices.push(v);
                    vertices.len() - 1
                }
            };
            *end = u32::try_from(k).map_err(|_| invalid("too many vertices"))?;
        }
        edges.push(TrimEdge { curve: &edge.curve, nurbs: edge.nurbs.as_ref(), interval: edge.interval, vertices: ends, tolerance: edge.tolerance });
    }
    let points = vertices
        .iter()
        .map(|&v| r.vertices.get(v as usize).map(|v| v.point).ok_or_else(|| invalid(format!("no vertex {v}"))))
        .collect::<Result<Vec<_>>>()?;
    let extent = solidcraft_geom::brep::form::extent(&face.surface, &boundary).ok_or_else(|| invalid("its boundary does not lie on its surface"))?;
    let (form, domain) = solidcraft_geom::brep::form::surface_on_own_arcs(
        &face.surface,
        extent,
        local.iter().filter_map(|&e| r.edges.get(e as usize)).map(|e| e.tolerance).fold(r.tolerance, f64::max),
    )
    .ok_or_else(|| invalid("no NURBS form of its surface over its boundary"))?;
    let trim = TrimFace { surface: &face.surface, nurbs: Some(&form), domain, edges, vertices: points, loops, tolerance: r.tolerance };
    let pcurves = solidcraft_smlib::pcurves::SmlibTrims.trims(&trim).map_err(KernelError::Failed)?;
    let mut out = face.clone();
    out.nurbs = Some(form);
    out.domain = domain;
    let mut it = pcurves.into_iter();
    for l in &mut out.loops {
        let b::Loop::Edges { edges } = l else { continue };
        let pcs = it.next().ok_or_else(|| invalid("pcurves of a loop"))?;
        for (u, pc) in edges.iter_mut().zip(pcs) {
            u.pcurve = pc;
        }
    }
    Ok(Some(out))
}

// ---- 2. Gaps ----------------------------------------------------------------------------

/// The edges of `r` only one face uses.
fn free_edges(r: &Brep) -> Result<Vec<u32>> {
    let free: Vec<u32> =
        (0..r.edges.len()).filter(|&e| r.edges.get(e).is_some_and(|e| e.uses.len() == 1)).filter_map(|e| u32::try_from(e).ok()).collect();
    if free.len() > MAX_FREE_EDGES {
        return Err(KernelError::TooLarge(format!("a part with {} free edges (the repair pairs at most {MAX_FREE_EDGES})", free.len())));
    }
    Ok(free)
}

/// Two free edges within the gap of each other.
struct Pair {
    edges: [u32; 2],
    faces: [usize; 2],
    gap: f64,
    at: Vec3,
}

/// An edge's points, evenly in its parameter (ends included).
fn points(r: &Brep, e: u32, n: usize) -> Vec<Vec3> {
    let Some(edge) = r.edges.get(e as usize) else { return Vec::new() };
    let Ok(c) = CurveEval::new(edge.parameters()) else { return Vec::new() };
    let [t0, t1] = edge.interval;
    (0..=n).filter_map(|k| c.point(t0 + (t1 - t0) * k as f64 / n as f64)).collect()
}

/// The widest distance from a point of edge `a` to edge `b` (each of `a`'s points to its nearest
/// point on `b`), `None` where `b` cannot be evaluated.
fn reach(r: &Brep, a: &[Vec3], b: u32) -> Option<f64> {
    let edge = r.edges.get(b as usize)?;
    let c = CurveEval::new(edge.parameters()).ok()?;
    let ends = [c.point(edge.interval[0])?, c.point(edge.interval[1])?];
    a.iter()
        .map(|p| {
            let inside = crate::surfaces::nearest_parameter(&c, edge.interval, *p).map_or(f64::INFINITY, |(_, d)| d);
            inside.min(ends[0].dist(*p)).min(ends[1].dist(*p))
        })
        .try_fold(0.0f64, |m, d| d.is_finite().then_some(m.max(d)))
}

/// The free edges that pair up within `gap`, both ways (each edge's every point near the other),
/// each edge in at most one pair: the closest pairs first. An edge of a face with itself is not
/// a gap.
fn pair_up(r: &Brep, free: &[u32], gap: f64) -> Vec<Pair> {
    let samples: Vec<Vec<Vec3>> = free.iter().map(|&e| points(r, e, GAP_SAMPLES)).collect();
    let boxes: Vec<Option<(Vec3, Vec3)>> = samples
        .iter()
        .map(|s| {
            let first = *s.first()?;
            Some(s.iter().fold((first, first), |(lo, hi), p| (lo.min(*p), hi.max(*p))))
        })
        .collect();
    let face = |e: u32| r.edges.get(e as usize).and_then(|e| e.uses.first()).map(|u| u.face as usize);
    let mut candidates = Vec::new();
    for i in 0..free.len() {
        for j in i + 1..free.len() {
            let (Some(&a), Some(&b)) = (free.get(i), free.get(j)) else { continue };
            let (Some(Some((alo, ahi))), Some(Some((blo, bhi)))) = (boxes.get(i), boxes.get(j)) else { continue };
            let apart = (blo.x - ahi.x).max(alo.x - bhi.x).max(blo.y - ahi.y).max(alo.y - bhi.y).max(blo.z - ahi.z).max(alo.z - bhi.z);
            if apart > gap || face(a) == face(b) {
                continue;
            }
            let (Some(sa), Some(sb)) = (samples.get(i), samples.get(j)) else { continue };
            let Some(d) = reach(r, sa, b).zip(reach(r, sb, a)).map(|(x, y)| x.max(y)) else { continue };
            if d <= gap {
                candidates.push((d, a, b));
            }
        }
    }
    candidates.sort_by(|x, y| x.0.total_cmp(&y.0));
    let mut taken = std::collections::HashSet::new();
    let mut out = Vec::new();
    for (d, a, b) in candidates {
        if taken.contains(&a) || taken.contains(&b) {
            continue;
        }
        let (Some(fa), Some(fb)) = (face(a), face(b)) else { continue };
        taken.insert(a);
        taken.insert(b);
        let at = points(r, a, 2).get(1).copied().unwrap_or(Vec3::ZERO);
        out.push(Pair { edges: [a, b], faces: [fa, fb], gap: d, at });
    }
    out
}

// ---- 3. Holes ---------------------------------------------------------------------------

/// The edges `rest` of `r` in chains joined at shared vertices: each a loop around a hole (or an
/// open run where the boundary does not close).
fn loops_of(r: &Brep, rest: &[u32]) -> Vec<Vec<u32>> {
    let mut by_vertex: std::collections::HashMap<u32, Vec<u32>> = std::collections::HashMap::new();
    for &e in rest {
        if let Some(edge) = r.edges.get(e as usize) {
            for v in edge.vertices {
                by_vertex.entry(v).or_default().push(e);
            }
        }
    }
    let mut seen = std::collections::HashSet::new();
    let mut out = Vec::new();
    for &start in rest {
        if !seen.insert(start) {
            continue;
        }
        let mut chain = vec![start];
        let mut stack = vec![start];
        while let Some(e) = stack.pop() {
            let Some(edge) = r.edges.get(e as usize) else { continue };
            for v in edge.vertices {
                for &n in by_vertex.get(&v).into_iter().flatten() {
                    if seen.insert(n) {
                        chain.push(n);
                        stack.push(n);
                    }
                }
            }
        }
        out.push(chain);
    }
    out
}

/// The hole a loop of free edges bounds, and how a patch would meet the faces around it: flat
/// (the loop's plane) when the loop is planar and every face around it is a plane, else tangent
/// to them.
fn hole(r: &Brep, edges: &[u32]) -> Hole {
    let mut faces: Vec<usize> = edges.iter().filter_map(|&e| r.edges.get(e as usize)?.uses.first().map(|u| u.face as usize)).collect();
    faces.sort_unstable();
    faces.dedup();
    let at: Vec<Vec3> = edges.iter().filter_map(|&e| points(r, e, 2).get(1).copied()).collect();
    let along: Vec<Vec3> = edges.iter().flat_map(|&e| points(r, e, 8)).collect();
    let tol = edges.iter().filter_map(|&e| r.edges.get(e as usize)).map(|e| e.tolerance).fold(r.tolerance, f64::max);
    let planes = faces.iter().all(|&f| r.faces.get(f).is_some_and(|face| plane_of(&face.surface).is_some()));
    let flat = planes && plane_through(&along).is_some_and(|(o, n)| along.iter().all(|p| (*p - o).dot(n).abs() <= tol));
    Hole { faces, edges: at, continuity: if flat { Continuity::G0 } else { Continuity::G1 }, patched: false, why: None }
}

/// The plane of a closed polygon's points (Newell's normal, through their centroid); `None`
/// where they enclose no area.
fn plane_through(pts: &[Vec3]) -> Option<(Vec3, Vec3)> {
    let n = pts.len();
    if n < 3 {
        return None;
    }
    let c = pts.iter().fold(Vec3::ZERO, |s, p| s + *p) * (1.0 / n as f64);
    let normal = (0..n).filter_map(|i| Some((pts.get(i)?, pts.get((i + 1) % n)?))).fold(Vec3::ZERO, |s, (p, q)| s + (*p - c).cross(*q - c));
    Some((c, normal.normalized()?))
}

/// A plane surface's point and unit normal.
fn plane_of(s: &b::Surface) -> Option<(Vec3, Vec3)> {
    let (o, u, v) = match s {
        b::Surface::Plane { origin, u_axis, v_axis } => (v3(*origin), v3(*u_axis), v3(*v_axis)),
        b::Surface::PlaneThrough { origin, u_point, v_point } => (v3(*origin), v3(*u_point) - v3(*origin), v3(*v_point) - v3(*origin)),
        _ => return None,
    };
    Some((o, u.cross(v).normalized()?))
}

/// `body` with each hole patched (Patch on its loop, at its continuity) and the patches sewn in
/// along the hole's own edges; a hole whose patch fails keeps why.
fn patch_holes(body: Body, holes: &mut [Hole]) -> Result<Body> {
    let mut patches = Vec::new();
    let mut tol = body.record().tolerance;
    for h in holes.iter_mut() {
        let spec = crate::PatchSpec { continuity: h.continuity, ..crate::PatchSpec::default() };
        match crate::patch_edges_with(&body, &h.edges, &spec) {
            Ok(p) => {
                tol = tol.max(largest_tolerance(p.record()));
                patches.push(p);
                h.patched = true;
            }
            Err(e) => h.why = Some(e.to_string()),
        }
    }
    if patches.is_empty() {
        return Ok(body);
    }
    let mut all: Vec<&Body> = vec![&body];
    all.extend(patches.iter());
    // A patch's edges are the hole's own: they meet within those edges' tolerances.
    crate::surfaces::stitch_no_worse(&all, tol * 2.0, &TOLERANCE_BOUND_TESTS)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{box_solid, copy_faces, measure, stitch, transform};

    /// The six faces of a 10 × 20 × 30 box, each its own surface body: bottom, top, then the sides.
    fn box_faces() -> Vec<Body> {
        let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap();
        [[5.0, 10.0, 0.0], [5.0, 10.0, 30.0], [0.0, 10.0, 15.0], [10.0, 10.0, 15.0], [5.0, 0.0, 15.0], [5.0, 20.0, 15.0]]
            .iter()
            .map(|p| copy_faces(&b, &[v3(*p)]).unwrap())
            .collect()
    }

    /// The box without its top: an open part with a hole the four sides and their plane bound.
    fn open_box(faces: &[Body]) -> Body {
        stitch(&[&faces[0], &faces[2], &faces[3], &faces[4], &faces[5]], 0.0).unwrap()
    }

    #[test]
    fn a_gap_between_faces_is_sewn_each_sewn_edge_carrying_its_gap() {
        let faces = box_faces();
        let open = open_box(&faces);
        // The lid 0.05 mm above the walls: one part of six faces whose top edges pair up 0.05 apart.
        let lid = transform(&faces[1], Vec3::new(0.0, 0.0, 0.05), Vec3::ZERO, Vec3::new(0.0, 0.0, 1.0), 0.0).unwrap();
        let part = stitch(&[&open, &lid], 1e-6).unwrap();
        assert_eq!(part.record().edges.iter().filter(|e| e.uses.len() == 1).count(), 8, "the gap's edges are free");
        let opts = RepairOptions { gap: 0.1, patch_holes: false };
        let (fixed, report) = repair(&part, &opts).unwrap();
        assert_eq!(report.sewn.len(), 4, "{report:?}");
        assert!(report.sewn.iter().all(|g| (g.gap - 0.05).abs() < 1e-6), "{report:?}");
        assert!(report.holes.is_empty() && report.rebuilt.is_empty());
        assert!(report.closed && report.modelling, "{report:?}");
        assert_eq!(report.faces, [6, 6]);
        let volume = measure(&fixed).unwrap().volume;
        assert!((6000.0..=6010.0).contains(&volume), "{volume}");
        // Only the four sewn edges carry the gap; the body's tolerance and every other edge's
        // stay SMLib's own.
        let r = fixed.record();
        assert_eq!(r.tolerance, part.record().tolerance);
        let loose: Vec<f64> = r.edges.iter().map(|e| e.tolerance).filter(|t| *t > 0.01).collect();
        assert_eq!(loose.len(), 4, "{loose:?}");
        assert!(loose.iter().all(|t| *t >= 0.05 && *t <= 0.25), "{loose:?}");
        // A gap wider than asked for is not sewn: the free edges then bound holes.
        let err = repair(&part, &RepairOptions { gap: 0.01, patch_holes: false }).unwrap_err().to_string();
        assert!(err.contains("nothing sewn"), "{err}");
    }

    #[test]
    fn a_hole_is_offered_then_patched_flat_in_the_plane_around_it() {
        let open = open_box(&box_faces());
        let opts = RepairOptions { gap: 0.2, patch_holes: false };
        let err = repair(&open, &opts).unwrap_err().to_string();
        assert!(err.contains("a loop of 4 edges"), "{err}");
        // Planar walls around a planar loop: the patch is the loop's plane.
        let (fixed, report) = repair(&open, &RepairOptions { patch_holes: true, ..opts }).unwrap();
        let [hole] = report.holes.as_slice() else { panic!("{report:?}") };
        assert_eq!((hole.faces.len(), hole.edges.len(), hole.continuity, hole.patched), (4, 4, Continuity::G0, true), "{hole:?}");
        assert!(report.closed && report.modelling, "{report:?}");
        assert_eq!(report.faces, [5, 6]);
        assert!((measure(&fixed).unwrap().volume - 6000.0).abs() < 1e-6);
    }

    #[test]
    fn a_part_with_nothing_to_repair_is_refused_with_why() {
        let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 20.0, 30.0)).unwrap();
        let err = repair(&b, &RepairOptions { gap: 0.2, patch_holes: true }).unwrap_err().to_string();
        assert!(err.contains("nothing to repair"), "{err}");
        for gap in [0.0, -1.0, 2.0, f64::NAN, f64::INFINITY] {
            assert!(repair(&b, &RepairOptions { gap, patch_holes: false }).is_err(), "{gap}");
        }
    }
}