Skip to content

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

Wave 143/509: kernel: CornerPatch exported with the G2 corner patch

jyvikobc9ab68c20b7
diff --git a/crates/kernel/Cargo.toml b/crates/kernel/Cargo.toml
index b41ac8f1b6..e1b4e691c6 100644
--- a/crates/kernel/Cargo.toml
+++ b/crates/kernel/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "solidcraft-kernel"
-description = "SolidCraft B-rep kernel boundary: solids, extrude/revolve/booleans/fillets, tessellation, measures and STEP, behind our own API (implemented with truck)"
+description = "SolidCraft B-rep kernel boundary: solids, extrude/revolve/booleans/fillets, meshes, measures and STEP, behind our own API (implemented with SMLib)"
version.workspace = true
edition.workspace = true
license.workspace = true
@@ -10,21 +10,18 @@ workspace = true
[features]
# Link NVIDIA's SMLib (tangency-labs/smlib) into the kernel; needs a C++ toolchain and
-# scripts/fetch-smlib.sh (ADR 0002).
-smlib = ["dep:solidcraft-smlib", "solidcraft-smlib/native"]
+# scripts/fetch-smlib.sh (ADR 0002). Without it every geometric operation answers that SMLib
+# was not built.
+smlib = ["solidcraft-smlib/native"]
[dependencies]
solidcraft-geom = { workspace = true }
-solidcraft-smlib = { workspace = true, optional = true }
+solidcraft-smlib = { workspace = true }
solidcraft-step = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
log = { workspace = true }
-truck-modeling = { workspace = true }
-truck-shapeops = { workspace = true }
-truck-stepio = { workspace = true }
-truck-topology = { workspace = true }
spade = { workspace = true }
web-time = { workspace = true }
diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rs
index 94c8cc30dc..a1b9b60f17 100644
--- a/crates/kernel/src/body.rs
+++ b/crates/kernel/src/body.rs
@@ -1,7 +1,6 @@
use serde::Serialize;
+use solidcraft_geom::brep::{self, Brep, Curve, Loop, Shell, Surface};
use solidcraft_geom::{Aabb3, Mesh, Vec3};
-use truck_meshalgo::prelude::*;
-use truck_modeling as mt;
use crate::history::BodyHistory;
use crate::{KernelError, Result, guard};
@@ -13,34 +12,26 @@ mod planar_sources;
#[path = "shell_groups.rs"]
pub(crate) mod shell_groups;
-pub(crate) type Solid = mt::Solid;
-
/// A solid body (one or more closed shells), or a mesh body (triangles only, like an imported
/// 3MF or STL: it renders, measures and exports, but B-rep features cannot use it). Cheap to
/// clone; never mutated in place.
+///
+/// A solid body is its schema 4 record ([`solidcraft_geom::brep`]): faces, edges and vertices
+/// in the record's canonical order are the body's own, everywhere (history, naming, meshes).
+/// SMLib works on the same body built from that record, made once and shared by clones.
#[derive(Clone, Debug)]
pub struct Body {
- pub(crate) solid: std::sync::Arc<Solid>,
- /// Bounding-box diagonal, measured by [`Body::new`] while it read the vertices anyway; 0
- /// means "not measured, walk the geometry". Every kernel tolerance is a fraction of it.
+ pub(crate) record: std::sync::Arc<Brep>,
+ /// The body in SMLib, built from `record` on first use (or kept from the operation that
+ /// made it), shared by clones because they share the record.
+ pub(crate) smlib: std::sync::Arc<std::sync::OnceLock<std::result::Result<solidcraft_smlib::Brep, String>>>,
+ /// Bounding-box diagonal of the vertices, measured when the body was made; 0 means "not
+ /// measured, walk the geometry". Every kernel tolerance is a fraction of it.
pub(crate) size: f64,
- /// How far this body's face boundaries may lie off their surfaces (mm) and still be taken as
- /// lying on them. `Some` for a body read from a file that declares its own numeric
- /// uncertainty (a STEP file's `GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT`, see
- /// `crate::step_in::Units::tol`); `None` for a body this kernel built, which has no such
- /// declaration.
- ///
- /// A band face's ring edges are held to it when the importer splits the band (see
- /// `crate::step_in::split`). The display planner takes it only where it is more than its own
- /// bound, a hundredth of the body (see `accept` in [`crate::tess::plan_face`]).
- pub(crate) boundary_tol: Option<f64>,
- /// The last volume measured for this solid and the tolerance it was measured at, shared by
- /// clones because they share the solid. A boolean measures its operands, and a later boolean
- /// takes the result as an operand again, so the same body is measured twice otherwise.
+ /// The last volume measured for this record and the tolerance it was measured at, shared by
+ /// clones because they share the record.
pub(crate) volume: Option<std::sync::Arc<std::sync::Mutex<Option<(u64, f64)>>>>,
- /// Missing-face check from the orientation mesh, reusable at exactly its tolerance.
- pub(crate) coarse_missing: Option<(f64, usize)>,
- /// Set for mesh bodies (`solid` is then empty).
+ /// Set for mesh bodies (`record` is then empty).
pub(crate) mesh: Option<std::sync::Arc<crate::meshbody::TriMesh>>,
/// Display colour (linear RGB 0..1) from an imported file; operations drop it.
pub(crate) color: Option<[f32; 3]>,
@@ -56,41 +47,22 @@ pub struct Body {
/// Exact history of the operation that made this body, relative to that operation's
/// operands; `None` when the operation does not report one.
pub(crate) history: Option<std::sync::Arc<crate::history::History>>,
- /// A placed copy of a solid that another body shows already (an instance of a part a STEP
+ /// A placed copy of a body that another body shows already (an instance of a part a STEP
/// assembly lists many times): its display mesh is that body's, placed by the matrix, so the
- /// part is tessellated once rather than once per instance. Dropped by anything that changes
- /// what the body shows (its geometry is never changed in place).
+ /// part is meshed once rather than once per instance. Dropped by anything that changes what
+ /// the body shows (its geometry is never changed in place).
pub(crate) display_of: Option<std::sync::Arc<(std::sync::Arc<SharedDisplay>, [[f64; 4]; 4])>>,
- /// Meshes of this solid kept for reuse, set by [`Body::keeping_meshes`]: a check that
+ /// Meshes of this record kept for reuse, set by [`Body::keeping_meshes`]: a check that
/// intersects one large body with many small ones meshes it at the same tolerance each time.
pub(crate) meshes: Option<std::sync::Arc<MeshMemo>>,
- /// Its revolved faces were turned away from their seams (see `rephase_revolved`), so a
- /// placed copy, which keeps them where they are, need not turn them again: searching every
- /// revolved face of every placed occurrence was most of the time moving an assembly took.
- pub(crate) phased: bool,
- /// The tolerances the record this solid was decoded from held for its edges and vertices
- /// (another kernel's approximations, which lie farther from their faces than this kernel's
- /// working tolerance), so that its own record of the solid holds them again. `None`: the
- /// working tolerance everywhere. Dropped by anything that makes a new solid.
- pub(crate) tolerances: Option<std::sync::Arc<Tolerances>>,
-}
-
-/// Per edge and per vertex, in [`Body::unique_edges`] and [`Body::unique_vertices`] order, the
-/// tolerance a decoded record gave it (see `Body::tolerances`).
-#[derive(Clone, Debug, Default, PartialEq)]
-pub(crate) struct Tolerances {
- pub(crate) edges: Vec<f64>,
- pub(crate) vertices: Vec<f64>,
}
-/// The meshes made of one solid (see [`Body::keeping_meshes`]), by tolerance, angle and
-/// refinement. They answer only for that solid: a copy whose solid was replaced makes its own.
+/// The meshes made of one record (see [`Body::keeping_meshes`]), by tolerance and angle. They
+/// answer only for that record: a copy whose record was replaced makes its own.
#[derive(Debug)]
pub(crate) struct MeshMemo {
- solid: std::sync::Arc<Solid>,
+ record: std::sync::Arc<Brep>,
made: Remembered,
- /// The meshes a boolean makes of the solid's shells, by tolerance.
- shells: std::sync::Mutex<Vec<(u64, std::sync::Arc<Vec<truck_shapeops::MeshedShell>>)>>,
}
/// Meshes a [`MeshMemo`] keeps at most (the oldest goes first).
@@ -161,11 +133,7 @@ fn placed_mesh(m: &Mesh, t: &[[f64; 4]; 4]) -> Option<Mesh> {
t[0][2] * v.x + t[1][2] * v.y + t[2][2] * v.z + w * t[3][2],
)
};
- let det = t[0][0] * (t[1][1] * t[2][2] - t[1][2] * t[2][1]) - t[0][1] * (t[1][0] * t[2][2] - t[1][2] * t[2][0])
- + t[0][2] * (t[1][0] * t[2][1] - t[1][1] * t[2][0]);
- if !(det > 0.0 && (det - 1.0).abs() < 1e-6) || t.iter().flatten().any(|x| !x.is_finite()) {
- return None;
- }
+ brep::placement::Rigid::of_matrix(t)?;
Some(Mesh {
positions: m.positions.iter().map(|p| r(*p, 1.0)).collect(),
normals: m.normals.iter().map(|n| r(*n, 0.0)).collect(),
@@ -174,6 +142,7 @@ fn placed_mesh(m: &Mesh, t: &[[f64; 4]; 4]) -> Option<Mesh> {
})
}
+
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum FaceSource {
ExtrudeSide {
@@ -347,123 +316,8 @@ impl MeshTolerance {
}
}
-/// Revolved surfaces are periodic in their angle; a face whose angles start at 0 is found at 0
-/// or 2π, which confuses the boolean's loop projection. Each revolved face's surface is turned
-/// (same geometry) so the face sits around angle π, well away from the wrap.
-fn rephase_revolved(solid: Solid) -> Solid {
- use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};
- #[cfg(test)]
- REPHASED.with(|n| n.set(n.get() + 1));
- let r = guard("rephase", || {
- let mut changed = false;
- let mut shells = Vec::new();
- for sh in solid.boundaries() {
- let mut faces = Vec::new();
- for f in sh.face_iter() {
- let mt::Surface::RevolutedCurve(proc_) = f.surface() else {
- faces.push(f.clone());
- continue;
- };
- // A face bounded by a seam it uses both ways goes all the way round (SMLib's
- // sphere, torus or cylinder side as one face): its wrap belongs on that seam,
- // and turning the surface would run it through the face or one of its holes.
- if uses_an_edge_twice(f) {
- faces.push(f.clone());
- continue;
- }
- let surf = f.surface();
- // The face's middle angle.
- let mut acc = Vec3::ZERO;
- let mut n = 0.0f64;
- for w in f.absolute_boundaries() {
- for e in w.edge_iter() {
- let c = e.oriented_curve();
- let (t0, t1) = c.range_tuple();
- for k in 0..4 {
- acc += from_p3(c.subs(t0 + (t1 - t0) * k as f64 / 4.0));
- n += 1.0;
- }
- }
- }
- let Some((_, v)) = surf.search_nearest_parameter(p3(acc / n.max(1.0)), None, 100) else {
- faces.push(f.clone());
- continue;
- };
- let phi = v.rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI;
- if phi.abs() < 0.3 {
- faces.push(f.clone());
- continue;
- }
- let new_proc = proc_.map_ref(|rc| {
- let (o, a) = (rc.origin(), rc.axis());
- let rot = mt::Matrix4::from_translation(mt::EuclideanSpace::to_vec(o))
- * mt::Matrix4::from_axis_angle(a, mt::Rad(phi))
- * mt::Matrix4::from_translation(-mt::EuclideanSpace::to_vec(o));
- mt::RevolutedCurve::by_revolution(mt::Transformed::transformed(rc.entity_curve(), rot), o, a)
- });
- match mt::Face::try_new(f.absolute_boundaries().clone(), mt::Surface::RevolutedCurve(new_proc)) {
- Ok(mut nf) => {
- if !f.orientation() {
- nf.invert();
- }
- faces.push(nf);
- changed = true;
- }
- Err(_) => faces.push(f.clone()),
- }
- }
- shells.push(mt::Shell::from(faces));
- }
- if !changed {
- return Ok(None);
- }
- Ok(Solid::try_new(shells).ok())
- });
- match r {
- Ok(Some(s)) => s,
- _ => solid,
- }
-}
-
-/// Whether a face's boundary uses one edge twice (a seam).
-fn uses_an_edge_twice(f: &mt::Face) -> bool {
- let mut seen = std::collections::HashSet::new();
- f.boundaries().iter().flat_map(|w| w.edge_iter()).any(|e| !seen.insert(e.id()))
-}
-
-pub(crate) fn p3(v: Vec3) -> mt::Point3 {
- mt::Point3::new(v.x, v.y, v.z)
-}
-pub(crate) fn v3(v: Vec3) -> mt::Vector3 {
- mt::Vector3::new(v.x, v.y, v.z)
-}
-pub(crate) fn from_p3(p: mt::Point3) -> Vec3 {
- Vec3::new(p.x, p.y, p.z)
-}
-
-/// The distinct edges of `faces` in order of first use, and the faces (by position) each one
-/// bounds: the one edge order of a body, used by [`Body::edges`], tessellations and
-/// [`crate::history`].
-pub(crate) fn edge_order<'a, P: 'a, C: 'a, S: 'a>(
- faces: impl IntoIterator<Item = &'a truck_topology::Face<P, C, S>>,
-) -> (Vec<truck_topology::Edge<P, C>>, Vec<Vec<usize>>) {
- let mut index = std::collections::HashMap::new();
- let (mut edges, mut bounds): (Vec<truck_topology::Edge<P, C>>, Vec<Vec<usize>>) = (Vec::new(), Vec::new());
- for (fi, f) in faces.into_iter().enumerate() {
- for e in f.edge_iter() {
- let i = *index.entry(e.id()).or_insert_with(|| {
- edges.push(e.clone());
- bounds.push(Vec::new());
- edges.len() - 1
- });
- if let Some(slot) = bounds.get_mut(i)
- && !slot.contains(&fi)
- {
- slot.push(fi);
- }
- }
- }
- (edges, bounds)
+pub(crate) fn v3(p: [f64; 3]) -> Vec3 {
+ Vec3::new(p[0], p[1], p[2])
}
pub(crate) fn polyline_mid(pts: &[Vec3]) -> (Vec3, f64) {
@@ -481,40 +335,17 @@ pub(crate) fn polyline_mid(pts: &[Vec3]) -> (Vec3, f64) {
(pts.first().copied().unwrap_or_default(), len)
}
-#[cfg(test)]
-thread_local! {
- /// Solids [`Body::new`] meshed on this thread to orient them (tests count the work an import does).
- pub(crate) static ORIENTED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
- /// Solids `rephase_revolved` searched on this thread.
- pub(crate) static REPHASED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
-}
-
-/// The volume one closed shell encloses, signed by the way its faces face (positive when they
-/// face out of it), from a mesh as coarse as the orientation mesh of a solid of its size.
-/// `None` when the planner cannot mesh it.
-pub(crate) fn shell_volume(shell: &mt::Shell) -> Option<f64> {
- let solid = Solid::new_unchecked(vec![shell.clone()]);
- let v = coarse_mesh(&solid, orientation_tolerance(span_of(&solid))).ok()?.measure().volume;
- v.is_finite().then_some(v)
-}
-
-/// `solid` meshed by the planner at chord tolerance `tol` alone, before it is a [`Body`] (whose
-/// [`Body::mesh`] this is).
-fn coarse_mesh(solid: &Solid, tol: f64) -> Result<Mesh> {
- guard("orientation mesh", || crate::tess::plan(solid, tol, None).map(|(plan, _)| plan.evaluate()))
-}
-
-/// Deflection the orientation mesh uses: coarse enough for a large solid, fine enough that a
-/// small one still tessellates. `unmeshed_faces` counts at the same value, so the count the
-/// orientation mesh produced is reused instead of meshing the body again.
-fn orientation_tolerance(span: f64) -> f64 {
+/// Deflection of the coarse mesh `unmeshed_faces` counts on: coarse enough for a large body,
+/// fine enough that a small one still meshes.
+fn coarse_tolerance(span: f64) -> f64 {
(span * 0.01).clamp(1e-3, 1.0)
}
-/// Bounding-box diagonal of a solid's vertices (1 when it has no finite extent).
-fn span_of(solid: &Solid) -> f64 {
- let bounds: Aabb3 = solid.vertex_iter().map(|v| from_p3(v.point())).collect();
- if bounds.is_empty() { 1.0 } else { bounds.diagonal() }
+/// Box diagonal of a record's vertices (0 when it has none or no finite extent).
+fn span_of(record: &Brep) -> f64 {
+ let bounds: Aabb3 = record.vertices.iter().map(|v| v3(v.point)).collect();
+ let d = if bounds.is_empty() { 0.0 } else { bounds.diagonal() };
+ if d.is_finite() && d > 0.0 { d } else { 0.0 }
}
/// Equal shared values: the same allocation (a clone of the body), else equal contents.
@@ -526,7 +357,87 @@ fn same_shared<T: PartialEq>(a: &Option<std::sync::Arc<T>>, b: &Option<std::sync
}
}
+/// `record`, checked to be a body's: valid structure (budgets, references, loops, regions,
+/// canonical order) and some bounded material.
+fn solid_record(record: Brep) -> Result<Brep> {
+ record.validate().map_err(|e| KernelError::Invalid(e.to_string()))?;
+ if record.faces.is_empty() || record.material_regions().is_empty() {
+ return Err(KernelError::Failed("empty result".into()));
+ }
+ Ok(record)
+}
+
+/// The record of no solid: only the infinite region.
+pub(crate) fn empty_record() -> Brep {
+ Brep {
+ version: brep::VERSION,
+ tolerance: 1e-6,
+ regions: vec![brep::Region { shells: Vec::new(), void: false }],
+ shells: Vec::new(),
+ faces: Vec::new(),
+ edges: Vec::new(),
+ vertices: Vec::new(),
+ }
+}
+
impl Body {
+ /// A body with `record` and nothing else set.
+ fn bare(record: Brep, smlib: Option<solidcraft_smlib::Brep>, mesh: Option<std::sync::Arc<crate::meshbody::TriMesh>>) -> Body {
+ let size = span_of(&record);
+ let cell = std::sync::OnceLock::new();
+ if let Some(handle) = smlib {
+ let _ = cell.set(Ok(handle));
+ }
+ Body {
+ record: std::sync::Arc::new(record),
+ smlib: std::sync::Arc::new(cell),
+ size,
+ volume: Some(std::sync::Arc::new(std::sync::Mutex::new(None))),
+ mesh,
+ color: None,
+ paint: None,
+ splits: None,
+ face_sources: None,
+ regularization_protected: false,
+ history: None,
+ display_of: None,
+ meshes: None,
+ }
+ }
+
+ /// The solid body of a schema 4 record: checked for structure (budgets, references, loops,
+ /// regions, canonical order) and for bounding material. Its faces face as the record says.
+ pub(crate) fn from_record(record: Brep) -> Result<Body> {
+ Ok(Body::bare(solid_record(record)?, None, None))
+ }
+
+ /// The body of an SMLib B-rep and its record (SMLib's export, in canonical order), keeping
+ /// the SMLib body so later operations need not build it again.
+ pub(crate) fn from_smlib_record(handle: solidcraft_smlib::Brep, record: Brep) -> Result<Body> {
+ Ok(Body::bare(solid_record(record)?, Some(handle), None))
+ }
+
+ /// A mesh body of `mesh`.
+ pub(crate) fn of_mesh(mesh: crate::meshbody::TriMesh) -> Body {
+ Body::bare(empty_record(), None, Some(std::sync::Arc::new(mesh)))
+ }
+
+ /// The body's record: faces, edges and vertices in the body's own order. Empty for a mesh body.
+ pub fn record(&self) -> &Brep {
+ &self.record
+ }
+
+ /// The body in SMLib, built from its record the first time it is asked for. The record is
+ /// SMLib's own form (`SmBrepData`), imported as given: a record SMLib refuses is an error that
+ /// names why, never repaired here.
+ pub fn smlib(&self) -> Result<&solidcraft_smlib::Brep> {
+ self.require_brep("an SMLib operation")?;
+ self.smlib
+ .get_or_init(|| solidcraft_smlib::Brep::from_record(&self.record, true).map_err(|e| e.to_string()))
+ .as_ref()
+ .map_err(|e| KernelError::Failed(format!("SMLib: {e}")))
+ }
+
/// The very same body (shared data), not just an equal-looking one. Its history (how an
/// operation made it) is not part of it: an operation that leaves a body as it is (a cut by
/// a tool clear of it) gives the same body, with that operation's history.
@@ -539,9 +450,9 @@ impl Body {
&& self.regularization_protected == other.regularization_protected
}
- /// The very same shape (shared solid or mesh), whatever its colour, paint or face splits.
+ /// The very same shape (shared record or mesh), whatever its colour, paint or face splits.
pub fn same_shape(&self, other: &Body) -> bool {
- std::sync::Arc::ptr_eq(&self.solid, &other.solid)
+ std::sync::Arc::ptr_eq(&self.record, &other.record)
&& match (&self.mesh, &other.mesh) {
(Some(a), Some(b)) => std::sync::Arc::ptr_eq(a, b),
(None, None) => true,
@@ -549,126 +460,19 @@ impl Body {
}
}
- pub(crate) fn new(solid: Solid) -> Result<Body> {
- if solid.boundaries().is_empty() {
- return Err(KernelError::Failed("empty result".into()));
- }
- let mut solid = rephase_revolved(solid);
- // Orient outward: a closed solid must have positive volume. Every face is meshed (a face
- // the planner cannot take is an error), so no missing face can flip the sign.
- let span = span_of(&solid);
- let tol = orientation_tolerance(span);
- #[cfg(test)]
- ORIENTED.with(|n| n.set(n.get() + 1));
- let mesh = coarse_mesh(&solid, tol)?;
- let v = mesh.measure().volume;
- let mut has = vec![false; solid.face_iter().count()];
- for f in &mesh.tri_face {
- if let Some(h) = has.get_mut(*f as usize) {
- *h = true;
- }
- }
- let missing = has.iter().filter(|h| !**h).count();
- if v < 0.0 {
- solid.not();
- }
- Ok(Body {
- solid: std::sync::Arc::new(solid),
- size: if span.is_finite() && span > 0.0 { span } else { 0.0 },
- boundary_tol: None,
- volume: Some(std::sync::Arc::new(std::sync::Mutex::new(None))),
- coarse_missing: Some((tol, missing)),
- mesh: None,
- color: None,
- paint: None,
- splits: None,
- face_sources: None,
- regularization_protected: false,
- history: None,
- display_of: None,
- meshes: None,
- phased: true,
- tolerances: None,
- })
- }
-
- /// Like [`Body::new`], for a solid whose faces already point out of its material as
- /// recorded (another kernel's B-rep, through its schema 4 record): revolved faces turned as
- /// `new` turns them, the orientation kept. `new` orients by the volume of truck's coarse
- /// mesh, which leaves out a face it cannot mesh (SMLib's sphere bounded by its seam alone)
- /// and then turns a correct body inside out.
- #[cfg_attr(not(feature = "smlib"), allow(dead_code))]
- pub(crate) fn oriented(solid: Solid) -> Result<Body> {
- Body::new_placed(solid, false, None, false)
- }
-
- /// Like [`Body::new`], for a solid made by placing an already-oriented body (see
- /// [`crate::ops::transform_matrix`]): a placement keeps the faces pointing the way they did
- /// unless it mirrors them, so its orientation is read from the matrix rather than meshed
- /// again. Only for closed solids; `coarse` is the input's cached missing-face count, which a
- /// rigid placement preserves exactly.
- /// `phased`: the solid was placed from a body whose revolved faces are turned already.
- pub(crate) fn new_placed(solid: Solid, flip: bool, coarse: Option<(f64, usize)>, phased: bool) -> Result<Body> {
- if solid.boundaries().is_empty() {
- return Err(KernelError::Failed("empty result".into()));
- }
- Body::placed_as_is(if phased { solid } else { rephase_revolved(solid) }, flip, coarse)
- }
-
- /// [`Body::new_placed`] for a solid whose revolved faces were already turned away from
- /// their seam (a placement of an oriented body keeps them where they were).
- fn placed_as_is(mut solid: Solid, flip: bool, coarse: Option<(f64, usize)>) -> Result<Body> {
- if solid.boundaries().is_empty() {
- return Err(KernelError::Failed("empty result".into()));
- }
- let span = span_of(&solid);
- if flip {
- solid.not();
- }
- Ok(Body {
- solid: std::sync::Arc::new(solid),
- size: if span.is_finite() && span > 0.0 { span } else { 0.0 },
- boundary_tol: None,
- volume: Some(std::sync::Arc::new(std::sync::Mutex::new(None))),
- coarse_missing: coarse,
- mesh: None,
- color: None,
- paint: None,
- splits: None,
- face_sources: None,
- regularization_protected: false,
- history: None,
- display_of: None,
- meshes: None,
- phased: true,
- tolerances: None,
- })
- }
-
- /// This oriented body's solid moved by `m` (an affine placement), as [`Body::new_placed`]
- /// makes it: the orientation comes from the matrix, so a part placed many times (assembly
- /// instances) is meshed to orient it only once. Topology only; appearance is the caller's.
- pub(crate) fn placed(&self, m: &mt::Matrix4) -> Result<Body> {
- use mt::SquareMatrix as _;
- if *m == mt::Matrix4::from_scale(1.0) {
- return Ok(self.clone());
- }
- let a = [[m.x.x, m.x.y, m.x.z, m.x.w], [m.y.x, m.y.y, m.y.z, m.y.w], [m.z.x, m.z.y, m.z.z, m.z.w], [m.w.x, m.w.y, m.w.z, m.w.w]];
- let det = m.determinant();
- if !det.is_finite() || det.abs() < 1e-12 {
- return Err(KernelError::Invalid("degenerate placement".into()));
- }
- let rigid = crate::ops::rigid_placement(&a);
- let mut placed = Body::placed_as_is(mt::builder::transformed(&*self.solid, *m), det < 0.0, rigid.then_some(self.coarse_missing).flatten())?;
- // A rigid placement moves every edge and vertex as it is, in the same order, and leaves
- // the boundaries exactly as far off their surfaces as they were, so the file's own figure
- // still describes them (see [`Body::boundary_tol`]); one that scales the part does not,
- // and the copy declares nothing. The same rule as the mesh count above.
- if rigid {
- placed.tolerances = self.tolerances.clone();
- placed = placed.with_boundary_tol(self.boundary_tol);
- }
- Ok(placed)
+ /// Whether face `index`'s normal in its body is its surface's natural normal (its first
+ /// oriented face's `forward`, the side the record walks it by).
+ pub(crate) fn face_forward(&self, index: usize) -> bool {
+ self.record
+ .shells
+ .iter()
+ .filter_map(|s| match s {
+ Shell::Faces { faces, .. } => Some(faces),
+ _ => None,
+ })
+ .flatten()
+ .find(|f| f.face as usize == index)
+ .is_none_or(|f| f.forward)
}
pub(crate) fn inherit_regularization_protection(mut self, input: &Body) -> Self {
@@ -745,24 +549,20 @@ impl Body {
}
}
- /// Exact current planar surface for an explicitly fixed snapshot, without source lineage.
+ /// Exact current planar surface for an explicitly fixed snapshot, without source lineage: the
+ /// face's plane as the face faces (out of the material in a closed shell).
pub fn planar_face(&self, index: usize) -> Option<solidcraft_geom::Plane> {
- if index >= 50_000 {
- return None;
- }
- guard("exact planar face", || {
- let plane = self.solid.face_iter().nth(index).and_then(|face| match face.oriented_surface() {
- mt::Surface::Plane(plane) => {
- let u = plane.u_axis();
- let v = plane.v_axis();
- solidcraft_geom::Plane::new(from_p3(plane.origin()), Vec3::new(u.x, u.y, u.z), Vec3::new(v.x, v.y, v.z))
- }
- _ => None,
- });
- Ok(plane)
- })
- .ok()
- .flatten()
+ let face = self.record.faces.get(index)?;
+ let (o, u, v) = match &face.surface {
+ Surface::Plane { origin, u_axis, v_axis } => (v3(*origin), v3(*u_axis), v3(*v_axis)),
+ Surface::PlaneThrough { origin, u_point, v_point } => {
+ let o = v3(*origin);
+ (o, v3(*u_point) - o, v3(*v_point) - o)
+ }
+ _ => return None,
+ };
+ let v = if self.face_forward(index) { v } else { -v };
+ solidcraft_geom::Plane::new(o, u, v)
}
/// Certify the two caps of a body built by [`crate::cylinder`]. Its wall stays uncertified.
@@ -930,11 +730,6 @@ impl Body {
self
}
- /// A deep copy of the solid that can be mutated without affecting other bodies.
- pub(crate) fn deep_copy(&self) -> Solid {
- mt::builder::clone(&*self.solid)
- }
-
/// Is this a mesh body (no B-rep)?
pub fn is_mesh(&self) -> bool {
self.mesh.is_some()
@@ -1000,7 +795,7 @@ impl Body {
/// Identity of the solid: clones of a body (and bodies a feature passed through unchanged)
/// share it.
pub fn solid_id(&self) -> usize {
- std::sync::Arc::as_ptr(&self.solid) as usize
+ std::sync::Arc::as_ptr(&self.record) as usize
}
pub fn with_split_lines(mut self, s: Option<std::sync::Arc<Vec<Vec<Vec3>>>>) -> Body {
@@ -1038,21 +833,20 @@ impl Body {
self
}
- /// Characteristic size (bounding box diagonal) for tolerances. [`Body::new`] measured it
- /// while it read the vertices anyway, and a mesh body when it was made, so the answer is
- /// cached; a body built by hand carries 0 and is walked here.
+ /// Characteristic size (bounding box diagonal of its vertices) for tolerances, measured
+ /// when the body was made; mesh bodies measure their triangles.
pub fn size(&self) -> f64 {
if self.size > 0.0 {
return self.size;
}
- let mut b = solidcraft_geom::Aabb3::EMPTY;
+ let mut b = Aabb3::EMPTY;
if let Some(m) = &self.mesh {
for p in &m.positions {
b.add(*p);
}
}
- for v in self.solid.vertex_iter() {
- b.add(from_p3(v.point()));
+ for v in &self.record.vertices {
+ b.add(v3(v.point));
}
let d = b.diagonal();
if d.is_finite() && d > 0.0 { d } else { 1.0 }
@@ -1062,51 +856,37 @@ impl Body {
/// points (a spline lies in the hull of its controls; a face's surface does not count, as an
/// imported face is often trimmed from a far larger one). A face curving out beyond all of
/// its edges (a dome on a circle) can reach past it, so it frames a view while the body is
- /// still being meshed; [`Mesh::bounds`] is the exact one.
- /// A mesh body's box is its triangles'.
- pub fn outline_bounds(&self) -> solidcraft_geom::Aabb3 {
- crate::guard("outline bounds", || Ok(self.outline_bounds_unguarded())).unwrap_or(solidcraft_geom::Aabb3::EMPTY)
- }
-
- fn outline_bounds_unguarded(&self) -> solidcraft_geom::Aabb3 {
- use mt::BoundedCurve;
- let mut b = solidcraft_geom::Aabb3::EMPTY;
+ /// still being meshed; [`Body::exact_bounds`] is the exact one. A mesh body's box is its
+ /// triangles'.
+ pub fn outline_bounds(&self) -> Aabb3 {
+ let mut b = Aabb3::EMPTY;
if let Some(m) = &self.mesh {
for p in &m.positions {
b.add(*p);
}
return b;
}
- let homogeneous = |b: &mut solidcraft_geom::Aabb3, v: mt::Vector4| {
- if v.w > 0.0 {
- b.add(Vec3::new(v.x / v.w, v.y / v.w, v.z / v.w));
- }
- };
- for v in self.solid.vertex_iter() {
- b.add(from_p3(v.point()));
+ for v in &self.record.vertices {
+ b.add(v3(v.point));
}
- for e in self.solid.edge_iter() {
- match e.curve() {
- mt::Curve::Line(l) => {
- b.add(from_p3(l.0));
- b.add(from_p3(l.1));
- }
- mt::Curve::BSplineCurve(c) => c.control_points().iter().for_each(|p| b.add(from_p3(*p))),
- mt::Curve::NurbsCurve(c) => c.control_points().iter().for_each(|p| homogeneous(&mut b, *p)),
- mt::Curve::IntersectionCurve(c) => {
- let (t0, t1) = c.range_tuple();
- for i in 0..=8 {
- b.add(from_p3(mt::ParametricCurve::subs(&e.curve(), t0 + (t1 - t0) * f64::from(i) / 8.0)));
- }
- }
- }
+ for e in &self.record.edges {
+ curve_hull(&e.curve, e.interval, &mut b);
}
b
}
- /// The body's volume from a mesh at `tol`, measured once per (solid, tolerance): clones of
- /// a body share the measurement, so an operand a later boolean takes again is not meshed
- /// twice for the same number. `None` when the body cannot be meshed.
+ /// The exact box of the body's faces, edges and vertices (SMLib's tight box); a mesh body's
+ /// is its triangles'.
+ pub fn exact_bounds(&self) -> Result<Aabb3> {
+ if self.is_mesh() {
+ return Ok(self.outline_bounds());
+ }
+ let (lo, hi) = self.smlib()?.bounds().map_err(|e| KernelError::Failed(format!("SMLib bounds: {e}")))?;
+ Ok(Aabb3 { min: v3(lo), max: v3(hi) })
+ }
+
+ /// The body's volume from a mesh at `tol`, measured once per (record, tolerance): clones of
+ /// a body share the measurement. `None` when the body cannot be meshed.
pub fn volume_at(&self, tol: f64) -> Option<f64> {
let key = if tol.is_finite() && tol > 0.0 { tol } else { 0.05 };
let key = key.to_bits();
@@ -1117,7 +897,7 @@ impl Body {
{
return Some(volume);
}
- let volume = self.mesh(&crate::MeshTolerance::chord(f64::from_bits(key))).ok()?.measure().volume;
+ let volume = self.mesh(&MeshTolerance::chord(f64::from_bits(key))).ok()?.measure().volume;
if let Some(cell) = &self.volume
&& let Ok(mut slot) = cell.lock()
{
@@ -1132,46 +912,14 @@ impl Body {
if let Some(m) = &self.mesh {
return m.positions.len() * 24 + m.triangles.len() * 12;
}
- // Counted on the borrowed boundaries: `Solid::edge_iter` and `vertex_iter` clone every
- // face's wires to walk them, which made this estimate (taken after every feature, over
- // every body) cost more than evaluating most features. Each edge use is one edge and
- // one vertex in those iterators, so the counts are the same.
- let (mut faces, mut uses) = (0usize, 0usize);
- for face in self.solid.face_iter() {
- faces += 1;
- uses += face.absolute_boundaries().iter().map(|w| w.len()).sum::<usize>();
- }
- faces * 2048 + uses * (512 + 96)
- }
-
- /// Distinct edges in a stable order (the order of `edges()` and `tessellate().edges`).
- pub(crate) fn unique_edges(solid: &Solid) -> Vec<mt::Edge> {
- let mut seen = std::collections::HashSet::new();
- solid.edge_iter().filter(|e| seen.insert(e.id())).collect()
- }
-
- /// The solid's vertices, each once, in the order [`Solid::vertex_iter`] first meets them.
- pub(crate) fn unique_vertices(solid: &Solid) -> Vec<mt::Vertex> {
- let mut seen = std::collections::HashSet::new();
- solid.vertex_iter().filter(|v| seen.insert(v.id())).collect()
- }
-
- /// The record tolerances this body keeps for its own solid (`Body::tolerances`), when they
- /// still number its edges and vertices.
- pub(crate) fn kept_tolerances(&self) -> Option<&Tolerances> {
- self.tolerances.as_deref().filter(|t| t.edges.len() == self.edge_count() && t.vertices.len() == Body::unique_vertices(&self.solid).len())
- }
-
- /// This body keeping `t` as its record tolerances (see `Body::tolerances`).
- pub(crate) fn with_tolerances(mut self, t: Option<Tolerances>) -> Self {
- self.tolerances = t.map(std::sync::Arc::new);
- self
+ let uses: usize = self.record.faces.iter().flat_map(|f| &f.loops).map(|l| if let Loop::Edges { edges } = l { edges.len() } else { 1 }).sum();
+ self.record.faces.len() * 2048 + uses * (512 + 96)
}
/// The body's triangles, `t` from its exact surfaces: SolidCraft's one mesher (the planner,
/// [`crate::tess`]), evaluated on the CPU, with its edges flagged for display (seams, tangent
/// joins, protected creases). Triangles carry their face index and the edges their polylines,
- /// in [`Body::edges`] order; neighbouring faces share every boundary node, so the mesh is
+ /// in the record's order; neighbouring faces share every boundary node, so the mesh is
/// watertight wherever the B-rep is. A mesh body gives its own triangles. A face the planner
/// cannot mesh is an error that names it and why.
pub fn mesh(&self, t: &MeshTolerance) -> Result<Mesh> {
@@ -1189,7 +937,7 @@ impl Body {
return Ok(placed);
}
}
- match self.meshes.as_ref().filter(|m| std::sync::Arc::ptr_eq(&m.solid, &self.solid)) {
+ match self.meshes.as_ref().filter(|m| std::sync::Arc::ptr_eq(&m.record, &self.record)) {
Some(memo) => Ok(Mesh::clone(&remembered(&memo.made, t, || self.mesh_of(&self.mesh_plan_untimed(t)?))?)),
None => self.mesh_of(&self.mesh_plan_untimed(t)?),
}
@@ -1204,10 +952,10 @@ impl Body {
fn mesh_plan_untimed(&self, t: &MeshTolerance) -> Result<solidcraft_geom::tess::TessPlan> {
if self.is_mesh() {
- return Err(KernelError::Invalid("a mesh body has no surfaces to tessellate".into()));
+ return Err(KernelError::Invalid("a mesh body has no surfaces to mesh".into()));
}
let (tol, turn) = t.rules(self.size());
- guard("tessellate", || crate::tess::plan(&self.solid, tol, turn).map(|(plan, _)| plan))
+ guard("mesh", || crate::tess::plan(&self.record, tol, turn).map(|(plan, _)| plan))
}
/// The mesh of `plan`, a plan [`Body::mesh_plan`] made of this body: what [`Body::mesh`]
@@ -1220,25 +968,7 @@ impl Body {
/// (or a clone of it) lives: for many operations on one large body at the same tolerance,
/// such as cutting it down to the region of each of many contacts.
pub fn keeping_meshes(&self) -> Body {
- let (made, shells) = (std::sync::Mutex::new(Vec::new()), std::sync::Mutex::new(Vec::new()));
- Body { meshes: Some(std::sync::Arc::new(MeshMemo { solid: self.solid.clone(), made, shells })), ..self.clone() }
- }
-
- /// The meshes of this body's shells a boolean at `tol` makes, when the body keeps its meshes
- /// ([`Body::keeping_meshes`]); `None` otherwise.
- pub(crate) fn boolean_meshes(&self, tol: f64) -> Option<std::sync::Arc<Vec<truck_shapeops::MeshedShell>>> {
- let memo = self.meshes.as_ref().filter(|m| std::sync::Arc::ptr_eq(&m.solid, &self.solid))?;
- // Held while meshing, as in `tessellate_within`.
- let mut shells = memo.shells.lock().ok()?;
- if let Some((_, m)) = shells.iter().find(|(k, _)| *k == tol.to_bits()) {
- return Some(m.clone());
- }
- let made = std::sync::Arc::new(guard("boolean meshes", || Ok(truck_shapeops::meshes(&*self.solid, tol))).ok()?);
- if shells.len() >= MEMO_MESHES {
- shells.remove(0);
- }
- shells.push((tol.to_bits(), made.clone()));
- Some(made)
+ Body { meshes: Some(std::sync::Arc::new(MeshMemo { record: self.record.clone(), made: std::sync::Mutex::new(Vec::new()) })), ..self.clone() }
}
/// Planar faces whose boundary crosses itself: two of its loops crossing each other, or a
@@ -1253,7 +983,6 @@ impl Body {
/// The faces [`Body::crossed_face_loops`] counts, each as the mean of its boundary's
/// points: the same for a face an operation carried over unchanged.
pub fn crossed_faces(&self) -> Result<Vec<Vec3>> {
- use mt::{BoundedCurve, ParameterDivision1D};
if self.is_mesh() {
return Ok(Vec::new());
}
@@ -1262,32 +991,22 @@ impl Body {
let tol = (size * 1e-6).max(1e-9);
let chord = (size * 1e-3).max(1e-4);
let mut crossed = Vec::new();
- for f in self.solid.face_iter() {
- let mt::Surface::Plane(pl) = f.oriented_surface() else { continue };
- let o = from_p3(pl.origin());
- let (Some(u), Some(n)) = (
- Vec3::new(pl.u_axis().x, pl.u_axis().y, pl.u_axis().z).normalized(),
- Vec3::new(pl.normal().x, pl.normal().y, pl.normal().z).normalized(),
- ) else {
- continue;
- };
- let v = n.cross(u);
- let flat = |p: mt::Point3| {
- let d = from_p3(p) - o;
+ for (fi, f) in self.record.faces.iter().enumerate() {
+ let Some(plane) = self.planar_face(fi) else { continue };
+ let (o, u, v) = (plane.origin, plane.x, plane.y);
+ let flat = |p: Vec3| {
+ let d = p - o;
(d.dot(u), d.dot(v))
};
// Each loop's segments, in the face's plane.
let mut loops: Vec<Vec<((f64, f64), (f64, f64))>> = Vec::new();
let mut total = 0usize;
- for w in f.boundaries() {
+ for l in &f.loops {
+ let Loop::Edges { edges } = l else { continue };
let mut segs = Vec::new();
- for e in w.edge_iter() {
- let pts = guard("face loops", || {
- Ok(match e.curve() {
- mt::Curve::Line(_) => vec![e.front().point(), e.back().point()],
- c => c.parameter_division(c.range_tuple(), chord).1,
- })
- })?;
+ for u in edges {
+ let e = self.record.edges.get(u.edge as usize).ok_or_else(|| KernelError::Invalid("edge reference".into()))?;
+ let pts = edge_points(e, chord)?;
segs.extend(pts.windows(2).filter_map(|q| Some((flat(*q.first()?), flat(*q.get(1)?)))));
}
total = total.saturating_add(segs.len());
@@ -1310,53 +1029,23 @@ impl Body {
let (d3, d4) = (side(t.0, t.1, s.0), side(t.0, t.1, s.1));
((d1 > tol && d2 < -tol) || (d1 < -tol && d2 > tol)) && ((d3 > tol && d4 < -tol) || (d3 < -tol && d4 > tol))
};
- let all: Vec<(usize, &((f64, f64), (f64, f64)))> =
- loops.iter().enumerate().flat_map(|(l, segs)| segs.iter().map(move |s| (l, s))).collect();
- let bad = all.iter().enumerate().any(|(i, (_, s))| all.iter().skip(i + 1).any(|(_, t)| cross(s, t)));
+ let all: Vec<&((f64, f64), (f64, f64))> = loops.iter().flatten().collect();
+ let bad = all.iter().enumerate().any(|(i, s)| all.iter().skip(i + 1).any(|t| cross(s, t)));
if bad {
- let ends: Vec<(f64, f64)> = all.iter().map(|(_, s)| s.0).collect();
- let k = ends.len().max(1) as f64;
- let (su, sv) = ends.iter().fold((0.0, 0.0), |acc, p| (acc.0 + p.0, acc.1 + p.1));
+ let k = all.len().max(1) as f64;
+ let (su, sv) = all.iter().fold((0.0, 0.0), |acc, s| (acc.0 + s.0.0, acc.1 + s.0.1));
crossed.push(o + u * (su / k) + v * (sv / k));
}
}
Ok(crossed)
}
- /// Faces with no triangles of their own, and so not shown: none in a coarse tessellation,
- /// and none in the display plan either (the plan is what the viewport draws, and it meshes
- /// faces the reference mesher gives up on). Only faces the coarse tessellation misses are
- /// looked for in the plan, so a sound body costs no planning.
+ /// Faces with no triangles in a coarse mesh (the mesher failed or gave up).
pub fn unmeshed_faces(&self) -> usize {
if self.is_mesh() {
return 0;
}
- let tol = orientation_tolerance(self.size());
- // The count [`Body::new`] already took at this tolerance, else the same count made now.
- let missing = match self.coarse_missing {
- Some((cached_tol, missing)) if cached_tol == tol => missing,
- _ => {
- let Ok(m) = self.tessellate(tol) else { return self.face_count() };
- let mut has = vec![false; self.face_count()];
- for f in &m.tri_face {
- if let Some(h) = has.get_mut(*f as usize) {
- *h = true;
- }
- }
- has.iter().filter(|h| !**h).count()
- }
- };
- // A body the coarse mesh covers whole is shown whole: no plan is made for it, whether the
- // count came from the cache or from the mesh above.
- if missing == 0 {
- return 0;
- }
- self.unmeshed_in_plan(tol).unwrap_or(missing)
- }
-
- /// Faces the display plan leaves without triangles; `None` when the body has no plan.
- fn unmeshed_in_plan(&self, tol: f64) -> Option<usize> {
- let plan = self.display_plan(tol).ok()?;
+ let Ok(m) = self.mesh(&MeshTolerance::chord(coarse_tolerance(self.size()))) else { return self.face_count() };
let mut has = vec![false; self.face_count()];
for f in &plan.faces {
if !f.triangles.is_empty()
@@ -1368,7 +1057,7 @@ impl Body {
Some(has.iter().filter(|h| !**h).count())
}
- /// A tessellation with its edges flagged for display (seams, tangent joins, protected creases).
+ /// A mesh with its edges flagged for display (seams, tangent joins, protected creases).
fn flagged(&self, mut m: Mesh) -> Result<Mesh> {
if self.is_mesh() {
return Ok(m);
@@ -1378,9 +1067,9 @@ impl Body {
Ok(m)
}
- /// Edges with polylines (index = position in [`Body::tessellate`]'s `edges`).
+ /// Edges with polylines (index = the record's edge index).
pub fn edges(&self, tol: f64) -> Result<Vec<EdgeInfo>> {
- let m = self.mesh(&crate::MeshTolerance::chord(tol))?;
+ let m = self.mesh(&MeshTolerance::chord(tol))?;
Ok(m.edges
.into_iter()
.enumerate()
@@ -1391,32 +1080,27 @@ impl Body {
.collect())
}
- /// Edges `indices` (as in [`Body::tessellate`]'s `edges`) in `plane`'s coordinates,
- /// exactly: lines, circular arcs, and free-form curves as the Bézier spans they are, for a
- /// sketch to project them. `None` for an edge that doesn't lie in a plane parallel to
- /// `plane`, isn't read exactly or isn't there, and for every edge of a mesh body.
+ /// Edges `indices` (record edge indices) in `plane`'s coordinates, exactly: lines, circular
+ /// arcs, and free-form curves as the Bézier spans they are, for a sketch to project them.
+ /// `None` for an edge that doesn't lie in a plane parallel to `plane`, isn't read exactly or
+ /// isn't there, and for every edge of a mesh body.
pub fn planar_edges(&self, plane: &solidcraft_geom::Plane, indices: &[usize]) -> Vec<Option<Vec<solidcraft_geom::Seg2>>> {
- let none = || vec![None; indices.len()];
if self.is_mesh() {
- return none();
+ return vec![None; indices.len()];
}
let tol = (self.size() * 1e-7).max(1e-9) * 10.0;
- guard("planar edges", || {
- let edges = Self::unique_edges(&self.solid);
- Ok(indices
- .iter()
- .map(|i| {
- let mut work = 262_144usize;
- edges.get(*i).and_then(|e| crate::prism_curve::projected(e, plane, tol, &mut work))
- })
- .collect())
- })
- .unwrap_or_else(|_| none())
+ indices
+ .iter()
+ .map(|i| {
+ let mut work = 262_144usize;
+ crate::prism_curve::Run::of(&self.record, *i, true).and_then(|run| crate::prism_curve::projected(&run, plane, tol, &mut work))
+ })
+ .collect()
}
/// Faces with area and centroid.
pub fn faces(&self, tol: f64) -> Result<Vec<FaceInfo>> {
- let m = self.mesh(&crate::MeshTolerance::chord(tol))?;
+ let m = self.mesh(&MeshTolerance::chord(tol))?;
let nf = self.face_count();
let mut acc: Vec<(f64, Vec3, Vec3, bool)> = vec![(0.0, Vec3::ZERO, Vec3::ZERO, true); nf];
for (t, f) in m.triangles.iter().zip(&m.tri_face) {
@@ -1466,42 +1150,34 @@ impl Body {
/// Is the point inside the solid?
pub fn contains(&self, p: Vec3) -> bool {
- self.mesh(&crate::MeshTolerance::chord(self.size() * 2e-3)).map(|m| m.contains(p)).unwrap_or(false)
+ self.mesh(&MeshTolerance::chord(self.size() * 2e-3)).map(|m| m.contains(p)).unwrap_or(false)
}
/// B-rep faces (a mesh body is one face; [`crate::measure`] counts its triangles).
pub fn face_count(&self) -> usize {
- match &self.mesh {
- Some(_) => 1,
- None => self.solid.face_iter().count(),
- }
+ if self.mesh.is_some() { 1 } else { self.record.faces.len() }
}
/// B-rep edges (none for a mesh body).
pub fn edge_count(&self) -> usize {
- match &self.mesh {
- Some(_) => 0,
- None => Self::unique_edges(&self.solid).len(),
- }
+ self.record.edges.len()
}
/// B-rep vertices (none for a mesh body).
pub fn vertex_count(&self) -> usize {
- if self.mesh.is_some() {
- return 0;
- }
- let mut seen = std::collections::HashSet::new();
- self.solid.vertex_iter().filter(|v| seen.insert(v.id())).count()
+ self.record.vertices.len()
}
- /// What is wrong with the body as a solid: shells that aren't closed and consistently
- /// oriented, faces that don't mesh, a volume that isn't positive. Empty when it is sound.
+
+ /// What is wrong with the body as a solid: face shells that aren't closed, faces that don't
+ /// mesh, a volume that isn't positive. Empty when it is sound.
pub fn validity(&self) -> Vec<String> {
if let Some(m) = &self.mesh {
return if crate::meshbody::is_closed(m) { Vec::new() } else { vec!["the mesh is not closed".into()] };
}
let mut out = Vec::new();
- for (i, sh) in self.solid.boundaries().iter().enumerate() {
- let c = sh.shell_condition();
- if c != truck_topology::shell::ShellCondition::Closed {
- out.push(format!("shell {i} is {c:?}, not closed"));
+ for (i, shell) in self.record.shells.iter().enumerate() {
+ if let Shell::Faces { .. } = shell
+ && !self.record.regions.iter().skip(1).any(|r| r.shells.first() == Some(&(i as u32)))
+ {
+ out.push(format!("shell {i} is open, not closed"));
}
}
let missing = self.unmeshed_faces();
@@ -1516,26 +1192,33 @@ impl Body {
out
}
+ /// Face shells (a mesh body is one).
pub fn shell_count(&self) -> usize {
- match &self.mesh {
- Some(_) => 1,
- None => self.solid.boundaries().len(),
- }
+ if self.mesh.is_some() { 1 } else { self.record.shells.iter().filter(|s| matches!(s, Shell::Faces { .. })).count() }
}
-}
-impl Body {
- /// The separate pieces of a body: each outer shell with the voids inside it. A body in one
- /// piece comes back as itself. Pieces of a body in several carry their history over
- /// `[self]` (their faces and edges are its own), so whoever names them can follow it.
+ /// The separate pieces of a body: each material region with the voids inside it, read from
+ /// the record's regions. A body in one piece comes back as itself. Pieces of a body in
+ /// several carry their history over `[self]` (their faces and edges are its own), so
+ /// whoever names them can follow it.
pub fn lumps(&self) -> Result<Vec<Body>> {
- let pieces = self.lumps_with_clearance(0.0)?;
- if pieces.len() < 2 {
- return Ok(pieces);
+ let regions = self.record.material_regions();
+ if self.is_mesh() || regions.len() < 2 {
+ return Ok(vec![self.clone()]);
}
let counts = [(self.face_count(), self.edge_count())];
- let histories = crate::boolean_record::parts_of(&pieces, self);
- Ok(pieces.into_iter().zip(histories).map(|(piece, history)| piece.with_checked_history(history, &counts)).collect())
+ regions
+ .into_iter()
+ .map(|r| {
+ let part = self.record.part(&[r]).map_err(|e| KernelError::Failed(format!("lump: {e}")))?;
+ let sources = self.face_sources.as_ref().map(|all| {
+ std::sync::Arc::new(part.faces.iter().map(|&f| all.get(f as usize).cloned().flatten()).collect::<Vec<_>>())
+ });
+ let history = crate::history::History::of_part(&part);
+ let piece = Body::from_record(part.brep)?.with_face_sources(sources).inherit_regularization_protection(self);
+ Ok(piece.with_checked_history(Some(history), &counts))
+ })
+ .collect()
}
/// Whether this body and `other` share material or touch (within a fine mesh tolerance).
@@ -1543,7 +1226,7 @@ impl Body {
self.require_brep("contact test")?;
other.require_brep("contact test")?;
let tol = (self.size().max(other.size()) * 1e-4).max(1e-6);
- let (a, b) = (self.mesh(&crate::MeshTolerance::chord(tol))?, other.mesh(&crate::MeshTolerance::chord(tol))?);
+ let (a, b) = (self.mesh(&MeshTolerance::chord(tol))?, other.mesh(&MeshTolerance::chord(tol))?);
shell_groups::meshes_meet(&a, &b, 2.0 * tol)
}
@@ -1566,152 +1249,86 @@ impl Body {
if meshes.len() == 16 {
meshes.clear();
}
- meshes.insert(key, self.mesh(&crate::MeshTolerance::chord(tol))?);
+ meshes.insert(key, self.mesh(&MeshTolerance::chord(tol))?);
}
let mesh = meshes.get(&key).ok_or_else(|| KernelError::Internal("contact mesh disappeared".into()))?;
- contacts.push(shell_groups::meshes_meet(mesh, &other.mesh(&crate::MeshTolerance::chord(tol))?, 2.0 * tol)?);
+ contacts.push(shell_groups::meshes_meet(mesh, &other.mesh(&MeshTolerance::chord(tol))?, 2.0 * tol)?);
}
Ok(contacts)
}
- /// A boolean shortcut needs clearance larger than both shell mesh deflections.
- pub(crate) fn separated_lumps(&self) -> Result<Vec<Body>> {
- self.lumps_with_clearance(4.0 * (self.size() * 1e-3).max(1e-3))
- }
-
- /// A union's pieces must be clear of each other by the contact distance of [`Body::meets`];
- /// closer shells are touching material that was never fused (#396).
- pub(crate) fn union_lumps(&self) -> Result<Vec<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;
+ /// For each shell: whether it bounds material (else a void or an open/wire shell), and the
+ /// shell directly around it (the outer shell of the region it lies in; `None` in the open).
+ pub(crate) fn shell_nesting(&self) -> (Vec<bool>, Vec<Option<usize>>) {
+ let n = self.record.shells.len();
+ let (mut material, mut parent) = (vec![false; n], vec![None; n]);
+ for (r, region) in self.record.regions.iter().enumerate() {
+ let around = if r == 0 { None } else { region.shells.first().map(|&s| s as usize) };
+ for (k, &s) in region.shells.iter().enumerate() {
+ let s = s as usize;
+ if r > 0 && k == 0 {
+ if let Some(m) = material.get_mut(s) {
+ *m = !region.void;
}
- m.triangles.push(indices);
- m.tri_face.push(0);
+ } else if let Some(p) = parent.get_mut(s) {
+ *p = around;
}
- 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)
+ }
+ }
+ (material, parent)
}
+}
- /// 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))
- })
+/// Points of an edge's curve over its interval, within `chord` of it: lines by their ends, the
+/// rest at the evaluator's points (capped).
+fn edge_points(e: &brep::Edge, chord: f64) -> Result<Vec<Vec3>> {
+ const MAX_POINTS: usize = 4096;
+ let curve = brep::eval::CurveEval::new(&e.curve).map_err(|err| KernelError::Invalid(err.to_string()))?;
+ let [t0, t1] = e.interval;
+ let at = |t: f64| curve.point(t).ok_or_else(|| KernelError::Invalid(format!("edge curve has no point at {t}")));
+ if let Curve::Line { .. } = e.curve {
+ return Ok(vec![at(t0)?, at(t1)?]);
+ }
+ // Halve until every chord's midpoint is within `chord` of the curve.
+ let mut ts = vec![t0, t1];
+ let mut k = 0;
+ while k + 1 < ts.len() && ts.len() < MAX_POINTS {
+ let (a, b) = (ts[k], ts[k + 1]);
+ let m = 0.5 * (a + b);
+ let (pa, pb, pm) = (at(a)?, at(b)?, at(m)?);
+ if pm.dist(pa.lerp(pb, 0.5)) > chord {
+ ts.insert(k + 1, m);
+ } else {
+ k += 1;
+ }
}
+ ts.into_iter().map(at).collect()
+}
- 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()]);
- }
- let tol = (self.size() * 1e-3).max(1e-3);
- guard("lumps", || {
- let shells: Vec<mt::Shell> = self.solid.boundaries().clone();
- 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 {
- return Ok(vec![self.clone()]);
- }
- // Grouping keeps existing shells; certificates belong to their
- // exact face identities, not the new lump's positional face index.
- // This is not propagation through a geometry-changing operation.
- let sources_by_face = if let Some(sources) = &self.face_sources {
- if sources.len() != self.solid.face_iter().count() {
- return Err(KernelError::Invalid("lumps: face source table does not match the body".into()));
- }
- let mut by_id = std::collections::HashMap::new();
- for (face, source) in self.solid.face_iter().zip(sources.iter()) {
- if by_id.insert(face.id(), Some((face.orientation(), source))).is_some() {
- // A repeated identity has no unique source association.
- by_id.insert(face.id(), None);
+/// Grow `b` by a curve's hull over `interval`: its control points for splines, its points for
+/// lines, circles and ellipses (their exact extreme points), the leader's hull for an
+/// intersection curve.
+fn curve_hull(c: &Curve, interval: [f64; 2], b: &mut Aabb3) {
+ match c {
+ Curve::Line { .. } | Curve::Circle { .. } | Curve::Ellipse { .. } => {
+ if let Ok(e) = brep::eval::CurveEval::new(c) {
+ let [t0, t1] = interval;
+ for i in 0..=16 {
+ if let Some(p) = e.point(t0 + (t1 - t0) * f64::from(i) / 16.0) {
+ b.add(p);
}
}
- Some(by_id)
- } else {
- None
- };
- groups
- .into_iter()
- .map(|g| {
- let shells = g
- .into_iter()
- .map(|i| shells.get(i).cloned().ok_or_else(|| KernelError::Failed("lumps: missing shell".into())))
- .collect::<Result<Vec<_>>>()?;
- let result = Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("lump: {e}"))).and_then(Body::new)?;
- let sources = sources_by_face.as_ref().map(|old| {
- result
- .solid
- .face_iter()
- .map(|face| match old.get(&face.id()) {
- Some(Some((orientation, source))) if *orientation == face.orientation() => (*source).clone(),
- _ => None,
- })
- .collect()
- });
- Ok(result.with_face_sources(sources.map(std::sync::Arc::new)).inherit_regularization_protection(self))
- })
- .collect()
- })
+ }
+ }
+ Curve::Polyline { points } | Curve::Spline { points, .. } => points.iter().for_each(|p| b.add(v3(*p))),
+ Curve::RationalSpline { homogeneous, .. } => {
+ for h in homogeneous {
+ if h[3] > 0.0 {
+ b.add(Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3]));
+ }
+ }
+ }
+ Curve::SurfaceIntersection { leader, .. } => curve_hull(leader, interval, b),
}
}
@@ -1723,10 +1340,6 @@ mod lump_tests;
#[path = "mesh_memo_tests.rs"]
mod mesh_memo_tests;
-#[cfg(test)]
-#[path = "refine_cache_tests.rs"]
-mod refine_cache_tests;
-
#[cfg(test)]
#[path = "display_mesh_tests.rs"]
mod display_mesh_tests;
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index 825982cbb8..7a8fdcc019 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -176,7 +176,7 @@ pub use coaxial_overlap::{CoaxialOverlap, coaxial_candidate, coaxial_overlap};
pub use continuity::{
ContinuityReport, ContinuityTolerances, EdgePick, MAX_SAMPLES, MIN_SAMPLES, SeamReport, SeamVerdict, SeamWorst, pick_edges, seam_diagnostics,
};
-pub use corner_g2::{corner_g2_patch, seam_error};
+pub use corner_g2::{CornerPatch, corner_g2_patch, seam_error};
pub use delete_face::delete_faces;
pub use distance::{BodyDistance, DistanceShape, body_distance};
pub use emboss::{cylinder_emboss_anchor, emboss_cylinder, emboss_cylinder_at, has_cylinder_emboss_wall, infer_cylinder_emboss};
diff --git a/crates/kernel/src/refine_cache_tests.rs b/crates/kernel/src/refine_cache_tests.rs
deleted file mode 100644
index d6702df115..0000000000
--- a/crates/kernel/src/refine_cache_tests.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use super::*;
-
-fn bits(v: Vec3) -> [u64; 3] {
- [v.x.to_bits(), v.y.to_bits(), v.z.to_bits()]
-}
-
-fn check_body(body: &Body) -> usize {
- let meshes = mesh_shells(&body.solid, 0.5);
- let mut changed = 0;
- for (face, meshed) in body.solid.face_iter().zip(meshes.iter().flat_map(|shell| shell.face_iter())) {
- let Some(mesh) = meshed.surface() else { continue };
- let surface = face.surface();
- let cached = refined_with_cache(&mesh, &surface, 0.002, true);
- let original = refined_with_cache(&mesh, &surface, 0.002, false);
- match (cached, original) {
- (None, None) => {}
- (Some(cached), Some(original)) => {
- changed += 1;
- assert_eq!(cached.len(), original.len(), "triangle count/winding must not change");
- for (cached, original) in cached.into_iter().zip(original) {
- for ((point, normal), (old_point, old_normal)) in cached.into_iter().zip(original) {
- assert_eq!(bits(point), bits(old_point), "every refined coordinate must remain bit-identical");
- assert_eq!(bits(normal), bits(old_normal), "every refined normal must remain bit-identical");
- }
- }
- }
- _ => panic!("memoization changed the refine/no-refine decision"),
- }
- }
- changed
-}
-
-#[test]
-fn exact_refinement_cache_preserves_periodic_seams_and_normals() {
- let cylinder = crate::cylinder(Vec3::ZERO, Vec3::Z, 15., 8.).unwrap();
- let torus = crate::torus(Vec3::ZERO, 18., 4.).unwrap();
- assert!(check_body(&cylinder) > 0, "the fixture must actually refine");
- assert!(check_body(&torus) > 0, "the periodic fixture must actually refine");
-}
-
-#[test]
-fn exact_refinement_cache_preserves_singular_poles_and_placed_surfaces() {
- let sphere = crate::sphere(Vec3::ZERO, 12.).unwrap();
- assert!(check_body(&sphere) > 0, "the polar fixture must actually refine");
- let placed = crate::transform(&sphere, Vec3::new(120., -85., 40.), Vec3::ZERO, Vec3::new(1., 2., 3.), 0.371).unwrap();
- assert!(check_body(&placed) > 0);
-}
-
-#[test]
-fn exact_refinement_cache_keeps_unnecessary_planar_refinement_absent() {
- let body = crate::box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.)).unwrap();
- assert_eq!(check_body(&body), 0);
-}