Files
solidcraft/crates/smlib/src/import.rs
T
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

688 lines
32 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.
//! Schema 4 records (`solidcore_record::brep::Brep`) into SMLib: the record is laid out as the C
//! API's flat arrays (`capi/include/smlib.h`, "Flat B-rep arrays"), which solidcore builds into
//! its B-rep ([`crate::core::from_arrays`]).
//!
//! The two models differ in four places, and the mapping takes care of each:
//! - A closed shell is one record listed by the two regions it separates; SMLib keeps one shell
//! per region, the face used on opposite sides. A sheet's shell holds both sides of its faces.
//! - The infinite region is never a void here; SMLib marks it as one.
//! - Pcurves run along the edge (interval min → max) here; SMLib's UV trims run along their
//! edgeuse. They are carried on B-spline faces only: on analytic faces SMLib keeps its trims in
//! its own parameterisation and rebuilds them from the 3D edges.
//! - Every end value (edge intervals, face domains) is already in the flat arrays' units, radians
//! for angles; the C side converts them to SMLib's own pointwise.
use std::collections::{BTreeMap, HashMap, HashSet};
use solidcore_record::brep as b;
use crate::flat;
/// Why a record cannot go to SMLib.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Unsupported {
/// The record failed `Brep::validate`.
Invalid(&'static str),
/// A part of schema 4 this mapping does not carry yet.
NotYet(&'static str),
}
impl std::fmt::Display for Unsupported {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Unsupported::Invalid(w) => write!(f, "invalid B-rep record: {w}"),
Unsupported::NotYet(w) => write!(f, "not supported yet: {w} in SMLib"),
}
}
}
type R<T> = std::result::Result<T, Unsupported>;
/// The flat arrays of one B-rep, by array id.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Arrays {
pub ints: BTreeMap<i32, Vec<i64>>,
pub reals: BTreeMap<i32, Vec<f64>>,
}
impl Arrays {
fn i(&mut self, id: i32) -> &mut Vec<i64> {
self.ints.entry(id).or_default()
}
fn r(&mut self, id: i32) -> &mut Vec<f64> {
self.reals.entry(id).or_default()
}
fn r3(&mut self, id: i32, p: [f64; 3]) {
self.r(id).extend(p);
}
}
fn int(n: usize) -> R<i64> {
i64::try_from(n).map_err(|_| Unsupported::Invalid("count"))
}
fn sub(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {
[a[0] - b[0], a[1] - b[1], a[2] - b[2]]
}
fn cross(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {
[a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
}
fn dot(a: [f64; 3], b: [f64; 3]) -> f64 {
a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
}
fn add(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {
[a[0] + b[0], a[1] + b[1], a[2] + b[2]]
}
fn scale(a: [f64; 3], s: f64) -> [f64; 3] {
[a[0] * s, a[1] * s, a[2] * s]
}
fn z_axis(f: &b::Frame) -> [f64; 3] {
cross(f.x_axis, f.y_axis)
}
/// The record as flat arrays. `trusted`: the record comes from a modeller that keeps SMLib's
/// rules (SMLib then skips its healer); otherwise SMLib heals it on import.
pub fn arrays(brep: &b::Brep, trusted: bool) -> R<Arrays> {
solidcraft_geom::brep::check::validate_built(brep).map_err(|e| Unsupported::Invalid(e.0))?;
let brep = analytic::analytic(brep)?;
laid_out(brep.as_ref(), trusted, true, &HashSet::new())
}
/// [`arrays`] with every surface as the record holds it: a round face truck holds as a rational
/// spline (an extruded circle) stays one, and a plane off unit orthogonal axes goes as its
/// bilinear patch, to compare what SMLib makes of splines with what it makes of its own analytic
/// surfaces. A revolution is still refused (SMLib has no such surface).
pub fn arrays_keeping_splines(brep: &b::Brep, trusted: bool) -> R<Arrays> {
solidcraft_geom::brep::check::validate_built(brep).map_err(|e| Unsupported::Invalid(e.0))?;
laid_out(brep, trusted, false, &HashSet::new())
}
/// The flat arrays of a record whose uses in `bare` (face, loop, position) go without their
/// UV trims, for SMLib to make (their pcurves in the record are not read): what
/// [`crate::pcurves`] hands SMLib. Not validated, as its bare uses have no pcurves.
pub(crate) fn arrays_with_bare_uses(brep: &b::Brep, bare: &HashSet<(u32, u32, u32)>) -> R<Arrays> {
laid_out(brep, true, true, bare)
}
/// The flat arrays; `analytic`: a plane on any axes goes as SMLib's plane (else, off unit
/// orthogonal axes, as the bilinear patch it is). The uses in `bare` go without UV trims.
fn laid_out(brep: &b::Brep, trusted: bool, analytic: bool, bare: &HashSet<(u32, u32, u32)>) -> R<Arrays> {
let mut a = Arrays::default();
// Regions and shells. Each region gets its own copy of each shell it lists.
let enclosed_by: HashMap<u32, usize> =
brep.regions.iter().enumerate().skip(1).filter_map(|(r, region)| region.shells.first().map(|&s| (s, r))).collect();
let listed = |s: u32| brep.regions.iter().filter(|r| r.shells.contains(&s)).count();
for (r, region) in brep.regions.iter().enumerate() {
a.i(flat::REGION_SHELL_COUNT).push(int(region.shells.len())?);
// SMLib marks the infinite region as a void.
a.i(flat::REGION_TYPE).push(i64::from(r == 0 || region.void));
for (k, &s) in region.shells.iter().enumerate() {
let Some(b::Shell::Faces { faces, wires }) = brep.shells.get(s as usize) else {
return Err(Unsupported::NotYet("wire and vertex shells"));
};
if !wires.is_empty() {
return Err(Unsupported::NotYet("wire edges embedded in a shell"));
}
let uses: Vec<(u32, bool)> = if listed(s) == 2 {
// A closed shell: the outward normals (out of the material) point into the
// region that is not material. As the outer shell of region r (k == 0) the shell
// encloses r; as an inner shell r lies outside it.
let inside = enclosed_by.get(&s).copied().ok_or(Unsupported::Invalid("closed shell encloses no region"))?;
let inside_is_void = brep.regions.get(inside).is_some_and(|e| e.void);
let normals_into_this = if k == 0 && r > 0 { inside_is_void } else { !inside_is_void };
faces.iter().map(|f| (f.face, f.forward == normals_into_this)).collect()
} else {
// An open shell lies in one region and holds both sides of each face.
faces.iter().flat_map(|f| [(f.face, true), (f.face, false)]).collect()
};
a.i(flat::SHELL_FACEUSE_COUNT).push(int(uses.len())?);
a.i(flat::SHELL_WIRE_EDGE_COUNT).push(0);
a.i(flat::SHELL_POINT_TYPE).push(0);
for (face, same) in uses {
a.i(flat::FACEUSE_FACE).push(i64::from(face));
a.i(flat::FACEUSE_ORIENTATION).push(i64::from(same));
}
}
}
// Edgeuses are numbered face → loop → position.
let mut eu_index: HashMap<(u32, u32, u32), i64> = HashMap::new();
let mut n = 0i64;
for (fi, f) in brep.faces.iter().enumerate() {
for (li, l) in f.loops.iter().enumerate() {
if let b::Loop::Edges { edges } = l {
for p in 0..edges.len() {
eu_index.insert((idx(fi)?, idx(li)?, idx(p)?), n);
n += 1;
}
}
}
}
let mut next = vec![-1i64; usize::try_from(n).unwrap_or(0)];
let mut entry = vec![0i64; next.len()];
for e in &brep.edges {
let at = |u: &b::EdgeUseRef| eu_index.get(&(u.face, u.r#loop, u.position)).copied().ok_or(Unsupported::Invalid("edge use"));
for (k, u) in e.uses.iter().enumerate() {
let here = at(u)?;
let after = e.uses.get((k + 1) % e.uses.len()).ok_or(Unsupported::Invalid("edge use"))?;
let slot = usize::try_from(here).map_err(|_| Unsupported::Invalid("edge use"))?;
*next.get_mut(slot).ok_or(Unsupported::Invalid("edge use"))? = at(after)?;
*entry.get_mut(slot).ok_or(Unsupported::Invalid("edge use"))? = i64::from(u.upper);
}
}
// Each edge's interval as SMLib takes it, and how far it moved (see `turned`).
// An edge on its NURBS form keeps that NURBS's interval.
let intervals: Vec<([f64; 2], f64)> =
brep.edges.iter().map(|e| if e.nurbs.is_some() { (e.interval, 0.0) } else { turned(&e.curve, e.interval) }).collect();
// Faces, loops and edgeuses, with the surfaces and, on B-spline faces, the trims.
let any_spline_face =
brep.faces.iter().any(|f| f.nurbs.is_some() || matches!(f.surface, b::Surface::Spline { .. } | b::Surface::RationalSpline { .. }));
let any_form = brep.faces.iter().any(|f| f.nurbs.is_some());
for (fi, f) in brep.faces.iter().enumerate() {
a.i(flat::FACE_LOOP_COUNT).push(int(f.loops.len())?);
a.i(flat::FACE_TRIM_TYPE).push(0);
// A face with a NURBS form: what it is (its analytic entry), then the NURBS it is
// parameterised on, whose range and trims these are (FACE_NURBS_FORM). A revolution
// (SMLib has no class for one) is that form alone, a NURBS face. A ball patch is its form
// too, as a NURBS face's block under its own kind, with its sphere as its definition.
let form_is_face = f.nurbs.is_some() && matches!(f.surface, b::Surface::PlacedRevolution { .. } | b::Surface::BallPatch { .. });
let spline = match (&f.nurbs, &f.surface) {
(Some(n), b::Surface::BallPatch { center, radius }) => ball_patch(&mut a, n, *center, *radius, f.domain)?,
(Some(n), _) if form_is_face => surface(&mut a, n, f.domain, analytic)?,
(Some(n), _) => {
surface(&mut a, &f.surface, f.domain, analytic)?;
nurbs_block(&mut a, n)?;
true
}
// SMLib's tube angle counts from the outer equator, the record's from its tube start.
(None, _) => match f.surface {
b::Surface::Torus { tube_start, .. } => {
let [u, v] = f.domain;
surface(&mut a, &f.surface, [u, v.map(|t| t + tube_start)], analytic)?
}
_ => surface(&mut a, &f.surface, f.domain, analytic)?,
},
};
if any_form {
a.i(flat::FACE_NURBS_FORM).push(i64::from(f.nurbs.is_some() && !form_is_face));
}
for (li, l) in f.loops.iter().enumerate() {
match l {
b::Loop::Vertex { vertex } => {
a.i(flat::LOOP_EDGEUSE_COUNT).push(0);
a.i(flat::LOOP_VERTEX).push(i64::from(*vertex));
}
b::Loop::Edges { edges } => {
a.i(flat::LOOP_EDGEUSE_COUNT).push(int(edges.len())?);
a.i(flat::LOOP_VERTEX).push(-1);
for (p, u) in edges.iter().enumerate() {
a.i(flat::EDGEUSE_EDGE).push(i64::from(u.edge));
a.i(flat::EDGEUSE_ORIENTATION).push(i64::from(u.forward));
if any_spline_face {
if spline && !bare.contains(&(idx(fi)?, idx(li)?, idx(p)?)) {
let shift = intervals.get(u.edge as usize).map_or(0.0, |i| i.1);
trim(&mut a, &u.pcurve, u.forward, shift)?;
} else {
a.i(flat::EDGEUSE_NURBS_VERTEX_COUNT).push(0);
a.i(flat::EDGEUSE_NURBS_ORDER).push(0);
}
}
}
}
}
}
}
a.i(flat::EDGEUSE_NEXT_RADIAL).extend(next);
a.i(flat::EDGEUSE_RADIAL_ENTRY).extend(entry);
let any_edge_form = brep.edges.iter().any(|e| e.nurbs.is_some());
for (e, (interval, _)) in brep.edges.iter().zip(&intervals) {
// A circle or ellipse on its NURBS form: what it is (its conic entry), then the NURBS it
// is parameterised on (EDGE_NURBS_FORM). Another curve on a NURBS form is written as that
// NURBS, whose parameter the edge's interval and trims are in.
let form = match (&e.curve, &e.nurbs) {
(b::Curve::Circle { .. } | b::Curve::Ellipse { .. }, Some(n)) => {
curve(&mut a, &e.curve)?;
edge_nurbs_block(&mut a, n)?;
true
}
(_, Some(n)) => {
curve(&mut a, n)?;
false
}
(_, None) => {
curve(&mut a, &e.curve)?;
false
}
};
if any_edge_form {
a.i(flat::EDGE_NURBS_FORM).push(i64::from(form));
}
a.i(flat::EDGE_VERTICES).extend([i64::from(e.vertices[0]), i64::from(e.vertices[1])]);
a.r(flat::EDGE_RANGE).extend(*interval);
// Each edge's own tolerance, never below the body's, and never past what SMLib takes.
let tolerance = e.tolerance.max(brep.tolerance);
if !(tolerance <= flat::MAX_TOLERANCE) {
return Err(Unsupported::NotYet("an edge tolerance over 1 mm"));
}
a.r(flat::EDGE_TOLERANCE).push(tolerance);
}
let (mut lo, mut hi) = ([f64::INFINITY; 3], [f64::NEG_INFINITY; 3]);
for v in &brep.vertices {
a.i(flat::VERTEX_POINT_TYPE).push(1);
a.r3(flat::VERTEX_POSITION, v.point);
let tolerance = v.tolerance.max(brep.tolerance);
if !(tolerance <= flat::MAX_TOLERANCE) {
return Err(Unsupported::NotYet("a vertex tolerance over 1 mm"));
}
a.r(flat::VERTEX_TOLERANCE).push(tolerance);
for k in 0..3 {
lo[k] = lo[k].min(v.point[k]);
hi[k] = hi[k].max(v.point[k]);
}
}
if brep.vertices.is_empty() {
(lo, hi) = ([0.0; 3], [0.0; 3]);
}
a.r(flat::EXTENT).extend(lo.into_iter().chain(hi));
a.r(flat::TOLERANCE).push(brep.tolerance);
a.i(flat::SOURCE).push(i64::from(trusted));
Ok(a)
}
fn idx(i: usize) -> R<u32> {
u32::try_from(i).map_err(|_| Unsupported::Invalid("index"))
}
/// A NURBS net's control points and weights, cartesian, U-major.
fn net(a: &mut Arrays, rows: impl Iterator<Item = ([f64; 3], f64)>) {
for (p, w) in rows {
a.r3(flat::FACE_NURBS_CVS, p);
a.r(flat::FACE_NURBS_WEIGHTS).push(w);
}
}
fn nurbs_face(a: &mut Arrays, u_knots: &[f64], v_knots: &[f64], nu: usize, nv: usize) -> R<()> {
a.i(flat::FACE_SURFACE_TYPE).push(i64::from(flat::SURFACE_NURBS));
nurbs_sizes(a, u_knots, v_knots, nu, nv)
}
/// A NURBS block's sizes, orders and knots.
fn nurbs_sizes(a: &mut Arrays, u_knots: &[f64], v_knots: &[f64], nu: usize, nv: usize) -> R<()> {
let order = |k: &[f64], n: usize| k.len().checked_sub(n).filter(|o| *o >= 2).ok_or(Unsupported::Invalid("spline order"));
a.i(flat::FACE_NURBS_U_VERTEX_COUNT).push(int(nu)?);
a.i(flat::FACE_NURBS_V_VERTEX_COUNT).push(int(nv)?);
a.i(flat::FACE_NURBS_U_ORDER).push(int(order(u_knots, nu)?)?);
a.i(flat::FACE_NURBS_V_ORDER).push(int(order(v_knots, nv)?)?);
a.r(flat::FACE_NURBS_U_KNOTS).extend_from_slice(u_knots);
a.r(flat::FACE_NURBS_V_KNOTS).extend_from_slice(v_knots);
Ok(())
}
/// The NURBS block of a face's NURBS form, with no surface kind or range of its own.
fn nurbs_block(a: &mut Arrays, s: &b::Surface) -> R<()> {
match s {
b::Surface::Spline { u_knots, v_knots, points } => {
nurbs_sizes(a, u_knots, v_knots, points.len(), points.first().map_or(0, Vec::len))?;
net(a, points.iter().flatten().map(|p| (*p, 1.0)));
}
b::Surface::RationalSpline { u_knots, v_knots, homogeneous } => {
nurbs_sizes(a, u_knots, v_knots, homogeneous.len(), homogeneous.first().map_or(0, Vec::len))?;
net(a, homogeneous.iter().flatten().map(|h| ([h[0] / h[3], h[1] / h[3], h[2] / h[3]], h[3])));
}
_ => return Err(Unsupported::Invalid("NURBS form is not a NURBS")),
}
Ok(())
}
/// A ball patch's face: its net `n` as a NURBS face's block and range under the ball patch's kind,
/// and its sphere as its definition (SMLib checks the net is on it). True: it carries trims.
fn ball_patch(a: &mut Arrays, n: &b::Surface, center: [f64; 3], radius: f64, domain: [[f64; 2]; 2]) -> R<bool> {
let [[u0, u1], [v0, v1]] = domain;
a.i(flat::FACE_SURFACE_TYPE).push(i64::from(flat::SURFACE_BALL_PATCH));
nurbs_block(a, n)?;
a.r(flat::FACE_RANGE).extend([u0, v0, u1, v1]);
a.i(flat::FACE_DEFINITION_REAL_COUNT).push(4);
a.r3(flat::FACE_DEFINITION_REALS, center);
a.r(flat::FACE_DEFINITION_REALS).push(radius);
Ok(true)
}
/// The face's surface and range; true for a B-spline surface (which carries trims).
fn surface(a: &mut Arrays, s: &b::Surface, domain: [[f64; 2]; 2], analytic_planes: bool) -> R<bool> {
let [[u0, u1], [v0, v1]] = domain;
let analytic = |a: &mut Arrays, kind: u8, ids: [i32; 3], f: &b::Frame| {
a.i(flat::FACE_SURFACE_TYPE).push(i64::from(kind));
a.r3(ids[0], f.origin);
a.r3(ids[1], z_axis(f));
a.r3(ids[2], f.x_axis);
a.r(flat::FACE_RANGE).extend([u0, v0, u1, v1]);
};
match s {
b::Surface::Plane { origin, u_axis, v_axis } => plane(a, *origin, *u_axis, *v_axis, domain, analytic_planes)?,
b::Surface::PlaneThrough { origin, u_point, v_point } => {
plane(a, *origin, sub(*u_point, *origin), sub(*v_point, *origin), domain, analytic_planes)?
}
b::Surface::Cylinder { frame, radius } => {
analytic(a, flat::SURFACE_CYLINDER, [flat::FACE_CYLINDER_ORIGIN, flat::FACE_CYLINDER_AXIS, flat::FACE_CYLINDER_REF_DIRECTION], frame);
a.r(flat::FACE_CYLINDER_RADIUS).push(*radius);
}
b::Surface::Cone { frame, radius_at_origin, half_angle } => {
analytic(a, flat::SURFACE_CONE, [flat::FACE_CONE_ORIGIN, flat::FACE_CONE_AXIS, flat::FACE_CONE_REF_DIRECTION], frame);
a.r(flat::FACE_CONE_RADIUS).push(*radius_at_origin);
a.r(flat::FACE_CONE_SEMI_ANGLE).push(*half_angle);
}
b::Surface::Sphere { frame, radius } => {
analytic(a, flat::SURFACE_SPHERE, [flat::FACE_SPHERE_CENTER, flat::FACE_SPHERE_AXIS, flat::FACE_SPHERE_REF_DIRECTION], frame);
a.r(flat::FACE_SPHERE_RADIUS).push(*radius);
}
b::Surface::Torus { frame, major_radius, minor_radius, .. } => {
analytic(a, flat::SURFACE_TORUS, [flat::FACE_TORUS_ORIGIN, flat::FACE_TORUS_AXIS, flat::FACE_TORUS_REF_DIRECTION], frame);
a.r(flat::FACE_TORUS_MAJOR_RADIUS).push(*major_radius);
a.r(flat::FACE_TORUS_MINOR_RADIUS).push(*minor_radius);
}
b::Surface::Spline { u_knots, v_knots, points } => {
let nv = points.first().map_or(0, Vec::len);
nurbs_face(a, u_knots, v_knots, points.len(), nv)?;
net(a, points.iter().flatten().map(|p| (*p, 1.0)));
a.r(flat::FACE_RANGE).extend([u0, v0, u1, v1]);
return Ok(true);
}
b::Surface::RationalSpline { u_knots, v_knots, homogeneous } => {
let nv = homogeneous.first().map_or(0, Vec::len);
nurbs_face(a, u_knots, v_knots, homogeneous.len(), nv)?;
net(a, homogeneous.iter().flatten().map(|h| ([h[0] / h[3], h[1] / h[3], h[2] / h[3]], h[3])));
a.r(flat::FACE_RANGE).extend([u0, v0, u1, v1]);
return Ok(true);
}
b::Surface::PlacedRevolution { profile, origin, axis, matrix, forward } => revolution(a, profile, *origin, *axis, matrix, *forward, domain)?,
b::Surface::BallPatch { .. } => return Err(Unsupported::Invalid("a ball patch without its NURBS form")),
}
Ok(false)
}
/// The quarter-circle arc's rational parameter `s` in [0, 1] at angle `phi` in [0, π/2]: the
/// circle NURBS below is not linear in the angle, so end values are converted pointwise.
fn quarter_param(phi: f64) -> f64 {
let c = std::f64::consts::FRAC_1_SQRT_2;
let angle = |s: f64| {
let (b0, b1, b2) = ((1.0 - s) * (1.0 - s), 2.0 * s * (1.0 - s) * c, s * s);
(b1 + b2).atan2(b0 + b1)
};
let (mut lo, mut hi) = (0.0f64, 1.0f64);
for _ in 0..64 {
let mid = 0.5 * (lo + hi);
if angle(mid) < phi {
lo = mid;
} else {
hi = mid;
}
}
0.5 * (lo + hi)
}
/// The circle NURBS's parameter (knots 0..4, one quarter turn per span) at `angle` after its start.
fn circle_param(angle: f64) -> f64 {
let q = std::f64::consts::FRAC_PI_2;
let a = angle.clamp(0.0, 4.0 * q);
let k = (a / q).floor().min(3.0);
k + quarter_param(a - k * q)
}
/// A revolution, exactly, as a rational B-spline surface: each profile control point swept round
/// the axis by a full circle of four rational quadratic quarters starting at the face's first
/// angle, then mapped by the placement. The circle's parameter is not the angle, so the face's
/// angle range is converted pointwise and its pcurves are not carried (SMLib rebuilds the trims).
/// Where the placement mirrors, the record's natural normal is the opposite of the map's
/// (`brep::eval`), so the B-spline takes the two directions the other way round.
fn revolution(
a: &mut Arrays,
profile: &b::Curve,
origin: [f64; 3],
axis: [f64; 3],
m: &[[f64; 4]; 4],
forward: bool,
domain: [[f64; 2]; 2],
) -> R<()> {
let (knots, pts): (Vec<f64>, Vec<([f64; 3], f64)>) = match profile {
b::Curve::Line { start, end } => (vec![0.0, 0.0, 1.0, 1.0], vec![(*start, 1.0), (*end, 1.0)]),
b::Curve::Spline { knots, points } => (knots.clone(), points.iter().map(|p| (*p, 1.0)).collect()),
b::Curve::RationalSpline { knots, homogeneous } => {
(knots.clone(), homogeneous.iter().map(|h| ([h[0] / h[3], h[1] / h[3], h[2] / h[3]], h[3])).collect())
}
_ => return Err(Unsupported::NotYet("revolutions of conic, polyline or intersection profiles")),
};
let len = dot(axis, axis).sqrt();
if !(len > 0.0) {
return Err(Unsupported::Invalid("revolution axis"));
}
let z = scale(axis, 1.0 / len);
// The record's u and v: the profile's parameter and the angle, or the other way round.
let ([p0, p1], [a0, a1]) = if forward { (domain[0], domain[1]) } else { (domain[1], domain[0]) };
let t1 = circle_param(a1 - a0);
// Column-major placement: point' = M · (p, 1).
let place = |p: [f64; 3]| [0, 1, 2].map(|r| m[0][r] * p[0] + m[1][r] * p[1] + m[2][r] * p[2] + m[3][r]);
let det = {
let col = |c: usize| [m[c][0], m[c][1], m[c][2]];
dot(cross(col(0), col(1)), col(2))
};
let c = std::f64::consts::FRAC_1_SQRT_2;
// net[i][k]: profile point i at circle control point k.
let mut net: Vec<Vec<([f64; 3], f64)>> = Vec::with_capacity(pts.len());
for (p, w) in &pts {
let r = sub(*p, origin);
let centre = add(origin, scale(z, dot(r, z)));
let x0 = sub(*p, centre);
let y0 = cross(z, x0);
// Start at the face's first angle.
let (s0, c0) = a0.sin_cos();
let (x, y) = (add(scale(x0, c0), scale(y0, s0)), sub(scale(y0, c0), scale(x0, s0)));
let row = (0..9)
.map(|k| {
let (sk, ck) = (k as f64 * std::f64::consts::FRAC_PI_4).sin_cos();
let (f, wk) = if k % 2 == 1 { (1.0 / c, c) } else { (1.0, 1.0) };
(place(add(centre, scale(add(scale(x, ck), scale(y, sk)), f))), w * wk)
})
.collect();
net.push(row);
}
let circle_knots = [0.0, 0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 4.0];
// Profile along the B-spline's first direction when the record's u is the profile and the
// placement keeps orientation, or the angle is u and it mirrors; else the angle goes first.
let profile_first = forward == (det > 0.0);
if profile_first {
nurbs_face(a, &knots, &circle_knots, pts.len(), 9)?;
net_rows(a, net.iter().flatten().copied());
a.r(flat::FACE_RANGE).extend([p0, 0.0, p1, t1]);
} else {
nurbs_face(a, &circle_knots, &knots, 9, pts.len())?;
net_rows(a, (0..9).flat_map(|k| net.iter().filter_map(move |row| row.get(k).copied())));
a.r(flat::FACE_RANGE).extend([0.0, p0, t1, p1]);
}
Ok(())
}
fn net_rows(a: &mut Arrays, cps: impl Iterator<Item = ([f64; 3], f64)>) {
net(a, cps);
}
/// A plane `origin + u·U + v·V` as SMLib's plane, whose (u, v) are distances along unit,
/// orthogonal axes: U's direction, and the one at a right angle to it in the plane, the normal
/// U × V as the record's. The range is the record's domain mapped onto those axes (its bounding
/// box: a face's range need not be tight, and SMLib rebuilds an analytic face's trims from its
/// edges). Truck's planes run through three points, their axes the face's own sides.
/// Off unit orthogonal axes and not `analytic`, it goes as the exact bilinear patch over the
/// domain instead.
fn plane(a: &mut Arrays, origin: [f64; 3], u: [f64; 3], v: [f64; 3], domain: [[f64; 2]; 2], analytic: bool) -> R<()> {
let [[u0, u1], [v0, v1]] = domain;
let unit = |x: [f64; 3]| (dot(x, x).sqrt() - 1.0).abs() <= 1e-12;
if !analytic && !(unit(u) && unit(v) && dot(u, v).abs() <= 1e-12) {
nurbs_face(a, &[u0, u0, u1, u1], &[v0, v0, v1, v1], 2, 2)?;
let at = |s: f64, t: f64| add(origin, add(scale(u, s), scale(v, t)));
net(a, [at(u0, v0), at(u0, v1), at(u1, v0), at(u1, v1)].into_iter().map(|p| (p, 1.0)));
a.r(flat::FACE_RANGE).extend([u0, v0, u1, v1]);
return Ok(());
}
let n = cross(u, v);
let (lu, ln) = (dot(u, u).sqrt(), dot(n, n).sqrt());
if !(lu > 0.0 && ln > 0.0 && lu.is_finite() && ln.is_finite()) {
return Err(Unsupported::Invalid("plane axes"));
}
let (x, z) = (scale(u, 1.0 / lu), scale(n, 1.0 / ln));
let y = cross(z, x);
let corners = [[u0, v0], [u0, v1], [u1, v0], [u1, v1]].map(|[s, t]| {
let d = add(scale(u, s), scale(v, t));
[dot(d, x), dot(d, y)]
});
let lo = |k: usize| corners.iter().map(|c| c[k]).fold(f64::INFINITY, f64::min);
let hi = |k: usize| corners.iter().map(|c| c[k]).fold(f64::NEG_INFINITY, f64::max);
a.i(flat::FACE_SURFACE_TYPE).push(i64::from(flat::SURFACE_PLANE));
a.r3(flat::FACE_PLANE_ORIGIN, origin);
a.r3(flat::FACE_PLANE_AXIS, z);
a.r3(flat::FACE_PLANE_REF_DIRECTION, x);
a.r(flat::FACE_RANGE).extend([lo(0), lo(1), hi(0), hi(1)]);
Ok(())
}
/// A circle's or ellipse's interval (radians) as SMLib takes it, within [-2π, 2π]: schema 4
/// lets one run past a full turn (a quarter arc after the seam, [2π, 2.5π]), SMLib's circles
/// take angles up to one turn either way. The same arc a whole turn back, and that shift, by
/// which the edge's pcurves move too (their parameter is the edge's).
fn turned(c: &b::Curve, interval: [f64; 2]) -> ([f64; 2], f64) {
use std::f64::consts::TAU;
if !matches!(c, b::Curve::Circle { .. } | b::Curve::Ellipse { .. }) {
return (interval, 0.0);
}
let [lo, hi] = interval;
let shift = if hi > TAU {
-TAU * ((hi - TAU) / TAU).ceil()
} else if lo < -TAU {
TAU * ((-TAU - lo) / TAU).ceil()
} else {
0.0
};
([lo + shift, hi + shift], shift)
}
/// A pcurve as the edgeuse's UV trim, its parameter moved by `shift` (the edge's, see
/// [`turned`]): reversed when the loop runs against the edge.
fn trim(a: &mut Arrays, c: &b::Curve2, forward: bool, shift: f64) -> R<()> {
let (knots, mut pts): (&[f64], Vec<([f64; 2], f64)>) = match c {
b::Curve2::Spline { knots, points } => (knots, points.iter().map(|p| (*p, 1.0)).collect()),
b::Curve2::RationalSpline { knots, homogeneous } => (knots, homogeneous.iter().map(|h| ([h[0] / h[2], h[1] / h[2]], h[2])).collect()),
};
let order = knots.len().checked_sub(pts.len()).filter(|o| *o >= 2).ok_or(Unsupported::Invalid("pcurve order"))?;
let mut k: Vec<f64> = knots.iter().map(|t| t + shift).collect();
if !forward {
pts.reverse();
k = k.iter().rev().map(|t| -t).collect();
}
a.i(flat::EDGEUSE_NURBS_VERTEX_COUNT).push(int(pts.len())?);
a.i(flat::EDGEUSE_NURBS_ORDER).push(int(order)?);
for (p, w) in pts {
a.r(flat::EDGEUSE_NURBS_CVS).extend(p);
a.r(flat::EDGEUSE_NURBS_WEIGHTS).push(w);
}
a.r(flat::EDGEUSE_NURBS_KNOTS).extend(k);
Ok(())
}
fn nurbs_curve(a: &mut Arrays, knots: &[f64], pts: impl ExactSizeIterator<Item = ([f64; 3], f64)>) -> R<()> {
a.i(flat::EDGE_CURVE_TYPE).push(i64::from(flat::CURVE_NURBS));
nurbs_curve_block(a, knots, pts)
}
/// An edge NURBS block (counts, points, weights, knots) with no curve kind of its own.
fn nurbs_curve_block(a: &mut Arrays, knots: &[f64], pts: impl ExactSizeIterator<Item = ([f64; 3], f64)>) -> R<()> {
let n = pts.len();
let order = knots.len().checked_sub(n).filter(|o| *o >= 2).ok_or(Unsupported::Invalid("spline order"))?;
a.i(flat::EDGE_NURBS_VERTEX_COUNT).push(int(n)?);
a.i(flat::EDGE_NURBS_ORDER).push(int(order)?);
for (p, w) in pts {
a.r3(flat::EDGE_NURBS_CVS, p);
a.r(flat::EDGE_NURBS_WEIGHTS).push(w);
}
a.r(flat::EDGE_NURBS_KNOTS).extend_from_slice(knots);
Ok(())
}
/// The NURBS block of an edge's NURBS form.
fn edge_nurbs_block(a: &mut Arrays, c: &b::Curve) -> R<()> {
match c {
b::Curve::Spline { knots, points } => nurbs_curve_block(a, knots, points.iter().map(|p| (*p, 1.0))),
b::Curve::RationalSpline { knots, homogeneous } => {
nurbs_curve_block(a, knots, homogeneous.iter().map(|h| ([h[0] / h[3], h[1] / h[3], h[2] / h[3]], h[3])))
}
_ => Err(Unsupported::Invalid("NURBS form is not a NURBS")),
}
}
fn curve(a: &mut Arrays, c: &b::Curve) -> R<()> {
match c {
b::Curve::Line { start, end } => {
a.i(flat::EDGE_CURVE_TYPE).push(i64::from(flat::CURVE_LINE));
a.r3(flat::EDGE_LINE_ORIGIN, *start);
a.r3(flat::EDGE_LINE_DIRECTION, sub(*end, *start));
}
b::Curve::Circle { frame, radius } => {
a.i(flat::EDGE_CURVE_TYPE).push(i64::from(flat::CURVE_CIRCLE));
a.r3(flat::EDGE_CIRCLE_CENTER, frame.origin);
a.r3(flat::EDGE_CIRCLE_AXIS, z_axis(frame));
a.r3(flat::EDGE_CIRCLE_REF_DIRECTION, frame.x_axis);
a.r(flat::EDGE_CIRCLE_RADIUS).push(*radius);
}
b::Curve::Ellipse { frame, radii } => {
a.i(flat::EDGE_CURVE_TYPE).push(i64::from(flat::CURVE_ELLIPSE));
a.r3(flat::EDGE_ELLIPSE_CENTER, frame.origin);
a.r3(flat::EDGE_ELLIPSE_AXIS, z_axis(frame));
a.r3(flat::EDGE_ELLIPSE_REF_DIRECTION, frame.x_axis);
a.r(flat::EDGE_ELLIPSE_X_RADIUS).push(radii[0]);
a.r(flat::EDGE_ELLIPSE_Y_RADIUS).push(radii[1]);
}
b::Curve::Polyline { points } => {
// Segment i spans [i, i + 1]: a degree-1 B-spline with those knots.
let n = points.len();
let mut k = vec![0.0];
k.extend((0..n).map(|i| i as f64));
k.push(n.saturating_sub(1) as f64);
nurbs_curve(a, &k, points.iter().map(|p| (*p, 1.0)))?;
}
b::Curve::Spline { knots, points } => nurbs_curve(a, knots, points.iter().map(|p| (*p, 1.0)))?,
b::Curve::RationalSpline { knots, homogeneous } => {
nurbs_curve(a, knots, homogeneous.iter().map(|h| ([h[0] / h[3], h[1] / h[3], h[2] / h[3]], h[3])))?
}
b::Curve::SurfaceIntersection { .. } => return Err(Unsupported::NotYet("traced intersection curves")),
}
Ok(())
}
mod analytic;
#[cfg(test)]
mod tests;
impl crate::Brep {
/// A body from flat arrays.
pub(crate) fn from_arrays(a: &Arrays) -> crate::Result<crate::Brep> {
crate::core::from_arrays(a).map(crate::Brep::made_core)
}
/// The SMLib B-rep of a schema 4 record. `trusted` as in [`arrays`].
pub fn from_record(brep: &b::Brep, trusted: bool) -> crate::Result<crate::Brep> {
let r = arrays(brep, trusted).map_err(crate::Error::Record).and_then(|a| crate::Brep::from_arrays(&a));
crate::trace::imported(&r, brep, trusted, false);
r
}
/// [`crate::Brep::from_record`] through [`arrays_keeping_splines`].
pub fn from_record_keeping_splines(brep: &b::Brep, trusted: bool) -> crate::Result<crate::Brep> {
let r = arrays_keeping_splines(brep, trusted).map_err(crate::Error::Record).and_then(|a| crate::Brep::from_arrays(&a));
crate::trace::imported(&r, brep, trusted, true);
r
}
}