Files
makeCAD/crates/kernel/src/measure.rs
T
jyviko dc38349cbf Layer split stage 1: the B-rep record, native body file and Vec/Plane come from solidcore-record (#11496)
* Kernel: the B-rep record and the native body file come from solidcore-record

SolidCraft's portable B-rep record (`solidcraft_geom::brep`: brep.rs, topology, history,
envelope, part, curve2) and the native body file (`solidcraft_kernel::native`: the tagged binary
codec and the container) move to solidcore's `solidcore-record` crate: geometry as data, with
structural validation and no maths (solidcore's docs/layers.md, stage 1). Every caller uses
`solidcore_record::brep` and `solidcore_record::native`; the old copies are deleted.

What computes from coordinates stays with the kernel, in geom's `brep`:
- `brep::check`: the record's geometric checks (orthonormal frames, non-degenerate planes,
  unit revolution axes, non-singular placements). `check::validate` and
  `check::validate_built` are the record's validation and these together, and every caller of
  `Brep::validate` uses them, so what is accepted is unchanged;
- `brep::label`: a surface's natural ranges (a cone's apex), `curve_interval`,
  `edge_curve_interval` and `form_turns`;
- `brep::pcurve::eval`: a pcurve's point;
- `geometry::check`, `placement::moved` and `split_edges` become functions on the record.

The kernel's native module keeps the conversion between a body and its saved record
(metadata.rs) and checks the decoded record's geometry. `native/analytic.rs`, which no module
declared, is deleted.

solidcore-record is pinned to its rev on solidcore's `layer-record` branch.

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

* Geometry: Vec2, Vec3, Plane and the profile types come from solidcore-record

The plain data of vectors and points, sketch planes and planar profiles (`Seg2`, `Loop2`,
`Region2`) moves to `solidcore-record`, with its constants and component-wise operators only
(owner decision, solidcore layer split). Their geometry stays in geom as traits:
`Vec2Geom`, `Vec3Geom`, `PlaneGeom`, `Seg2Geom`, `Loop2Geom`, `Region2Geom`, `Seg2ArcFit`,
`Loop2ArcFit` and `Region2ArcFit`, in scope with `use solidcraft_geom::prelude::*`. Every caller
names the types from `solidcore_record`; geom no longer defines or re-exports them.

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

* Kernel: pin solidcore-record to solidcore main f5e8e9a29

solidcore-record is merged on solidcore main (tangency-labs/solidcore#2519); its crate there is
identical to the rev pinned before but for its clippy configuration. The lock is regenerated
against the merged rev.

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

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:04:26 -05:00

199 lines
8.6 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use serde::Serialize;
use solidcore_record::Vec3;
use solidcraft_geom::Aabb3;
use crate::Result;
use crate::body::Body;
use crate::topo::{TopoCounts, merged_topology};
/// Measured properties of a body.
#[derive(Clone, Debug, Serialize)]
pub struct BodyMeasure {
pub volume: f64,
pub area: f64,
pub centroid: Vec3,
pub bbox: Aabb3,
/// Raw kernel topology counts (closed curves and surfaces may be split in pieces).
pub faces: usize,
pub edges: usize,
pub vertices: usize,
pub shells: usize,
/// Counts after merging split pieces of the same analytic surface/curve (comparable with
/// systems that use periodic faces and edges).
pub merged: TopoCounts,
/// What volume, area and centre come from: `smlib` (exact, integrated on the surfaces) or
/// `mesh` (a mesh body's own triangles).
pub measured_by: &'static str,
/// Anything the measurement says about itself.
#[serde(skip_serializing_if = "Vec::is_empty")]
pub notes: Vec<String>,
}
/// Volume, area, centre and box of a body, as [`measure`] works them out, without the topology
/// counts.
#[derive(Clone, Debug, Serialize)]
pub struct MassMeasure {
pub volume: f64,
pub area: f64,
pub centroid: Vec3,
pub bbox: Aabb3,
/// As [`BodyMeasure::measured_by`].
pub measured_by: &'static str,
/// As [`BodyMeasure::notes`].
#[serde(skip_serializing_if = "Vec::is_empty")]
pub notes: Vec<String>,
}
/// The relative accuracy SMLib integrates at: the finest the C API takes
/// ([`solidcraft_smlib::MEASURE_ACCURACY`], 1e-8). `smlib_brep_mass_properties` calls the
/// kernel's integration directly because SmApiBrepComputeMassProperties clamps to [1e-4, 1e-1],
/// which leaves curved faces off by 1e-5 to 1e-3; asking 1e-4 here threw that away.
const ACCURACY: f64 = solidcraft_smlib::MEASURE_ACCURACY;
/// Measure a body. A B-rep body's volume, area and centre are SMLib's, integrated on its exact
/// surfaces over its material regions (a sheet's: its faces' area and their centre, volume 0),
/// and its box is SMLib's exact box; a body SMLib cannot measure is an error. A mesh body is
/// measured from its triangles, exactly.
pub fn measure(b: &Body) -> Result<BodyMeasure> {
let _span = solidcraft_profile::span("kernel", "measure");
if let Some((pos, tris)) = b.triangle_mesh() {
// Exact for a mesh body; topology counts are facets, sides and vertices.
let m = b.mesh(&crate::MeshTolerance::chord(1.0))?;
let mm = m.measure();
let edges = b.mesh.as_ref().map(|m| m.edge_count()).unwrap_or(0);
let merged =
TopoCounts { faces: tris.len(), edges, vertices: pos.len(), face_types: [("mesh".to_string(), tris.len())].into_iter().collect() };
return Ok(BodyMeasure {
volume: mm.volume,
area: mm.area,
centroid: mm.centroid,
bbox: m.bounds(),
faces: tris.len(),
edges,
vertices: pos.len(),
shells: 1,
merged,
measured_by: "mesh",
notes: Vec::new(),
});
}
let m = measure_mass(b)?;
let topo = b.mesh(&crate::MeshTolerance::chord((b.size() * 1e-3).max(1e-3)))?;
Ok(BodyMeasure {
volume: m.volume,
area: m.area,
centroid: m.centroid,
bbox: m.bbox,
faces: b.face_count(),
edges: b.edge_count(),
vertices: b.vertex_count(),
shells: b.shell_count(),
merged: merged_topology(b, &topo)?,
measured_by: m.measured_by,
notes: m.notes,
})
}
/// [`measure`]'s volume, area, centre and box alone (for callers that need no topology counts,
/// such as an interference check).
pub fn measure_mass(b: &Body) -> Result<MassMeasure> {
let _span = solidcraft_profile::span("kernel", "measure_mass");
if b.triangle_mesh().is_some() {
let m = measure(b)?;
return Ok(MassMeasure { volume: m.volume, area: m.area, centroid: m.centroid, bbox: m.bbox, measured_by: m.measured_by, notes: m.notes });
}
let m = crate::guard("SMLib mass properties", || {
b.smlib()?.mass_properties(ACCURACY).map_err(|e| crate::KernelError::smlib("SMLib mass properties", e))
})?;
let [x, y, z] = m.centroid;
Ok(MassMeasure { volume: m.volume, area: m.area, centroid: Vec3::new(x, y, z), bbox: b.exact_bounds()?, measured_by: "smlib", notes: Vec::new() })
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{BoolOp, boolean, cylinder, torus};
use solidcraft_geom::prelude::*;
/// The mass properties alone are [`measure`]'s, to the bit; and on a curved intersection
/// they are the textbook ones.
#[test]
fn mass_alone_is_the_full_measure() {
let ring = torus(Vec3::ZERO, 10.0, 2.0).unwrap();
let post = cylinder(Vec3::new(10.0, 0.0, -5.0), Vec3::Z, 1.5, 10.0).unwrap();
let shared = boolean(&ring, &post, BoolOp::Intersect).unwrap().unwrap();
for b in [&ring, &shared] {
let (full, mass) = (measure(b).unwrap(), measure_mass(b).unwrap());
assert_eq!(full.volume.to_bits(), mass.volume.to_bits());
assert_eq!(full.area.to_bits(), mass.area.to_bits());
assert_eq!(full.centroid, mass.centroid);
assert_eq!((full.bbox.min, full.bbox.max), (mass.bbox.min, mass.bbox.max));
}
let want = 2.0 * std::f64::consts::PI.powi(2) * 10.0 * 4.0;
let got = measure_mass(&ring).unwrap().volume;
assert!((got - want).abs() < 1e-3 * want, "{got} against {want}");
assert!(measure(&ring).unwrap().merged.faces > 0);
}
/// A cube 1000 mm from the origin with one 0.5 mm² facet left out: about the box's centre
/// the sums miss a cone of that facet to the centre (0.08 %), where about the origin they are
/// 17 % over. Closed, it measures the same about either.
// A body's measured volume does not depend on where it sits: the same revolved ring of cones
// and cylinders, moved far from the origin, measures what it measures at the origin.
use crate::{revolve, transform};
use solidcore_record::{Loop2, Plane, Region2, Vec2};
use std::f64::consts::{PI, TAU};
/// Ring cross-section in (radius, height): cones top and bottom, cylinders inside and out.
const PROFILE: [(f64, f64); 6] = [(5.0, 0.0), (9.0, 0.0), (11.0, 2.0), (11.0, 6.0), (8.0, 8.0), (5.0, 8.0)];
/// Pappus: 2π × the section's first moment about the axis.
fn ring_volume() -> f64 {
let mut moment6 = 0.0;
for (i, &(x0, y0)) in PROFILE.iter().enumerate() {
let (x1, y1) = PROFILE[(i + 1) % PROFILE.len()];
moment6 += (x0 + x1) * (x0 * y1 - x1 * y0);
}
TAU * moment6 / 6.0
}
fn revolved(plane: &Plane, pts: &[Vec2]) -> Body {
let region = Region2 { outer: Loop2::polygon(pts), holes: vec![] };
revolve(plane, &[region], Vec2::ZERO, Vec2::Y, TAU).unwrap().pop().unwrap()
}
fn rel(a: f64, b: f64) -> f64 {
(a - b).abs() / b.abs()
}
#[test]
fn ring_volume_does_not_depend_on_placement() {
let pts: Vec<Vec2> = PROFILE.iter().map(|&(r, z)| Vec2::new(r, z)).collect();
let base = revolved(&Plane::XZ, &pts);
let at_origin = measure(&base).unwrap();
assert!(rel(at_origin.volume, ring_volume()) < 1e-4, "{} vs {}", at_origin.volume, ring_volume());
for d in [100.0, 1000.0, 10000.0] {
for axis in [Vec3::X, Vec3::Y, Vec3::Z, Vec3::new(1.0, 1.0, 1.0)] {
let m = measure(&transform(&base, axis * d, Vec3::ZERO, Vec3::Z, 0.0).unwrap()).unwrap();
assert!(rel(m.volume, at_origin.volume) < 1e-6, "moved {d} along {axis:?}: {} vs {}", m.volume, at_origin.volume);
let off = m.centroid - at_origin.centroid - axis * d;
assert!(off.len() < 1e-6 * d, "centroid moved {d} along {axis:?}: off by {off:?}");
}
}
}
#[test]
fn cylinder_and_cone_volumes_far_from_the_origin() {
let (r, h) = (7.0, 12.0);
// A frustum, radii 7 and 3, height 10: πh/3 (R² + Rr + r²).
let frustum = [Vec2::new(0.0, 0.0), Vec2::new(7.0, 0.0), Vec2::new(3.0, 10.0), Vec2::new(0.0, 10.0)];
let cone_volume = PI * 10.0 / 3.0 * (49.0 + 21.0 + 9.0);
for at in [Vec3::ZERO, Vec3::new(5000.0, -3000.0, 8000.0)] {
let cyl = measure(&cylinder(at, Vec3::Z, r, h).unwrap()).unwrap();
assert!(rel(cyl.volume, PI * r * r * h) < 5e-4, "cylinder at {at:?}: {}", cyl.volume);
let cone = measure(&revolved(&Plane { origin: at, ..Plane::XZ }, &frustum)).unwrap();
assert!(rel(cone.volume, cone_volume) < 5e-4, "frustum at {at:?}: {} vs {cone_volume}", cone.volume);
}
}
}