Files
solidcraft/crates/kernel/src/iso.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

374 lines
18 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.
//! Isoparametric curves of a face: the curves of its surface along which one parameter is held
//! (u = const or v = const), each exactly as a record curve, cut to the face by its trims (the
//! pcurves of its loops in (u, v)). One routine clips an iso line to a face ([`FaceTrims::clip`]);
//! the curve through a point ([`iso_curves`], projected into sketches) and the analysis grid
//! across a face ([`iso_grid`], drawn by Isocurve Analysis) both use it.
//!
//! Seams, poles and periods need nothing of their own: a face's loops and pcurves lie in one lift
//! of its surface's (u, v) inside its box ([`brep::Face::domain`]), a seam edge is in the loop
//! twice (once on each side of the box), and a pole is a degenerate edge or a vertex loop on the
//! box's side, where the outer loop's polygon closes. Every iso line of a closed surface is
//! therefore one line across the box, cut where it crosses the loops.
use solidcore_record::Vec3;
use solidcore_record::brep;
use solidcraft_geom::brep::eval::SurfaceEval;
use solidcraft_geom::prelude::*;
use crate::body::Body;
use crate::point_path::{MAX_CURVE_POINTS, curve_path};
use crate::{KernelError, Result};
/// Samples per knot span (and at least this many per pcurve) where the iso curves look for the
/// crossings of a face's loops and classify the face's inside.
const ISO_SAMPLES: usize = 64;
/// Most iso curves each way [`iso_grid`] draws across one face.
pub const MAX_ISO_COUNT: usize = 100;
/// One piece of an isoparametric curve of a face, inside the face.
#[derive(Clone, Debug, PartialEq)]
pub struct IsoLine {
/// The curve runs along the surface's first parameter (u runs, v is held), or its second.
pub along_u: bool,
/// The parameter held: v when `along_u`, else u.
pub fixed: f64,
/// The exact record curve on `interval` of its own parameter.
pub curve: brep::Curve,
pub interval: [f64; 2],
/// The surface parameter that runs along the curve (u when `along_u`, else v), from the
/// start of `interval` to its end.
pub span: [f64; 2],
/// Its points from the start of `interval` to its end, at the chord tolerance asked for.
pub points: Vec<Vec3>,
}
/// A face's surface and its loops in (u, v), read once for any number of iso lines.
struct FaceTrims<'a> {
surface: &'a brep::Surface,
eval: SurfaceEval,
domain: [[f64; 2]; 2],
/// Each edge loop's pcurves, each with its samples ([`pcurve_samples`]) and whether the loop
/// runs along it (from its interval's start to its end).
loops: Vec<Vec<(&'a brep::Curve2, Vec<(f64, [f64; 2])>, bool)>>,
/// Each edge loop as a closed polygon in (u, v), for telling the face's inside.
polygons: Vec<Vec<[f64; 2]>>,
}
impl<'a> FaceTrims<'a> {
fn new(body: &'a Body, face: usize) -> Result<FaceTrims<'a>> {
let f = body.record().faces.get(face).ok_or_else(|| KernelError::Invalid(format!("the body has no face {face}")))?;
let surface = f.parameters();
let eval = SurfaceEval::new(surface).map_err(|e| KernelError::Failed(format!("iso curve: {e}")))?;
let loops: Vec<Vec<(&brep::Curve2, Vec<(f64, [f64; 2])>, bool)>> = f
.loops
.iter()
.filter_map(|l| match l {
brep::Loop::Edges { edges } => Some(edges.iter().map(|e| (&e.pcurve, pcurve_samples(&e.pcurve), e.forward)).collect()),
// A pole: the outer loop's polygon closes along the box's side there.
brep::Loop::Vertex { .. } => None,
})
.collect();
let polygons = loops
.iter()
.map(|l| {
// In the loop's order: a pcurve runs along its edge's interval whichever way the
// loop does, so one the loop runs against is walked backwards.
let mut poly: Vec<[f64; 2]> = Vec::new();
for (_, samples, forward) in l {
let pts = samples.iter().map(|(_, q)| *q);
if *forward { poly.extend(pts) } else { poly.extend(pts.rev()) }
}
// Closed: a loop whose pcurves leave a side of the box out (a sphere's poles, as
// vertex loops) has that side as its closing edge.
if let Some(first) = poly.first().copied() {
poly.push(first);
}
poly
})
.collect();
Ok(FaceTrims { surface, eval, domain: f.domain, loops, polygons })
}
/// The face's own extent in (u, v): the box around its loops, within the surface's box.
fn extent(&self) -> [[f64; 2]; 2] {
let mut b = [[f64::INFINITY, f64::NEG_INFINITY]; 2];
for q in self.polygons.iter().flatten() {
for (k, x) in q.iter().enumerate() {
b[k] = [b[k][0].min(*x), b[k][1].max(*x)];
}
}
let [[u0, u1], [v0, v1]] = self.domain;
[[b[0][0].max(u0), b[0][1].min(u1)], [b[1][0].max(v0), b[1][1].min(v1)]]
}
/// Whether `q` is inside the face: inside its outer loop and outside its holes.
fn inside(&self, q: [f64; 2]) -> bool {
self.polygons.iter().filter(|l| crosses_right(q, l)).count() % 2 == 1
}
/// The iso line of the surface at `fixed` (v when `along_u`, else u) across the face's box,
/// cut to the face: the pieces inside it, each as its exact record curve on its interval and
/// the running parameter's span, in the order the line runs (none when the line misses the
/// face).
fn clip(&self, along_u: bool, fixed: f64) -> Result<Vec<(brep::Curve, [f64; 2], [f64; 2])>> {
let [[u0, u1], [v0, v1]] = self.domain;
let (lo, hi) = if along_u { (u0, u1) } else { (v0, v1) };
let at_t = |t: f64| if along_u { [t, fixed] } else { [fixed, t] };
// Where the line crosses the loops' pcurves (along it), each crossing solved on the
// pcurve itself, with the box's ends.
let across = |q: [f64; 2]| if along_u { q[1] - fixed } else { q[0] - fixed };
let along = |q: [f64; 2]| if along_u { q[0] } else { q[1] };
let mut cuts = vec![lo, hi];
for (c, samples, _) in self.loops.iter().flatten() {
for w in samples.windows(2) {
let ((ta, qa), (tb, qb)) = (w[0], w[1]);
let (ka, kb) = (across(qa), across(qb));
if (ka < 0.0) == (kb < 0.0) || ka == kb {
continue;
}
let (mut x, mut y) = (ta, tb);
for _ in 0..80 {
let m = 0.5 * (x + y);
match solidcraft_geom::brep::pcurve::eval(c, m).map(across) {
Some(k) if (k < 0.0) == (ka < 0.0) => x = m,
Some(_) => y = m,
None => break,
}
}
if let Some(t) = solidcraft_geom::brep::pcurve::eval(c, 0.5 * (x + y)).map(along).filter(|t| *t > lo && *t < hi) {
cuts.push(t);
}
}
}
cuts.sort_by(f64::total_cmp);
cuts.dedup_by(|a, b| (*a - *b).abs() <= 1e-9 * (1.0 + b.abs()));
let mut out = Vec::new();
// Neighbouring inside pieces are one piece.
let mut run: Option<(f64, f64)> = None;
for w in cuts.windows(2) {
let (a, b) = (w[0], w[1]);
if !(b - a > 1e-12) {
continue;
}
if self.inside(at_t(0.5 * (a + b))) {
run = Some(run.map_or((a, b), |(s, _)| (s, b)));
} else if let Some(r) = run.take() {
let (curve, interval) = iso_record(self.surface, along_u, fixed, r)?;
out.push((curve, interval, [r.0, r.1]));
}
}
if let Some(r) = run {
let (curve, interval) = iso_record(self.surface, along_u, fixed, r)?;
out.push((curve, interval, [r.0, r.1]));
}
Ok(out)
}
}
/// The isoparametric curve of face `face` of `body` through the point `at` on it, the pieces of
/// it inside the face, each as its exact record curve on its interval: along the surface's first
/// parameter (`along_u`; around a cylinder, cone, sphere or torus) or its second (along them).
/// On a B-spline surface the curve is the surface's row at the point's other parameter (each
/// control point the column through it evaluated there, exactly); on an analytic surface its
/// line or circle. The pieces are where the curve crosses the face's loops (their pcurves).
pub fn iso_curves(body: &Body, face: usize, at: Vec3, along_u: bool) -> Result<Vec<(brep::Curve, [f64; 2])>> {
let trims = FaceTrims::new(body, face)?;
let [[u0, u1], [v0, v1]] = trims.domain;
let size = body.size().max(1e-9);
let mid = [0.5 * (u0 + u1), 0.5 * (v0 + v1)];
let [mut pu, mut pv] = trims
.eval
.project(at, Some(mid), size * 1e-3 + 1e-6)
.ok_or_else(|| KernelError::Invalid("iso curve: the point is not on the face".into()))?;
// Into the face's box, by whole periods.
let period = trims.eval.domain().period;
for (x, (lo, hi), p) in [(&mut pu, (u0, u1), period[0]), (&mut pv, (v0, v1), period[1])] {
if let Some(p) = p.filter(|p| *p > 0.0) {
*x = lo + (*x - lo).rem_euclid(p);
if *x > hi + 1e-12 {
*x -= p;
}
}
}
let out: Vec<(brep::Curve, [f64; 2])> = trims.clip(along_u, if along_u { pv } else { pu })?.into_iter().map(|(c, i, _)| (c, i)).collect();
if out.is_empty() {
return Err(KernelError::Invalid("the iso curve runs outside the face".into()));
}
Ok(out)
}
/// The isoparametric curves of face `face` of `body` for Isocurve Analysis: `count`
/// (1…[`MAX_ISO_COUNT`]) curves each way, evenly spaced across the face, the held parameter at
/// `lo + k · (hi − lo) / (count + 1)` for `k = 1…count` over the face's extent in (u, v), so
/// neither side of the extent (the face's boundary) is drawn as a curve. Faces of the body on the
/// very same surface (a face a boss splits in two) are spaced together, across the extent of all
/// of them, so their curves are the same lines, straight across where they meet. Each curve is
/// cut to the face ([`FaceTrims::clip`]), its points at chord tolerance `chord`. Along u first,
/// then v.
pub fn iso_grid(body: &Body, face: usize, count: usize, chord: f64) -> Result<Vec<IsoLine>> {
if !(1..=MAX_ISO_COUNT).contains(&count) {
return Err(KernelError::Invalid(format!("iso curves: 1…{MAX_ISO_COUNT} each way")));
}
if !(chord.is_finite() && chord > 0.0) {
return Err(KernelError::Invalid("iso curves: the chord tolerance must be positive".into()));
}
let trims = FaceTrims::new(body, face)?;
let [[u0, u1], [v0, v1]] = shared_extent(body, face, &trims)?;
let mut out = Vec::new();
for along_u in [true, false] {
let (lo, hi) = if along_u { (v0, v1) } else { (u0, u1) };
if !(hi > lo) {
continue;
}
for k in 1..=count {
let fixed = lo + (hi - lo) * k as f64 / (count + 1) as f64;
for (curve, interval, span) in trims.clip(along_u, fixed)? {
let segs = curve_path(&curve, interval)?;
let mut points: Vec<Vec3> = segs.first().map(crate::PathSeg::start).into_iter().collect();
for s in &segs {
points.extend(s.points_after_start(chord));
}
out.push(IsoLine { along_u, fixed, curve, interval, span, points });
}
}
}
Ok(out)
}
/// The extent in (u, v) of face `face` together with every other face of `body` on the same
/// surface record (the same surface and parameters, so one (u, v) for all of them): the box round
/// all their extents ([`FaceTrims::extent`]).
fn shared_extent(body: &Body, face: usize, trims: &FaceTrims) -> Result<[[f64; 2]; 2]> {
let mut b = trims.extent();
for (i, other) in body.record().faces.iter().enumerate() {
if i == face || other.parameters() != trims.surface {
continue;
}
let [[a0, a1], [c0, c1]] = FaceTrims::new(body, i)?.extent();
b = [[b[0][0].min(a0), b[0][1].max(a1)], [b[1][0].min(c0), b[1][1].max(c1)]];
}
Ok(b)
}
/// A pcurve's parameters and points at [`ISO_SAMPLES`] per knot span, in its direction.
fn pcurve_samples(c: &brep::Curve2) -> Vec<(f64, [f64; 2])> {
let Some([a, b]) = c.interval() else { return Vec::new() };
let spans = match c {
brep::Curve2::Spline { knots, .. } | brep::Curve2::RationalSpline { knots, .. } => knots.windows(2).filter(|w| w[1] > w[0]).count().max(1),
};
let n = (spans * ISO_SAMPLES).min(1 << 16);
(0..=n)
.filter_map(|i| {
let t = a + (b - a) * i as f64 / n as f64;
solidcraft_geom::brep::pcurve::eval(c, t).map(|q| (t, q))
})
.collect()
}
/// Whether the ray from `q` along +u crosses the closed polygon `l` an odd number of times.
fn crosses_right(q: [f64; 2], l: &[[f64; 2]]) -> bool {
let mut odd = false;
for w in l.windows(2) {
let (a, b) = (w[0], w[1]);
if (a[1] > q[1]) != (b[1] > q[1]) && q[0] < a[0] + (b[0] - a[0]) * (q[1] - a[1]) / (b[1] - a[1]) {
odd = !odd;
}
}
odd
}
/// The iso curve of `surface` at `fixed` (the other parameter) as a record curve on `[a, b]` of
/// its own parameter: the surface's own line or circle, or its B-spline row.
fn iso_record(surface: &brep::Surface, along_u: bool, fixed: f64, (a, b): (f64, f64)) -> Result<(brep::Curve, [f64; 2])> {
use solidcore_record::brep::{Curve, Frame, Surface};
let v = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]);
let d = |q: Vec3| [q.x, q.y, q.z];
let line = |p: Vec3, q: Vec3| (Curve::Line { start: d(p), end: d(q) }, [0.0, 1.0]);
let circle = |o: Vec3, x: Vec3, y: Vec3, r: f64| (Curve::Circle { frame: Frame { origin: d(o), x_axis: d(x), y_axis: d(y) }, radius: r }, [a, b]);
let frame = |f: &Frame| (v(f.origin), v(f.x_axis), v(f.y_axis), v(f.x_axis).cross(v(f.y_axis)));
Ok(match surface {
Surface::Plane { origin, u_axis, v_axis } => {
let (o, x, y) = (v(*origin), v(*u_axis), v(*v_axis));
let at = |t: f64| if along_u { o + x * t + y * fixed } else { o + x * fixed + y * t };
line(at(a), at(b))
}
Surface::PlaneThrough { origin, u_point, v_point } => {
let (o, x, y) = (v(*origin), v(*u_point) - v(*origin), v(*v_point) - v(*origin));
let at = |t: f64| if along_u { o + x * t + y * fixed } else { o + x * fixed + y * t };
line(at(a), at(b))
}
Surface::Cylinder { frame: f, radius } => {
let (o, x, y, z) = frame(f);
if along_u {
circle(o + z * fixed, x, y, *radius)
} else {
let r = (x * fixed.cos() + y * fixed.sin()) * *radius;
line(o + r + z * a, o + r + z * b)
}
}
Surface::Cone { frame: f, radius_at_origin, half_angle } => {
let (o, x, y, z) = frame(f);
let r = |h: f64| radius_at_origin + h * half_angle.tan();
if along_u {
circle(o + z * fixed, x, y, r(fixed))
} else {
let dir = x * fixed.cos() + y * fixed.sin();
line(o + dir * r(a) + z * a, o + dir * r(b) + z * b)
}
}
Surface::Sphere { frame: f, radius } => {
let (o, x, y, z) = frame(f);
if along_u {
circle(o + z * (radius * fixed.sin()), x, y, radius * fixed.cos())
} else {
circle(o, x * fixed.cos() + y * fixed.sin(), z, *radius)
}
}
Surface::Torus { frame: f, major_radius, minor_radius, tube_start } => {
let (o, x, y, z) = frame(f);
if along_u {
let w = fixed + tube_start;
circle(o + z * (minor_radius * w.sin()), x, y, major_radius + minor_radius * w.cos())
} else {
// The tube circle from its start, so its angle is v.
let dir = x * fixed.cos() + y * fixed.sin();
let (s, c) = tube_start.sin_cos();
circle(o + dir * *major_radius, dir * c + z * s, z * c - dir * s, *minor_radius)
}
}
Surface::Spline { u_knots, v_knots, points } => {
let rows: Vec<Vec<[f64; 4]>> = points.iter().map(|r| r.iter().map(|q| [q[0], q[1], q[2], 1.0]).collect()).collect();
spline_iso(u_knots, v_knots, &rows, along_u, fixed, a, b)?
}
Surface::RationalSpline { u_knots, v_knots, homogeneous } => spline_iso(u_knots, v_knots, homogeneous, along_u, fixed, a, b)?,
Surface::PlacedRevolution { .. } => {
return Err(KernelError::Failed("not supported yet: an iso curve of a revolved surface record".into()));
}
// A label: the face's (u, v) are its NURBS form's, whose rows are its iso curves.
Surface::BallPatch { .. } => return Err(KernelError::Invalid("an iso curve of a ball patch's label (take its NURBS form's)".into())),
})
}
/// The row of a B-spline surface (homogeneous `net[i][j]`, i along u) at `fixed`: along u, each
/// control point the v-column through it evaluated at `fixed` (along v, the u-row), on `[a, b]`.
fn spline_iso(u_knots: &[f64], v_knots: &[f64], net: &[Vec<[f64; 4]>], along_u: bool, fixed: f64, a: f64, b: f64) -> Result<(brep::Curve, [f64; 2])> {
use solidcraft_geom::bspline::CurveN;
let bad = || KernelError::Invalid("iso curve: the surface's B-spline does not evaluate".into());
let (nu, nv) = (net.len(), net.first().map_or(0, Vec::len));
if nu * nv > MAX_CURVE_POINTS || net.iter().any(|r| r.len() != nv) {
return Err(bad());
}
let (pu, pv) = (u_knots.len().checked_sub(nu + 1).ok_or_else(bad)?, v_knots.len().checked_sub(nv + 1).ok_or_else(bad)?);
let at = |degree: usize, knots: &[f64], ctrl: Vec<[f64; 4]>| CurveN::<4> { degree, knots: knots.to_vec(), ctrl }.eval(fixed).map(|(p, _)| p);
let (knots, homogeneous): (Vec<f64>, Vec<[f64; 4]>) = if along_u {
(u_knots.to_vec(), net.iter().map(|row| at(pv, v_knots, row.clone())).collect::<Option<_>>().ok_or_else(bad)?)
} else {
(
v_knots.to_vec(),
(0..nv).map(|j| at(pu, u_knots, net.iter().filter_map(|r| r.get(j).copied()).collect())).collect::<Option<_>>().ok_or_else(bad)?,
)
};
Ok((brep::Curve::RationalSpline { knots, homogeneous }, [a, b]))
}