Wave 4/509: brep: schema 4 types, validator and truck adapter
1 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.
- 445fb2385 jyviko: brep: schema 4 types, validator and truck adapter
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
1 parent
1db9bf54f0
commit
b3cf2ff2af
11 files changed
+1582
-672
No files matched your search
+284
-351
@@ -1,58 +1,156 @@
|
||||
//! SolidCraft-owned portable B-rep data, independent of a modelling backend.
|
||||
//! Millimetres, radians, right-handed Z-up. See docs/native-brep.md for semantics.
|
||||
//! Validation checks structure and resource budgets, not geometric equivalence or trust.
|
||||
//!
|
||||
//! The records follow SMLib's flat form (`SmBrepData`): one record per logical use, the mated
|
||||
//! halves a kernel keeps at run time left for it to rebuild. Names are STEP's B-rep names; each
|
||||
//! type says its SMLib counterpart and STEP entity. Curves and surfaces are unbounded: an edge's
|
||||
//! bounds are its `interval`, a face's its `domain` and loops.
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
mod curve2;
|
||||
pub mod envelope;
|
||||
pub mod history;
|
||||
mod topology;
|
||||
pub use curve2::Curve2;
|
||||
|
||||
pub const VERSION: u32 = 3;
|
||||
pub const VERSION: u32 = 4;
|
||||
pub const MAX_ITEMS: usize = 1_000_000;
|
||||
pub const MAX_SHELLS: usize = 1024;
|
||||
const MAX_DEPTH: usize = 16;
|
||||
/// Most control points along one direction of a spline (a helical thread flank written as one
|
||||
/// spline has thousands along the helix); the item budget bounds a surface's grid as a whole.
|
||||
pub const MAX_SPLINE_CONTROLS: usize = 8192;
|
||||
const TAU: f64 = std::f64::consts::TAU;
|
||||
|
||||
/// A body (SMLib `SmBrep`, STEP `MANIFOLD_SOLID_BREP`/`BREP_WITH_VOIDS`/`SHELL_BASED_SURFACE_MODEL`).
|
||||
/// Every list is in canonical order (docs/native-brep.md, "Canonical order"): a face's index
|
||||
/// here is its face index everywhere, and so for edges and vertices.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Brep {
|
||||
pub version: u32,
|
||||
/// Intersection tolerance, mm (SMLib's per-brep `XSectTol3d`).
|
||||
pub tolerance: f64,
|
||||
/// `regions[0]` is the infinite region, then the bounded regions.
|
||||
pub regions: Vec<Region>,
|
||||
pub shells: Vec<Shell>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Shell {
|
||||
pub vertices: Vec<[f64; 3]>,
|
||||
pub edges: Vec<Edge>,
|
||||
pub faces: Vec<Face>,
|
||||
pub edges: Vec<Edge>,
|
||||
pub vertices: Vec<Vertex>,
|
||||
}
|
||||
|
||||
/// A connected volume of space (SMLib `SmRegionData`). The infinite region has no outer shell
|
||||
/// and is never a void. A bounded region's `shells[0]` is its outer shell, a closed face shell;
|
||||
/// the rest are inner shells. A closed shell separates two regions and is listed by both: as
|
||||
/// the outer shell of the one it encloses and as an inner shell of the one around it. An open
|
||||
/// shell, a wire shell or a vertex shell lies in one region and is listed by that one only.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Edge {
|
||||
pub vertices: [u32; 2],
|
||||
pub curve: Curve,
|
||||
pub struct Region {
|
||||
pub shells: Vec<u32>,
|
||||
/// A bounded region that is empty space (a void), not material. False for the infinite region.
|
||||
pub void: bool,
|
||||
}
|
||||
|
||||
/// A connected boundary component (SMLib `SmShellData`; STEP `CLOSED_SHELL`/`OPEN_SHELL`,
|
||||
/// `WIRE_SHELL`, `VERTEX_SHELL`). One record stands for both runtime sides of a shell.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
|
||||
pub enum Shell {
|
||||
/// Connected faces, with wire edges embedded in them (`wires`, edges no face uses).
|
||||
Faces { faces: Vec<OrientedFace>, wires: Vec<u32> },
|
||||
/// A connected graph of wire edges and no faces.
|
||||
Wire { edges: Vec<u32> },
|
||||
/// One isolated point.
|
||||
Vertex { vertex: u32 },
|
||||
}
|
||||
|
||||
/// A face as one shell uses it (SMLib `SmFaceuseData`, STEP `ORIENTED_FACE`).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct OrientedFace {
|
||||
pub face: u32,
|
||||
/// The face's normal in this shell is its surface's natural normal (∂S/∂u × ∂S/∂v). In a
|
||||
/// closed shell the normals point out of the material.
|
||||
pub forward: bool,
|
||||
}
|
||||
|
||||
/// A bounded piece of a surface (SMLib `SmFaceData`, STEP `ADVANCED_FACE`).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Face {
|
||||
pub loops: Vec<Vec<EdgeUse>>,
|
||||
pub surface: Surface,
|
||||
pub forward: bool,
|
||||
/// The modelled rectangle in surface parameters, `[[u0, u1], [v0, v1]]`, inside the
|
||||
/// surface's natural domain and around every loop.
|
||||
pub domain: [[f64; 2]; 2],
|
||||
/// `loops[0]` is the outer loop, the rest inner. Loops are stored relative to the surface's
|
||||
/// natural normal, whatever side a shell uses: seen from that normal, the outer loop runs
|
||||
/// counter-clockwise and inner loops clockwise.
|
||||
pub loops: Vec<Loop>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
|
||||
/// A face boundary (SMLib `SmLoopData`; STEP `FACE_BOUND` of an `EDGE_LOOP` or `VERTEX_LOOP`).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
|
||||
pub enum Loop {
|
||||
/// A closed chain of oriented edges, in traversal order (STEP `EDGE_LOOP`).
|
||||
Edges { edges: Vec<OrientedEdge> },
|
||||
/// A one-vertex loop: a pole or a collapsed boundary (STEP `VERTEX_LOOP`). Inner only.
|
||||
Vertex { vertex: u32 },
|
||||
}
|
||||
|
||||
/// One occurrence of an edge in a face's loop (SMLib `SmEUData`, one mated pair of runtime
|
||||
/// edgeuses; STEP `ORIENTED_EDGE` with its `PCURVE`).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct EdgeUse {
|
||||
pub struct OrientedEdge {
|
||||
pub edge: u32,
|
||||
/// The loop runs along the edge from interval min (start vertex) to max (end vertex).
|
||||
pub forward: bool,
|
||||
/// The edge in this face's (u, v), on the edge's own interval and running min → max
|
||||
/// whatever `forward` says. A seam edge has two uses on one face, each with its pcurve.
|
||||
pub pcurve: Curve2,
|
||||
}
|
||||
|
||||
/// Right-handed orthonormal frame; z = x_axis cross y_axis.
|
||||
/// A bounded piece of a curve (SMLib `SmEdgeData`, STEP `EDGE_CURVE`).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Edge {
|
||||
pub curve: Curve,
|
||||
/// The modelled interval in the curve's own parameter, min < max.
|
||||
pub interval: [f64; 2],
|
||||
/// `[start, end]`, at interval min and max; equal for a closed edge.
|
||||
pub vertices: [u32; 2],
|
||||
/// mm.
|
||||
pub tolerance: f64,
|
||||
/// Every oriented edge on this edge, each once, the primary use (the first in canonical
|
||||
/// order) first and the rest in radial order: right-hand rule about the edge's direction.
|
||||
/// Empty for a wire edge.
|
||||
pub uses: Vec<EdgeUseRef>,
|
||||
}
|
||||
|
||||
/// Where one use of an edge sits (SMLib `SmEUData`'s radial fields): `faces[face]`,
|
||||
/// `loops[loop]`, `edges[position]`.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct EdgeUseRef {
|
||||
pub face: u32,
|
||||
pub r#loop: u32,
|
||||
pub position: u32,
|
||||
/// Going round the edge, the radial cycle enters this use at the side on the surface's
|
||||
/// natural normal (SMLib's selected member of the mated pair). It follows from the loop
|
||||
/// convention: always `!forward` of the use it names.
|
||||
pub upper: bool,
|
||||
}
|
||||
|
||||
/// A point (SMLib `SmVertexData`, STEP `VERTEX_POINT`).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Vertex {
|
||||
pub point: [f64; 3],
|
||||
/// mm.
|
||||
pub tolerance: f64,
|
||||
}
|
||||
|
||||
/// Right-handed orthonormal frame; z = x_axis cross y_axis (STEP `AXIS2_PLACEMENT_3D`).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Frame {
|
||||
@@ -61,116 +159,61 @@ pub struct Frame {
|
||||
pub y_axis: [f64; 3],
|
||||
}
|
||||
|
||||
/// Unbounded 3D curves, each with its parameter `t` (docs/native-brep.md, "Curves").
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
|
||||
pub enum Curve {
|
||||
Line {
|
||||
start: [f64; 3],
|
||||
end: [f64; 3],
|
||||
},
|
||||
CircleArc {
|
||||
frame: Frame,
|
||||
radius: f64,
|
||||
angle: [f64; 2],
|
||||
},
|
||||
EllipseArc {
|
||||
frame: Frame,
|
||||
radii: [f64; 2],
|
||||
angle: [f64; 2],
|
||||
},
|
||||
Polyline {
|
||||
points: Vec<[f64; 3]>,
|
||||
},
|
||||
Spline {
|
||||
knots: Vec<f64>,
|
||||
points: Vec<[f64; 3]>,
|
||||
},
|
||||
RationalSpline {
|
||||
knots: Vec<f64>,
|
||||
homogeneous: Vec<[f64; 4]>,
|
||||
},
|
||||
Intersection {
|
||||
knots: Vec<f64>,
|
||||
points: Vec<[f64; 3]>,
|
||||
fitting_tolerance: f64,
|
||||
faces: Option<[u32; 2]>,
|
||||
},
|
||||
/// The line through both points: `start + t * (end - start)`, t = 0 at `start` and 1 at
|
||||
/// `end` (STEP `LINE`; truck's `Line`).
|
||||
Line { start: [f64; 3], end: [f64; 3] },
|
||||
/// `origin + radius * (cos t * x + sin t * y)`, t the angle from x (STEP `CIRCLE`).
|
||||
Circle { frame: Frame, radius: f64 },
|
||||
/// `origin + radii[0] cos t * x + radii[1] sin t * y` (STEP `ELLIPSE`).
|
||||
Ellipse { frame: Frame, radii: [f64; 2] },
|
||||
/// Straight segments; segment i spans t in [i, i + 1] (STEP `POLYLINE`).
|
||||
Polyline { points: Vec<[f64; 3]> },
|
||||
/// A B-spline on its knots (STEP `B_SPLINE_CURVE_WITH_KNOTS`).
|
||||
Spline { knots: Vec<f64>, points: Vec<[f64; 3]> },
|
||||
/// A NURBS curve: homogeneous `[x*w, y*w, z*w, w]` coefficients (STEP `RATIONAL_B_SPLINE_CURVE`).
|
||||
RationalSpline { knots: Vec<f64>, homogeneous: Vec<[f64; 4]> },
|
||||
/// The intersection of two surfaces, traced from `leader` (a polyline or spline near it)
|
||||
/// to within `tolerance`: the procedural curve itself, exactly as its producer holds it.
|
||||
SurfaceIntersection {
|
||||
surfaces: [Box<Surface>; 2],
|
||||
leader: Box<Curve>,
|
||||
tolerance: f64,
|
||||
},
|
||||
/// to within `tolerance`: the procedural curve itself, exactly as its producer holds it
|
||||
/// (STEP `INTERSECTION_CURVE`). t is the leader's parameter.
|
||||
SurfaceIntersection { surfaces: [Box<Surface>; 2], leader: Box<Curve>, tolerance: f64 },
|
||||
}
|
||||
|
||||
/// Unbounded surfaces, each with its (u, v) (docs/native-brep.md, "Surfaces"). Natural
|
||||
/// normals are ∂S/∂u × ∂S/∂v.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
|
||||
pub enum Surface {
|
||||
Plane {
|
||||
origin: [f64; 3],
|
||||
u_axis: [f64; 3],
|
||||
v_axis: [f64; 3],
|
||||
},
|
||||
/// The plane through three points, parameter (1, 0) at `u_point` and (0, 1) at `v_point`:
|
||||
/// the points themselves, as its producer holds them (axes worked out from them would round).
|
||||
PlaneThrough {
|
||||
origin: [f64; 3],
|
||||
u_point: [f64; 3],
|
||||
v_point: [f64; 3],
|
||||
},
|
||||
Cylinder {
|
||||
frame: Frame,
|
||||
radius: f64,
|
||||
angle: [f64; 2],
|
||||
height: [f64; 2],
|
||||
},
|
||||
Cone {
|
||||
frame: Frame,
|
||||
radius_at_origin: f64,
|
||||
half_angle: f64,
|
||||
angle: [f64; 2],
|
||||
height: [f64; 2],
|
||||
},
|
||||
Sphere {
|
||||
frame: Frame,
|
||||
radius: f64,
|
||||
longitude: [f64; 2],
|
||||
latitude: [f64; 2],
|
||||
},
|
||||
Torus {
|
||||
frame: Frame,
|
||||
major_radius: f64,
|
||||
minor_radius: f64,
|
||||
longitude: [f64; 2],
|
||||
meridian: [f64; 2],
|
||||
},
|
||||
Spline {
|
||||
u_knots: Vec<f64>,
|
||||
v_knots: Vec<f64>,
|
||||
points: Vec<Vec<[f64; 3]>>,
|
||||
},
|
||||
RationalSpline {
|
||||
u_knots: Vec<f64>,
|
||||
v_knots: Vec<f64>,
|
||||
homogeneous: Vec<Vec<[f64; 4]>>,
|
||||
},
|
||||
Revolution {
|
||||
profile: Box<Curve>,
|
||||
origin: [f64; 3],
|
||||
axis: [f64; 3],
|
||||
angle: [f64; 2],
|
||||
},
|
||||
/// A full revolution of `profile` about `origin` and unit `axis`, then mapped by the
|
||||
/// column-major affine `matrix`, with the normal reversed unless `forward`: the
|
||||
/// revolution exactly as its producer holds it, nothing baked into the profile.
|
||||
PlacedRevolution {
|
||||
profile: Box<Curve>,
|
||||
origin: [f64; 3],
|
||||
axis: [f64; 3],
|
||||
matrix: [[f64; 4]; 4],
|
||||
forward: bool,
|
||||
},
|
||||
/// `origin + u * u_axis + v * v_axis` (STEP `PLANE`).
|
||||
Plane { origin: [f64; 3], u_axis: [f64; 3], v_axis: [f64; 3] },
|
||||
/// `origin + u * (u_point - origin) + v * (v_point - origin)`: the plane through three points,
|
||||
/// as its producer holds them (axes worked out from them would round; truck's `Plane`).
|
||||
PlaneThrough { origin: [f64; 3], u_point: [f64; 3], v_point: [f64; 3] },
|
||||
/// `origin + v z + radius (cos u x + sin u y)`: u the angle, v the height (STEP
|
||||
/// `CYLINDRICAL_SURFACE`).
|
||||
Cylinder { frame: Frame, radius: f64 },
|
||||
/// `origin + v z + r(v) (cos u x + sin u y)`, `r(v) = radius_at_origin + v tan(half_angle)`,
|
||||
/// v ≥ the apex's height (STEP `CONICAL_SURFACE`).
|
||||
Cone { frame: Frame, radius_at_origin: f64, half_angle: f64 },
|
||||
/// `origin + radius (cos v (cos u x + sin u y) + sin v z)`: u the longitude, v the latitude
|
||||
/// in [-π/2, π/2] (STEP `SPHERICAL_SURFACE`).
|
||||
Sphere { frame: Frame, radius: f64 },
|
||||
/// `origin + (R + r cos v)(cos u x + sin u y) + r sin v z`: u the longitude, v the meridian
|
||||
/// angle (STEP `TOROIDAL_SURFACE`).
|
||||
Torus { frame: Frame, major_radius: f64, minor_radius: f64 },
|
||||
/// A tensor-product B-spline: `points[i][j]`, i along u (STEP `B_SPLINE_SURFACE_WITH_KNOTS`).
|
||||
Spline { u_knots: Vec<f64>, v_knots: Vec<f64>, points: Vec<Vec<[f64; 3]>> },
|
||||
/// A NURBS surface: homogeneous `[x*w, y*w, z*w, w]` coefficients.
|
||||
RationalSpline { u_knots: Vec<f64>, v_knots: Vec<f64>, homogeneous: Vec<Vec<[f64; 4]>> },
|
||||
/// `profile` revolved about `origin` and unit `axis` (right-hand rule), then mapped by the
|
||||
/// column-major affine `matrix`: the revolution exactly as its producer holds it, nothing
|
||||
/// baked into the profile (truck's `RevolutedCurve` under a `Processor`). When `forward`,
|
||||
/// u is the profile's parameter and v the angle in [0, 2π); otherwise u and v swap (u the
|
||||
/// angle, v the profile's), which reverses the natural normal.
|
||||
PlacedRevolution { profile: Box<Curve>, origin: [f64; 3], axis: [f64; 3], matrix: [[f64; 4]; 4], forward: bool },
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, thiserror::Error)]
|
||||
@@ -201,7 +244,7 @@ fn knots(values: &[f64], count: usize, budget: &mut Budget) -> Result<()> {
|
||||
budget.add(values.len())?;
|
||||
numbers(values.iter().copied())?;
|
||||
let degree = values.len().checked_sub(count.saturating_add(1)).ok_or(Invalid("spline degree"))?;
|
||||
require((2..=MAX_SPLINE_CONTROLS).contains(&count) && (1..=16).contains(°ree) && degree < count, "spline degree or size")?;
|
||||
require((2..=4096).contains(&count) && (1..=16).contains(°ree) && degree < count, "spline degree or size")?;
|
||||
require(values.windows(2).all(|w| w.first() <= w.get(1)), "unordered knots")?;
|
||||
require(values.get(degree) < values.get(count), "empty spline domain")?;
|
||||
// No knot may have multiplicity greater than degree + 1.
|
||||
@@ -233,17 +276,87 @@ fn frame(f: &Frame, budget: &mut Budget) -> Result<()> {
|
||||
let (x, y) = (vector(f.x_axis), vector(f.y_axis));
|
||||
require((x.len() - 1.).abs() <= 1e-8 && (y.len() - 1.).abs() <= 1e-8 && x.dot(y).abs() <= 1e-8, "nonorthonormal frame")
|
||||
}
|
||||
fn range(r: &[f64; 2]) -> Result<()> {
|
||||
numbers(*r)?;
|
||||
require(r[0] < r[1], "empty parameter range")
|
||||
}
|
||||
fn angle(r: &[f64; 2]) -> Result<()> {
|
||||
range(r)?;
|
||||
require(r[1] - r[0] <= std::f64::consts::TAU + 1e-12, "angular range exceeds one turn")
|
||||
}
|
||||
fn radius(r: f64) -> Result<()> {
|
||||
require(r.is_finite() && (1e-12..=1e12).contains(&r), "radius")
|
||||
}
|
||||
/// A tolerance in mm.
|
||||
fn tolerance(t: f64) -> Result<()> {
|
||||
require(t.is_finite() && t > 0. && t <= 1e3, "tolerance")
|
||||
}
|
||||
|
||||
/// A parameter's natural range: periodic with period 2π, or between two bounds (infinite for
|
||||
/// an unbounded direction).
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum Natural {
|
||||
Periodic,
|
||||
Range(f64, f64),
|
||||
}
|
||||
const UNBOUNDED: Natural = Natural::Range(f64::NEG_INFINITY, f64::INFINITY);
|
||||
|
||||
/// The active interval of a spline's knots (already validated).
|
||||
fn knot_domain(k: &[f64], count: usize) -> Natural {
|
||||
let degree = k.len().saturating_sub(count + 1);
|
||||
match (k.get(degree), k.get(count)) {
|
||||
(Some(a), Some(b)) => Natural::Range(*a, *b),
|
||||
_ => Natural::Range(0., 0.),
|
||||
}
|
||||
}
|
||||
fn curve_natural(c: &Curve) -> Natural {
|
||||
match c {
|
||||
Curve::Line { .. } => UNBOUNDED,
|
||||
Curve::Circle { .. } | Curve::Ellipse { .. } => Natural::Periodic,
|
||||
Curve::Polyline { points } => Natural::Range(0., points.len().saturating_sub(1) as f64),
|
||||
Curve::Spline { knots, points } => knot_domain(knots, points.len()),
|
||||
Curve::RationalSpline { knots, homogeneous } => knot_domain(knots, homogeneous.len()),
|
||||
Curve::SurfaceIntersection { leader, .. } => curve_natural(leader),
|
||||
}
|
||||
}
|
||||
fn surface_natural(s: &Surface) -> [Natural; 2] {
|
||||
use std::f64::consts::FRAC_PI_2;
|
||||
match s {
|
||||
Surface::Plane { .. } | Surface::PlaneThrough { .. } => [UNBOUNDED; 2],
|
||||
Surface::Cylinder { .. } => [Natural::Periodic, UNBOUNDED],
|
||||
Surface::Cone { radius_at_origin, half_angle, .. } => {
|
||||
[Natural::Periodic, Natural::Range(-radius_at_origin / half_angle.tan(), f64::INFINITY)]
|
||||
}
|
||||
Surface::Sphere { .. } => [Natural::Periodic, Natural::Range(-FRAC_PI_2, FRAC_PI_2)],
|
||||
Surface::Torus { .. } => [Natural::Periodic; 2],
|
||||
Surface::Spline { u_knots, v_knots, points } => {
|
||||
[knot_domain(u_knots, points.len()), knot_domain(v_knots, points.first().map_or(0, Vec::len))]
|
||||
}
|
||||
Surface::RationalSpline { u_knots, v_knots, homogeneous } => {
|
||||
[knot_domain(u_knots, homogeneous.len()), knot_domain(v_knots, homogeneous.first().map_or(0, Vec::len))]
|
||||
}
|
||||
Surface::PlacedRevolution { profile, forward: true, .. } => [curve_natural(profile), Natural::Periodic],
|
||||
Surface::PlacedRevolution { profile, forward: false, .. } => [Natural::Periodic, curve_natural(profile)],
|
||||
}
|
||||
}
|
||||
impl Curve {
|
||||
/// The range of `t`. Call on a validated record.
|
||||
pub fn natural(&self) -> Natural {
|
||||
curve_natural(self)
|
||||
}
|
||||
}
|
||||
impl Surface {
|
||||
/// The ranges of u and v. Call on a validated record.
|
||||
pub fn natural(&self) -> [Natural; 2] {
|
||||
surface_natural(self)
|
||||
}
|
||||
}
|
||||
|
||||
/// `[min, max]`: finite, min < max, inside `natural` (at most one turn long where periodic).
|
||||
fn interval(r: &[f64; 2], natural: Natural) -> Result<()> {
|
||||
numbers(*r)?;
|
||||
require(r[0] < r[1], "empty parameter interval")?;
|
||||
match natural {
|
||||
Natural::Periodic => {
|
||||
let slack = 1e-12 * (1. + r[0].abs().max(r[1].abs()));
|
||||
require(r[1] - r[0] <= TAU + slack, "parameter interval exceeds one turn")
|
||||
}
|
||||
Natural::Range(a, b) => require(a <= r[0] && r[1] <= b, "parameter interval outside the natural domain"),
|
||||
}
|
||||
}
|
||||
|
||||
fn curve(c: &Curve, depth: usize, budget: &mut Budget) -> Result<()> {
|
||||
require(depth <= MAX_DEPTH, "geometry depth")?;
|
||||
budget.add(1)?;
|
||||
@@ -252,17 +365,13 @@ fn curve(c: &Curve, depth: usize, budget: &mut Budget) -> Result<()> {
|
||||
points(&[*start, *end], budget)?;
|
||||
require(start != end, "collapsed line")
|
||||
}
|
||||
Curve::CircleArc { frame: f, radius: r, angle: a } => {
|
||||
Curve::Circle { frame: f, radius: r } => {
|
||||
frame(f, budget)?;
|
||||
radius(*r)?;
|
||||
angle(a)
|
||||
radius(*r)
|
||||
}
|
||||
Curve::EllipseArc { frame: f, radii, angle: a } => {
|
||||
Curve::Ellipse { frame: f, radii } => {
|
||||
frame(f, budget)?;
|
||||
for r in radii {
|
||||
radius(*r)?;
|
||||
}
|
||||
angle(a)
|
||||
radii.iter().try_for_each(|r| radius(*r))
|
||||
}
|
||||
Curve::Polyline { points: p } => {
|
||||
require(p.len() >= 2, "empty polyline")?;
|
||||
@@ -278,11 +387,6 @@ fn curve(c: &Curve, depth: usize, budget: &mut Budget) -> Result<()> {
|
||||
points(p, budget)?;
|
||||
weights(p)
|
||||
}
|
||||
Curve::Intersection { knots: k, points: p, fitting_tolerance, .. } => {
|
||||
require((1e-12..=1.0).contains(fitting_tolerance), "intersection fitting tolerance")?;
|
||||
knots(k, p.len(), budget)?;
|
||||
points(p, budget)
|
||||
}
|
||||
Curve::SurfaceIntersection { surfaces, leader, tolerance } => {
|
||||
require(tolerance.is_finite() && (0.0..=1e3).contains(tolerance), "intersection tolerance")?;
|
||||
for s in surfaces {
|
||||
@@ -319,34 +423,20 @@ fn surface(s: &Surface, depth: usize, budget: &mut Budget) -> Result<()> {
|
||||
let o = vector(*origin);
|
||||
require((vector(*u_point) - o).cross(vector(*v_point) - o).len() > 1e-12, "degenerate plane")
|
||||
}
|
||||
Surface::Cylinder { frame: f, radius: r, angle: a, height } => {
|
||||
Surface::Cylinder { frame: f, radius: r } | Surface::Sphere { frame: f, radius: r } => {
|
||||
frame(f, budget)?;
|
||||
radius(*r)?;
|
||||
angle(a)?;
|
||||
range(height)
|
||||
radius(*r)
|
||||
}
|
||||
Surface::Cone { frame: f, radius_at_origin, half_angle, angle: a, height } => {
|
||||
Surface::Cone { frame: f, radius_at_origin, half_angle } => {
|
||||
frame(f, budget)?;
|
||||
numbers([*radius_at_origin, *half_angle])?;
|
||||
require(*radius_at_origin >= 0. && *half_angle > 0. && *half_angle < std::f64::consts::FRAC_PI_2, "cone dimensions")?;
|
||||
angle(a)?;
|
||||
range(height)?;
|
||||
require(height.iter().all(|h| radius_at_origin + h * half_angle.tan() >= 0.), "negative cone radius")
|
||||
require(*radius_at_origin >= 0. && *half_angle >= 1e-12 && *half_angle < std::f64::consts::FRAC_PI_2, "cone dimensions")
|
||||
}
|
||||
Surface::Sphere { frame: f, radius: r, longitude, latitude } => {
|
||||
frame(f, budget)?;
|
||||
radius(*r)?;
|
||||
angle(longitude)?;
|
||||
range(latitude)?;
|
||||
require(latitude[0] >= -std::f64::consts::FRAC_PI_2 && latitude[1] <= std::f64::consts::FRAC_PI_2, "sphere latitude")
|
||||
}
|
||||
Surface::Torus { frame: f, major_radius, minor_radius, longitude, meridian } => {
|
||||
Surface::Torus { frame: f, major_radius, minor_radius } => {
|
||||
frame(f, budget)?;
|
||||
radius(*major_radius)?;
|
||||
radius(*minor_radius)?;
|
||||
require(major_radius > minor_radius, "ring torus radii")?;
|
||||
angle(longitude)?;
|
||||
angle(meridian)
|
||||
require(major_radius > minor_radius, "ring torus radii")
|
||||
}
|
||||
Surface::Spline { u_knots, v_knots, points: p } => grid(u_knots, v_knots, p, budget),
|
||||
Surface::RationalSpline { u_knots, v_knots, homogeneous: p } => {
|
||||
@@ -356,12 +446,6 @@ fn surface(s: &Surface, depth: usize, budget: &mut Budget) -> Result<()> {
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
Surface::Revolution { profile, origin, axis, angle: a } => {
|
||||
points(&[*origin, *axis], budget)?;
|
||||
require((vector(*axis).len() - 1.0).abs() <= 1e-8, "revolution axis is not unit length")?;
|
||||
angle(a)?;
|
||||
curve(profile, depth + 1, budget)
|
||||
}
|
||||
Surface::PlacedRevolution { profile, origin, axis, matrix, .. } => {
|
||||
points(&[*origin, *axis], budget)?;
|
||||
require((vector(*axis).len() - 1.0).abs() <= 1e-8, "revolution axis is not unit length")?;
|
||||
@@ -374,197 +458,46 @@ fn surface(s: &Surface, depth: usize, budget: &mut Budget) -> Result<()> {
|
||||
}
|
||||
|
||||
impl Brep {
|
||||
/// Validate portable structure without calling a kernel or evaluating geometry.
|
||||
/// Does not certify watertightness, surface coincidence, or authoritative state.
|
||||
/// Validate portable structure without calling a kernel or evaluating geometry: resource
|
||||
/// budgets, geometry records, parameter ranges, references, loops, regions, every edge's
|
||||
/// list of uses and the canonical order. Does not certify watertightness, that edges lie on
|
||||
/// their surfaces or that pcurves lift onto their edges.
|
||||
pub fn validate(&self) -> Result<()> {
|
||||
require(self.version == VERSION, "unsupported version")?;
|
||||
require(!self.shells.is_empty() && self.shells.len() <= 1024, "shell count")?;
|
||||
tolerance(self.tolerance)?;
|
||||
require(!self.shells.is_empty() && self.shells.len() <= MAX_SHELLS, "shell count")?;
|
||||
require(!self.regions.is_empty() && self.regions.len() <= 2 * MAX_SHELLS + 1, "region count")?;
|
||||
let mut budget = Budget(0);
|
||||
for shell in &self.shells {
|
||||
points(&shell.vertices, &mut budget)?;
|
||||
budget.add(shell.edges.len())?;
|
||||
budget.add(shell.faces.len())?;
|
||||
require(!shell.faces.is_empty(), "empty shell")?;
|
||||
for edge in &shell.edges {
|
||||
require(edge.vertices.iter().all(|&v| (v as usize) < shell.vertices.len()), "edge vertices")?;
|
||||
curve(&edge.curve, 0, &mut budget)?;
|
||||
if let Curve::Intersection { faces: Some(hints), .. } = &edge.curve {
|
||||
require(hints.iter().all(|&i| (i as usize) < shell.faces.len()), "intersection face hint")?;
|
||||
}
|
||||
}
|
||||
for face in &shell.faces {
|
||||
require(!face.loops.is_empty(), "face loops")?;
|
||||
surface(&face.surface, 0, &mut budget)?;
|
||||
for wire in &face.loops {
|
||||
require(!wire.is_empty(), "empty wire")?;
|
||||
budget.add(wire.len())?;
|
||||
let mut first = None;
|
||||
let mut last = None;
|
||||
for use_ in wire {
|
||||
let edge = shell.edges.get(use_.edge as usize).ok_or(Invalid("edge reference"))?;
|
||||
let [a, b] = edge.vertices;
|
||||
let (start, end) = if use_.forward { (a, b) } else { (b, a) };
|
||||
require(last.is_none_or(|v| v == start), "disconnected wire")?;
|
||||
first.get_or_insert(start);
|
||||
last = Some(end);
|
||||
budget.add(self.regions.len() + self.faces.len() + self.edges.len())?;
|
||||
for v in &self.vertices {
|
||||
points(&[v.point], &mut budget)?;
|
||||
tolerance(v.tolerance)?;
|
||||
}
|
||||
for e in &self.edges {
|
||||
curve(&e.curve, 0, &mut budget)?;
|
||||
interval(&e.interval, curve_natural(&e.curve))?;
|
||||
require(e.vertices.iter().all(|&v| (v as usize) < self.vertices.len()), "edge vertices")?;
|
||||
tolerance(e.tolerance)?;
|
||||
budget.add(e.uses.len())?;
|
||||
}
|
||||
for f in &self.faces {
|
||||
surface(&f.surface, 0, &mut budget)?;
|
||||
let [u, v] = surface_natural(&f.surface);
|
||||
interval(&f.domain[0], u)?;
|
||||
interval(&f.domain[1], v)?;
|
||||
budget.add(f.loops.len())?;
|
||||
for l in &f.loops {
|
||||
if let Loop::Edges { edges } = l {
|
||||
budget.add(edges.len())?;
|
||||
for e in edges {
|
||||
curve2::curve2(&e.pcurve, &mut budget)?;
|
||||
}
|
||||
require(first == last, "open wire")?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
topology::check(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
fn triangle() -> Brep {
|
||||
let vertices = vec![[0., 0., 0.], [1., 0., 0.], [0., 1., 0.]];
|
||||
let edges = (0..3)
|
||||
.map(|i| Edge { vertices: [i as u32, ((i + 1) % 3) as u32], curve: Curve::Line { start: vertices[i], end: vertices[(i + 1) % 3] } })
|
||||
.collect();
|
||||
Brep {
|
||||
version: VERSION,
|
||||
shells: vec![Shell {
|
||||
vertices,
|
||||
edges,
|
||||
faces: vec![Face {
|
||||
loops: vec![(0..3).map(|edge| EdgeUse { edge, forward: true }).collect()],
|
||||
surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
|
||||
forward: true,
|
||||
}],
|
||||
}],
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn portable_open_face_round_trip_without_a_kernel() {
|
||||
let body = triangle();
|
||||
body.validate().unwrap();
|
||||
let bytes = serde_json::to_vec(&body).unwrap();
|
||||
let restored: Brep = serde_json::from_slice(&bytes).unwrap();
|
||||
restored.validate().unwrap();
|
||||
assert_eq!(body, restored);
|
||||
assert!(!String::from_utf8(bytes).unwrap().contains("truck"));
|
||||
}
|
||||
#[test]
|
||||
fn topology_references_and_wire_orientation_are_checked() {
|
||||
let mut b = triangle();
|
||||
b.shells[0].faces[0].loops[0][0].edge = u32::MAX;
|
||||
assert!(b.validate().is_err());
|
||||
let mut b = triangle();
|
||||
b.shells[0].faces[0].loops[0][1].forward = false;
|
||||
assert!(b.validate().is_err());
|
||||
let mut b = triangle();
|
||||
b.shells[0].edges[0].vertices[0] = u32::MAX;
|
||||
assert!(b.validate().is_err());
|
||||
let mut b = triangle();
|
||||
b.version += 1;
|
||||
assert!(b.validate().is_err());
|
||||
let mut b = triangle();
|
||||
b.shells[0].vertices[0][0] = f64::NAN;
|
||||
assert!(b.validate().is_err());
|
||||
}
|
||||
#[test]
|
||||
fn closed_edge_can_share_its_endpoint_vertex() {
|
||||
let mut body = triangle();
|
||||
body.shells[0].vertices.truncate(1);
|
||||
body.shells[0].edges =
|
||||
vec![Edge { vertices: [0, 0], curve: Curve::Polyline { points: vec![[0., 0., 0.], [1., 0., 0.], [0., 1., 0.], [0., 0., 0.]] } }];
|
||||
body.shells[0].faces[0].loops = vec![vec![EdgeUse { edge: 0, forward: true }]];
|
||||
body.validate().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spline_domains_weights_and_nesting_are_bounded() {
|
||||
let mut budget = Budget(0);
|
||||
assert!(knots(&[0., 0., 1., 1.], 2, &mut budget).is_ok());
|
||||
for bad in [vec![0., 0., 0., 0.], vec![0., 1., 0., 1.], vec![0., 0., f64::INFINITY, 1.]] {
|
||||
assert!(knots(&bad, 2, &mut Budget(0)).is_err());
|
||||
}
|
||||
let c = Curve::RationalSpline { knots: vec![0., 0., 1., 1.], homogeneous: vec![[0., 0., 0., 0.], [1., 0., 0., 1.]] };
|
||||
assert!(curve(&c, 0, &mut Budget(0)).is_err());
|
||||
let p = Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [2., 0., 0.] };
|
||||
assert!(surface(&p, 0, &mut Budget(0)).is_err());
|
||||
assert!(curve(&Curve::Line { start: [0.; 3], end: [1.; 3] }, MAX_DEPTH + 1, &mut Budget(0)).is_err());
|
||||
assert!(Budget(MAX_ITEMS).add(1).is_err());
|
||||
// Control points along one direction: up to the cap, not one more (a clamped cubic).
|
||||
let clamped = |count: usize| {
|
||||
let mut k = vec![0.0; 4];
|
||||
k.extend((1..count - 3).map(|i| i as f64));
|
||||
k.extend([(count - 3) as f64; 4]);
|
||||
k
|
||||
};
|
||||
assert!(knots(&clamped(MAX_SPLINE_CONTROLS), MAX_SPLINE_CONTROLS, &mut Budget(0)).is_ok());
|
||||
assert!(knots(&clamped(MAX_SPLINE_CONTROLS + 1), MAX_SPLINE_CONTROLS + 1, &mut Budget(0)).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exact_procedural_records_are_validated_and_round_trip() {
|
||||
let plane = |z: f64| Box::new(Surface::Plane { origin: [0., 0., z], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] });
|
||||
let leader = Box::new(Curve::Polyline { points: vec![[0.; 3], [0.; 3], [1., 0., 0.]] });
|
||||
let c = Curve::SurfaceIntersection { surfaces: [plane(0.), plane(1.)], leader: leader.clone(), tolerance: 1e-6 };
|
||||
curve(&c, 0, &mut Budget(0)).unwrap();
|
||||
assert_eq!(serde_json::from_str::<Curve>(&serde_json::to_string(&c).unwrap()).unwrap(), c);
|
||||
let line = Box::new(Curve::Line { start: [0.; 3], end: [1.; 3] });
|
||||
for bad in [
|
||||
Curve::SurfaceIntersection { surfaces: [plane(0.), plane(1.)], leader: line.clone(), tolerance: 1e-6 },
|
||||
Curve::SurfaceIntersection { surfaces: [plane(0.), plane(1.)], leader: leader.clone(), tolerance: f64::NAN },
|
||||
Curve::SurfaceIntersection { surfaces: [plane(f64::INFINITY), plane(1.)], leader, tolerance: 1e-6 },
|
||||
] {
|
||||
assert!(curve(&bad, 0, &mut Budget(0)).is_err());
|
||||
}
|
||||
let identity = [[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]];
|
||||
let s = Surface::PlacedRevolution { profile: line.clone(), origin: [0.; 3], axis: [0., 0., 1.], matrix: identity, forward: false };
|
||||
surface(&s, 0, &mut Budget(0)).unwrap();
|
||||
assert_eq!(serde_json::from_str::<Surface>(&serde_json::to_string(&s).unwrap()).unwrap(), s);
|
||||
let mut flat = identity;
|
||||
flat[2] = [0.; 4];
|
||||
let bad = Surface::PlacedRevolution { profile: line, origin: [0.; 3], axis: [0., 0., 1.], matrix: flat, forward: true };
|
||||
assert!(surface(&bad, 0, &mut Budget(0)).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn analytic_records_have_independent_frames_and_domains() {
|
||||
use std::f64::consts::{FRAC_PI_2, TAU};
|
||||
let f = Frame { origin: [1., 2., 3.], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] };
|
||||
let surfaces = [
|
||||
Surface::Cylinder { frame: f.clone(), radius: 2., angle: [0., TAU], height: [-1., 3.] },
|
||||
Surface::Cone { frame: f.clone(), radius_at_origin: 2., half_angle: 0.2, angle: [0., TAU], height: [0., 3.] },
|
||||
Surface::Sphere { frame: f.clone(), radius: 2., longitude: [0., TAU], latitude: [-FRAC_PI_2, FRAC_PI_2] },
|
||||
Surface::Torus { frame: f.clone(), major_radius: 4., minor_radius: 1., longitude: [0., TAU], meridian: [0., TAU] },
|
||||
Surface::Revolution {
|
||||
profile: Box::new(Curve::Line { start: [2., 0., 0.], end: [2., 0., 3.] }),
|
||||
origin: [0.; 3],
|
||||
axis: [0., 0., 1.],
|
||||
angle: [0., TAU],
|
||||
},
|
||||
];
|
||||
for s in surfaces {
|
||||
surface(&s, 0, &mut Budget(0)).unwrap();
|
||||
let encoded = serde_json::to_string(&s).unwrap();
|
||||
assert_eq!(serde_json::from_str::<Surface>(&encoded).unwrap(), s);
|
||||
assert!(!encoded.contains("columns") && !encoded.contains("forward"));
|
||||
}
|
||||
for c in [
|
||||
Curve::CircleArc { frame: f.clone(), radius: 2., angle: [0., FRAC_PI_2] },
|
||||
Curve::EllipseArc { frame: f.clone(), radii: [2., 3.], angle: [0., TAU] },
|
||||
Curve::Intersection { knots: vec![0., 0., 1., 1.], points: vec![[0.; 3], [1.; 3]], fitting_tolerance: 1e-6, faces: None },
|
||||
] {
|
||||
curve(&c, 0, &mut Budget(0)).unwrap();
|
||||
let encoded = serde_json::to_string(&c).unwrap();
|
||||
assert_eq!(serde_json::from_str::<Curve>(&encoded).unwrap(), c);
|
||||
assert!(!encoded.contains("leader") && !encoded.contains("surfaces"));
|
||||
}
|
||||
let mut bad = f;
|
||||
bad.y_axis = bad.x_axis;
|
||||
assert!(frame(&bad, &mut Budget(0)).is_err());
|
||||
assert!(angle(&[0., TAU + 0.1]).is_err());
|
||||
assert!(range(&[2., 1.]).is_err());
|
||||
assert!(radius(f64::NAN).is_err());
|
||||
let mut b = triangle();
|
||||
b.shells[0].edges[0].curve =
|
||||
Curve::Intersection { knots: vec![0., 0., 1., 1.], points: vec![[0.; 3], [1., 0., 0.]], fitting_tolerance: 1e-6, faces: Some([0, 1]) };
|
||||
assert!(b.validate().is_err());
|
||||
}
|
||||
}
|
||||
mod tests;
|
||||
@@ -31,7 +31,6 @@ impl Curve2 {
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)] // called by the schema 4 validator
|
||||
pub(super) fn curve2(c: &Curve2, budget: &mut Budget) -> Result<()> {
|
||||
budget.add(1)?;
|
||||
match c {
|
||||
|
||||
@@ -0,0 +1,497 @@
|
||||
use super::*;
|
||||
use std::f64::consts::{FRAC_PI_2, TAU};
|
||||
|
||||
fn segment(a: f64, b: f64) -> Curve2 {
|
||||
Curve2::Spline { knots: vec![a, a, b, b], points: vec![[a, 0.], [b, 1.]] }
|
||||
}
|
||||
fn plane() -> Surface {
|
||||
Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] }
|
||||
}
|
||||
fn a_frame() -> Frame {
|
||||
Frame { origin: [1., 2., 3.], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] }
|
||||
}
|
||||
|
||||
/// Every edge's uses as the canonical walk meets them (faces are all forward here).
|
||||
fn list_uses(b: &mut Brep) {
|
||||
for e in &mut b.edges {
|
||||
e.uses.clear();
|
||||
}
|
||||
for (fi, f) in b.faces.iter().enumerate() {
|
||||
for (li, l) in f.loops.iter().enumerate() {
|
||||
if let Loop::Edges { edges } = l {
|
||||
for (p, u) in edges.iter().enumerate() {
|
||||
let at = EdgeUseRef { face: fi as u32, r#loop: li as u32, position: p as u32, upper: !u.forward };
|
||||
b.edges[u.edge as usize].uses.push(at);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Planar faces, one per vertex cycle, grouped into shells; edges and vertices numbered in
|
||||
/// canonical order as the cycles first meet them.
|
||||
fn faceted(points: &[[f64; 3]], shells: &[&[&[usize]]], regions: Vec<Region>) -> Brep {
|
||||
let mut b = Brep { version: VERSION, tolerance: 1e-7, regions, shells: Vec::new(), faces: Vec::new(), edges: Vec::new(), vertices: Vec::new() };
|
||||
let mut vertex_of = vec![None; points.len()];
|
||||
let mut vertex = |b: &mut Brep, p: usize| -> u32 {
|
||||
*vertex_of[p].get_or_insert_with(|| {
|
||||
b.vertices.push(Vertex { point: points[p], tolerance: 1e-7 });
|
||||
b.vertices.len() as u32 - 1
|
||||
})
|
||||
};
|
||||
let mut by_pair = std::collections::HashMap::new();
|
||||
for cycles in shells {
|
||||
let mut uses = Vec::new();
|
||||
for cycle in cycles.iter() {
|
||||
let mut loop_ = Vec::new();
|
||||
for k in 0..cycle.len() {
|
||||
let (a, z) = (cycle[k], cycle[(k + 1) % cycle.len()]);
|
||||
let (edge, forward) = match by_pair.get(&(z, a)) {
|
||||
Some(&e) => (e, false),
|
||||
None => {
|
||||
let vs = [vertex(&mut b, a), vertex(&mut b, z)];
|
||||
b.edges.push(Edge {
|
||||
curve: Curve::Line { start: points[a], end: points[z] },
|
||||
interval: [0., 1.],
|
||||
vertices: vs,
|
||||
tolerance: 1e-7,
|
||||
uses: vec![],
|
||||
});
|
||||
let e = b.edges.len() as u32 - 1;
|
||||
by_pair.insert((a, z), e);
|
||||
(e, true)
|
||||
}
|
||||
};
|
||||
loop_.push(OrientedEdge { edge, forward, pcurve: segment(0., 1.) });
|
||||
}
|
||||
uses.push(OrientedFace { face: b.faces.len() as u32, forward: true });
|
||||
b.faces.push(Face { surface: plane(), domain: [[-10., 10.], [-10., 10.]], loops: vec![Loop::Edges { edges: loop_ }] });
|
||||
}
|
||||
b.shells.push(Shell::Faces { faces: uses, wires: vec![] });
|
||||
}
|
||||
list_uses(&mut b);
|
||||
b
|
||||
}
|
||||
|
||||
fn infinite(shells: Vec<u32>) -> Region {
|
||||
Region { shells, void: false }
|
||||
}
|
||||
const SQUARE: [[f64; 3]; 4] = [[0., 0., 0.], [1., 0., 0.], [1., 1., 0.], [0., 1., 0.]];
|
||||
fn sheet() -> Brep {
|
||||
faceted(&SQUARE, &[&[&[0, 1, 2, 3]]], vec![infinite(vec![0])])
|
||||
}
|
||||
const TETRA: [[f64; 3]; 4] = [[0., 0., 0.], [1., 0., 0.], [0., 1., 0.], [0., 0., 1.]];
|
||||
const TETRA_FACES: [&[usize]; 4] = [&[0, 2, 1], &[0, 1, 3], &[1, 2, 3], &[0, 3, 2]];
|
||||
fn tetra() -> Brep {
|
||||
faceted(&TETRA, &[&TETRA_FACES], vec![infinite(vec![0]), Region { shells: vec![0], void: false }])
|
||||
}
|
||||
/// A tetrahedron with a tetrahedral void inside it.
|
||||
fn hollow() -> Brep {
|
||||
let mut points = TETRA.to_vec();
|
||||
points.extend(TETRA.map(|p| p.map(|x| 0.2 + 0.1 * x)));
|
||||
let inner: Vec<Vec<usize>> = TETRA_FACES.iter().map(|c| c.iter().rev().map(|i| i + 4).collect()).collect();
|
||||
let inner: Vec<&[usize]> = inner.iter().map(Vec::as_slice).collect();
|
||||
faceted(
|
||||
&points,
|
||||
&[&TETRA_FACES, &inner],
|
||||
vec![infinite(vec![0]), Region { shells: vec![0, 1], void: false }, Region { shells: vec![1], void: true }],
|
||||
)
|
||||
}
|
||||
/// The side of a cylinder: one face bounded by two circles and a seam edge used twice.
|
||||
fn tube() -> Brep {
|
||||
let f = a_frame();
|
||||
let circle = |z: f64| Curve::Circle { frame: Frame { origin: [1., 2., 3. + z], ..f.clone() }, radius: 2. };
|
||||
let edge = |curve, interval, vertices| Edge { curve, interval, vertices, tolerance: 1e-7, uses: vec![] };
|
||||
let mut b = Brep {
|
||||
version: VERSION,
|
||||
tolerance: 1e-7,
|
||||
regions: vec![infinite(vec![0])],
|
||||
shells: vec![Shell::Faces { faces: vec![OrientedFace { face: 0, forward: true }], wires: vec![] }],
|
||||
faces: vec![Face {
|
||||
surface: Surface::Cylinder { frame: f.clone(), radius: 2. },
|
||||
domain: [[0., TAU], [0., 5.]],
|
||||
loops: vec![Loop::Edges {
|
||||
edges: vec![
|
||||
OrientedEdge { edge: 0, forward: true, pcurve: segment(0., TAU) },
|
||||
OrientedEdge { edge: 1, forward: true, pcurve: segment(0., 1.) },
|
||||
OrientedEdge { edge: 2, forward: false, pcurve: segment(0., TAU) },
|
||||
OrientedEdge { edge: 1, forward: false, pcurve: segment(0., 1.) },
|
||||
],
|
||||
}],
|
||||
}],
|
||||
edges: vec![
|
||||
edge(circle(0.), [0., TAU], [0, 0]),
|
||||
edge(Curve::Line { start: [3., 2., 3.], end: [3., 2., 8.] }, [0., 1.], [0, 1]),
|
||||
edge(circle(5.), [0., TAU], [1, 1]),
|
||||
],
|
||||
vertices: vec![Vertex { point: [3., 2., 3.], tolerance: 1e-7 }, Vertex { point: [3., 2., 8.], tolerance: 1e-7 }],
|
||||
};
|
||||
list_uses(&mut b);
|
||||
b
|
||||
}
|
||||
/// The sheet with a vertex loop inside it, a wire shell and a vertex shell beside it.
|
||||
fn sheet_with_lower_forms() -> Brep {
|
||||
let mut b = sheet();
|
||||
let n = b.vertices.len() as u32;
|
||||
// Vertex order: edge vertices first (the wire edge's), then the vertex loop's, then the shell's.
|
||||
b.vertices.extend([[2., 0., 0.], [3., 0., 0.], [0.5, 0.5, 0.], [5., 5., 5.]].map(|point| Vertex { point, tolerance: 1e-7 }));
|
||||
b.edges.push(Edge {
|
||||
curve: Curve::Line { start: [2., 0., 0.], end: [3., 0., 0.] },
|
||||
interval: [0., 1.],
|
||||
vertices: [n, n + 1],
|
||||
tolerance: 1e-7,
|
||||
uses: vec![],
|
||||
});
|
||||
b.faces[0].loops.push(Loop::Vertex { vertex: n + 2 });
|
||||
b.shells.push(Shell::Wire { edges: vec![4] });
|
||||
b.shells.push(Shell::Vertex { vertex: n + 3 });
|
||||
b.regions[0].shells.extend([1, 2]);
|
||||
b
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_form_validates_and_round_trips_without_a_kernel() {
|
||||
for (name, body) in [("sheet", sheet()), ("closed", tetra()), ("void", hollow()), ("seam", tube()), ("lower forms", sheet_with_lower_forms())] {
|
||||
body.validate().unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
let bytes = serde_json::to_vec(&body).unwrap();
|
||||
let restored: Brep = serde_json::from_slice(&bytes).unwrap();
|
||||
assert_eq!(body, restored, "{name}");
|
||||
assert!(!String::from_utf8(bytes).unwrap().contains("truck"));
|
||||
}
|
||||
}
|
||||
|
||||
/// One defect each; every one is refused.
|
||||
#[test]
|
||||
fn one_defect_fixtures_are_refused() {
|
||||
let cases: Vec<(&str, &str, Brep)> = vec![
|
||||
("version", "unsupported version", {
|
||||
let mut b = sheet();
|
||||
b.version = 3;
|
||||
b
|
||||
}),
|
||||
("tolerance", "tolerance", {
|
||||
let mut b = sheet();
|
||||
b.tolerance = f64::NAN;
|
||||
b
|
||||
}),
|
||||
("vertex tolerance", "tolerance", {
|
||||
let mut b = sheet();
|
||||
b.vertices[0].tolerance = 0.;
|
||||
b
|
||||
}),
|
||||
("coordinate", "non-finite or excessive coordinate", {
|
||||
let mut b = sheet();
|
||||
b.vertices[0].point[0] = f64::INFINITY;
|
||||
b
|
||||
}),
|
||||
("edge reference", "edge reference", {
|
||||
let mut b = sheet();
|
||||
if let Loop::Edges { edges } = &mut b.faces[0].loops[0] {
|
||||
edges[0].edge = u32::MAX;
|
||||
}
|
||||
b
|
||||
}),
|
||||
("edge vertices", "edge vertices", {
|
||||
let mut b = sheet();
|
||||
b.edges[0].vertices[0] = u32::MAX;
|
||||
b
|
||||
}),
|
||||
("disconnected loop", "disconnected loop", {
|
||||
let mut b = sheet();
|
||||
if let Loop::Edges { edges } = &mut b.faces[0].loops[0] {
|
||||
edges.swap(1, 2);
|
||||
}
|
||||
list_uses(&mut b);
|
||||
b
|
||||
}),
|
||||
("reversed use", "disconnected loop", {
|
||||
let mut b = sheet();
|
||||
if let Loop::Edges { edges } = &mut b.faces[0].loops[0] {
|
||||
edges[1].forward = false;
|
||||
}
|
||||
list_uses(&mut b);
|
||||
b
|
||||
}),
|
||||
("outer vertex loop", "outer loop is not an edge loop", {
|
||||
let mut b = sheet_with_lower_forms();
|
||||
b.faces[0].loops.swap(0, 1);
|
||||
b
|
||||
}),
|
||||
("missing use", "edge uses do not list the edge's uses", {
|
||||
let mut b = tetra();
|
||||
b.edges[0].uses.pop();
|
||||
b
|
||||
}),
|
||||
("repeated use", "edge use listed twice or not a use of the edge", {
|
||||
let mut b = tetra();
|
||||
let first = b.edges[0].uses[0];
|
||||
b.edges[0].uses[1] = first;
|
||||
b
|
||||
}),
|
||||
("primary not first", "edge's primary use is not its first", {
|
||||
let mut b = tetra();
|
||||
b.edges[0].uses.reverse();
|
||||
b
|
||||
}),
|
||||
("upper", "edge use listed twice or not a use of the edge", {
|
||||
let mut b = tetra();
|
||||
b.edges[0].uses[1].upper = !b.edges[0].uses[1].upper;
|
||||
b
|
||||
}),
|
||||
("wire edge with uses", "wire edge with face uses", {
|
||||
let mut b = sheet_with_lower_forms();
|
||||
let u = b.edges[0].uses[0];
|
||||
b.edges[4].uses.push(u);
|
||||
b
|
||||
}),
|
||||
("pcurve interval", "pcurve interval differs from its edge's", {
|
||||
let mut b = tube();
|
||||
if let Loop::Edges { edges } = &mut b.faces[0].loops[0] {
|
||||
edges[0].pcurve = segment(0., TAU - 1e-3);
|
||||
}
|
||||
b
|
||||
}),
|
||||
("edge interval past one turn", "parameter interval exceeds one turn", {
|
||||
let mut b = tube();
|
||||
b.edges[0].interval = [0., TAU + 0.1];
|
||||
b
|
||||
}),
|
||||
("edge interval outside a spline", "parameter interval outside the natural domain", {
|
||||
let mut b = sheet();
|
||||
b.edges[0].curve = Curve::Spline { knots: vec![0., 0., 1., 1.], points: vec![SQUARE[0], SQUARE[1]] };
|
||||
b.edges[0].interval = [0., 1.5];
|
||||
b
|
||||
}),
|
||||
("empty edge interval", "empty parameter interval", {
|
||||
let mut b = sheet();
|
||||
b.edges[0].interval = [1., 1.];
|
||||
b
|
||||
}),
|
||||
("face domain outside the sphere", "parameter interval outside the natural domain", {
|
||||
let mut b = sheet();
|
||||
b.faces[0].surface = Surface::Sphere { frame: a_frame(), radius: 2. };
|
||||
b.faces[0].domain = [[0., TAU], [-FRAC_PI_2 - 0.1, FRAC_PI_2]];
|
||||
b
|
||||
}),
|
||||
("face domain past one turn", "parameter interval exceeds one turn", {
|
||||
let mut b = tube();
|
||||
b.faces[0].domain[0] = [0., TAU + 0.1];
|
||||
b
|
||||
}),
|
||||
("face domain outside a spline surface", "parameter interval outside the natural domain", {
|
||||
let mut b = sheet();
|
||||
b.faces[0].surface = Surface::Spline {
|
||||
u_knots: vec![0., 0., 1., 1.],
|
||||
v_knots: vec![0., 0., 1., 1.],
|
||||
points: vec![vec![[0.; 3], [0., 1., 0.]], vec![[1., 0., 0.], [1., 1., 0.]]],
|
||||
};
|
||||
b
|
||||
}),
|
||||
("edges out of order", "edges out of canonical order", {
|
||||
let mut b = sheet();
|
||||
b.edges.swap(0, 1);
|
||||
for f in &mut b.faces {
|
||||
for l in &mut f.loops {
|
||||
if let Loop::Edges { edges } = l {
|
||||
for u in edges {
|
||||
u.edge = [1, 0, 2, 3][u.edge as usize];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
list_uses(&mut b);
|
||||
b
|
||||
}),
|
||||
("vertices out of order", "vertices out of canonical order", {
|
||||
let mut b = sheet();
|
||||
b.vertices.swap(0, 1);
|
||||
for e in &mut b.edges {
|
||||
e.vertices = e.vertices.map(|v| [1, 0, 2, 3][v as usize]);
|
||||
}
|
||||
b
|
||||
}),
|
||||
("faces out of order", "faces out of canonical order", {
|
||||
let mut b = tetra();
|
||||
if let Shell::Faces { faces, .. } = &mut b.shells[0] {
|
||||
faces.swap(0, 1);
|
||||
}
|
||||
b
|
||||
}),
|
||||
("orphan vertex", "vertices out of canonical order", {
|
||||
let mut b = sheet();
|
||||
b.vertices.push(Vertex { point: [9.; 3], tolerance: 1e-7 });
|
||||
b
|
||||
}),
|
||||
("void infinite region", "the infinite region is a void", {
|
||||
let mut b = sheet();
|
||||
b.regions[0].void = true;
|
||||
b
|
||||
}),
|
||||
("open outer shell", "an open, wire or vertex shell lies in one region", {
|
||||
let mut b = sheet();
|
||||
b.regions.push(Region { shells: vec![0], void: false });
|
||||
b
|
||||
}),
|
||||
("closed shell in one region", "a closed shell bounds two regions and encloses one", {
|
||||
let mut b = tetra();
|
||||
b.regions.pop();
|
||||
b
|
||||
}),
|
||||
("bounded region without shells", "bounded region without an outer shell", {
|
||||
let mut b = tetra();
|
||||
b.regions.push(Region { shells: vec![], void: true });
|
||||
b
|
||||
}),
|
||||
("unlisted shell", "a closed shell bounds two regions and encloses one", {
|
||||
let mut b = hollow();
|
||||
b.regions[1].shells.pop();
|
||||
b.regions.pop();
|
||||
b
|
||||
}),
|
||||
("face used three times", "face used by neither one nor two oriented faces", {
|
||||
let mut b = tetra();
|
||||
if let Shell::Faces { faces, .. } = &mut b.shells[0] {
|
||||
faces.push(OrientedFace { face: 0, forward: false });
|
||||
faces.push(OrientedFace { face: 0, forward: true });
|
||||
}
|
||||
b
|
||||
}),
|
||||
("face twice in one shell", "a face's two sides", {
|
||||
let mut b = tetra();
|
||||
if let Shell::Faces { faces, .. } = &mut b.shells[0] {
|
||||
faces.push(OrientedFace { face: 0, forward: false });
|
||||
}
|
||||
b
|
||||
}),
|
||||
("cone domain past its apex", "parameter interval outside the natural domain", {
|
||||
let mut b = sheet();
|
||||
b.faces[0].surface = Surface::Cone { frame: a_frame(), radius_at_origin: 1., half_angle: 0.25 * std::f64::consts::PI };
|
||||
b.faces[0].domain = [[0., 1.], [-2., 1.]];
|
||||
b
|
||||
}),
|
||||
];
|
||||
for (name, expected, body) in cases {
|
||||
let error = body.validate().err().unwrap_or_else(|| panic!("{name} was accepted"));
|
||||
assert_eq!(error.0, expected, "{name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_reversed_face_is_walked_backwards() {
|
||||
// The sheet seen from below: its first (only) side is reversed, so the canonical walk
|
||||
// meets its loop's edges last to first.
|
||||
let mut b = sheet();
|
||||
if let Shell::Faces { faces, .. } = &mut b.shells[0] {
|
||||
faces[0].forward = false;
|
||||
}
|
||||
assert!(b.validate().is_err());
|
||||
// Renumber the edges (and vertices) in the backward walk's order.
|
||||
let Loop::Edges { edges } = &mut b.faces[0].loops[0] else { panic!("an edge loop") };
|
||||
let order: Vec<u32> = edges.iter().rev().map(|u| u.edge).collect();
|
||||
let mut new = vec![0; order.len()];
|
||||
for (i, e) in order.iter().enumerate() {
|
||||
new[*e as usize] = i as u32;
|
||||
}
|
||||
for u in edges.iter_mut() {
|
||||
u.edge = new[u.edge as usize];
|
||||
}
|
||||
let mut edges_ = b.edges.clone();
|
||||
for (old, e) in b.edges.iter().enumerate() {
|
||||
edges_[new[old] as usize] = e.clone();
|
||||
}
|
||||
b.edges = edges_;
|
||||
let mut seen = Vec::new();
|
||||
for e in &b.edges {
|
||||
for v in e.vertices {
|
||||
if !seen.contains(&v) {
|
||||
seen.push(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
let vertices = seen.iter().map(|&v| b.vertices[v as usize].clone()).collect();
|
||||
b.vertices = vertices;
|
||||
for e in &mut b.edges {
|
||||
e.vertices = e.vertices.map(|v| seen.iter().position(|&s| s == v).unwrap() as u32);
|
||||
}
|
||||
for e in &mut b.edges {
|
||||
e.uses.clear();
|
||||
}
|
||||
let Loop::Edges { edges } = &b.faces[0].loops[0] else { panic!("an edge loop") };
|
||||
for (p, u) in edges.iter().enumerate().rev() {
|
||||
b.edges[u.edge as usize].uses.push(EdgeUseRef { face: 0, r#loop: 0, position: p as u32, upper: !u.forward });
|
||||
}
|
||||
b.validate().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spline_domains_weights_and_nesting_are_bounded() {
|
||||
let mut budget = Budget(0);
|
||||
assert!(knots(&[0., 0., 1., 1.], 2, &mut budget).is_ok());
|
||||
for bad in [vec![0., 0., 0., 0.], vec![0., 1., 0., 1.], vec![0., 0., f64::INFINITY, 1.]] {
|
||||
assert!(knots(&bad, 2, &mut Budget(0)).is_err());
|
||||
}
|
||||
let c = Curve::RationalSpline { knots: vec![0., 0., 1., 1.], homogeneous: vec![[0., 0., 0., 0.], [1., 0., 0., 1.]] };
|
||||
assert!(curve(&c, 0, &mut Budget(0)).is_err());
|
||||
let p = Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [2., 0., 0.] };
|
||||
assert!(surface(&p, 0, &mut Budget(0)).is_err());
|
||||
assert!(curve(&Curve::Line { start: [0.; 3], end: [1.; 3] }, MAX_DEPTH + 1, &mut Budget(0)).is_err());
|
||||
assert!(Budget(MAX_ITEMS).add(1).is_err());
|
||||
assert_eq!(curve_natural(&Curve::Spline { knots: vec![0., 0., 0., 1., 2., 2., 2.], points: vec![[0.; 3]; 4] }), Natural::Range(0., 2.));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exact_procedural_records_are_validated_and_round_trip() {
|
||||
let plane = |z: f64| Box::new(Surface::Plane { origin: [0., 0., z], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] });
|
||||
let leader = Box::new(Curve::Polyline { points: vec![[0.; 3], [0.; 3], [1., 0., 0.]] });
|
||||
let c = Curve::SurfaceIntersection { surfaces: [plane(0.), plane(1.)], leader: leader.clone(), tolerance: 1e-6 };
|
||||
curve(&c, 0, &mut Budget(0)).unwrap();
|
||||
assert_eq!(curve_natural(&c), Natural::Range(0., 2.));
|
||||
assert_eq!(serde_json::from_str::<Curve>(&serde_json::to_string(&c).unwrap()).unwrap(), c);
|
||||
let line = Box::new(Curve::Line { start: [0.; 3], end: [1.; 3] });
|
||||
for bad in [
|
||||
Curve::SurfaceIntersection { surfaces: [plane(0.), plane(1.)], leader: line.clone(), tolerance: 1e-6 },
|
||||
Curve::SurfaceIntersection { surfaces: [plane(0.), plane(1.)], leader: leader.clone(), tolerance: f64::NAN },
|
||||
Curve::SurfaceIntersection { surfaces: [plane(f64::INFINITY), plane(1.)], leader, tolerance: 1e-6 },
|
||||
] {
|
||||
assert!(curve(&bad, 0, &mut Budget(0)).is_err());
|
||||
}
|
||||
let identity = [[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]];
|
||||
let s = Surface::PlacedRevolution { profile: line.clone(), origin: [0.; 3], axis: [0., 0., 1.], matrix: identity, forward: false };
|
||||
surface(&s, 0, &mut Budget(0)).unwrap();
|
||||
assert_eq!(surface_natural(&s), [Natural::Periodic, UNBOUNDED]);
|
||||
assert_eq!(serde_json::from_str::<Surface>(&serde_json::to_string(&s).unwrap()).unwrap(), s);
|
||||
let mut flat = identity;
|
||||
flat[2] = [0.; 4];
|
||||
let bad = Surface::PlacedRevolution { profile: line, origin: [0.; 3], axis: [0., 0., 1.], matrix: flat, forward: true };
|
||||
assert!(surface(&bad, 0, &mut Budget(0)).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn analytic_records_are_unbounded_with_independent_frames() {
|
||||
let f = a_frame();
|
||||
let surfaces = [
|
||||
Surface::Cylinder { frame: f.clone(), radius: 2. },
|
||||
Surface::Cone { frame: f.clone(), radius_at_origin: 2., half_angle: 0.2 },
|
||||
Surface::Sphere { frame: f.clone(), radius: 2. },
|
||||
Surface::Torus { frame: f.clone(), major_radius: 4., minor_radius: 1. },
|
||||
];
|
||||
for s in surfaces {
|
||||
surface(&s, 0, &mut Budget(0)).unwrap();
|
||||
let encoded = serde_json::to_string(&s).unwrap();
|
||||
assert_eq!(serde_json::from_str::<Surface>(&encoded).unwrap(), s);
|
||||
assert!(!encoded.contains("\"angle\"") && !encoded.contains("height") && !encoded.contains("longitude"));
|
||||
}
|
||||
for c in [Curve::Circle { frame: f.clone(), radius: 2. }, Curve::Ellipse { frame: f.clone(), radii: [2., 3.] }] {
|
||||
curve(&c, 0, &mut Budget(0)).unwrap();
|
||||
assert_eq!(serde_json::from_str::<Curve>(&serde_json::to_string(&c).unwrap()).unwrap(), c);
|
||||
assert_eq!(curve_natural(&c), Natural::Periodic);
|
||||
// A periodic edge may start anywhere and run up to one turn.
|
||||
interval(&[-1., TAU - 1.], Natural::Periodic).unwrap();
|
||||
}
|
||||
let mut bad = f;
|
||||
bad.y_axis = bad.x_axis;
|
||||
assert!(frame(&bad, &mut Budget(0)).is_err());
|
||||
assert!(interval(&[2., 1.], UNBOUNDED).is_err());
|
||||
assert!(radius(f64::NAN).is_err());
|
||||
assert!(surface(&Surface::Torus { frame: a_frame(), major_radius: 1., minor_radius: 2. }, 0, &mut Budget(0)).is_err());
|
||||
}
|
||||
@@ -0,0 +1,249 @@
|
||||
//! The structural rules of the topology records: references, loops, regions and shells, each
|
||||
//! edge's list of uses and the canonical order (docs/native-brep.md). Indices are hostile:
|
||||
//! every lookup is checked, and work is linear in the records.
|
||||
use std::collections::HashSet;
|
||||
|
||||
use super::{Brep, EdgeUseRef, Invalid, Loop, Result, Shell, require};
|
||||
|
||||
/// How far a pcurve's interval may differ from its edge's: this fraction of the interval's
|
||||
/// magnitude (at least 1), room for a linear remap's rounding and nothing more.
|
||||
pub(super) const PCURVE_INTERVAL: f64 = 1e-9;
|
||||
|
||||
fn get<'a, T>(items: &'a [T], i: u32, what: &'static str) -> Result<&'a T> {
|
||||
items.get(i as usize).ok_or(Invalid(what))
|
||||
}
|
||||
|
||||
/// The next index in a first-appearance order: `seen[i]` is set the first time `i` turns up,
|
||||
/// and that must be in index order (the first new one is `next`).
|
||||
struct Order {
|
||||
seen: Vec<bool>,
|
||||
next: usize,
|
||||
what: &'static str,
|
||||
}
|
||||
impl Order {
|
||||
fn new(n: usize, what: &'static str) -> Order {
|
||||
Order { seen: vec![false; n], next: 0, what }
|
||||
}
|
||||
fn visit(&mut self, i: u32) -> Result<bool> {
|
||||
let slot = self.seen.get_mut(i as usize).ok_or(Invalid(self.what))?;
|
||||
if *slot {
|
||||
return Ok(false);
|
||||
}
|
||||
require(i as usize == self.next, self.what)?;
|
||||
*slot = true;
|
||||
self.next += 1;
|
||||
Ok(true)
|
||||
}
|
||||
fn complete(&self) -> Result<()> {
|
||||
require(self.next == self.seen.len(), self.what)
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn check(b: &Brep) -> Result<()> {
|
||||
// Regions and shells: which regions list each shell, and as whose outer shell.
|
||||
let mut listed = vec![0u32; b.shells.len()];
|
||||
let mut outer_of = vec![0u32; b.shells.len()];
|
||||
let infinite = b.regions.first().ok_or(Invalid("region count"))?;
|
||||
require(!infinite.void, "the infinite region is a void")?;
|
||||
for (r, region) in b.regions.iter().enumerate() {
|
||||
require(region.shells.len() <= b.shells.len(), "region shells")?;
|
||||
for (k, &s) in region.shells.iter().enumerate() {
|
||||
require(!region.shells.get(..k).is_some_and(|before| before.contains(&s)), "shell listed twice in a region")?;
|
||||
let n = listed.get_mut(s as usize).ok_or(Invalid("region shell reference"))?;
|
||||
*n += 1;
|
||||
if r > 0 && k == 0 {
|
||||
require(matches!(get(&b.shells, s, "region shell reference")?, Shell::Faces { .. }), "outer shell is not a face shell")?;
|
||||
if let Some(n) = outer_of.get_mut(s as usize) {
|
||||
*n += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
require(r == 0 || !region.shells.is_empty(), "bounded region without an outer shell")?;
|
||||
}
|
||||
|
||||
// Faces: who uses each one. Loops: references, shape and connectivity.
|
||||
let mut face_uses: Vec<Vec<(usize, bool)>> = vec![Vec::new(); b.faces.len()];
|
||||
for (s, shell) in b.shells.iter().enumerate() {
|
||||
match shell {
|
||||
Shell::Faces { faces, wires } => {
|
||||
require(!faces.is_empty(), "empty shell")?;
|
||||
for f in faces {
|
||||
face_uses.get_mut(f.face as usize).ok_or(Invalid("oriented face reference"))?.push((s, f.forward));
|
||||
}
|
||||
for &e in wires {
|
||||
require(get(&b.edges, e, "wire edge reference")?.uses.is_empty(), "wire edge with face uses")?;
|
||||
}
|
||||
}
|
||||
Shell::Wire { edges } => {
|
||||
require(!edges.is_empty(), "empty wire shell")?;
|
||||
for &e in edges {
|
||||
require(get(&b.edges, e, "wire edge reference")?.uses.is_empty(), "wire edge with face uses")?;
|
||||
}
|
||||
}
|
||||
Shell::Vertex { vertex } => {
|
||||
get(&b.vertices, *vertex, "vertex shell reference")?;
|
||||
}
|
||||
}
|
||||
}
|
||||
for uses in &face_uses {
|
||||
match uses.as_slice() {
|
||||
[_] => {}
|
||||
[(a, fa), (b, fb)] => require(a != b && fa != fb, "a face's two sides")?,
|
||||
_ => return Err(Invalid("face used by neither one nor two oriented faces")),
|
||||
}
|
||||
}
|
||||
for f in &b.faces {
|
||||
require(matches!(f.loops.first(), Some(Loop::Edges { .. })), "outer loop is not an edge loop")?;
|
||||
for l in &f.loops {
|
||||
match l {
|
||||
Loop::Vertex { vertex } => {
|
||||
get(&b.vertices, *vertex, "vertex loop reference")?;
|
||||
}
|
||||
Loop::Edges { edges } => {
|
||||
require(!edges.is_empty(), "empty loop")?;
|
||||
let (mut first, mut last) = (None, None);
|
||||
for u in edges {
|
||||
let edge = get(&b.edges, u.edge, "edge reference")?;
|
||||
let [a, z] = edge.vertices;
|
||||
let (start, end) = if u.forward { (a, z) } else { (z, a) };
|
||||
require(last.is_none_or(|v| v == start), "disconnected loop")?;
|
||||
first.get_or_insert(start);
|
||||
last = Some(end);
|
||||
let p = u.pcurve.interval().ok_or(Invalid("pcurve interval"))?;
|
||||
let scale = PCURVE_INTERVAL * (1f64).max(edge.interval[0].abs()).max(edge.interval[1].abs());
|
||||
require(
|
||||
(p[0] - edge.interval[0]).abs() <= scale && (p[1] - edge.interval[1]).abs() <= scale,
|
||||
"pcurve interval differs from its edge's",
|
||||
)?;
|
||||
}
|
||||
require(first == last, "open loop")?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Shells: a closed face shell (every edge on its faces used at least twice among them)
|
||||
// separates two regions and encloses one; any other shell lies in one region.
|
||||
let mut count = vec![0u32; b.edges.len()];
|
||||
for (s, shell) in b.shells.iter().enumerate() {
|
||||
let (listed, outer) = (listed.get(s).copied().unwrap_or(0), outer_of.get(s).copied().unwrap_or(0));
|
||||
let closed = match shell {
|
||||
Shell::Faces { faces, .. } => {
|
||||
let edges = || {
|
||||
faces.iter().filter_map(|f| b.faces.get(f.face as usize)).flat_map(|f| &f.loops).flat_map(|l| match l {
|
||||
Loop::Edges { edges } => edges.as_slice(),
|
||||
Loop::Vertex { .. } => &[],
|
||||
})
|
||||
};
|
||||
for u in edges() {
|
||||
if let Some(n) = count.get_mut(u.edge as usize) {
|
||||
*n = n.saturating_add(1);
|
||||
}
|
||||
}
|
||||
let closed = edges().all(|u| count.get(u.edge as usize).is_some_and(|n| *n >= 2));
|
||||
for u in edges() {
|
||||
if let Some(n) = count.get_mut(u.edge as usize) {
|
||||
*n = 0;
|
||||
}
|
||||
}
|
||||
closed
|
||||
}
|
||||
Shell::Wire { .. } | Shell::Vertex { .. } => false,
|
||||
};
|
||||
if closed {
|
||||
require(listed == 2 && outer == 1, "a closed shell bounds two regions and encloses one")?;
|
||||
} else {
|
||||
require(listed == 1 && outer == 0, "an open, wire or vertex shell lies in one region")?;
|
||||
}
|
||||
}
|
||||
|
||||
// Canonical order. Shells and faces in first appearance walking regions → shells →
|
||||
// oriented faces; each face is walked in the direction its first oriented face gives.
|
||||
let mut shells = Order::new(b.shells.len(), "shells out of canonical order");
|
||||
let mut faces = Order::new(b.faces.len(), "faces out of canonical order");
|
||||
let mut direction = vec![true; b.faces.len()];
|
||||
for region in &b.regions {
|
||||
for &s in ®ion.shells {
|
||||
if !shells.visit(s)? {
|
||||
continue;
|
||||
}
|
||||
if let Some(Shell::Faces { faces: uses, .. }) = b.shells.get(s as usize) {
|
||||
for f in uses {
|
||||
if faces.visit(f.face)?
|
||||
&& let Some(d) = direction.get_mut(f.face as usize)
|
||||
{
|
||||
*d = f.forward;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
shells.complete()?;
|
||||
faces.complete()?;
|
||||
|
||||
// Edges in first appearance walking faces → loops → oriented edges (backwards in a face
|
||||
// whose first side is reversed), then wire edges walking shells; each edge's uses in that
|
||||
// walk's order, the first one primary.
|
||||
let mut edges = Order::new(b.edges.len(), "edges out of canonical order");
|
||||
let mut walked: Vec<Vec<EdgeUseRef>> = vec![Vec::new(); b.edges.len()];
|
||||
for (fi, f) in b.faces.iter().enumerate() {
|
||||
let forward = direction.get(fi).copied().unwrap_or(true);
|
||||
for (li, l) in f.loops.iter().enumerate() {
|
||||
let Loop::Edges { edges: uses } = l else { continue };
|
||||
let n = uses.len();
|
||||
for k in 0..n {
|
||||
let p = if forward { k } else { n - 1 - k };
|
||||
let u = uses.get(p).ok_or(Invalid("edge reference"))?;
|
||||
edges.visit(u.edge)?;
|
||||
let at = EdgeUseRef { face: index(fi)?, r#loop: index(li)?, position: index(p)?, upper: !u.forward };
|
||||
walked.get_mut(u.edge as usize).ok_or(Invalid("edge reference"))?.push(at);
|
||||
}
|
||||
}
|
||||
}
|
||||
for shell in &b.shells {
|
||||
let wires = match shell {
|
||||
Shell::Faces { wires, .. } => wires.as_slice(),
|
||||
Shell::Wire { edges } => edges.as_slice(),
|
||||
Shell::Vertex { .. } => &[],
|
||||
};
|
||||
for &e in wires {
|
||||
edges.visit(e)?;
|
||||
}
|
||||
}
|
||||
edges.complete()?;
|
||||
for (edge, walked) in b.edges.iter().zip(&walked) {
|
||||
require(edge.uses.len() == walked.len(), "edge uses do not list the edge's uses")?;
|
||||
require(edge.uses.first() == walked.first(), "edge's primary use is not its first")?;
|
||||
// As many entries as uses, and each one a use not listed before: each use once.
|
||||
let mut left: HashSet<EdgeUseRef> = walked.iter().copied().collect();
|
||||
for u in &edge.uses {
|
||||
require(left.remove(u), "edge use listed twice or not a use of the edge")?;
|
||||
}
|
||||
}
|
||||
|
||||
// Vertices in first appearance walking edges (start, end), then vertex loops walking
|
||||
// faces → loops, then vertex shells walking shells.
|
||||
let mut vertices = Order::new(b.vertices.len(), "vertices out of canonical order");
|
||||
for e in &b.edges {
|
||||
for &v in &e.vertices {
|
||||
vertices.visit(v)?;
|
||||
}
|
||||
}
|
||||
for f in &b.faces {
|
||||
for l in &f.loops {
|
||||
if let Loop::Vertex { vertex } = l {
|
||||
vertices.visit(*vertex)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
for shell in &b.shells {
|
||||
if let Shell::Vertex { vertex } = shell {
|
||||
vertices.visit(*vertex)?;
|
||||
}
|
||||
}
|
||||
vertices.complete()
|
||||
}
|
||||
|
||||
fn index(i: usize) -> Result<u32> {
|
||||
u32::try_from(i).map_err(|_| Invalid("index"))
|
||||
}
|
||||
+75
-57
@@ -1818,6 +1818,80 @@ impl Body {
|
||||
self.lumps_with_clearance(2.0 * (self.size() * 1e-4).max(1e-6))
|
||||
}
|
||||
|
||||
/// Each shell's mesh at `tol` with its signed volume (positive: it bounds material).
|
||||
fn shell_meshes(&self, tol: f64) -> Result<Vec<(f64, Mesh)>> {
|
||||
let shells: Vec<mt::Shell> = self.solid.boundaries().clone();
|
||||
if shells.len() > shell_groups::MAX_SHELLS
|
||||
|| shells.iter().flat_map(mt::Shell::vertex_iter).take(shell_groups::MAX_POINTS + 1).count() > shell_groups::MAX_POINTS
|
||||
|| shells.iter().flat_map(mt::Shell::face_iter).take(shell_groups::MAX_TRIANGLES + 1).count() > shell_groups::MAX_TRIANGLES
|
||||
{
|
||||
return Err(KernelError::Failed("lumps: topology exceeds the shell grouping limit".into()));
|
||||
}
|
||||
let (mut point_count, mut triangle_count) = (0usize, 0usize);
|
||||
let data: Vec<(f64, Mesh)> = shells
|
||||
.iter()
|
||||
.map(|sh| {
|
||||
let meshed = sh.robust_triangulation(tol);
|
||||
if meshed.face_iter().any(|f| f.surface().is_none_or(|m| m.faces().triangle_iter().next().is_none())) {
|
||||
return Err(KernelError::Failed("lumps: cannot mesh a complete shell boundary".into()));
|
||||
}
|
||||
let pm = meshed.to_polygon();
|
||||
point_count = point_count
|
||||
.checked_add(pm.positions().len())
|
||||
.ok_or_else(|| KernelError::Failed("lumps: mesh exceeds the shell grouping limit".into()))?;
|
||||
triangle_count = triangle_count
|
||||
.checked_add(pm.faces().triangle_iter().take(shell_groups::MAX_TRIANGLES + 1).count())
|
||||
.ok_or_else(|| KernelError::Failed("lumps: mesh exceeds the shell grouping limit".into()))?;
|
||||
if point_count > shell_groups::MAX_POINTS || triangle_count > shell_groups::MAX_TRIANGLES {
|
||||
return Err(KernelError::Failed("lumps: mesh exceeds the shell grouping limit".into()));
|
||||
}
|
||||
let mut m = Mesh::default();
|
||||
for p in pm.positions() {
|
||||
m.positions.push(Vec3::new(p.x, p.y, p.z));
|
||||
}
|
||||
for t in pm.faces().triangle_iter() {
|
||||
let idx = |k: usize| {
|
||||
t.get(k).and_then(|x| u32::try_from(x.pos).ok()).ok_or_else(|| KernelError::Failed("lumps: invalid mesh index".into()))
|
||||
};
|
||||
let indices = [idx(0)?, idx(1)?, idx(2)?];
|
||||
let [a, b, c] = m.tri(&indices).ok_or_else(|| KernelError::Failed("lumps: invalid mesh triangle".into()))?;
|
||||
// STEP sphere poles can produce zero-area duplicate triangles.
|
||||
// They have no boundary area or volume and are not ray crossings.
|
||||
if (b - a).cross(c - a) == Vec3::ZERO {
|
||||
continue;
|
||||
}
|
||||
m.triangles.push(indices);
|
||||
m.tri_face.push(0);
|
||||
}
|
||||
let origin = m.positions.first().copied().ok_or_else(|| KernelError::Failed("lumps: empty mesh".into()))?;
|
||||
let v = m
|
||||
.triangles
|
||||
.iter()
|
||||
.map(|t| {
|
||||
m.tri(t)
|
||||
.map(|[a, b, c]| (a - origin).dot((b - origin).cross(c - origin)) / 6.0)
|
||||
.ok_or_else(|| KernelError::Failed("lumps: invalid mesh triangle".into()))
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?
|
||||
.into_iter()
|
||||
.sum();
|
||||
Ok((v, m))
|
||||
})
|
||||
.collect::<Result<_>>()?;
|
||||
Ok(data)
|
||||
}
|
||||
|
||||
/// The shell directly around each of the body's shells (`None` for one in the open) and
|
||||
/// whether each bounds material (else a void), for closed shells; see `shell_groups`.
|
||||
pub(crate) fn shell_nesting(&self) -> Result<(Vec<bool>, Vec<Option<usize>>)> {
|
||||
guard("shell nesting", || {
|
||||
let data = self.shell_meshes((self.size() * 1e-3).max(1e-3))?;
|
||||
let (volumes, meshes): (Vec<_>, Vec<_>) = data.into_iter().unzip();
|
||||
let parents = shell_groups::parents(&meshes, &volumes, (self.size() * 1e-8).max(1e-9))?;
|
||||
Ok((volumes.iter().map(|v| *v > 0.0).collect(), parents))
|
||||
})
|
||||
}
|
||||
|
||||
fn lumps_with_clearance(&self, clearance: f64) -> Result<Vec<Body>> {
|
||||
if self.mesh.is_some() || self.solid.boundaries().len() < 2 {
|
||||
return Ok(vec![self.clone()]);
|
||||
@@ -1825,63 +1899,7 @@ impl Body {
|
||||
let tol = (self.size() * 1e-3).max(1e-3);
|
||||
guard("lumps", || {
|
||||
let shells: Vec<mt::Shell> = self.solid.boundaries().clone();
|
||||
if shells.len() > shell_groups::MAX_SHELLS
|
||||
|| shells.iter().flat_map(mt::Shell::vertex_iter).take(shell_groups::MAX_POINTS + 1).count() > shell_groups::MAX_POINTS
|
||||
|| shells.iter().flat_map(mt::Shell::face_iter).take(shell_groups::MAX_TRIANGLES + 1).count() > shell_groups::MAX_TRIANGLES
|
||||
{
|
||||
return Err(KernelError::Failed("lumps: topology exceeds the shell grouping limit".into()));
|
||||
}
|
||||
let (mut point_count, mut triangle_count) = (0usize, 0usize);
|
||||
let data: Vec<(f64, Mesh)> = shells
|
||||
.iter()
|
||||
.map(|sh| {
|
||||
let meshed = sh.robust_triangulation(tol);
|
||||
if meshed.face_iter().any(|f| f.surface().is_none_or(|m| m.faces().triangle_iter().next().is_none())) {
|
||||
return Err(KernelError::Failed("lumps: cannot mesh a complete shell boundary".into()));
|
||||
}
|
||||
let pm = meshed.to_polygon();
|
||||
point_count = point_count
|
||||
.checked_add(pm.positions().len())
|
||||
.ok_or_else(|| KernelError::Failed("lumps: mesh exceeds the shell grouping limit".into()))?;
|
||||
triangle_count = triangle_count
|
||||
.checked_add(pm.faces().triangle_iter().take(shell_groups::MAX_TRIANGLES + 1).count())
|
||||
.ok_or_else(|| KernelError::Failed("lumps: mesh exceeds the shell grouping limit".into()))?;
|
||||
if point_count > shell_groups::MAX_POINTS || triangle_count > shell_groups::MAX_TRIANGLES {
|
||||
return Err(KernelError::Failed("lumps: mesh exceeds the shell grouping limit".into()));
|
||||
}
|
||||
let mut m = Mesh::default();
|
||||
for p in pm.positions() {
|
||||
m.positions.push(Vec3::new(p.x, p.y, p.z));
|
||||
}
|
||||
for t in pm.faces().triangle_iter() {
|
||||
let idx = |k: usize| {
|
||||
t.get(k).and_then(|x| u32::try_from(x.pos).ok()).ok_or_else(|| KernelError::Failed("lumps: invalid mesh index".into()))
|
||||
};
|
||||
let indices = [idx(0)?, idx(1)?, idx(2)?];
|
||||
let [a, b, c] = m.tri(&indices).ok_or_else(|| KernelError::Failed("lumps: invalid mesh triangle".into()))?;
|
||||
// STEP sphere poles can produce zero-area duplicate triangles.
|
||||
// They have no boundary area or volume and are not ray crossings.
|
||||
if (b - a).cross(c - a) == Vec3::ZERO {
|
||||
continue;
|
||||
}
|
||||
m.triangles.push(indices);
|
||||
m.tri_face.push(0);
|
||||
}
|
||||
let origin = m.positions.first().copied().ok_or_else(|| KernelError::Failed("lumps: empty mesh".into()))?;
|
||||
let v = m
|
||||
.triangles
|
||||
.iter()
|
||||
.map(|t| {
|
||||
m.tri(t)
|
||||
.map(|[a, b, c]| (a - origin).dot((b - origin).cross(c - origin)) / 6.0)
|
||||
.ok_or_else(|| KernelError::Failed("lumps: invalid mesh triangle".into()))
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?
|
||||
.into_iter()
|
||||
.sum();
|
||||
Ok((v, m))
|
||||
})
|
||||
.collect::<Result<_>>()?;
|
||||
let data = self.shell_meshes(tol)?;
|
||||
let (volumes, meshes): (Vec<_>, Vec<_>) = data.into_iter().unzip();
|
||||
let groups = shell_groups::groups(&meshes, &volumes, (self.size() * 1e-8).max(1e-9).max(clearance))?;
|
||||
if groups.len() == 1 {
|
||||
|
||||
+12
-34
@@ -8,14 +8,14 @@ use std::sync::Arc;
|
||||
mod adapter;
|
||||
mod binary;
|
||||
mod metadata;
|
||||
#[allow(dead_code)]
|
||||
mod pcurve;
|
||||
mod preview;
|
||||
pub use preview::native_preview_mesh;
|
||||
|
||||
// 01/02 were development-only prototypes; independent metadata records start at 03; 04 stores
|
||||
// procedural intersections and placed revolutions exactly, and the measured runtime values.
|
||||
const MAGIC: &[u8; 8] = b"SCBREP04";
|
||||
// procedural intersections and placed revolutions exactly, and the measured runtime values; 05
|
||||
// nests geometry schema 4 (regions, unbounded geometry, pcurves, canonical order).
|
||||
const MAGIC: &[u8; 8] = b"SCBREP05";
|
||||
// A body's own limits. A design's cache holds many bodies within the container's budgets, and
|
||||
// decoding is linear in the bytes, so one large part (an imported casting) fits.
|
||||
const MAX_BYTES: usize = 256 << 20;
|
||||
@@ -39,10 +39,6 @@ struct Runtime {
|
||||
size: f64,
|
||||
/// The orientation mesh's missing-face count at its tolerance.
|
||||
coarse_missing: Option<(f64, u64)>,
|
||||
/// [`Body::boundary_tol`]: the accuracy the file it was read from declares. Written only
|
||||
/// when there is one, so a body without it is stored as before.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
boundary_tol: Option<f64>,
|
||||
}
|
||||
fn invalid(detail: impl std::fmt::Display) -> KernelError {
|
||||
KernelError::Invalid(format!("native B-rep: {detail}"))
|
||||
@@ -72,9 +68,8 @@ pub fn encode_native_body(body: &Body) -> Result<Vec<u8>> {
|
||||
if body.mesh.is_some() {
|
||||
return Err(invalid("mesh bodies are source blobs, not B-rep"));
|
||||
}
|
||||
let runtime =
|
||||
Runtime { size: body.size, coarse_missing: body.coarse_missing.map(|(tol, n)| (tol, n as u64)), boundary_tol: body.boundary_tol };
|
||||
let saved = SavedBody { solid: adapter::encode(&body.solid)?, metadata: metadata::encode(body)?, runtime };
|
||||
let runtime = Runtime { size: body.size, coarse_missing: body.coarse_missing.map(|(tol, n)| (tol, n as u64)) };
|
||||
let saved = SavedBody { solid: adapter::encode(body, pcurve::pcurves)?, metadata: metadata::encode(body)?, runtime };
|
||||
// Structural validation does not invoke another geometric reconstruction.
|
||||
validate_topology(&saved)?;
|
||||
let value = serde_json::to_value(saved).map_err(invalid)?;
|
||||
@@ -105,17 +100,13 @@ pub fn decode_native_body(bytes: &[u8]) -> Result<Body> {
|
||||
let saved: SavedBody = serde_json::from_value(value).map_err(invalid)?;
|
||||
validate_topology(&saved)?;
|
||||
let solid = adapter::decode(saved.solid)?;
|
||||
let Runtime { size, coarse_missing, boundary_tol } = saved.runtime;
|
||||
if !(size.is_finite() && size >= 0.0)
|
||||
|| coarse_missing.is_some_and(|(tol, n)| !tol.is_finite() || n > MAX_ITEMS as u64)
|
||||
|| boundary_tol.is_some_and(|t| !(t.is_finite() && t > 0.0))
|
||||
{
|
||||
let Runtime { size, coarse_missing } = saved.runtime;
|
||||
if !(size.is_finite() && size >= 0.0) || coarse_missing.is_some_and(|(tol, n)| !tol.is_finite() || n > MAX_ITEMS as u64) {
|
||||
return Err(invalid("runtime values"));
|
||||
}
|
||||
let mut body = Body {
|
||||
solid: Arc::new(solid),
|
||||
size,
|
||||
boundary_tol,
|
||||
volume: Some(std::sync::Arc::new(std::sync::Mutex::new(None))),
|
||||
coarse_missing: coarse_missing.map(|(tol, n)| (tol, n as usize)),
|
||||
mesh: None,
|
||||
@@ -136,8 +127,7 @@ pub fn decode_native_body(bytes: &[u8]) -> Result<Body> {
|
||||
|
||||
fn validate_topology(saved: &SavedBody) -> Result<()> {
|
||||
saved.solid.validate().map_err(invalid)?;
|
||||
let faces: usize = saved.solid.shells.iter().map(|s| s.faces.len()).sum();
|
||||
let edges: usize = saved.solid.shells.iter().map(|s| s.edges.len()).sum();
|
||||
let (faces, edges) = (saved.solid.faces.len(), saved.solid.edges.len());
|
||||
let saved = &saved.metadata;
|
||||
if saved.version != solidcraft_geom::brep::envelope::VERSION {
|
||||
return Err(invalid("metadata version"));
|
||||
@@ -239,18 +229,6 @@ mod tests {
|
||||
assert!((crate::measure(&a).unwrap().volume - crate::measure(&b).unwrap().volume).abs() < 1e-7);
|
||||
}
|
||||
}
|
||||
/// A body read from a file keeps the accuracy the file declares through the model cache, so
|
||||
/// a reopened design plans its faces as the import did; one without it is stored as before.
|
||||
#[test]
|
||||
fn a_files_declared_accuracy_survives_the_model_cache() {
|
||||
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(4., 3., 1.)).unwrap();
|
||||
let plain = encode_native_body(&cube).unwrap();
|
||||
assert_eq!(decode_native_body(&plain).unwrap().boundary_tol, None);
|
||||
let read = cube.with_boundary_tol(Some(1e-5));
|
||||
let bytes = encode_native_body(&read).unwrap();
|
||||
assert_ne!(bytes, plain);
|
||||
assert_eq!(decode_native_body(&bytes).unwrap().boundary_tol, Some(1e-5));
|
||||
}
|
||||
#[test]
|
||||
fn native_spheres_tori_and_open_faces_round_trip_without_conversion() {
|
||||
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap();
|
||||
@@ -277,7 +255,7 @@ mod tests {
|
||||
.iter()
|
||||
.map(|body| {
|
||||
let bytes = encode_native_body(body).unwrap();
|
||||
assert_eq!(&bytes[..8], b"SCBREP04");
|
||||
assert_eq!(&bytes[..8], b"SCBREP05");
|
||||
let mut raw = &bytes[8..];
|
||||
let value = binary::read(&mut raw, 0, &mut 2_000_000).unwrap();
|
||||
assert!(raw.is_empty());
|
||||
@@ -285,7 +263,7 @@ mod tests {
|
||||
})
|
||||
.collect();
|
||||
let actual = serde_json::json!(records);
|
||||
let expected: Value = serde_json::from_str(include_str!("native/fixtures/box-fillet-v4.json")).unwrap();
|
||||
let expected: Value = serde_json::from_str(include_str!("native/fixtures/box-fillet-v5.json")).unwrap();
|
||||
compare_wire(&expected, &actual);
|
||||
}
|
||||
|
||||
@@ -328,9 +306,9 @@ mod tests {
|
||||
for key in ["vertices", "index"] {
|
||||
let mut v = value.clone();
|
||||
if key == "vertices" {
|
||||
v["solid"]["shells"][0]["edges"][0]["vertices"] = serde_json::json!([u64::MAX, 0]);
|
||||
v["solid"]["edges"][0]["vertices"] = serde_json::json!([u64::MAX, 0]);
|
||||
} else {
|
||||
v["solid"]["shells"][0]["faces"][0]["loops"][0][0]["edge"] = serde_json::json!(u64::MAX);
|
||||
v["solid"]["faces"][0]["loops"][0]["edges"][0]["edge"] = serde_json::json!(u64::MAX);
|
||||
}
|
||||
let mut bad = MAGIC.to_vec();
|
||||
binary::write(&v, &mut bad, 0).unwrap();
|
||||
|
||||
+277
-200
@@ -1,12 +1,23 @@
|
||||
//! The truck adapter. Persisted data belongs to solidcraft_geom::brep, never truck.
|
||||
//!
|
||||
//! Truck keeps a face's wires relative to its surface (`absolute_boundaries`) and flips the
|
||||
//! face with an orientation flag, which is schema 4's convention: loops are written as truck
|
||||
//! holds them and the flag becomes the oriented face's `forward`. Faces, edges and vertices are
|
||||
//! numbered in canonical order, which is truck's own (`face_iter`, and first appearance through
|
||||
//! `edge_iter`, which walks a reversed face's wires backwards), so every index the kernel hands
|
||||
//! out (history, face sources, paint) means the same face or edge in the record.
|
||||
use super::{Result, invalid};
|
||||
use mt::Invertible;
|
||||
use crate::Body;
|
||||
use mt::{Invertible, ParametricCurve};
|
||||
use solidcraft_geom::brep as b;
|
||||
use std::collections::HashMap;
|
||||
use truck_modeling as mt;
|
||||
|
||||
#[path = "analytic.rs"]
|
||||
mod analytic;
|
||||
use analytic::{arc, full_turn, load_analytic, revolved};
|
||||
#[cfg(test)]
|
||||
use analytic::revolved;
|
||||
use analytic::{arc, load_analytic};
|
||||
fn point(p: mt::Point3) -> [f64; 3] {
|
||||
[p.x, p.y, p.z]
|
||||
}
|
||||
@@ -31,6 +42,9 @@ fn index(i: usize) -> Result<u32> {
|
||||
fn depth(d: usize) -> Result<()> {
|
||||
if d > 16 { Err(invalid("geometry nesting")) } else { Ok(()) }
|
||||
}
|
||||
fn unsupported(what: &str) -> crate::KernelError {
|
||||
crate::KernelError::Failed(format!("native B-rep: not supported yet: {what}"))
|
||||
}
|
||||
|
||||
// Truck evaluates the full knot interval. The portable domain is the standard
|
||||
// active interval, so only coincident (clamped) domains can cross this adapter.
|
||||
@@ -45,7 +59,6 @@ fn compatible_curve(c: &b::Curve) -> Result<()> {
|
||||
match c {
|
||||
b::Curve::Spline { knots, points } => clamped(knots, points.len()),
|
||||
b::Curve::RationalSpline { knots, homogeneous } => clamped(knots, homogeneous.len()),
|
||||
b::Curve::Intersection { knots, points, .. } => clamped(knots, points.len()),
|
||||
// The producer's own trace: its surfaces must load; its leader is kept as it was.
|
||||
b::Curve::SurfaceIntersection { surfaces, .. } => surfaces.iter().try_for_each(|s| compatible_surface(s)),
|
||||
_ => Ok(()),
|
||||
@@ -68,124 +81,261 @@ fn compatible_surface(s: &b::Surface) -> Result<()> {
|
||||
clamped(u_knots, homogeneous.len())?;
|
||||
clamped(v_knots, homogeneous.first().map_or(0, Vec::len))
|
||||
}
|
||||
b::Surface::Revolution { profile, angle, .. } => {
|
||||
full_turn(angle)?;
|
||||
compatible_curve(profile)
|
||||
}
|
||||
b::Surface::PlaneThrough { .. } => Ok(()),
|
||||
b::Surface::PlacedRevolution { profile, .. } => compatible_curve(profile),
|
||||
b::Surface::Cylinder { angle, .. } | b::Surface::Cone { angle, .. } => full_turn(angle),
|
||||
b::Surface::Sphere { longitude, .. } | b::Surface::Torus { longitude, .. } => full_turn(longitude),
|
||||
_ => Ok(()),
|
||||
}
|
||||
}
|
||||
fn compatible(body: &b::Brep) -> Result<()> {
|
||||
for shell in &body.shells {
|
||||
for edge in &shell.edges {
|
||||
compatible_curve(&edge.curve)?;
|
||||
}
|
||||
for face in &shell.faces {
|
||||
compatible_surface(&face.surface)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn encode(solid: &mt::Solid) -> Result<b::Brep> {
|
||||
let mut shells = Vec::new();
|
||||
for shell in solid.compress().boundaries {
|
||||
let vertices = shell.vertices.into_iter().map(point).collect();
|
||||
let edges = shell
|
||||
.edges
|
||||
.into_iter()
|
||||
.map(|e| Ok(b::Edge { vertices: [index(e.vertices.0)?, index(e.vertices.1)?], curve: save_curve(&e.curve, 0)? }))
|
||||
.collect::<Result<_>>()?;
|
||||
let faces = shell
|
||||
.faces
|
||||
.into_iter()
|
||||
.map(|f| {
|
||||
let surface = save_surface(&f.surface, 0)?;
|
||||
Ok(b::Face {
|
||||
loops: f
|
||||
.boundaries
|
||||
.into_iter()
|
||||
.map(|w| {
|
||||
let mut uses = w
|
||||
.into_iter()
|
||||
.map(|e| Ok(b::EdgeUse { edge: index(e.index)?, forward: e.orientation }))
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
// Wire direction is explicit; Face.forward changes only the normal.
|
||||
if !f.orientation {
|
||||
reverse_wire(&mut uses);
|
||||
}
|
||||
Ok(uses)
|
||||
})
|
||||
.collect::<Result<_>>()?,
|
||||
surface,
|
||||
forward: f.orientation,
|
||||
})
|
||||
})
|
||||
.collect::<Result<_>>()?;
|
||||
shells.push(b::Shell { vertices, edges, faces });
|
||||
/// The body's working tolerance, mm: its "same point" tolerance (`fill::planarity_tolerance`).
|
||||
fn working_tolerance(body: &Body) -> f64 {
|
||||
crate::fill::planarity_tolerance(body)
|
||||
}
|
||||
|
||||
/// The record of `body`'s solid, with each face's pcurves from `pcurves` (the face, then the
|
||||
/// tolerance), for its wires and edges in `face.boundaries()` order.
|
||||
pub(super) fn encode(body: &Body, pcurves: impl Fn(&mt::Face, f64) -> Result<Vec<Vec<b::Curve2>>>) -> Result<b::Brep> {
|
||||
let solid = &body.solid;
|
||||
let tolerance = working_tolerance(body);
|
||||
let shells = solid.boundaries();
|
||||
let regions = regions(body)?;
|
||||
|
||||
// Faces in truck's order; edges and vertices in first appearance.
|
||||
let mut face_index = HashMap::new();
|
||||
let mut edge_index = HashMap::new();
|
||||
let mut edges: Vec<mt::Edge> = Vec::new();
|
||||
let mut uses: Vec<Vec<b::EdgeUseRef>> = Vec::new();
|
||||
let mut faces = Vec::new();
|
||||
let mut shell_records = Vec::new();
|
||||
for shell in shells {
|
||||
let mut oriented = Vec::new();
|
||||
for face in shell.face_iter() {
|
||||
let fi = faces.len();
|
||||
if face_index.insert(face.id(), fi).is_some() {
|
||||
return Err(unsupported("a face in two shells"));
|
||||
}
|
||||
oriented.push(b::OrientedFace { face: index(fi)?, forward: face.orientation() });
|
||||
let wires = face.absolute_boundaries();
|
||||
// The canonical walk: wires in order, each backwards on a reversed face.
|
||||
for (li, wire) in wires.iter().enumerate() {
|
||||
let n = wire.len();
|
||||
for k in 0..n {
|
||||
let position = if face.orientation() { k } else { n - 1 - k };
|
||||
let e = wire.get(position).ok_or_else(|| invalid("wire position"))?;
|
||||
let i = *edge_index.entry(e.id()).or_insert_with(|| {
|
||||
edges.push(e.absolute_clone());
|
||||
uses.push(Vec::new());
|
||||
edges.len() - 1
|
||||
});
|
||||
let at = b::EdgeUseRef { face: index(fi)?, r#loop: index(li)?, position: index(position)?, upper: !e.orientation() };
|
||||
uses.get_mut(i).ok_or_else(|| invalid("edge use"))?.push(at);
|
||||
}
|
||||
}
|
||||
faces.push(face_record(face, wires, &edge_index, &pcurves, tolerance)?);
|
||||
}
|
||||
shell_records.push(b::Shell::Faces { faces: oriented, wires: Vec::new() });
|
||||
}
|
||||
let result = b::Brep { version: b::VERSION, shells };
|
||||
let mut vertex_index = HashMap::new();
|
||||
let mut vertices = Vec::new();
|
||||
let mut edge_records = Vec::with_capacity(edges.len());
|
||||
for (e, uses) in edges.iter().zip(uses) {
|
||||
if uses.len() > 2 {
|
||||
return Err(unsupported("the radial order of an edge with more than two uses"));
|
||||
}
|
||||
let mut vertex = |x: &mt::Vertex| {
|
||||
*vertex_index.entry(x.id()).or_insert_with(|| {
|
||||
vertices.push(b::Vertex { point: point(x.point()), tolerance });
|
||||
vertices.len() - 1
|
||||
})
|
||||
};
|
||||
let ends = [vertex(e.absolute_front()), vertex(e.absolute_back())];
|
||||
let curve = e.curve();
|
||||
let (t0, t1) = curve.try_range_tuple().ok_or_else(|| invalid("unbounded edge curve"))?;
|
||||
edge_records.push(b::Edge {
|
||||
curve: save_curve(&curve, 0)?,
|
||||
interval: [t0, t1],
|
||||
vertices: [index(ends[0])?, index(ends[1])?],
|
||||
tolerance,
|
||||
uses,
|
||||
});
|
||||
}
|
||||
let result = b::Brep { version: b::VERSION, tolerance, regions, shells: shell_records, faces, edges: edge_records, vertices };
|
||||
result.validate().map_err(invalid)?;
|
||||
compatible(&result)?;
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
/// A face's record: its surface, its loops as truck holds them and their pcurves, and the
|
||||
/// domain around the pcurves.
|
||||
fn face_record(
|
||||
face: &mt::Face,
|
||||
wires: &[mt::Wire],
|
||||
edge_index: &HashMap<mt::EdgeID, usize>,
|
||||
pcurves: &impl Fn(&mt::Face, f64) -> Result<Vec<Vec<b::Curve2>>>,
|
||||
tolerance: f64,
|
||||
) -> Result<b::Face> {
|
||||
let surface = save_surface(&face.surface(), 0)?;
|
||||
// `pcurves` lists the oriented wires: a reversed face's run backwards.
|
||||
let mut curves = pcurves(face, tolerance)?;
|
||||
if !face.orientation() {
|
||||
curves.iter_mut().for_each(|w| w.reverse());
|
||||
}
|
||||
if curves.len() != wires.len() || curves.iter().zip(wires).any(|(c, w)| c.len() != w.len()) {
|
||||
return Err(invalid("pcurves do not match the face's wires"));
|
||||
}
|
||||
let mut loops = Vec::with_capacity(wires.len());
|
||||
for (wire, curves) in wires.iter().zip(curves) {
|
||||
let edges = wire
|
||||
.edge_iter()
|
||||
.zip(curves)
|
||||
.map(|(e, pcurve)| {
|
||||
let i = edge_index.get(&e.id()).ok_or_else(|| invalid("edge index"))?;
|
||||
Ok(b::OrientedEdge { edge: index(*i)?, forward: e.orientation(), pcurve })
|
||||
})
|
||||
.collect::<Result<_>>()?;
|
||||
loops.push(b::Loop::Edges { edges });
|
||||
}
|
||||
let domain = domain(&surface, &loops)?;
|
||||
Ok(b::Face { surface, domain, loops })
|
||||
}
|
||||
|
||||
/// The rectangle around a face's pcurves (their control polygons, which hold them), clamped to
|
||||
/// the surface's natural domain; at most one turn in a periodic direction, about its middle.
|
||||
fn domain(surface: &b::Surface, loops: &[b::Loop]) -> Result<[[f64; 2]; 2]> {
|
||||
let mut d = [[f64::INFINITY, f64::NEG_INFINITY]; 2];
|
||||
let mut add = |uv: [f64; 2]| {
|
||||
for (r, x) in d.iter_mut().zip(uv) {
|
||||
r[0] = r[0].min(x);
|
||||
r[1] = r[1].max(x);
|
||||
}
|
||||
};
|
||||
for l in loops {
|
||||
let b::Loop::Edges { edges } = l else { continue };
|
||||
for e in edges {
|
||||
match &e.pcurve {
|
||||
b::Curve2::Spline { points, .. } => points.iter().for_each(|q| add(*q)),
|
||||
b::Curve2::RationalSpline { homogeneous, .. } => homogeneous.iter().for_each(|[x, y, w]| add([x / w, y / w])),
|
||||
}
|
||||
}
|
||||
}
|
||||
for (r, natural) in d.iter_mut().zip(surface.natural()) {
|
||||
match natural {
|
||||
b::Natural::Range(lo, hi) => *r = [r[0].max(lo), r[1].min(hi)],
|
||||
b::Natural::Periodic if r[1] - r[0] > std::f64::consts::TAU => {
|
||||
let middle = 0.5 * (r[0] + r[1]);
|
||||
*r = [middle - std::f64::consts::PI, middle + std::f64::consts::PI];
|
||||
}
|
||||
b::Natural::Periodic => {}
|
||||
}
|
||||
if !(r[0].is_finite() && r[1].is_finite() && r[0] < r[1]) {
|
||||
return Err(invalid("face domain"));
|
||||
}
|
||||
}
|
||||
Ok(d)
|
||||
}
|
||||
|
||||
/// The infinite region and the bounded ones, from the shells as truck holds them: an open shell
|
||||
/// lies in the infinite region; a closed one bounds material when it faces out (each truck
|
||||
/// solid's shells are oriented) and a void when it faces in, and lies in the region around it.
|
||||
/// Bounded regions come in the order of their outer shells.
|
||||
fn regions(body: &Body) -> Result<Vec<b::Region>> {
|
||||
let shells = body.solid.boundaries();
|
||||
let closed: Vec<bool> = shells.iter().map(|s| s.shell_condition() == mt::ShellCondition::Closed).collect();
|
||||
let all: Vec<u32> = (0..shells.len()).map(index).collect::<Result<_>>()?;
|
||||
let mut regions = Vec::new();
|
||||
match closed.iter().filter(|c| **c).count() {
|
||||
0 => regions.push(b::Region { shells: all, void: false }),
|
||||
1 => {
|
||||
regions.push(b::Region { shells: all, void: false });
|
||||
let s = closed.iter().position(|c| *c).ok_or_else(|| invalid("closed shell"))?;
|
||||
regions.push(b::Region { shells: vec![index(s)?], void: false });
|
||||
}
|
||||
n if n < shells.len() => return Err(unsupported("open shells beside several closed shells")),
|
||||
_ => {
|
||||
let (material, parents) = body.shell_nesting()?;
|
||||
let inside =
|
||||
|p: Option<usize>| -> Result<Vec<u32>> { parents.iter().enumerate().filter(|(_, q)| **q == p).map(|(i, _)| index(i)).collect() };
|
||||
regions.push(b::Region { shells: inside(None)?, void: false });
|
||||
for (s, m) in material.iter().enumerate() {
|
||||
let mut shells = vec![index(s)?];
|
||||
shells.extend(inside(Some(s))?);
|
||||
regions.push(b::Region { shells, void: !m });
|
||||
}
|
||||
// The canonical shell order walks the regions; truck's must be the same.
|
||||
let mut seen = Vec::new();
|
||||
for s in regions.iter().flat_map(|r| &r.shells) {
|
||||
if !seen.contains(s) {
|
||||
seen.push(*s);
|
||||
}
|
||||
}
|
||||
if seen != all {
|
||||
return Err(unsupported("shells in an order other than canonical (a void before another body)"));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(regions)
|
||||
}
|
||||
|
||||
fn compatible(body: &b::Brep) -> Result<()> {
|
||||
body.edges.iter().try_for_each(|e| compatible_curve(&e.curve))?;
|
||||
body.faces.iter().try_for_each(|f| compatible_surface(&f.surface))
|
||||
}
|
||||
|
||||
pub(super) fn decode(body: b::Brep) -> Result<mt::Solid> {
|
||||
body.validate().map_err(invalid)?;
|
||||
compatible(&body)?;
|
||||
let shells = body.shells.into_iter().map(shell).collect::<Result<Vec<_>>>()?;
|
||||
let b::Brep { shells, faces, edges, vertices, .. } = body;
|
||||
let vertices: Vec<mt::Vertex> = vertices.into_iter().map(|v| mt::Vertex::new(p(v.point))).collect();
|
||||
let vertex = |i: u32| vertices.get(i as usize).ok_or_else(|| invalid("edge vertices"));
|
||||
let edges = edges
|
||||
.into_iter()
|
||||
.map(|e| Ok(mt::Edge::new_unchecked(vertex(e.vertices[0])?, vertex(e.vertices[1])?, load_edge_curve(e.curve, e.interval)?)))
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
let mut faces: Vec<Option<b::Face>> = faces.into_iter().map(Some).collect();
|
||||
let shells = shells
|
||||
.into_iter()
|
||||
.map(|s| match s {
|
||||
b::Shell::Faces { faces: uses, wires } if wires.is_empty() => uses
|
||||
.into_iter()
|
||||
.map(|u| {
|
||||
// A face in two shells (both its sides used) is refused here: truck has one.
|
||||
let f = faces.get_mut(u.face as usize).and_then(Option::take).ok_or_else(|| unsupported("a face in two shells"))?;
|
||||
face(f, u.forward, &edges)
|
||||
})
|
||||
.collect::<Result<mt::Shell>>(),
|
||||
b::Shell::Faces { .. } => Err(unsupported("wire edges embedded in a shell")),
|
||||
b::Shell::Wire { .. } | b::Shell::Vertex { .. } => Err(unsupported("wire and vertex shells")),
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
if shells.iter().any(|s| s.shell_condition() == mt::ShellCondition::Irregular) {
|
||||
return Err(invalid("non-manifold shell"));
|
||||
}
|
||||
Ok(mt::Solid::new_unchecked(shells))
|
||||
}
|
||||
/// A shell's topology as recorded, references already checked: built as the kernel built it,
|
||||
/// A face's topology as recorded, references already checked: built as the kernel built it,
|
||||
/// without truck's checks for wires that touch themselves (a seam edge used twice, a closed edge
|
||||
/// on one vertex), which imported and modelled faces have.
|
||||
fn shell(s: b::Shell) -> Result<mt::Shell> {
|
||||
let vertices: Vec<mt::Vertex> = s.vertices.into_iter().map(|v| mt::Vertex::new(p(v))).collect();
|
||||
let vertex = |i: u32| vertices.get(i as usize).ok_or_else(|| invalid("edge vertices"));
|
||||
let edges = s
|
||||
.edges
|
||||
/// on one vertex), which imported and modelled faces have. Pcurves are not needed (truck has none).
|
||||
fn face(f: b::Face, forward: bool, edges: &[mt::Edge]) -> Result<mt::Face> {
|
||||
let wires = f
|
||||
.loops
|
||||
.into_iter()
|
||||
.map(|e| Ok(mt::Edge::new_unchecked(vertex(e.vertices[0])?, vertex(e.vertices[1])?, load_curve(e.curve)?)))
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
s.faces
|
||||
.into_iter()
|
||||
.map(|f| {
|
||||
let mut loops = f.loops;
|
||||
if !f.forward {
|
||||
for wire in &mut loops {
|
||||
reverse_wire(wire);
|
||||
}
|
||||
}
|
||||
let wires = loops
|
||||
.map(|l| match l {
|
||||
b::Loop::Edges { edges: uses } => uses
|
||||
.into_iter()
|
||||
.map(|w| {
|
||||
w.into_iter()
|
||||
.map(|u| {
|
||||
let e = edges.get(u.edge as usize).ok_or_else(|| invalid("edge reference"))?;
|
||||
Ok(if u.forward { e.clone() } else { e.inverse() })
|
||||
})
|
||||
.collect::<Result<mt::Wire>>()
|
||||
.map(|u| {
|
||||
let e = edges.get(u.edge as usize).ok_or_else(|| invalid("edge reference"))?;
|
||||
Ok(if u.forward { e.clone() } else { e.inverse() })
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
let mut face = mt::Face::new_unchecked(wires, load_surface(f.surface)?);
|
||||
if !f.forward {
|
||||
face.invert();
|
||||
}
|
||||
Ok(face)
|
||||
.collect::<Result<mt::Wire>>(),
|
||||
b::Loop::Vertex { .. } => Err(unsupported("vertex loops")),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn reverse_wire(wire: &mut [b::EdgeUse]) {
|
||||
wire.reverse();
|
||||
for edge in wire {
|
||||
edge.forward = !edge.forward;
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
let mut face = mt::Face::new_unchecked(wires, load_surface(f.surface, f.domain)?);
|
||||
if !forward {
|
||||
face.invert();
|
||||
}
|
||||
Ok(face)
|
||||
}
|
||||
|
||||
/// Exact: every record holds the producer's own numbers, so loading it gives back the same
|
||||
/// curve, never a refit.
|
||||
fn save_curve(c: &mt::Curve, d: usize) -> Result<b::Curve> {
|
||||
@@ -271,11 +421,30 @@ fn save_surface(s: &mt::Surface, d: usize) -> Result<b::Surface> {
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// An edge's curve for truck, which bounds an edge by its curve's range: the record itself
|
||||
/// where the interval is that range (all this adapter writes), else the piece on the interval
|
||||
/// for the kinds that have one in closed form.
|
||||
fn load_edge_curve(c: b::Curve, interval: [f64; 2]) -> Result<mt::Curve> {
|
||||
match c {
|
||||
b::Curve::Line { start, end } if interval != [0., 1.] => {
|
||||
let at = |t: f64| p(start) + (p(end) - p(start)) * t;
|
||||
Ok(mt::Curve::Line(mt::Line(at(interval[0]), at(interval[1]))))
|
||||
}
|
||||
b::Curve::Circle { frame, radius } => arc(&frame, [radius, radius], interval),
|
||||
b::Curve::Ellipse { frame, radii } => arc(&frame, radii, interval),
|
||||
b::Curve::Line { .. } => load_curve(c),
|
||||
c => match c.natural() {
|
||||
b::Natural::Range(a, z) if [a, z] == interval => load_curve(c),
|
||||
_ => Err(unsupported("a spline or intersection edge on part of its curve")),
|
||||
},
|
||||
}
|
||||
}
|
||||
fn load_curve(c: b::Curve) -> Result<mt::Curve> {
|
||||
Ok(match c {
|
||||
b::Curve::Line { start, end } => mt::Curve::Line(mt::Line(p(start), p(end))),
|
||||
b::Curve::CircleArc { frame, radius, angle } => arc(&frame, [radius, radius], angle)?,
|
||||
b::Curve::EllipseArc { frame, radii, angle } => arc(&frame, radii, angle)?,
|
||||
b::Curve::Circle { frame, radius } => arc(&frame, [radius, radius], [0., std::f64::consts::TAU])?,
|
||||
b::Curve::Ellipse { frame, radii } => arc(&frame, radii, [0., std::f64::consts::TAU])?,
|
||||
b::Curve::Spline { knots, points } => {
|
||||
mt::Curve::BSplineCurve(mt::BSplineCurve::try_new(knots.into(), points.into_iter().map(p).collect()).map_err(invalid)?)
|
||||
}
|
||||
@@ -283,9 +452,6 @@ fn load_curve(c: b::Curve) -> Result<mt::Curve> {
|
||||
mt::BSplineCurve::try_new(knots.into(), homogeneous.into_iter().map(v4).collect()).map_err(invalid)?,
|
||||
)),
|
||||
b::Curve::Polyline { .. } => return Err(invalid("standalone polyline unsupported by this adapter")),
|
||||
b::Curve::Intersection { knots, points, .. } => {
|
||||
mt::Curve::BSplineCurve(mt::BSplineCurve::try_new(knots.into(), points.into_iter().map(p).collect()).map_err(invalid)?)
|
||||
}
|
||||
b::Curve::SurfaceIntersection { surfaces: [s0, s1], leader, tolerance } => {
|
||||
let leader = match *leader {
|
||||
b::Curve::Polyline { points } => mt::Leader::Polyline(mt::PolylineCurve(points.into_iter().map(p).collect())),
|
||||
@@ -294,12 +460,16 @@ fn load_curve(c: b::Curve) -> Result<mt::Curve> {
|
||||
}
|
||||
_ => return Err(invalid("intersection leader")),
|
||||
};
|
||||
let (s0, s1) = (load_surface(*s0)?, load_surface(*s1)?);
|
||||
let (s0, s1) = (load_surface(*s0, UNIT)?, load_surface(*s1, UNIT)?);
|
||||
mt::Curve::IntersectionCurve(mt::IntersectionCurve::new_unchecked(Box::new(s0), Box::new(s1), leader, tolerance))
|
||||
}
|
||||
})
|
||||
}
|
||||
fn load_surface(s: b::Surface) -> Result<mt::Surface> {
|
||||
/// The domain an intersection's surfaces load with: they have no face of their own.
|
||||
const UNIT: [[f64; 2]; 2] = [[0., 1.]; 2];
|
||||
/// A surface for truck; `domain` (the face's) bounds the profile of an analytic surface,
|
||||
/// which truck holds as a revolution.
|
||||
fn load_surface(s: b::Surface, domain: [[f64; 2]; 2]) -> Result<mt::Surface> {
|
||||
Ok(match s {
|
||||
b::Surface::Plane { origin, u_axis, v_axis } => mt::Surface::Plane(mt::Plane::new(p(origin), p(origin) + v(u_axis), p(origin) + v(v_axis))),
|
||||
b::Surface::Spline { u_knots, v_knots, points } => mt::Surface::BSplineSurface(
|
||||
@@ -310,10 +480,6 @@ fn load_surface(s: b::Surface) -> Result<mt::Surface> {
|
||||
mt::BSplineSurface::try_new((u_knots.into(), v_knots.into()), homogeneous.into_iter().map(|r| r.into_iter().map(v4).collect()).collect())
|
||||
.map_err(invalid)?,
|
||||
)),
|
||||
b::Surface::Revolution { profile, origin, axis, angle } => {
|
||||
full_turn(&angle)?;
|
||||
revolved(load_curve(*profile)?, p(origin), v(axis), false)
|
||||
}
|
||||
b::Surface::PlaneThrough { origin, u_point, v_point } => mt::Surface::Plane(mt::Plane::new(p(origin), p(u_point), p(v_point))),
|
||||
b::Surface::PlacedRevolution { profile, origin, axis, matrix: [x, y, z, w], forward } => {
|
||||
let placed = PlacedRevolution {
|
||||
@@ -323,99 +489,10 @@ fn load_surface(s: b::Surface) -> Result<mt::Surface> {
|
||||
};
|
||||
mt::Surface::RevolutedCurve(serde_json::from_value(serde_json::to_value(placed).map_err(invalid)?).map_err(invalid)?)
|
||||
}
|
||||
analytic => load_analytic(analytic)?,
|
||||
analytic => load_analytic(analytic, domain[1])?,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use mt::{BoundedCurve, InnerSpace, ParametricCurve, Transformed};
|
||||
|
||||
#[test]
|
||||
fn refuses_domain_or_axis_changes_instead_of_approximating() {
|
||||
let curve = b::Curve::Spline { knots: vec![0., 1., 2., 3.], points: vec![[0.; 3], [1.; 3]] };
|
||||
assert!(compatible_curve(&curve).is_err());
|
||||
let plane = b::Surface::Plane { origin: [1e12; 3], u_axis: [1e-6, 0., 0.], v_axis: [0., 1., 0.] };
|
||||
assert!(compatible_surface(&plane).is_err());
|
||||
assert!(clamped(&[0., 0., 1., 1.], 2).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn analytic_records_decode_as_their_mathematical_loci_and_normals() {
|
||||
use mt::{MetricSpace, ParametricSurface, ParametricSurface3D};
|
||||
use std::f64::consts::{FRAC_PI_2, TAU};
|
||||
let frame = b::Frame { origin: [1., 2., 3.], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] };
|
||||
let circle = load_curve(b::Curve::CircleArc { frame: frame.clone(), radius: 2., angle: [0., FRAC_PI_2] }).unwrap();
|
||||
assert!(circle.subs(0.).distance(p([3., 2., 3.])) < 1e-12);
|
||||
assert!(circle.subs(1.).distance(p([1., 4., 3.])) < 1e-12);
|
||||
let ellipse = load_curve(b::Curve::EllipseArc { frame: frame.clone(), radii: [2., 3.], angle: [0., FRAC_PI_2] }).unwrap();
|
||||
assert!(ellipse.subs(1.).distance(p([1., 5., 3.])) < 1e-12);
|
||||
let cases = [
|
||||
(b::Surface::Cylinder { frame: frame.clone(), radius: 2., angle: [0., TAU], height: [-1., 3.] }, 0.5, [3., 2., 4.], [1., 0., 0.]),
|
||||
(
|
||||
b::Surface::Cone { frame: frame.clone(), radius_at_origin: 2., half_angle: 0.2, angle: [0., TAU], height: [0., 3.] },
|
||||
0.5,
|
||||
[3. + 1.5 * 0.2f64.tan(), 2., 4.5],
|
||||
[1., 0., -0.2f64.tan()],
|
||||
),
|
||||
(
|
||||
b::Surface::Sphere { frame: frame.clone(), radius: 2., longitude: [0., TAU], latitude: [-FRAC_PI_2, FRAC_PI_2] },
|
||||
0.5,
|
||||
[3., 2., 3.],
|
||||
[1., 0., 0.],
|
||||
),
|
||||
(
|
||||
b::Surface::Torus { frame, major_radius: 4., minor_radius: 1., longitude: [0., TAU], meridian: [0., TAU] },
|
||||
0.,
|
||||
[6., 2., 3.],
|
||||
[1., 0., 0.],
|
||||
),
|
||||
];
|
||||
for (record, parameter, expected, normal) in cases {
|
||||
let surface = load_surface(record).unwrap();
|
||||
assert!(surface.subs(0., parameter).distance(p(expected)) < 1e-10);
|
||||
assert!(surface.normal(0., parameter).normalize().dot(v(normal).normalize()) > 1. - 1e-10);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intersections_and_revolutions_reload_exactly() {
|
||||
use solidcraft_geom::Vec3;
|
||||
let cyl = crate::cylinder(Vec3::ZERO, Vec3::Z, 5., 40.).unwrap();
|
||||
let block = crate::box_solid(Vec3::new(-20., -20., 20.), Vec3::new(20., 20., 60.)).unwrap();
|
||||
let block = crate::transform(&block, Vec3::ZERO, Vec3::new(0., 0., 20.), Vec3::X, 0.4).unwrap();
|
||||
let cut = crate::boolean(&cyl, &block, crate::BoolOp::Cut).unwrap().unwrap();
|
||||
let curve = cut.solid.edge_iter().map(|e| e.curve()).find(|c| matches!(c, mt::Curve::IntersectionCurve(_))).unwrap();
|
||||
let record = save_curve(&curve, 0).unwrap();
|
||||
assert!(matches!(record, b::Curve::SurfaceIntersection { .. }), "the procedural curve itself, not a fit");
|
||||
let restored = load_curve(record.clone()).unwrap();
|
||||
let (a, b) = curve.range_tuple();
|
||||
for i in 0..=64 {
|
||||
let t = a + (b - a) * i as f64 / 64.;
|
||||
assert_eq!(curve.subs(t), restored.subs(t), "sample {i}");
|
||||
}
|
||||
assert_eq!(save_curve(&restored, 0).unwrap(), record);
|
||||
// The whole body: the same records again, and the same volume to the last bit.
|
||||
let bytes = crate::encode_native_body(&cut).unwrap();
|
||||
let decoded = crate::decode_native_body(&bytes).unwrap();
|
||||
assert_eq!(crate::encode_native_body(&decoded).unwrap(), bytes);
|
||||
assert_eq!(crate::measure(&decoded).unwrap().volume, crate::measure(&cut).unwrap().volume);
|
||||
// A revolution keeps its own placement, reversed normal included.
|
||||
let line = mt::Curve::Line(mt::Line(mt::Point3::new(2., 0., 0.), mt::Point3::new(2.5, 0., 3.)));
|
||||
let mt::Surface::RevolutedCurve(mut placed) = revolved(line, mt::Point3::new(0., 1., 0.), mt::Vector3::new(0., 0., 1.), true) else {
|
||||
panic!("a revolution")
|
||||
};
|
||||
placed.transform_by(mt::Matrix4::from_translation(mt::Vector3::new(1., 2., 3.)) * mt::Matrix4::from_angle_x(mt::Rad(0.3)));
|
||||
let placed = mt::Surface::RevolutedCurve(placed);
|
||||
let record = save_surface(&placed, 0).unwrap();
|
||||
assert!(matches!(record, b::Surface::PlacedRevolution { forward: false, .. }));
|
||||
let restored = load_surface(record.clone()).unwrap();
|
||||
assert_eq!(save_surface(&restored, 0).unwrap(), record);
|
||||
use mt::{ParametricSurface, ParametricSurface3D};
|
||||
for (u, v) in [(0., 0.), (1.3, 0.4), (4., 1.)] {
|
||||
assert_eq!(placed.subs(u, v), restored.subs(u, v));
|
||||
assert_eq!(placed.normal(u, v), restored.normal(u, v));
|
||||
}
|
||||
}
|
||||
}
|
||||
#[path = "adapter_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,160 @@
|
||||
use super::*;
|
||||
use mt::{BoundedCurve, InnerSpace, Transformed};
|
||||
use solidcraft_geom::Vec3;
|
||||
|
||||
#[test]
|
||||
fn refuses_domain_or_axis_changes_instead_of_approximating() {
|
||||
let curve = b::Curve::Spline { knots: vec![0., 1., 2., 3.], points: vec![[0.; 3], [1.; 3]] };
|
||||
assert!(compatible_curve(&curve).is_err());
|
||||
let plane = b::Surface::Plane { origin: [1e12; 3], u_axis: [1e-6, 0., 0.], v_axis: [0., 1., 0.] };
|
||||
assert!(compatible_surface(&plane).is_err());
|
||||
assert!(clamped(&[0., 0., 1., 1.], 2).is_ok());
|
||||
// A spline edge on part of its curve would need truck to cut it: refused, not refitted.
|
||||
let spline = b::Curve::Spline { knots: vec![0., 0., 1., 1.], points: vec![[0.; 3], [1.; 3]] };
|
||||
assert!(load_edge_curve(spline.clone(), [0., 0.5]).is_err());
|
||||
assert!(load_edge_curve(spline, [0., 1.]).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn analytic_records_decode_as_their_mathematical_loci_and_normals() {
|
||||
use mt::{MetricSpace, ParametricSurface, ParametricSurface3D};
|
||||
use std::f64::consts::{FRAC_PI_2, TAU};
|
||||
let frame = b::Frame { origin: [1., 2., 3.], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] };
|
||||
let circle = load_edge_curve(b::Curve::Circle { frame: frame.clone(), radius: 2. }, [0., FRAC_PI_2]).unwrap();
|
||||
assert!(circle.subs(0.).distance(p([3., 2., 3.])) < 1e-12);
|
||||
assert!(circle.subs(1.).distance(p([1., 4., 3.])) < 1e-12);
|
||||
let ellipse = load_edge_curve(b::Curve::Ellipse { frame: frame.clone(), radii: [2., 3.] }, [0., FRAC_PI_2]).unwrap();
|
||||
assert!(ellipse.subs(1.).distance(p([1., 5., 3.])) < 1e-12);
|
||||
// Past the seam: an arc from -π/2 to π/2.
|
||||
let across = load_edge_curve(b::Curve::Circle { frame: frame.clone(), radius: 2. }, [-FRAC_PI_2, FRAC_PI_2]).unwrap();
|
||||
assert!(across.subs(0.).distance(p([1., 0., 3.])) < 1e-12);
|
||||
// A line edge on part of its line.
|
||||
let line = load_edge_curve(b::Curve::Line { start: [0.; 3], end: [1., 0., 0.] }, [-1., 2.]).unwrap();
|
||||
assert!(line.subs(0.).distance(p([-1., 0., 0.])) < 1e-12 && line.subs(1.).distance(p([2., 0., 0.])) < 1e-12);
|
||||
let cases = [
|
||||
(b::Surface::Cylinder { frame: frame.clone(), radius: 2. }, [-1., 3.], 0.5, [3., 2., 4.], [1., 0., 0.]),
|
||||
(
|
||||
b::Surface::Cone { frame: frame.clone(), radius_at_origin: 2., half_angle: 0.2 },
|
||||
[0., 3.],
|
||||
0.5,
|
||||
[3. + 1.5 * 0.2f64.tan(), 2., 4.5],
|
||||
[1., 0., -0.2f64.tan()],
|
||||
),
|
||||
(b::Surface::Sphere { frame: frame.clone(), radius: 2. }, [-FRAC_PI_2, FRAC_PI_2], 0.5, [3., 2., 3.], [1., 0., 0.]),
|
||||
(b::Surface::Torus { frame, major_radius: 4., minor_radius: 1. }, [0., TAU], 0., [6., 2., 3.], [1., 0., 0.]),
|
||||
];
|
||||
for (record, height, parameter, expected, normal) in cases {
|
||||
let surface = load_surface(record, [[0., TAU], height]).unwrap();
|
||||
assert!(surface.subs(0., parameter).distance(p(expected)) < 1e-10);
|
||||
assert!(surface.normal(0., parameter).normalize().dot(v(normal).normalize()) > 1. - 1e-10);
|
||||
}
|
||||
}
|
||||
|
||||
/// Every face, edge and vertex index of the record is the kernel's own: faces in `face_iter`
|
||||
/// order, edges in `Body::edges` order (first appearance through `edge_iter`, which walks a
|
||||
/// reversed face backwards).
|
||||
fn same_indices(body: &Body, record: &b::Brep) {
|
||||
assert_eq!(record.faces.len(), body.face_count());
|
||||
let edges = Body::unique_edges(&body.solid);
|
||||
assert_eq!(record.edges.len(), edges.len());
|
||||
for (r, e) in record.edges.iter().zip(&edges) {
|
||||
let ends = [e.absolute_front().point(), e.absolute_back().point()];
|
||||
let recorded = r.vertices.map(|i| p(record.vertices[i as usize].point));
|
||||
assert_eq!(recorded, ends);
|
||||
}
|
||||
for (r, f) in record.faces.iter().zip(body.solid.face_iter()) {
|
||||
let b::Loop::Edges { edges } = &r.loops[0] else { panic!("an edge loop") };
|
||||
assert_eq!(edges.len(), f.absolute_boundaries()[0].len());
|
||||
}
|
||||
let history = crate::history::edge_faces(&body.solid);
|
||||
for (i, faces) in history.iter().enumerate() {
|
||||
let mut recorded: Vec<usize> = record.edges[i].uses.iter().map(|u| u.face as usize).collect();
|
||||
recorded.dedup();
|
||||
assert_eq!(&recorded, faces, "edge {i}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn planar_bodies_encode_in_the_kernels_order_and_decode_exactly() {
|
||||
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap();
|
||||
let slot = crate::box_solid(Vec3::new(10., -1., 4.), Vec3::new(20., 31., 11.)).unwrap();
|
||||
let notched = crate::boolean(&cube, &slot, crate::BoolOp::Cut).unwrap().unwrap();
|
||||
let sheet = crate::copy_faces(&cube, &[Vec3::new(20., 15., 10.)]).unwrap();
|
||||
let inner = crate::box_solid(Vec3::new(5., 5., 2.), Vec3::new(10., 10., 6.)).unwrap();
|
||||
let hollow = crate::boolean(&cube, &inner, crate::BoolOp::Cut).unwrap().unwrap();
|
||||
for (name, body) in [("cube", cube), ("notched", notched), ("sheet", sheet), ("hollow", hollow)] {
|
||||
assert!(body.solid.face_iter().any(|f| !f.orientation()) || name == "sheet", "{name}: a reversed face is walked");
|
||||
let record = encode(&body, super::super::pcurve::pcurves).unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
same_indices(&body, &record);
|
||||
let decoded = decode(record.clone()).unwrap();
|
||||
let again = Body::new(decoded).unwrap();
|
||||
let record2 = encode(&again, super::super::pcurve::pcurves).unwrap();
|
||||
assert_eq!(record, record2, "{name}: decoded body re-encodes to the same record");
|
||||
match name {
|
||||
"sheet" => assert_eq!(record.regions, vec![b::Region { shells: vec![0], void: false }]),
|
||||
"hollow" => {
|
||||
assert_eq!(record.shells.len(), 2);
|
||||
assert_eq!(
|
||||
record.regions,
|
||||
vec![
|
||||
b::Region { shells: vec![0], void: false },
|
||||
b::Region { shells: vec![0, 1], void: false },
|
||||
b::Region { shells: vec![1], void: true },
|
||||
]
|
||||
);
|
||||
}
|
||||
_ => assert_eq!(record.regions, vec![b::Region { shells: vec![0], void: false }, b::Region { shells: vec![0], void: false }]),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn records_truck_cannot_hold_are_refused() {
|
||||
let cube = crate::box_solid(Vec3::ZERO, Vec3::new(4., 3., 1.)).unwrap();
|
||||
let record = encode(&cube, super::super::pcurve::pcurves).unwrap();
|
||||
let mut wire = record.clone();
|
||||
wire.shells.push(b::Shell::Vertex { vertex: 0 });
|
||||
assert!(decode(wire).is_err());
|
||||
let mut vertex_loop = record;
|
||||
vertex_loop.faces[0].loops.push(b::Loop::Vertex { vertex: 0 });
|
||||
assert!(decode(vertex_loop).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intersections_and_revolutions_reload_exactly() {
|
||||
let cyl = crate::cylinder(Vec3::ZERO, Vec3::Z, 5., 40.).unwrap();
|
||||
let block = crate::box_solid(Vec3::new(-20., -20., 20.), Vec3::new(20., 20., 60.)).unwrap();
|
||||
let block = crate::transform(&block, Vec3::ZERO, Vec3::new(0., 0., 20.), Vec3::X, 0.4).unwrap();
|
||||
let cut = crate::boolean(&cyl, &block, crate::BoolOp::Cut).unwrap().unwrap();
|
||||
let curve = cut.solid.edge_iter().map(|e| e.curve()).find(|c| matches!(c, mt::Curve::IntersectionCurve(_))).unwrap();
|
||||
let record = save_curve(&curve, 0).unwrap();
|
||||
assert!(matches!(record, b::Curve::SurfaceIntersection { .. }), "the procedural curve itself, not a fit");
|
||||
let (a, z) = curve.range_tuple();
|
||||
let restored = load_edge_curve(record.clone(), [a, z]).unwrap();
|
||||
for i in 0..=64 {
|
||||
let t = a + (z - a) * i as f64 / 64.;
|
||||
assert_eq!(curve.subs(t), restored.subs(t), "sample {i}");
|
||||
}
|
||||
assert_eq!(save_curve(&restored, 0).unwrap(), record);
|
||||
// A revolution keeps its own placement, reversed normal included.
|
||||
let line = mt::Curve::Line(mt::Line(mt::Point3::new(2., 0., 0.), mt::Point3::new(2.5, 0., 3.)));
|
||||
let mt::Surface::RevolutedCurve(mut placed) = revolved(line, mt::Point3::new(0., 1., 0.), mt::Vector3::new(0., 0., 1.), true) else {
|
||||
panic!("a revolution")
|
||||
};
|
||||
placed.transform_by(mt::Matrix4::from_translation(mt::Vector3::new(1., 2., 3.)) * mt::Matrix4::from_angle_x(mt::Rad(0.3)));
|
||||
let placed = mt::Surface::RevolutedCurve(placed);
|
||||
let record = save_surface(&placed, 0).unwrap();
|
||||
assert!(matches!(record, b::Surface::PlacedRevolution { forward: false, .. }));
|
||||
let restored = load_surface(record.clone(), UNIT).unwrap();
|
||||
assert_eq!(save_surface(&restored, 0).unwrap(), record);
|
||||
use mt::{ParametricSurface, ParametricSurface3D};
|
||||
for (u, v) in [(0., 0.), (1.3, 0.4), (4., 1.)] {
|
||||
assert_eq!(placed.subs(u, v), restored.subs(u, v));
|
||||
assert_eq!(placed.normal(u, v), restored.normal(u, v));
|
||||
}
|
||||
// The whole body: the same records again, and the same volume to the last bit.
|
||||
let bytes = crate::encode_native_body(&cut).unwrap();
|
||||
let decoded = crate::decode_native_body(&bytes).unwrap();
|
||||
assert_eq!(crate::encode_native_body(&decoded).unwrap(), bytes);
|
||||
assert_eq!(crate::measure(&decoded).unwrap().volume, crate::measure(&cut).unwrap().volume);
|
||||
}
|
||||
@@ -1,14 +1,6 @@
|
||||
//! Analytic wire records are mathematical loci, independent of backend parameterizations.
|
||||
use super::*;
|
||||
|
||||
pub(super) fn full_turn(angle: &[f64; 2]) -> Result<()> {
|
||||
if (angle[1] - angle[0] - std::f64::consts::TAU).abs() > 1e-12 {
|
||||
Err(invalid("partial angular surface domains need another adapter representation"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Exact rational conic locus. The adapter reparameterizes angle by rational spans.
|
||||
pub(super) fn arc(frame: &b::Frame, radii: [f64; 2], angle: [f64; 2]) -> Result<mt::Curve> {
|
||||
let span = angle[1] - angle[0];
|
||||
@@ -36,32 +28,32 @@ pub(super) fn revolved(profile: mt::Curve, origin: mt::Point3, axis: mt::Vector3
|
||||
mt::Surface::RevolutedCurve(s)
|
||||
}
|
||||
|
||||
pub(super) fn load_analytic(surface: b::Surface) -> Result<mt::Surface> {
|
||||
/// An unbounded analytic surface as a truck revolution, its profile over `height` (the face's
|
||||
/// v range) for a cylinder or cone, and the whole meridian for a sphere or torus. Truck's
|
||||
/// revolution has its own (u, v); the record's loops, not its parameters, bound the face.
|
||||
pub(super) fn load_analytic(surface: b::Surface, height: [f64; 2]) -> Result<mt::Surface> {
|
||||
use std::f64::consts::{FRAC_PI_2, TAU};
|
||||
let axis = |f: &b::Frame| v(f.x_axis).cross(v(f.y_axis));
|
||||
Ok(match surface {
|
||||
b::Surface::Cylinder { frame, radius, angle, height } => {
|
||||
full_turn(&angle)?;
|
||||
b::Surface::Cylinder { frame, radius } => {
|
||||
let z = axis(&frame);
|
||||
let at = |h| p(frame.origin) + v(frame.x_axis) * radius + z * h;
|
||||
revolved(mt::Curve::Line(mt::Line(at(height[0]), at(height[1]))), p(frame.origin), z, true)
|
||||
}
|
||||
b::Surface::Cone { frame, radius_at_origin, half_angle, angle, height } => {
|
||||
full_turn(&angle)?;
|
||||
b::Surface::Cone { frame, radius_at_origin, half_angle } => {
|
||||
let z = axis(&frame);
|
||||
let at = |h| p(frame.origin) + v(frame.x_axis) * (radius_at_origin + h * half_angle.tan()) + z * h;
|
||||
revolved(mt::Curve::Line(mt::Line(at(height[0]), at(height[1]))), p(frame.origin), z, true)
|
||||
}
|
||||
b::Surface::Sphere { frame, radius, longitude, latitude } => {
|
||||
full_turn(&longitude)?;
|
||||
b::Surface::Sphere { frame, radius } => {
|
||||
let z = axis(&frame);
|
||||
let meridian = b::Frame { origin: frame.origin, x_axis: frame.x_axis, y_axis: vector(z) };
|
||||
revolved(arc(&meridian, [radius; 2], latitude)?, p(frame.origin), z, true)
|
||||
revolved(arc(&meridian, [radius; 2], [-FRAC_PI_2, FRAC_PI_2])?, p(frame.origin), z, true)
|
||||
}
|
||||
b::Surface::Torus { frame, major_radius, minor_radius, longitude, meridian } => {
|
||||
full_turn(&longitude)?;
|
||||
b::Surface::Torus { frame, major_radius, minor_radius } => {
|
||||
let z = axis(&frame);
|
||||
let profile = b::Frame { origin: point(p(frame.origin) + v(frame.x_axis) * major_radius), x_axis: frame.x_axis, y_axis: vector(z) };
|
||||
revolved(arc(&profile, [minor_radius; 2], meridian)?, p(frame.origin), z, true)
|
||||
revolved(arc(&profile, [minor_radius; 2], [0., TAU])?, p(frame.origin), z, true)
|
||||
}
|
||||
_ => return Err(invalid("expected analytic surface")),
|
||||
})
|
||||
|
||||
File renamed without changes.
@@ -113,6 +113,22 @@ pub(super) fn meshes_meet(a: &Mesh, b: &Mesh, gap: f64) -> Result<bool> {
|
||||
}
|
||||
|
||||
pub(super) fn groups(meshes: &[Mesh], volumes: &[f64], gap: f64) -> Result<Vec<Vec<usize>>> {
|
||||
let parent = parents(meshes, volumes, gap)?;
|
||||
let mut groups = Vec::new();
|
||||
for (i, v) in volumes.iter().enumerate() {
|
||||
if *v <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
let mut group = vec![i];
|
||||
group.extend(parent.iter().enumerate().filter_map(|(j, p)| (*p == Some(i)).then_some(j)));
|
||||
groups.push(group);
|
||||
}
|
||||
Ok(groups)
|
||||
}
|
||||
|
||||
/// The shell directly around each closed shell (`None` for one in the open): outward shells
|
||||
/// (positive volume) bound material, inward ones voids, and nesting alternates them.
|
||||
pub(super) fn parents(meshes: &[Mesh], volumes: &[f64], gap: f64) -> Result<Vec<Option<usize>>> {
|
||||
if meshes.is_empty() || meshes.len() != volumes.len() || meshes.len() > MAX_SHELLS {
|
||||
return Err(failed("shell count exceeds the grouping limit or is invalid"));
|
||||
}
|
||||
@@ -229,14 +245,5 @@ pub(super) fn groups(meshes: &[Mesh], volumes: &[f64], gap: f64) -> Result<Vec<V
|
||||
}
|
||||
parent.push(owner);
|
||||
}
|
||||
let mut groups = Vec::new();
|
||||
for (i, v) in volumes.iter().enumerate() {
|
||||
if *v <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
let mut group = vec![i];
|
||||
group.extend(parent.iter().enumerate().filter_map(|(j, p)| (*p == Some(i)).then_some(j)));
|
||||
groups.push(group);
|
||||
}
|
||||
Ok(groups)
|
||||
Ok(parent)
|
||||
}
|
||||
Reference in new issue
Block a user