geometry: brush contours

crates/nanobrush-geometry/src/brush.rs

@@ -0,0 +1,258 @@
+use crate::{math::*, *};
+#[derive(Debug)]
+pub struct Mesh {
+    pub contours: Vec<Vec<DVec3>>,
+    pub bounds: Aabb,
+    pub stats: Stats,
+}
+fn recession(eq: &[Equation], dir: DVec3, budget: &mut Budget, p: Policy) -> Result<bool> {
+    if length(dir) <= p.angular_epsilon {
+        return Ok(false);
+    }
+    let d = unit(dir)?;
+    for e in eq {
+        budget.work(1)?;
+        if dot(e.normal(), d) > p.angular_epsilon {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
+/// Strict bounded, full-dimensional convex brush. Redundant/duplicate faces are
+/// rejected rather than dropping persistent plane identities.
+pub fn contours(brush: &mb3_dat::Brush, policy: Policy, limits: ComputeLimits) -> Result<Mesh> {
+    let p = policy.validate()?;
+    let n = brush.planes.len();
+    if n < 4 {
+        return Err(Error::InvalidBrush);
+    }
+    if n > limits.max_planes {
+        return Err(Error::Limit);
+    }
+    let mut b = Budget {
+        limits,
+        stats: Stats::default(),
+    };
+    let mut eq = b.reserve(n)?;
+    for plane in &brush.planes {
+        eq.push(Equation::from_basis(plane, p)?);
+    }
+    // A nonzero feasible recession direction proves unboundedness. Pairwise normal
+    // crosses cover pointed cone rays; normal-axis crosses cover rank-one slabs.
+    for i in 0..n {
+        for axis in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]] {
+            let r = cross(eq[i].normal(), axis);
+            if recession(&eq, r, &mut b, p)? || recession(&eq, scale(r, -1.), &mut b, p)? {
+                return Err(Error::InvalidBrush);
+            }
+        }
+        for j in i + 1..n {
+            b.work(1)?;
+            if length(sub(eq[i].normal(), eq[j].normal())) <= p.angular_epsilon
+                && (eq[i].offset() - eq[j].offset()).abs() <= p.distance_epsilon
+            {
+                return Err(Error::InvalidBrush);
+            }
+            let r = cross(eq[i].normal(), eq[j].normal());
+            if recession(&eq, r, &mut b, p)? || recession(&eq, scale(r, -1.), &mut b, p)? {
+                return Err(Error::InvalidBrush);
+            }
+        }
+    }
+    let mut vertices = Vec::new();
+    for i in 0..n {
+        for j in i + 1..n {
+            for k in j + 1..n {
+                b.work(1)?;
+                if let Some(v) = Equation::intersection(eq[i], eq[j], eq[k], p)? {
+                    let mut inside = true;
+                    for e in &eq {
+                        b.work(1)?;
+                        if e.distance(v)? > p.distance_epsilon {
+                            inside = false;
+                            break;
+                        }
+                    }
+                    if !inside {
+                        continue;
+                    }
+                    let mut duplicate = false;
+                    for old in &vertices {
+                        b.work(1)?;
+                        if length(sub(*old, v)) <= p.distance_epsilon {
+                            duplicate = true;
+                            break;
+                        }
+                    }
+                    if !duplicate {
+                        b.push(&mut vertices, v)?;
+                    }
+                }
+            }
+        }
+    }
+    if vertices.len() < 4 {
+        return Err(Error::InvalidBrush);
+    }
+    let bounds = Aabb::from_points(vertices.iter().copied())?.ok_or(Error::InvalidBrush)?;
+    let mut out = b.reserve(n)?;
+    let mut edges = Vec::new();
+    let mut total = 0usize;
+    let mut volume = 0.;
+    let reference = vertices[0];
+    for (i, e) in eq.iter().enumerate() {
+        let mut face = Vec::new();
+        for (id, v) in vertices.iter().enumerate() {
+            b.work(1)?;
+            if e.distance(*v)?.abs() <= p.distance_epsilon {
+                b.push(&mut face, id)?;
+            }
+        }
+        if face.len() < 3 {
+            return Err(Error::InvalidBrush);
+        }
+        total = total.checked_add(face.len()).ok_or(Error::Overflow)?;
+        if total > limits.max_vertices {
+            return Err(Error::Limit);
+        }
+        let center = scale(
+            face.iter().fold([0.; 3], |sum, id| add(sum, vertices[*id])),
+            1. / face.len() as f64,
+        );
+        let u = unit(from_f32(brush.planes[i].u)?)?;
+        let v = cross(e.normal(), u);
+        face.sort_unstable_by(|a, c| {
+            let a0 = sub(vertices[*a], center);
+            let c0 = sub(vertices[*c], center);
+            dot(a0, v)
+                .atan2(dot(a0, u))
+                .total_cmp(&dot(c0, v).atan2(dot(c0, u)))
+                .then(a.cmp(c))
+        });
+        let start = (0..face.len())
+            .min_by(|a, c| {
+                for d in 0..3 {
+                    let order = vertices[face[*a]][d].total_cmp(&vertices[face[*c]][d]);
+                    if !order.is_eq() {
+                        return order;
+                    }
+                }
+                std::cmp::Ordering::Equal
+            })
+            .ok_or(Error::InvalidBrush)?;
+        face.rotate_left(start);
+        let mut polygon = b.reserve(face.len())?;
+        for j in 0..face.len() {
+            let a = face[j];
+            let c = face[(j + 1) % face.len()];
+            b.push(&mut edges, if a < c { (a, c) } else { (c, a) })?;
+            polygon.push(vertices[a]);
+        }
+        for j in 1..polygon.len() - 1 {
+            volume += dot(
+                sub(polygon[0], reference),
+                cross(sub(polygon[j], reference), sub(polygon[j + 1], reference)),
+            ) / 6.;
+        }
+        out.push(polygon);
+    }
+    edges.sort_unstable();
+    if edges.len() % 2 != 0
+        || edges
+            .chunks(2)
+            .any(|pair| pair.len() != 2 || pair[0] != pair[1])
+        || edges.windows(3).any(|a| a[0] == a[2])
+    {
+        return Err(Error::InvalidBrush);
+    }
+    if !volume.is_finite() || volume <= p.distance_epsilon.powi(3) {
+        return Err(Error::InvalidBrush);
+    }
+    b.stats.vertices = total;
+    Ok(Mesh {
+        contours: out,
+        bounds,
+        stats: b.stats,
+    })
+}
+#[cfg(test)]
+pub(crate) fn cube() -> mb3_dat::Brush {
+    use mb3_dat::Plane;
+    let mut planes = Vec::new();
+    for axis in 0..3 {
+        for sign in [-1., 1.] {
+            let mut p = Plane::default();
+            p.p0[axis] = sign;
+            let a = (axis + 1) % 3;
+            let c = (axis + 2) % 3;
+            p.u[a] = 1.;
+            p.v[c] = sign;
+            planes.push(p);
+        }
+    }
+    mb3_dat::Brush { planes }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn cube_topology_winding_determinism() {
+        let brush = cube();
+        let m = contours(&brush, Policy::default(), ComputeLimits::default()).unwrap();
+        assert_eq!(m.contours.len(), 6);
+        assert!(m.contours.iter().all(|p| p.len() == 4));
+        assert_eq!(m.bounds, Aabb::new([-1.; 3], [1.; 3]).unwrap());
+        for (p, poly) in brush.planes.iter().zip(&m.contours) {
+            let n = Equation::from_basis(p, Policy::default()).unwrap().normal();
+            assert!(dot(cross(sub(poly[1], poly[0]), sub(poly[2], poly[1])), n) > 0.);
+        }
+        assert_eq!(
+            m.contours,
+            contours(&brush, Policy::default(), ComputeLimits::default())
+                .unwrap()
+                .contours
+        );
+    }
+    #[test]
+    fn invalid_unbounded_redundant_and_limits() {
+        let mut b = cube();
+        b.planes.pop();
+        assert!(contours(&b, Policy::default(), ComputeLimits::default()).is_err());
+        b = cube();
+        b.planes.push(b.planes[0].clone());
+        assert!(contours(&b, Policy::default(), ComputeLimits::default()).is_err());
+        b = cube();
+        for l in [
+            ComputeLimits {
+                max_planes: 5,
+                ..Default::default()
+            },
+            ComputeLimits {
+                max_work: 1,
+                ..Default::default()
+            },
+            ComputeLimits {
+                max_vertices: 7,
+                ..Default::default()
+            },
+            ComputeLimits {
+                max_owned_bytes: 1,
+                ..Default::default()
+            },
+        ] {
+            assert!(contours(&b, Policy::default(), l).is_err());
+        }
+    }
+    #[test]
+    fn translated_box_and_inverted_halfspace() {
+        let mut b = cube();
+        for p in &mut b.planes {
+            p.p0[0] += 100.;
+            p.p0[1] -= 50.;
+        }
+        let m = contours(&b, Policy::default(), ComputeLimits::default()).unwrap();
+        assert_eq!(m.bounds.min, [99., -51., -1.]);
+        b.planes[0].v = b.planes[0].v.map(|x| -x);
+        assert!(contours(&b, Policy::default(), ComputeLimits::default()).is_err());
+    }
+}

crates/nanobrush-geometry/src/lib.rs

@@ -27,3 +27,78 @@ pub(crate) fn alloc<T>(n: usize) -> Result<Vec<T>> {
     out.try_reserve_exact(n).map_err(|_| Error::Allocation)?;
     Ok(out)
 }
+
+pub mod brush;
+#[derive(Clone, Copy, Debug)]
+pub struct ComputeLimits {
+    pub max_planes: usize,
+    pub max_vertices: usize,
+    pub max_work: usize,
+    pub max_owned_bytes: usize,
+}
+impl Default for ComputeLimits {
+    fn default() -> Self {
+        Self {
+            max_planes: 64,
+            max_vertices: 100_000,
+            max_work: 10_000_000,
+            max_owned_bytes: 128 * 1024 * 1024,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Stats {
+    pub work: usize,
+    pub owned: usize,
+    pub vertices: usize,
+}
+pub(crate) struct Budget {
+    pub limits: ComputeLimits,
+    pub stats: Stats,
+}
+impl Budget {
+    fn work(&mut self, n: usize) -> Result<()> {
+        self.stats.work = self.stats.work.checked_add(n).ok_or(Error::Overflow)?;
+        if self.stats.work > self.limits.max_work {
+            Err(Error::Limit)
+        } else {
+            Ok(())
+        }
+    }
+    fn bytes(&mut self, n: usize) -> Result<()> {
+        self.stats.owned = self.stats.owned.checked_add(n).ok_or(Error::Overflow)?;
+        if self.stats.owned > self.limits.max_owned_bytes {
+            Err(Error::Limit)
+        } else {
+            Ok(())
+        }
+    }
+    fn reserve<T>(&mut self, n: usize) -> Result<Vec<T>> {
+        self.bytes(
+            n.checked_mul(std::mem::size_of::<T>())
+                .ok_or(Error::Overflow)?,
+        )?;
+        alloc(n)
+    }
+    fn push<T>(&mut self, out: &mut Vec<T>, v: T) -> Result<()> {
+        if out.len() == out.capacity() {
+            let cap = out
+                .capacity()
+                .saturating_mul(2)
+                .max(1)
+                .min(self.limits.max_vertices);
+            if cap <= out.len() {
+                return Err(Error::Limit);
+            }
+            self.bytes(
+                (cap - out.capacity())
+                    .checked_mul(std::mem::size_of::<T>())
+                    .ok_or(Error::Overflow)?,
+            )?;
+            out.try_reserve_exact(cap - out.len())
+                .map_err(|_| Error::Allocation)?;
+        }
+        out.push(v);
+        Ok(())
+    }
+}

docs/GEOMETRY.md

@@ -5,3 +5,9 @@ This is an independently authored native policy, not verified editor parity. The
 Default distance tolerance is 1e-6 world units; angular/determinant tolerance is 1e-10. Both must be finite and positive, with angular tolerance below one. These are explicit native choices, not a claim to reproduce the source helper’s raw determinant threshold. Parallel/nearly parallel triples return no intersection. AABBs retain finite min/max values and include an explicit empty result. MAP/native axes follow the converter mapping `(x,y,z) -> (x,z,-y)` and its inverse. Invalid vectors/policies/ranges return errors.
 
 Tests cover signed basis orientation, asymmetric three-plane intersections, parallel triples, scaled bases, boxes, empty bounds, axis round trips and invalid values. See the [ten-task ledger](PROGRESS_2026-10-26.md) for staged extensions and remaining parity limits.
+
+## Convex brush contours
+
+`brush::contours` enumerates checked plane triples, keeps interior intersections, welds points within distance epsilon and orders each face around its outward normal. Starts are rotated to lexicographically smallest coordinates. Every original plane must contribute a face: duplicate/redundant/degenerate faces are errors, preserving plane identity rather than silently dropping them. Feasible recession directions, missing/invalid edges and nonpositive volume reject unbounded or collapsed objects. Every edge must occur twice. This is a strict native convex profile, not the host's collapse/discard behavior.
+
+Defaults cap 64 planes, 100,000 generated face vertices, 10 million work units and 128 MiB requested scratch/output storage. Work includes recession checks, triple candidates, containment and welding; face sorting is additionally bounded by vertex caps. Allocations are fallible; errors return no partial mesh. Analytic cube, translated box, winding/topology/determinism, contradictory/open/redundant and resource-limit tests pass. Near-degenerate geometry can be rejected conservatively; exact legacy tolerances remain unverified.

docs/PROGRESS_2026-10-26.md

@@ -9,7 +9,7 @@ Scope: extend native headless formats and geometry. Each stage is independently
 | 3 | P6.25 | Bounded computed OBJ writer | Complete: explicit contours and patch grids, stable per-brush exact position deduplication, global 1-based indices and quad winding. Four E02 OBJ outputs match exact bytes; invalid geometry/limits tests pass. |
 | 4 | P6.26 | CLI OBJ with loss acknowledgement | Complete: `--to obj`, grouped preflight losses and explicit `--allow-lossy`; missing computed data remains blocking. Existing atomic publication is reused. CLI acknowledgement/preflight/regression tests pass. |
 | 5 | P5.15 | Geometry primitives/bounds | Complete: f64 vector helpers, checked unit plane equations/triple intersections, f32 boundary checks, MAP axes and AABBs. Analytic/degenerate/scaled-basis tests pass; native epsilon/interior policy documented separately from legacy parity. |
-| 6 | P5.16 | Convex brush contours | Pending |
+| 6 | P5.16 | Convex brush contours | Complete: bounded half-space intersections, recession rejection, deterministic outward contours, closed-edge and volume checks. Cube/translation/winding/invalid/redundant/budget tests pass. |
 | 7 | P5.17 | Patch9 tessellation | Pending |
 | 8 | P5.18 | Computed world pipeline/CLI | Pending |
 | 9 | P5.19 | Nearest-hit ray queries | Pending |

docs/TODO.md

@@ -128,6 +128,8 @@ Each task ID is stable. Split tasks into child IDs as evidence grows. Record dep
 
 - [x] P5.15 Implement native checked geometry primitives, plane equations/intersections, numeric policy and bounds ([GEOMETRY.md](GEOMETRY.md)).
 
+- [x] P5.16 Implement bounded native convex brush contour reconstruction, topology checks and analytic regressions ([GEOMETRY.md](GEOMETRY.md)).
+
 ## P6 — File formats and converters
 
 **Depends on:** P3 oracle where available, P5 document model. **Exit:** standalone format specifications, declared compatibility subsets, fixture corpus, and native codecs.