Files
solidcraft/crates/kernel/src/planar_sources.rs
T
e12afd11cc Ellipse and spline extrudes make one wall; coplanar faces never lose their names to a budget (#11687)
* Planar sources: decide coplanar faces by support group, no budgets that drop sources

map_planar_sources kept two budgets, `metadata` (2 MB) and `identity_bytes`
(16 MB), charged by each face's source descriptor and by every extra
candidate on its plane. When one ran out, faces silently lost their source
and with it their persistent name: a 300-hole plate whose top a comb of
grooves cuts into 62 strips lost the cap source from strip ~47 on.

The budgets bounded the real cost: each result face looked at every
candidate on its plane, faces x candidates when many faces are coplanar.
The candidates are now grouped by support once (`same_support` against
each group's first plane, through the existing PlaneIndex), each group's
chosen source, ambiguity and inner flag decided once, and the faces
without a role together with the competing tool faces grouped the same
way. Each result face then looks up its plane's few groups. The decision
is the old one: blocked by an unknown or competing support, else the
first candidate on the plane unless another candidate there has a
different plane, source or role.

Work: grouping looks at each candidate's index window once per group
(each candidate is assigned on its group's first look), and each face
looks at the group representatives near its plane, so the planes looked
at grow with faces + candidates. A counter (`looked`) checks it: n
pieces of one cap and n faces on its plane take exactly 2n looks (n*n
before), 3n with n blocking supports.

Tests: the holed plate keeps the cap source on all 62 strips and the
bottom (fails on the old code: face 352 lost its source); the existing
planar source tests pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ

* Extrude: an ellipse or a spline sketch curve sweeps one wall

An extruded ellipse had four side faces (`F2:side:e1#1` to `#4`), one
per conic quarter, and a spline one per span: the profile holds such a
curve as several exact segments and SMLib got each as its own curve.

The Extrude feature's builder (`extrude_whole_sides`) now takes a
`one_curve` test from the caller. Each run of free-form segments of one
degree that it says are one curve goes to SMLib as one B-spline: the
Béziers' control points in a row, knots repeated the degree times at
each joint, each span as long as keeps the speed through the joint the
same (so the curve is C1 there and SMLib makes one face over it, as it
would not over a C0 parametrisation), weights scaled to meet. Exact: the
same curve, reparametrised. A loop starts at a run's start, so no run
wraps round it. The wall's history lists every piece, and its
construction source is its first piece's (as joined collinear lines).

The document says which segments are one curve: ExactSketchCurves now
also holds each free-form sketch curve's exact segments
(`find_free_form`: a segment that is one of them, either way round), and
the profile roles use it, so the wall is named `side:<curve>` from its
history rather than by the curve nearest its mesh centre.

Saved designs rebuild with these walls renamed (`F2:side:e1#k` ->
`F2:side:e1`); accepted, no alias kept.

Tests: kernel `pieces_of_one_curve_extrude_into_one_wall` (an ellipse in
four conics is 3 faces, its volume pi a b h to 1e-6, the wall generated by
all four pieces; a 3-span spline closed by lines is one wall; the same
solid as a face per piece); doc
`an_extruded_ellipse_or_spline_is_one_wall_named_by_its_curve` (one
`F2:side:e1`, no piece names, the same names on a second build and after
reopening).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ

* Tests: a tray's far rim name is checked on the exact B-rep face

The tray test took the point `sheet:...:rim.far` finds as right when it
lay within 1e-3 mm of the strip z = 30, 199 <= y <= 200: a slack sized to
the mesh. It now asserts on the face the name finds, on exact geometry:
the point's distance to that face's surface (FaceSurface::nearest) is
within rounding at the part's scale (1e-12 x its size), and the point is
inside the face's boundary, counted by crossings of its record edges
(each asserted to be a line, the rim being planar).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ

* Tests: delete tests/naming/, the records no test reads since the naming corpus stopped comparing against them

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ

* Viewport test: smooth wall joins drawn from eight G2 spline walls

The PR extrudes each spline or ellipse sketch curve as one wall, so the
offset-ellipse ring the test built has no joins between faces any more.
The test now extrudes a circle drawn as eight cubic splines: eight walls
meeting with one curvature along eight upright edges (24 edges in all).
It still checks that those joins are left out of the shaded view, drawn
in the wireframe and selectable as edges.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ

* Kernel ladder: 009 and 012 record the one-wall extrude (an extruded spline or ellipse sweeps one wall)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 21:27:14 +00:00

931 lines
48 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Exact oriented planar support lineage through a trim and an inside shell.
//! No tessellated face names, centroids, or nearest-plane choices are used.
use super::{Body, FaceSource};
use crate::{KernelError, Result, guard};
use solidcore_record::brep::{self, Surface};
use solidcore_record::{Plane, Vec3};
use solidcraft_geom::prelude::*;
use std::collections::HashMap;
use std::sync::Arc;
/// The oriented plane each face of `body` lies on (in face order), from its record: the
/// surface's plane, its normal turned with the face; none for a face on any other surface.
pub(super) fn actual_planes(body: &Body) -> Result<Vec<Option<Plane>>> {
let record = body.record();
let mut forward = vec![true; record.faces.len()];
for shell in &record.shells {
if let brep::Shell::Faces { faces, .. } = shell {
for o in faces {
if let Some(f) = forward.get_mut(o.face as usize) {
*f = o.forward;
}
}
}
}
let v = |p: [f64; 3]| Vec3::new(p[0], p[1], p[2]);
Ok(record
.faces
.iter()
.zip(forward)
.map(|(face, forward)| {
let (o, u, w) = match face.surface {
Surface::Plane { origin, u_axis, v_axis } => (v(origin), v(u_axis), v(v_axis)),
Surface::PlaneThrough { origin, u_point, v_point } => (v(origin), v(u_point) - v(origin), v(v_point) - v(origin)),
_ => return None,
};
if !o.is_finite() || !u.is_finite() || !w.is_finite() || u.cross(w).len() <= u.len() * w.len() * 1e-8 {
return None;
}
// A reversed face faces against its surface's normal.
if forward { Plane::new(o, u, w) } else { Plane::new(o, w, u) }
})
.collect())
}
/// The resolution two planar supports are compared at: SMLib's own, by which it calls two planes
/// coincident (SmPlane::CoincidenceCheck): a distance within the body's intersection tolerance
/// (the record's `tolerance`, SMLib's XSectTol3d) and normals within the angle that tolerance
/// makes across the body (`tolerance / size`; SMLib takes the plane's own extent, the body's is
/// at least as large, so this is no looser), never finer than rounding. Faces SMLib rebuilt
/// through a boolean lie within it of the plane they were made on (a cut cap at z = 10 came back
/// 2.1e-11 off and 1.4e-12 rad turned), not within a few ulps of it.
#[derive(Clone, Copy, Debug)]
pub(super) struct Resolution {
linear: f64,
angular: f64,
}
impl Resolution {
pub(super) fn of(body: &Body) -> Self {
let tolerance = body.record().tolerance;
let size = body.size();
let rounding = 4096. * f64::EPSILON;
let linear = if tolerance.is_finite() && tolerance > 0. { tolerance } else { 0. };
let angular = if size.is_finite() && size > 0. { linear / size } else { 0. };
Resolution { linear: linear.max(rounding * (1. + size.max(0.))), angular: angular.max(rounding) }
}
}
/// The planes of a list indexed by their unit normal and their offset, so the planes that can be
/// one support with a given plane at a resolution (`same_support`) are found without looking at
/// the rest: a superset of them, which the caller decides on exactly with `same_support`.
///
/// Two unit normals within the resolution's angle (`|na × nb| <= angular`, `na · nb > 0`) differ
/// by at most their angle, `asin(angular) <= π/2 · angular < 2 · angular`: the normal cells are
/// twice that wide and a plane looks in its own cell and the neighbour on each side it is near.
/// Their offsets from a common centre `c`, `d = (o - c) · n`, satisfy
/// `d_b - d_a = (b.o - a.o) · n_b + (a.o - c) · (n_b - n_a)`, so a match is within
/// `linear + |a.o - c| · |n_b - n_a|` of the plane's own offset; each cell is sorted by offset and
/// searched in that window, widened by far more than the rounding of the offsets. A plane whose
/// normal is not of unit length (a hostile record) is kept aside and offered to every query.
struct PlaneIndex {
cells: HashMap<[i64; 3], Vec<(f64, usize)>>,
/// Entries whose normal is not unit to `UNIT`: offered to every query.
loose: Vec<usize>,
len: usize,
centre: Vec3,
/// The farthest origin of an indexed plane from `centre`.
reach: f64,
/// The bound on two matching normals' difference; the cells are `2 * normal_reach` wide.
normal_reach: f64,
linear: f64,
}
/// How far from unit length a normal may be for the index's bounds to hold.
const UNIT: f64 = 1e-9;
impl PlaneIndex {
fn new<'a>(planes: impl Iterator<Item = &'a Plane> + Clone, at: Resolution) -> Self {
let mut lo = Vec3::new(f64::INFINITY, f64::INFINITY, f64::INFINITY);
let mut hi = -lo;
for p in planes.clone().filter(|p| p.origin.is_finite()) {
lo = Vec3::new(lo.x.min(p.origin.x), lo.y.min(p.origin.y), lo.z.min(p.origin.z));
hi = Vec3::new(hi.x.max(p.origin.x), hi.y.max(p.origin.y), hi.z.max(p.origin.z));
}
let centre = if lo.is_finite() && hi.is_finite() { (lo + hi) * 0.5 } else { Vec3::ZERO };
let normal_reach = 2. * at.angular + 4. * UNIT;
let mut index = PlaneIndex { cells: HashMap::new(), loose: Vec::new(), len: 0, centre, reach: 0., normal_reach, linear: at.linear };
for (position, plane) in planes.enumerate() {
index.len += 1;
let n = plane.normal();
let d = (plane.origin - centre).dot(n);
match index.cell(n) {
Some(key) if (n.len() - 1.).abs() <= UNIT && d.is_finite() => {
index.reach = index.reach.max((plane.origin - centre).len());
index.cells.entry(key).or_default().push((d, position));
}
_ => index.loose.push(position),
}
}
for cell in index.cells.values_mut() {
cell.sort_by(|a, b| a.0.total_cmp(&b.0));
}
index
}
fn cell(&self, n: Vec3) -> Option<[i64; 3]> {
let width = 2. * self.normal_reach;
let key = |v: f64| {
let k = (v / width).floor();
(k.is_finite() && k.abs() < 1e15).then_some(k as i64)
};
Some([key(n.x)?, key(n.y)?, key(n.z)?])
}
/// The positions of the indexed planes that can be one support with `plane`, in no order:
/// every one `same_support` accepts, and others it refuses.
fn near(&self, plane: &Plane) -> Vec<usize> {
let n = plane.normal();
let offset = (plane.origin - self.centre).dot(n);
let from_centre = (plane.origin - self.centre).len();
let (Some(low), Some(high)) =
(self.cell(n - Vec3::new(1., 1., 1.) * self.normal_reach), self.cell(n + Vec3::new(1., 1., 1.) * self.normal_reach))
else {
return (0..self.len).collect();
};
if (n.len() - 1.).abs() > UNIT || !offset.is_finite() || !from_centre.is_finite() {
return (0..self.len).collect();
}
let window = self.linear + from_centre * self.normal_reach + 1e-12 * (1. + from_centre + self.reach);
let mut out = self.loose.clone();
for x in low[0]..=high[0] {
for y in low[1]..=high[1] {
for z in low[2]..=high[2] {
let Some(cell) = self.cells.get(&[x, y, z]) else { continue };
let first = cell.partition_point(|e| e.0 < offset - window);
let last = cell.partition_point(|e| e.0 <= offset + window);
out.extend(cell.get(first..last.max(first)).unwrap_or_default().iter().map(|e| e.1));
}
}
}
out
}
}
/// Whether `a` and `b` are one oriented plane at resolution `at`: normals the same way within its
/// angle, each origin within its distance of the other plane.
pub(super) fn same_support(a: &Plane, b: &Plane, at: Resolution) -> bool {
let (na, nb) = (a.normal(), b.normal());
na.cross(nb).len() <= at.angular
&& na.dot(nb) > 0.
&& (b.origin - a.origin).dot(na).abs() <= at.linear
&& (a.origin - b.origin).dot(nb).abs() <= at.linear
}
/// A source a face on its plane can take: the plane it names (for a shell's inner role, the
/// source's plane moved in and turned round), the source, and whether it is that inner role.
#[derive(Clone, Copy, Debug, PartialEq)]
struct Candidate<'a> {
plane: Plane,
source: &'a FaceSource,
inner: bool,
}
/// What a mapping's inputs say of one plane of its result.
#[derive(Debug, PartialEq)]
enum Support<'a> {
/// A face without a role, or a competing tool face, lies on the plane.
Blocked,
/// Every candidate on the plane is one source, plane and role: the pieces of one logical face.
Source(Candidate<'a>),
/// No candidate lies on the plane, or candidates of distinct identities do.
Unnamed,
}
/// Planes partitioned into supports, in their order: a plane starts a group unless it is one
/// support (`same_support`) with the first plane of an earlier group, which it then joins. Returns
/// each plane's group and each group's first plane; `looked` counts the planes looked at.
fn group_supports(planes: &[Plane], at: Resolution, looked: &mut usize) -> (Vec<usize>, Vec<usize>) {
let index = PlaneIndex::new(planes.iter(), at);
let mut group: Vec<Option<usize>> = vec![None; planes.len()];
let mut first = Vec::new();
for (i, plane) in planes.iter().enumerate() {
if group.get(i).is_some_and(Option::is_some) {
continue;
}
let g = first.len();
first.push(i);
let near = index.near(plane);
*looked += near.len();
for j in near {
if let Some(slot @ None) = group.get_mut(j)
&& (j == i || planes.get(j).is_some_and(|other| same_support(plane, other, at)))
{
*slot = Some(g);
}
}
}
(group.into_iter().map(|g| g.unwrap_or(usize::MAX)).collect(), first)
}
/// The candidates and blocking planes of a mapping grouped by support once, so each result face
/// looks up its plane's few groups instead of every candidate on that plane: with many coplanar
/// faces the work grows with the faces plus the candidates, not with their product.
struct SupportDecisions<'a> {
/// Each candidate group's first plane, and its decision: its first candidate, or none when
/// the group holds candidates of distinct identities.
groups: Vec<(Plane, Option<Candidate<'a>>)>,
group_index: PlaneIndex,
/// The first plane of each group of the faces without a role and the competing tool faces.
blocking: Vec<Plane>,
blocking_index: PlaneIndex,
at: Resolution,
/// The planes looked at, building the groups and deciding faces.
looked: usize,
}
impl<'a> SupportDecisions<'a> {
/// `candidates` in the order that decides between them.
fn new(candidates: &[Candidate<'a>], unknown: &[Plane], competing: &[Plane], at: Resolution) -> Self {
let mut looked = 0;
let planes: Vec<Plane> = candidates.iter().map(|c| c.plane).collect();
let (group, first) = group_supports(&planes, at, &mut looked);
let mut groups: Vec<(Plane, Option<Candidate<'a>>)> = first.iter().filter_map(|&i| candidates.get(i)).map(|c| (c.plane, Some(*c))).collect();
for (candidate, g) in candidates.iter().zip(&group) {
if let Some((_, decision)) = groups.get_mut(*g)
&& decision.is_some_and(|d| d != *candidate)
{
*decision = None;
}
}
let group_index = PlaneIndex::new(groups.iter().map(|g| &g.0), at);
let all_blocking: Vec<Plane> = unknown.iter().chain(competing).copied().collect();
let (_, first) = group_supports(&all_blocking, at, &mut looked);
let blocking: Vec<Plane> = first.iter().filter_map(|&i| all_blocking.get(i).copied()).collect();
let blocking_index = PlaneIndex::new(blocking.iter(), at);
SupportDecisions { groups, group_index, blocking, blocking_index, at, looked }
}
/// What the inputs say of a face on `actual`.
fn at(&mut self, actual: &Plane) -> Support<'a> {
let at = self.at;
let near = self.blocking_index.near(actual);
self.looked += near.len();
if near.into_iter().any(|i| self.blocking.get(i).is_some_and(|plane| same_support(plane, actual, at))) {
return Support::Blocked;
}
let mut near = self.group_index.near(actual);
self.looked += near.len();
// Groups are numbered in the candidates' order, so the first matching group's first
// candidate is the first candidate on the plane.
near.sort_unstable();
let mut chosen: Option<Candidate<'a>> = None;
for (plane, decision) in near.into_iter().filter_map(|g| self.groups.get(g)) {
if !same_support(plane, actual, at) {
continue;
}
match (chosen, decision) {
(_, None) => return Support::Unnamed,
(None, Some(d)) => chosen = Some(*d),
(Some(c), Some(d)) if c != *d => return Support::Unnamed,
_ => {}
}
}
chosen.map_or(Support::Unnamed, Support::Source)
}
}
fn base_plane(source: &FaceSource, actual: &Plane) -> Option<Plane> {
match source {
FaceSource::CertifiedExtrudeSide { plane: Some(p), .. }
| FaceSource::CertifiedExtrudeCap { plane: p, .. }
| FaceSource::Box { producer: Some(_), plane: p, .. }
| FaceSource::CylinderCap { plane: p, .. }
| FaceSource::ShellPlanar { producer: Some(_), plane: p, .. } => Some(*p),
FaceSource::Imported { producer: Some(_), payload_sha256: Some(_), .. } => Some(*actual),
_ => None,
}
}
pub(super) fn certified_plane(source: &FaceSource) -> Option<Plane> {
match source {
FaceSource::CertifiedExtrudeSide { plane: Some(p), .. }
| FaceSource::CertifiedExtrudeCap { plane: p, .. }
| FaceSource::Box { producer: Some(_), plane: p, .. }
| FaceSource::CylinderCap { plane: p, .. }
| FaceSource::ShellPlanar { producer: Some(_), plane: p, .. } => Some(*p),
_ => None,
}
}
fn boolean_source(source: &FaceSource, constructed: bool) -> bool {
matches!(source, FaceSource::ShellPlanar { producer: Some(_), .. }) || (constructed && certified_plane(source).is_some())
}
pub(super) fn descriptor_cost(source: &FaceSource) -> Option<usize> {
let mut cost = 256usize;
match source {
FaceSource::CertifiedExtrudeCap { outer, holes, .. } => {
if holes.len() > 4096 {
return None;
}
cost = cost.checked_add(holes.len().checked_mul(64)?)?;
let mut entries = 4096usize;
for id in outer.iter().chain(holes.iter().flatten()) {
entries = entries.checked_sub(1)?;
if id.len() > 128 {
return None;
}
cost = cost.checked_add(id.len().checked_add(64)?)?;
}
}
FaceSource::CertifiedExtrudeSide { curve, .. } => {
if curve.len() > 128 {
return None;
}
cost = cost.checked_add(curve.len())?;
}
FaceSource::Imported { payload_sha256: Some(digest), .. } => {
if digest.len() > 64 {
return None;
}
cost = cost.checked_add(digest.len())?;
}
FaceSource::ShellPlanar { source, .. } if !matches!(source.as_ref(), FaceSource::ShellPlanar { .. }) => {
cost = cost.checked_add(descriptor_cost(source)?)?;
}
FaceSource::ExtrudeCap { region, .. } => {
if region.holes.len() > 8192 {
return None;
}
cost = cost.checked_add(region.holes.len().checked_mul(64)?)?;
let count = region.holes.iter().try_fold(region.outer.segs.len(), |sum, h| sum.checked_add(h.segs.len()))?;
if count > 8192 {
return None;
}
cost = cost.checked_add(count.checked_mul(128)?)?;
}
FaceSource::ExtrudeSide { .. } | FaceSource::Imported { .. } | FaceSource::Box { .. } | FaceSource::CylinderCap { .. } => {}
_ => return None,
}
Some(cost)
}
impl Body {
/// Preserve uniquely certified unchanged planar construction supports.
pub fn with_preserved_planar_sources(self, input: &Body) -> Result<Self> {
self.map_planar_sources(&[input], None, None, &[], false)
}
/// Generate distinct outer/inner roles from the exact original supports of
/// an inside shell. Generated rims and curved walls are intentionally absent.
pub(crate) fn with_shell_planar_sources(self, input: &Body, thickness: f64, open: &[Vec3]) -> Result<Self> {
self.map_planar_sources(&[input], Some(thickness), None, open, false)
}
/// Retain exact shell roles, and construction roles for Cut, only on unchanged
/// supports without a competing coplanar tool. No imported or fitted role is inferred.
pub(crate) fn with_preserved_boolean_planar_sources(self, input: &Body, tool: &Body, constructed: bool) -> Result<Self> {
let self_ = self.inherit_regularization_protection(input).inherit_regularization_protection(tool);
if !input.face_sources().is_some_and(|sources| sources.iter().flatten().any(|s| boolean_source(s, constructed))) {
return Ok(self_);
}
self_.map_planar_sources(&[input], None, Some(tool), &[], constructed)
}
/// Retain exact construction and shell roles through a Union from every operand, only on
/// unchanged supports. Coplanar supports of different operands carry distinct identities, so
/// a face merged from several stays without a role.
pub(crate) fn with_preserved_union_planar_sources(self, operands: &[&Body]) -> Result<Self> {
let self_ = operands.iter().fold(self, |body, operand| body.inherit_regularization_protection(operand));
if !operands.iter().any(|input| input.face_sources().is_some_and(|sources| sources.iter().flatten().any(|s| boolean_source(s, true)))) {
return Ok(self_);
}
self_.map_planar_sources(operands, None, None, &[], true)
}
fn map_planar_sources(mut self, inputs: &[&Body], shell: Option<f64>, blocker: Option<&Body>, open: &[Vec3], constructed: bool) -> Result<Self> {
// Every boolean (a Cut's tool, or a Union's second operand) leaves the result with
// faces whose support no input role describes.
let boolean = blocker.is_some() || inputs.len() > 1;
for input in inputs {
self.regularization_protected |= input.regularization_protected;
}
if inputs.iter().all(|input| input.face_sources().is_none()) {
return Ok(self);
}
if inputs.iter().any(|input| input.face_sources().is_some_and(|sources| sources.len() != input.face_count())) {
return Err(KernelError::Invalid("planar source alignment mismatch".into()));
}
if shell.is_some_and(|t| !t.is_finite() || t <= 0.) {
return Err(KernelError::Invalid("invalid shell source thickness".into()));
}
if open.len() > 256 {
return Ok(self);
}
let at = Resolution::of(&self);
let opening_tolerance = if shell.is_some() { inputs.iter().map(|input| input.size()).fold(0., f64::max) * 1e-4 + 1e-6 } else { 0. };
let mapped = guard("exact planar support lineage", || {
let mut competing = Vec::new();
for plane in blocker.map(actual_planes).transpose()?.into_iter().flatten().flatten() {
// A cut's tool face enters the result turned round (the wall of the hollow it
// leaves), so it competes only with a face on its plane facing against it: a
// pocket's floor, or a target face the tool sat on from outside. A tool face that
// faces the same way as the target's face on its plane (a pocket cut down from a
// cap, its top on the cap) is the tool's own outside and leaves the cap the cap.
let opposing = Plane::new(plane.origin, plane.x, -plane.y).ok_or_else(|| KernelError::Invalid("invalid opposing plane".into()))?;
competing.push(opposing);
}
let mut candidates = Vec::new();
let mut unknown_supports = Vec::new();
let mut faces = Vec::new();
for input in inputs {
let sources = input.face_sources().unwrap_or_default();
faces
.extend(actual_planes(input)?.into_iter().enumerate().map(|(index, plane)| (plane, sources.get(index).and_then(Option::as_ref))));
}
for (actual, source) in faces {
let Some(actual) = actual else { continue };
let Some(source) = source else {
unknown_supports.push(actual);
continue;
};
if (boolean && !boolean_source(source, constructed)) || (shell.is_some() && matches!(source, FaceSource::ShellPlanar { .. })) {
unknown_supports.push(actual);
continue;
}
let Some(plane) = base_plane(source, &actual) else {
unknown_supports.push(actual);
continue;
};
if !same_support(&plane, &actual, at) || (shell.is_some() && open.iter().any(|p| actual.height(*p).abs() <= opening_tolerance)) {
unknown_supports.push(actual);
continue;
}
if descriptor_cost(source).is_none() {
unknown_supports.push(actual);
continue;
}
candidates.push(Candidate { plane, source, inner: false });
if let Some(t) = shell {
let inner = Plane::new(plane.origin - plane.normal() * t, plane.x, -plane.y)
.ok_or_else(|| KernelError::Invalid("invalid shell inner source plane".into()))?;
candidates.push(Candidate { plane: inner, source, inner: true });
}
}
// The candidates are taken in the order of their normal's x: where several match one
// face, the first decides which the rest are compared with.
candidates.sort_by(|a, b| a.plane.normal().x.total_cmp(&b.plane.normal().x));
let mut decide = SupportDecisions::new(&candidates, &unknown_supports, &competing, at);
let mut result = Vec::new();
for (index, actual) in actual_planes(&self)?.into_iter().enumerate() {
// A face no candidate names keeps what it had, where an operation could have left
// it a source no role describes.
let existing = || {
self.face_sources()
.and_then(|sources| sources.get(index))
.and_then(|s| s.as_ref())
.filter(|s| (boolean || self.face_was_coalesced(index)) && !boolean_source(s, constructed) && descriptor_cost(s).is_some())
.cloned()
};
let found = match actual.map(|actual| decide.at(&actual)) {
Some(Support::Source(Candidate { plane, source, inner })) => Some(if shell.is_some() {
FaceSource::ShellPlanar { producer: None, source: Box::new(source.clone()), inner, plane }
} else {
source.clone()
}),
Some(Support::Blocked | Support::Unnamed) | None => existing(),
};
result.push(found);
}
Ok(result)
})?;
self.face_sources = Some(Arc::new(mapped));
self.regularize_certified_planar_faces()
}
pub fn with_shell_certificate(mut self, producer: u64) -> Result<Self> {
if producer == 0 {
return Err(KernelError::Invalid("invalid shell source producer".into()));
}
if let Some(sources) = &self.face_sources {
let mut sources = sources.as_ref().clone();
for source in sources.iter_mut().flatten() {
if let FaceSource::ShellPlanar { producer: id, .. } = source {
*id = Some(producer);
}
}
self.face_sources = Some(Arc::new(sources));
}
self.regularize_certified_planar_faces()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{box_solid, fillet, shell, transform_matrix};
/// The corner points of face `i` of `b`, from its record.
fn face_points(b: &Body, i: usize) -> Vec<Vec3> {
let record = b.record();
let mut out = Vec::new();
for l in &record.faces[i].loops {
match l {
brep::Loop::Edges { edges } => {
for e in edges {
for v in record.edges[e.edge as usize].vertices {
let p = record.vertices[v as usize].point;
out.push(Vec3::new(p[0], p[1], p[2]));
}
}
}
brep::Loop::Vertex { vertex } => {
let p = record.vertices[*vertex as usize].point;
out.push(Vec3::new(p[0], p[1], p[2]));
}
}
}
out
}
/// The edges of face `i` of `b` as their end points, from its record.
fn face_edges(b: &Body, i: usize) -> Vec<(Vec3, Vec3)> {
let record = b.record();
let at = |v: u32| {
let p = record.vertices[v as usize].point;
Vec3::new(p[0], p[1], p[2])
};
record.faces[i]
.loops
.iter()
.flat_map(|l| match l {
brep::Loop::Edges { edges } => edges.iter().map(|e| record.edges[e.edge as usize].vertices).map(|[a, b]| (at(a), at(b))).collect(),
brep::Loop::Vertex { .. } => Vec::new(),
})
.collect()
}
/// One body holding `a` and `b` side by side (their records' shells together, `b` wholly
/// beyond `a` along x), each face's source that of the face of its own operand on the same
/// plane (none from `b` when `b_sources` is false).
fn side_by_side(a: &Body, b: &Body, b_sources: bool) -> Body {
let part = brep::part::compound(&[a.record(), b.record()]).unwrap();
let mut combined = Body::from_record(part.brep).unwrap();
let planes = |x: &Body| actual_planes(x).unwrap();
let (pa, pb, pc) = (planes(a), planes(b), planes(&combined));
let a_right = a.outline_bounds().max.x;
let sources: Vec<Option<FaceSource>> = pc
.iter()
.enumerate()
.map(|(i, p)| {
let p = (*p)?;
let find = |of: &Body, ps: &[Option<Plane>]| {
ps.iter()
.position(|q| q.is_some_and(|q| same_support(&q, &p, Resolution::of(&combined))))
.and_then(|i| of.face_sources()?[i].clone())
};
let in_a = face_points(&combined, i).iter().all(|q| q.x <= a_right + 1e-9);
if in_a {
find(a, &pa)
} else if b_sources {
find(b, &pb)
} else {
None
}
})
.collect();
combined.face_sources = Some(Arc::new(sources));
combined
}
/// The plane index offers every plane `same_support` accepts: planes turned and moved by
/// about the resolution (either side of it, so across cell edges), far from the centre, and
/// with normals not of unit length, each checked against a scan of them all.
#[test]
fn plane_index_finds_every_support_a_scan_finds() {
let body = box_solid(Vec3::ZERO, Vec3::new(1000., 1000., 1000.)).unwrap();
let at = Resolution::of(&body);
let (eps, tol) = (at.angular, at.linear);
let mut planes = Vec::new();
let mut seed = 0x9e37_79b9_7f4a_7c15u64;
let mut next = || {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
(seed >> 11) as f64 / (1u64 << 53) as f64 * 2. - 1.
};
for base in [Vec3::X, Vec3::Y, Vec3::Z, -Vec3::Z, Vec3::new(1., 2., 3.)] {
for k in 0..200 {
let base = base.normalized().unwrap();
let n = (base + Vec3::new(next(), next(), next()) * (eps * 1.2)).normalized().unwrap();
// A point of the base plane (through the world origin), near or far, moved off it
// by up to one and a half times the resolution's distance.
let r = Vec3::new(next(), next(), next()) * if k % 3 == 0 { 1e4 } else { 300. };
let origin = r - base * r.dot(base) + n * (next() * tol * 1.5);
let p = Plane::from_normal(origin, n).unwrap();
planes.push(if k % 50 == 0 { Plane { x: p.x * 1.5, ..p } } else { p });
}
}
let index = PlaneIndex::new(planes.iter(), at);
let mut matches = 0;
for query in &planes {
let mut near = index.near(query);
near.sort_unstable();
let found: Vec<usize> = near.into_iter().filter(|&i| same_support(&planes[i], query, at)).collect();
let scan: Vec<usize> = (0..planes.len()).filter(|&i| same_support(&planes[i], query, at)).collect();
assert_eq!(found, scan);
matches += scan.len();
}
assert!(matches > 2 * planes.len(), "the planes meet each other, not only themselves: {matches}");
}
/// Many faces on one plane are decided with work that grows with the faces plus the
/// candidates: each face looks at its plane's one group, never at every candidate on it.
#[test]
fn coplanar_faces_are_decided_by_group_in_linear_work() {
let body = box_solid(Vec3::ZERO, Vec3::new(1000., 1000., 10.)).unwrap();
let at = Resolution::of(&body);
let top = Plane::new(Vec3::new(0., 0., 10.), Vec3::X, Vec3::Y).unwrap();
let one = FaceSource::Box { producer: Some(1), axis: 2, high: true, plane: top };
let other = FaceSource::Box { producer: Some(2), axis: 2, high: true, plane: top };
for n in [100usize, 1000] {
// `n` pieces of one cap and `n` faces of the result on its plane, each a little moved
// along the plane (as a split face's pieces are).
let pieces: Vec<Plane> = (0..n).map(|k| Plane::new(Vec3::new(k as f64, 0., 10.), Vec3::X, Vec3::Y).unwrap()).collect();
let candidates: Vec<Candidate> = (0..n).map(|_| Candidate { plane: top, source: &one, inner: false }).collect();
let mut decide = SupportDecisions::new(&candidates, &[], &[], at);
for piece in &pieces {
assert_eq!(decide.at(piece), Support::Source(Candidate { plane: top, source: &one, inner: false }));
}
// One look per candidate to group them, one per face to find its group: a scan of
// every candidate per face would look n * n times.
assert_eq!(decide.looked, 2 * n);
// A second identity among the candidates leaves the plane unnamed; a face without a
// role on it blocks it.
let mut mixed = candidates.clone();
mixed[n / 2] = Candidate { plane: top, source: &other, inner: false };
assert_eq!(SupportDecisions::new(&mixed, &[], &[], at).at(&pieces[0]), Support::Unnamed);
let unknown = vec![top; n];
let mut blocked = SupportDecisions::new(&candidates, &unknown, &[], at);
assert!(pieces.iter().all(|piece| blocked.at(piece) == Support::Blocked));
assert_eq!(blocked.looked, 3 * n);
}
}
/// A plate with 300 holes whose top a comb of grooves cuts into 62 strips: every strip keeps
/// the top cap's source, every bottom face the bottom cap's, however many there are.
#[test]
fn many_coplanar_pieces_of_a_holed_plate_all_keep_their_cap_source() {
use solidcore_record::{Loop2, Region2, Vec2};
let holes: Vec<Loop2> =
(0..60).flat_map(|k| (0..5).map(move |r| Loop2::circle(Vec2::new(10. + 10. * k as f64, 5. + 10. * r as f64), 1.))).collect();
let outer = Loop2::polygon(&[Vec2::new(0., 0.), Vec2::new(610., 0.), Vec2::new(610., 50.), Vec2::new(0., 50.)]);
let region = Region2 { outer, holes };
let raw = crate::extrude(&Plane::XY, std::slice::from_ref(&region), 0., 10.).unwrap().remove(0);
let hole_ids: Vec<Vec<String>> = (0..300).map(|k| vec![format!("c{k}")]).collect();
let signatures: Vec<_> = raw
.face_sources()
.unwrap()
.iter()
.map(|s| matches!(s, Some(FaceSource::ExtrudeCap { .. })).then(|| (vec!["l1".to_string()], hole_ids.clone())))
.collect();
let plate = raw.with_extrude_cap_certificates(5, 3, &signatures).unwrap();
// A comb: 61 teeth 2 wide across the plate between the columns of holes, 2 deep.
let mut comb = vec![Vec2::new(-5., 55.), Vec2::new(-5., 60.), Vec2::new(615., 60.), Vec2::new(615., 55.)];
for k in (0..=60).rev() {
let x = 4. + 10. * k as f64;
comb.extend([Vec2::new(x + 2., 55.), Vec2::new(x + 2., -5.), Vec2::new(x, -5.), Vec2::new(x, 55.)]);
}
let comb = Region2 { outer: Loop2::polygon(&comb), holes: vec![] };
let tool = crate::extrude(&Plane::XY, std::slice::from_ref(&comb), 8., 12.).unwrap().remove(0);
let cut = crate::boolean(&plate, &tool, crate::BoolOp::Cut).unwrap().unwrap();
let sources = cut.face_sources().unwrap();
let (mut tops, mut bottoms) = (0, 0);
for (i, plane) in actual_planes(&cut).unwrap().into_iter().enumerate() {
let Some(plane) = plane else { continue };
let high = if plane.normal().dot(Vec3::Z) > 0.999999 && (plane.origin.z - 10.).abs() < 1e-9 {
true
} else if plane.normal().dot(Vec3::Z) < -0.999999 && plane.origin.z.abs() < 1e-9 {
false
} else {
continue;
};
let Some(FaceSource::CertifiedExtrudeCap { producer: 5, high: h, holes, .. }) = &sources[i] else {
panic!("face {i} on the {} cap lost its source: {:?}", if high { "top" } else { "bottom" }, sources[i]);
};
assert_eq!((*h, holes.len()), (high, 300));
if high {
tops += 1;
} else {
bottoms += 1;
}
}
assert_eq!((tops, bottoms), (62, 1));
}
#[test]
fn rounded_shell_planar_roles_are_exact_distinct_and_transformable() {
for (width, thickness) in [(80., 2.), (100., 3.)] {
let box_body = box_solid(Vec3::new(-width / 2., -30., 0.), Vec3::new(width / 2., 30., 30.)).unwrap().with_box_certificate(7).unwrap();
let rounded = fillet(
&box_body,
&[
Vec3::new(width / 2., 30., 15.),
Vec3::new(-width / 2., 30., 15.),
Vec3::new(-width / 2., -30., 15.),
Vec3::new(width / 2., -30., 15.),
],
6.,
)
.unwrap()
.with_preserved_planar_sources(&box_body)
.unwrap();
assert_eq!(rounded.face_sources().unwrap().iter().flatten().count(), 6);
let cup = shell(&rounded, &[Vec3::new(0., 0., 30.)], thickness).unwrap().with_shell_certificate(9).unwrap();
let sources = cup.face_sources().unwrap();
assert!(
!sources
.iter()
.flatten()
.any(|s| matches!(s,FaceSource::ShellPlanar {source, ..} if matches!(source.as_ref(),FaceSource::Box {axis:2,high:true,..})))
);
let right = sources.iter().position(|s| matches!(s, Some(FaceSource::ShellPlanar { inner:false, source, .. }) if matches!(source.as_ref(),FaceSource::Box {axis:0,high:true,..}))).unwrap();
let floor = sources.iter().position(|s| matches!(s, Some(FaceSource::ShellPlanar { inner:true, source, .. }) if matches!(source.as_ref(),FaceSource::Box {axis:2,high:false,..}))).unwrap();
assert!((cup.face_plane(right).unwrap().origin.x - width / 2.).abs() < 1e-9);
let floor_plane = cup.face_plane(floor).unwrap();
assert!((floor_plane.origin.z - thickness).abs() < 1e-9);
assert!(floor_plane.normal().dot(Vec3::Z) > 0.999999);
for (i, s) in sources.iter().enumerate() {
if matches!(s, Some(FaceSource::ExtrudeSide { coalesced: true, plane: None, .. })) {
assert!(cup.face_plane(i).is_none(), "loss witness is not source authority");
} else if s.is_some() {
assert!(same_support(&cup.face_plane(i).unwrap(), &cup.planar_face(i).unwrap(), Resolution::of(&cup)));
}
}
let moved = transform_matrix(&cup, [[0., 1., 0., 0.], [-1., 0., 0., 0.], [0., 0., 1., 0.], [100., 200., 300., 1.]]).unwrap();
assert!((moved.face_plane(floor).unwrap().origin.z - (300. + thickness)).abs() < 1e-9);
assert!(matches!(moved.face_sources().unwrap().get(right), Some(Some(FaceSource::ShellPlanar { producer: Some(9), inner: false, .. }))));
assert!(moved.face_plane(right).unwrap().normal().dot(Vec3::Y) > 0.999999);
let display = cup.mesh(&crate::MeshTolerance::chord(0.01)).unwrap();
for axis in 0..2 {
for high in [false, true] {
let matching: Vec<_> = sources.iter().enumerate().filter_map(|(i,s)| matches!(s,Some(FaceSource::ShellPlanar {inner:false,source,..}) if matches!(source.as_ref(),FaceSource::Box {axis:a,high:h,..} if *a==axis && *h==high)).then_some(i)).collect();
assert_eq!(matching.len(), 1, "each straight exterior wall is one actual face");
let z: Vec<_> = face_points(&cup, matching[0]).iter().map(|p| p.z).collect();
assert!(z.iter().any(|z| z.abs() < 1e-9));
assert!(z.iter().any(|z| (*z - 30.).abs() < 1e-9));
}
}
assert!(display.contains(Vec3::new(width / 2. - thickness / 2., 0., thickness / 2.)));
assert!(display.contains(Vec3::new(width / 2. - thickness / 2., 0., 15.)));
assert!(!display.contains(Vec3::new(0., 0., 15.)));
// The rounded box less its inside, the box moved in by the wall with its corners'
// rounds at 6 − t, open at the top: exact (SMLib's volume, to 1e-8; the rounds
// are its surfaces).
let expected = (width * 60. - (4. - std::f64::consts::PI) * 36.) * 30.
- ((width - 2. * thickness) * (60. - 2. * thickness) - (4. - std::f64::consts::PI) * (6. - thickness).powi(2)) * (30. - thickness);
let v = crate::measure(&cup).unwrap().volume;
assert!((v - expected).abs() < 1e-6 * expected, "{v} vs {expected}");
let imported = crate::step_import(&crate::step_export(&[&cup], "regularized rounded shell").unwrap()).unwrap();
assert!(imported.warnings.is_empty());
let copy = &imported.bodies[0].body;
// The certified planar walls come back from STEP as one full-height face each.
for (axis, coordinate) in [(Vec3::X, width / 2.), (-Vec3::X, width / 2.), (Vec3::Y, 30.), (-Vec3::Y, 30.)] {
let walls: Vec<usize> = actual_planes(copy)
.unwrap()
.iter()
.enumerate()
.filter(|(_, p)| p.is_some_and(|p| p.normal().dot(axis) > 0.999 && (p.origin.dot(axis) - coordinate).abs() < 1e-8))
.map(|(i, _)| i)
.collect();
assert_eq!(walls.len(), 1);
let z: Vec<_> = face_points(copy, walls[0]).iter().map(|p| p.z).collect();
assert!(z.iter().any(|z| z.abs() < 1e-8));
assert!(z.iter().any(|z| (*z - 30.).abs() < 1e-8));
}
let copy_mesh = copy.mesh(&crate::MeshTolerance::chord(1e-4)).unwrap();
assert!((copy_mesh.measure().volume - expected).abs() < 0.2);
assert!(copy_mesh.contains(Vec3::new(width / 2. - thickness / 2., 0., 15.)));
assert!(!copy_mesh.contains(Vec3::new(0., 0., 15.)));
}
}
#[test]
fn simple_shell_has_one_full_height_face_per_outer_wall_and_exports_that_topology() {
let source = box_solid(Vec3::ZERO, Vec3::new(40., 30., 20.)).unwrap().with_box_certificate(1).unwrap();
let pending = shell(&source, &[Vec3::new(20., 15., 20.)], 2.).unwrap();
let cup = pending.clone().with_shell_certificate(2).unwrap();
assert_eq!(cup.face_count(), 11);
let mesh = cup.mesh(&crate::MeshTolerance::chord(0.01)).unwrap();
assert!((mesh.measure().volume - (40. * 30. * 20. - 36. * 26. * 18.)).abs() < 1e-6);
assert!(mesh.contains(Vec3::new(20., 1., 1.)));
assert!(mesh.contains(Vec3::new(20., 1., 10.)));
assert!(!mesh.contains(Vec3::new(20., 15., 10.)));
let imported = crate::step_import(&crate::step_export(&[&cup], "regularized shell").unwrap()).unwrap();
assert!(imported.warnings.is_empty());
let copy = &imported.bodies[0].body;
assert_eq!(copy.face_count(), 11);
assert!((copy.mesh(&crate::MeshTolerance::chord(0.01)).unwrap().measure().volume - mesh.measure().volume).abs() < 1e-6);
}
#[test]
fn union_keeps_unchanged_supports_of_both_operands_and_drops_shared_ones() {
use crate::{BoolOp, boolean};
let a = box_solid(Vec3::ZERO, Vec3::new(20., 20., 10.)).unwrap().with_box_certificate(1).unwrap();
// A taller box overlapping one side: the bottoms share z = 0, the tops do not.
let b = box_solid(Vec3::new(10., 5., 0.), Vec3::new(30., 15., 15.)).unwrap().with_box_certificate(2).unwrap();
let joined = boolean(&a, &b, BoolOp::Union).unwrap().unwrap();
let sources = joined.face_sources().unwrap();
let mut seen = Vec::new();
for (i, plane) in actual_planes(&joined).unwrap().into_iter().enumerate() {
let plane = plane.unwrap();
let source = sources[i].as_ref();
let height = plane.origin.z;
if plane.normal().z > 0.999 && (height - 10.).abs() < 1e-9 {
assert!(matches!(source, Some(FaceSource::Box { producer: Some(1), axis: 2, high: true, .. })), "{source:?}");
seen.push("a top");
} else if plane.normal().z > 0.999 && (height - 15.).abs() < 1e-9 {
assert!(matches!(source, Some(FaceSource::Box { producer: Some(2), axis: 2, high: true, .. })), "{source:?}");
seen.push("b top");
} else if plane.normal().z < -0.999 {
assert!(source.is_none(), "a bottom merged from both operands has no single identity: {source:?}");
seen.push("bottom");
}
}
for want in ["a top", "b top", "bottom"] {
assert!(seen.contains(&want), "{want} missing from {seen:?}");
}
}
#[test]
fn coincident_competing_source_planes_and_tool_planes_stay_unknown() {
let a = box_solid(Vec3::ZERO, Vec3::new(10., 10., 10.)).unwrap().with_box_certificate(1).unwrap();
let b = box_solid(Vec3::new(20., 0., 0.), Vec3::new(30., 10., 10.)).unwrap().with_box_certificate(2).unwrap();
let combined = side_by_side(&a, &b, true);
let result = a.clone().with_preserved_planar_sources(&combined).unwrap();
for (i, p) in actual_planes(&result).unwrap().into_iter().enumerate() {
if p.unwrap().normal().dot(Vec3::Z).abs() > 0.999 {
assert!(result.face_sources().unwrap()[i].is_none());
}
}
let mixed = side_by_side(&a, &b, false);
let guarded = a.clone().with_preserved_planar_sources(&mixed).unwrap();
for (i, p) in actual_planes(&guarded).unwrap().into_iter().enumerate() {
if p.unwrap().normal().dot(Vec3::Z).abs() > 0.999 {
assert!(guarded.face_sources().unwrap()[i].is_none(), "uncertified competing support must not gain identity");
}
}
let cup = shell(&a, &[Vec3::new(5., 5., 10.)], 1.).unwrap().with_shell_certificate(3).unwrap();
let tool = box_solid(Vec3::new(2., 2., 1.), Vec3::new(4., 4., 3.)).unwrap();
let preserved = cup.clone().with_preserved_boolean_planar_sources(&cup, &tool, false).unwrap();
for (i, p) in actual_planes(&preserved).unwrap().into_iter().enumerate() {
let Some(p) = p else { continue };
if p.normal().dot(Vec3::Z) > 0.999 && (p.origin.z - 1.).abs() < 1e-9 {
assert!(preserved.face_sources().unwrap()[i].is_none());
}
}
}
#[test]
fn pocket_cut_removes_internal_wall_faces_in_actual_topology() {
use solidcore_record::{Loop2, Region2, Vec2};
let region = Region2 {
outer: Loop2::polygon(&[Vec2::new(-30., -27.), Vec2::new(30., -27.), Vec2::new(30., 27.), Vec2::new(-30., 27.)]),
holes: vec![],
};
let original = crate::extrude(&Plane::XY, std::slice::from_ref(&region), 0., 10.).unwrap().pop().unwrap();
let curves: Vec<_> = original
.face_sources()
.unwrap()
.iter()
.enumerate()
.map(|(i, source)| matches!(source, Some(FaceSource::ExtrudeSide { .. })).then(|| format!("l{i}")))
.collect();
let original = original.with_extrude_certificates(2, 1, &curves).unwrap();
let (x, y) = (24.73317426966596, 21.733174269665962);
let cutter = box_solid(Vec3::new(-x, -y, 1.), Vec3::new(x, y, 10.)).unwrap();
let pocket = crate::boolean(&original, &cutter, crate::BoolOp::Cut).unwrap().unwrap();
let raw = pocket.mesh(&crate::MeshTolerance::chord(0.01)).unwrap();
let display = pocket.mesh(&crate::MeshTolerance::chord(0.01)).unwrap();
let sources = pocket.face_sources().unwrap();
assert_eq!(pocket.face_count(), 11, "four outer walls, four inner walls, rim, floor, bottom");
let sides: Vec<_> =
sources.iter().enumerate().filter_map(|(i, s)| matches!(s, Some(FaceSource::CertifiedExtrudeSide { .. })).then_some(i)).collect();
assert_eq!(sides.len(), 4);
for i in sides {
let z: Vec<_> = face_points(&pocket, i).iter().map(|p| p.z).collect();
assert!(z.iter().any(|z| z.abs() < 1e-9));
assert!(z.iter().any(|z| (*z - 10.).abs() < 1e-9));
assert!(!face_edges(&pocket, i).iter().any(|(a, b)| (a.z - 1.).abs() < 1e-9 && (b.z - 1.).abs() < 1e-9));
}
assert!(display.contains(Vec3::new(0., 0., 0.5)));
assert!(!display.contains(Vec3::new(0., 0., 5.)));
assert!(display.contains(Vec3::new(28., 0., 5.)));
assert!((display.measure().volume - (60. * 54. * 10. - 4. * x * y * 9.)).abs() < 1e-7);
// Different triangulations of the same polyhedron: equal up to rounding.
assert!((raw.measure().volume - display.measure().volume).abs() < 1e-9 * raw.measure().volume);
let imported = crate::step_import(&crate::step_export(&[&pocket], "regularized pocket").unwrap()).unwrap();
assert!(imported.warnings.is_empty());
let copy = &imported.bodies[0].body;
assert_eq!(copy.face_count(), 11);
let copy_mesh = copy.mesh(&crate::MeshTolerance::chord(0.01)).unwrap();
assert!((copy_mesh.measure().volume - raw.measure().volume).abs() < 1e-6);
assert!(copy_mesh.contains(Vec3::new(0., 0., 0.5)));
assert!(!copy_mesh.contains(Vec3::new(0., 0., 5.)));
let competing = box_solid(Vec3::new(30., -1., 0.), Vec3::new(31., 1., 2.)).unwrap();
let guarded = pocket.clone().with_preserved_boolean_planar_sources(&pocket, &competing, true).unwrap();
for (index, source) in guarded.face_sources().unwrap().iter().enumerate() {
if pocket.face_plane(index).is_some_and(|p| p.normal().dot(Vec3::X) > 0.999 && (p.origin.x - 30.).abs() < 1e-9) {
assert!(source.is_none(), "competing tool plane cannot retain source identity");
}
}
}
}