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

603 lines
31 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.
//! Display-only smooth joins: which edges the shaded view leaves out because they lie inside one
//! smooth surface (the two faces meet with one tangent plane and one curvature across the edge,
//! G2), and which it must keep because they are a crease or an authored split. A join that is
//! only tangent (G1: a fillet's boundary, a plane tangent to a cylinder) is a feature line and is
//! drawn.
//!
//! One rule for every surface: at stations along the edge, each face's outward normal and its
//! normal curvature across the edge are evaluated on its exact surface ([`Face::parameters`]) at
//! the edge's exact pcurve in that face (the use's own pcurve, so a seam a face meets itself
//! across is the same test with its two pcurves), turned by the side the shell uses the face on.
//! The edge is smooth when the normals agree within [`ANGLE`] and the curvatures within [`BEND`]
//! at every station; it is a crease where the normals differ by more than the
//! evaluation can account for anywhere (a crease far too small to see is both). Smoothness is
//! display-only: the edge keeps its identity, stays pickable and stays in the wireframe, and its
//! faces stay apart (pieces of one surface are [`crate::topo::seam_flags`]'s business). Unknown
//! geometry (a station that does not evaluate) keeps its existing presentation.
use solidcore_record::Vec3;
use solidcore_record::brep::{Brep, Loop, Shell};
use solidcraft_geom::Mesh;
use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval};
use solidcraft_geom::prelude::*;
use crate::body::Body;
const MAX_FACES: usize = 50_000;
const MAX_EDGES: usize = 200_000;
/// Surface evaluations one body may spend (two per station).
const WORK: usize = 2_000_000;
/// Stations along each edge: the middles of this many equal parameter spans, so neither end
/// (where a pole or a vertex of a degenerate face sits) is one.
const STATIONS: usize = 8;
/// Largest angle between the faces' normals, in radians, that still counts as tangent: half a
/// degree. Shading is the visible trace of a join: across a crease of angle θ the lit intensity
/// jumps by at most about θ of its range, and half a degree (0.0087) is under 1%, below the
/// 1–2% step the eye tells apart on a smooth gradient. So a join this close to tangent shows no
/// line in the shading. Exact tangency (fillets, analytic seams) reads 1e-12 or so, far inside
/// it; real creases a model means are degrees. Tangency alone does not hide an edge ([`BEND`]).
/// It is SolidCraft's one angle for smooth: a blend finds nothing to round below it too.
pub(crate) const ANGLE: f64 = 0.5 * std::f64::consts::PI / 180.0;
/// Largest difference of the two faces' normal curvatures across an edge, relative to the
/// larger one (or to 1 / the edge's length where both are flatter), that still counts as one
/// smooth surface (G2): [`ANGLE`], the same visibility criterion as for the normals. Continued
/// past the edge, two faces whose curvatures differ by Δκ turn their normals apart by Δκ per
/// mm; the bound keeps that under [`ANGLE`] over one radius of curvature (Δκ / κ) and over the
/// edge's own length (Δκ L), so the join leaves no visible kink in reflections either. A join
/// that is only tangent (G1) is a feature line and stays drawn: a fillet meets its plane with a
/// jump from 0 to 1 / radius (a relative difference of 1), a cylinder meets a tangent plane the
/// same way. Pieces of one surface pass: exact pieces agree to rounding, and a modelled thread's
/// flank pieces (spans of one sweep) differ by at most 0.0046 (measured, the thread test).
const BEND: f64 = ANGLE;
/// Below this sine of the angle between ∂S/∂u and ∂S/∂v the normal is undefined (a pole, an
/// apex): such a station says nothing.
const DEGENERATE: f64 = 1e-9;
/// Angle, in radians, that rounding alone can put between two unit normals evaluated in double
/// precision on exactly one tangent plane.
const ROUNDOFF: f64 = 1e-12;
/// What the stations along one edge say. The two verdicts are separate: a join can be too
/// close to tangent to show in the shading (`smooth`) and still be a measured crease
/// (`crease`) — a real edge between two surfaces, kept pickable and apart even where a coarse
/// fit takes its faces for one surface ([`crate::topo::seam_flags`]).
#[derive(Clone, Copy, Debug, Default, PartialEq)]
struct Join {
/// Every station's normals agree within [`ANGLE`] and its curvatures across within [`BEND`].
smooth: bool,
/// Some station's normals differ by more than the evaluation can account for: the pcurve
/// points lie some distance off the edge's curve (measured at the station), and over that
/// distance a normal turns by at most the distance times the surface's largest curvature.
crease: bool,
}
pub(crate) fn flags(body: &Body, mesh: &Mesh) -> (Vec<bool>, Vec<bool>) {
crate::guard("smooth display edges", || Ok(classify(body, mesh, WORK))).unwrap_or_default()
}
/// A face ready to evaluate: its surface and the sign that turns the natural normal outward.
struct FaceEval {
surface: SurfaceEval,
side: f64,
}
/// Each face's evaluator, or `None` where its surface does not evaluate or no shell uses it. A
/// face's side is the one its first shell uses it on.
fn face_evals(record: &Brep) -> Vec<Option<FaceEval>> {
let mut forward: Vec<Option<bool>> = vec![None; record.faces.len()];
for shell in &record.shells {
if let Shell::Faces { faces, .. } = shell {
for f in faces {
if let Some(slot) = forward.get_mut(f.face as usize) {
slot.get_or_insert(f.forward);
}
}
}
}
record
.faces
.iter()
.zip(forward)
.map(|(face, forward)| {
let surface = SurfaceEval::new(face.parameters()).ok()?;
Some(FaceEval { surface, side: if forward? { 1.0 } else { -1.0 } })
})
.collect()
}
/// A face at a station: its point, outward unit normal, first and second derivatives, and a
/// bound on its curvature.
struct Station {
point: Vec3,
normal: Vec3,
su: Vec3,
sv: Vec3,
/// `(S_uu, S_uv, S_vv)`; `None` where the surface has none (a revolution).
second: Option<(Vec3, Vec3, Vec3)>,
/// The larger principal curvature's size, 1/mm (`None`: no second derivatives, so a crease
/// cannot be told from evaluation error).
curvature: Option<f64>,
}
impl Station {
/// The normal curvature in the tangent direction `w`, 1/mm, signed by the outward normal:
/// II(w) / I(w), with `w` written in (u, v) by its projection on the tangent plane.
fn across(&self, w: Vec3) -> Option<f64> {
let (suu, suv, svv) = self.second?;
let (e, f, g) = (self.su.dot(self.su), self.su.dot(self.sv), self.sv.dot(self.sv));
let det = e * g - f * f;
let (wu, wv) = (self.su.dot(w), self.sv.dot(w));
let (a, b) = ((g * wu - f * wv) / det, (e * wv - f * wu) / det);
let first = e * a * a + 2. * f * a * b + g * b * b;
let (l, m, n) = (suu.dot(self.normal), suv.dot(self.normal), svv.dot(self.normal));
let k = (l * a * a + 2. * m * a * b + n * b * b) / first;
(det > 0. && first > 0. && k.is_finite()).then_some(k)
}
}
/// `face` at `uv`; `Some(None)` where the normal is undefined there, `None` where it does not
/// evaluate.
fn station(face: &FaceEval, uv: [f64; 2]) -> Option<Option<Station>> {
let (point, su, sv) = face.surface.derivs(uv[0], uv[1])?;
if !point.is_finite() || !su.is_finite() || !sv.is_finite() {
return None;
}
let n = su.cross(sv);
if !(n.len() > DEGENERATE * su.len() * sv.len()) {
return Some(None);
}
let Some(unit) = n.normalized() else { return Some(None) };
let second = face.surface.second(uv[0], uv[1]).filter(|(a, b, c)| a.is_finite() && b.is_finite() && c.is_finite());
// The principal curvatures, from the shape operator I⁻¹ II: H ± √(H² − K).
let curvature = second.and_then(|(suu, suv, svv)| {
let (e, f, g) = (su.dot(su), su.dot(sv), sv.dot(sv));
let (l, m, n) = (suu.dot(unit), suv.dot(unit), svv.dot(unit));
let det = e * g - f * f;
let mean = (e * n - 2. * f * m + g * l) / (2. * det);
let gauss = (l * n - m * m) / det;
let most = mean.abs() + (mean * mean - gauss).max(0.).sqrt();
(det > 0. && most.is_finite()).then_some(most)
});
Some(Some(Station { point, normal: unit * face.side, su, sv, second, curvature }))
}
/// How the two uses of edge `e` meet: their faces' outward normals compared at [`STATIONS`]
/// stations, each through its own pcurve.
fn join(record: &Brep, faces: &[Option<FaceEval>], e: usize, length: f64, work: &mut usize) -> Join {
let unknown = Join::default();
let Some(edge) = record.edges.get(e) else { return unknown };
let [a, b] = edge.uses.as_slice() else { return unknown };
let side = |u: &solidcore_record::brep::EdgeUseRef| {
let face = faces.get(u.face as usize)?.as_ref()?;
let Loop::Edges { edges } = record.faces.get(u.face as usize)?.loops.get(u.r#loop as usize)? else { return None };
let used = edges.get(u.position as usize)?;
(used.edge as usize == e).then_some((face, &used.pcurve))
};
let (Some((fa, pa)), Some((fb, pb))) = (side(a), side(b)) else { return unknown };
let [t0, t1] = edge.interval;
if !(t0.is_finite() && t1.is_finite() && t0 < t1 && edge.tolerance.is_finite() && edge.tolerance >= 0.) {
return unknown;
}
let curve = CurveEval::new(edge.parameters()).ok();
let (mut measured, mut smooth, mut crease) = (false, true, false);
for k in 0..STATIONS {
let Some(left) = work.checked_sub(2) else { return unknown };
*work = left;
let t = t0 + (t1 - t0) * (k as f64 + 0.5) / STATIONS as f64;
let (Some(ua), Some(ub)) = (solidcraft_geom::brep::pcurve::eval(pa, t), solidcraft_geom::brep::pcurve::eval(pb, t)) else { return unknown };
let (Some(sa), Some(sb)) = (station(fa, ua), station(fb, ub)) else { return unknown };
let (Some(sa), Some(sb)) = (sa, sb) else { continue };
let angle = sa.normal.cross(sb.normal).len().atan2(sa.normal.dot(sb.normal));
if !angle.is_finite() {
return unknown;
}
measured = true;
smooth &= angle <= ANGLE && same_bend(&sa, &sb, curve.as_ref().and_then(|c| c.derivs(t)).map(|d| d.1), length);
// How far each evaluated point lies off the edge, measured on the edge's own curve
// (its tolerance where the curve does not evaluate).
let off = match curve.as_ref().and_then(|c| c.point(t)).filter(|c| c.is_finite()) {
Some(c) => sa.point.dist(c).max(sb.point.dist(c)).max(sa.point.dist(sb.point)),
None => edge.tolerance,
};
if let (Some(ka), Some(kb)) = (sa.curvature, sb.curvature) {
crease |= angle > off * (ka + kb) + ROUNDOFF;
}
crease |= angle > ANGLE;
}
if measured { Join { smooth, crease } } else { unknown }
}
/// Do the two faces bend alike across the edge at a station (G2 there): their normal
/// curvatures in the direction across the edge (in the tangent plane, square to the edge's
/// tangent `along`) within [`BEND`] of the larger, or of 1 / `length` where both are flatter
/// than that? Unknown (no tangent, no second derivatives) is no.
fn same_bend(a: &Station, b: &Station, along: Option<Vec3>, length: f64) -> bool {
let Some(w) = along.and_then(|t| a.normal.cross(t).normalized()) else { return false };
let (Some(ka), Some(kb)) = (a.across(w), b.across(w)) else { return false };
let scale = ka.abs().max(kb.abs()).max(1. / length);
(ka - kb).abs() <= BEND * scale
}
/// Does the mesh's edge `e` bound the faces the record's edge `e` is used by? A mesh that says
/// otherwise is not this record's, and its edge keeps its presentation.
fn same_faces(record: &Brep, mesh: &Mesh, e: usize) -> bool {
let (Some(edge), Some(listed)) = (record.edges.get(e), mesh.edge_faces.get(e)) else { return false };
let mut used: Vec<u32> = edge.uses.iter().map(|u| u.face).collect();
let mut listed = listed.clone();
used.sort_unstable();
used.dedup();
listed.sort_unstable();
listed.dedup();
used == listed
}
fn classify(body: &Body, mesh: &Mesh, mut work: usize) -> (Vec<bool>, Vec<bool>) {
let Ok(rec) = crate::native::brep_record(body) else { return (Vec::new(), Vec::new()) };
if rec.faces.len() > MAX_FACES || mesh.edges.len() > MAX_EDGES {
return (Vec::new(), Vec::new());
}
let mut split_points = 0usize;
for line in body.split_keep() {
let Some(left) = work.checked_sub(line.len().saturating_add(1)) else { return (Vec::new(), Vec::new()) };
work = left;
let Some(total) = split_points.checked_add(line.len()) else { return (Vec::new(), Vec::new()) };
split_points = total;
}
let faces = face_evals(&rec);
let mut smooth = vec![false; mesh.edges.len()];
let mut sharp = vec![false; mesh.edges.len()];
// Edges of one join: the measured edges between the same faces that continue each other.
let mut joins: Vec<usize> = Vec::new();
// The mesh's edges are the record's, in its order.
for (current, line) in mesh.edges.iter().enumerate().take(rec.edges.len()) {
let Some(split_work) = line.len().checked_add(1).and_then(|n| n.checked_mul(split_points)) else { break };
let Some(left) = work.checked_sub(split_work) else { break };
work = left;
let flag = if crate::heal::on_split_line(line, body.split_keep()) {
sharp.get_mut(current)
} else if !same_faces(&rec, mesh, current) {
None
} else {
joins.push(current);
let length: f64 = line.windows(2).map(|w| if let [a, b] = w { a.dist(*b) } else { 0. }).sum();
let Join { smooth: tangent, crease } =
if length > 0. && length.is_finite() { join(&rec, &faces, current, length, &mut work) } else { Join::default() };
if let (true, Some(flag)) = (tangent, smooth.get_mut(current)) {
*flag = true;
}
crease.then(|| sharp.get_mut(current)).flatten()
};
if let Some(flag) = flag {
*flag = true;
}
if work == 0 {
break;
}
}
whole_joins(&rec, &joins, &mut smooth, work);
(smooth, sharp)
}
/// One verdict for each join, however the B-rep splits it: the edges in `measured` between the
/// same faces that continue each other at a shared vertex (their curves' tangents there within
/// [`ANGLE`] of one line) are one join, smooth only where every one of its edges is. A seam
/// SMLib holds as two edges, G2 along one and only near G2 along the other (a G2 corner patch's
/// side next to the face it ends on), is drawn whole, never to a vertex in the middle of the
/// line. `work` bounds the pairs compared; past it the edges keep their own verdicts.
fn whole_joins(record: &Brep, measured: &[usize], smooth: &mut [bool], mut work: usize) {
// Per vertex, each measured edge ending there: its faces and its tangent leaving the vertex.
let mut ends: std::collections::HashMap<u32, Vec<(usize, Vec<u32>, Vec3)>> = std::collections::HashMap::new();
for &e in measured {
let Some(edge) = record.edges.get(e) else { continue };
let Some(curve) = CurveEval::new(edge.parameters()).ok() else { continue };
let mut faces: Vec<u32> = edge.uses.iter().map(|u| u.face).collect();
faces.sort_unstable();
faces.dedup();
let [t0, t1] = edge.interval;
for (vertex, t, sign) in [(edge.vertices[0], t0, 1.), (edge.vertices[1], t1, -1.)] {
if let Some(d) = curve.derivs(t).and_then(|d| (d.1 * sign).normalized()) {
ends.entry(vertex).or_default().push((e, faces.clone(), d));
}
}
}
let mut parent: Vec<usize> = (0..smooth.len()).collect();
fn root(parent: &mut [usize], mut i: usize) -> usize {
while let Some(&p) = parent.get(i) {
if p == i {
break;
}
let up = parent.get(p).copied().unwrap_or(p);
if let Some(slot) = parent.get_mut(i) {
*slot = up;
}
i = up;
}
i
}
let cos = ANGLE.cos();
'vertices: for at in ends.values() {
for (i, (a, fa, da)) in at.iter().enumerate() {
for (b, fb, db) in at.iter().skip(i + 1) {
let Some(left) = work.checked_sub(1) else { break 'vertices };
work = left;
// Leaving the vertex in opposite directions: one continues the other.
if a != b && fa == fb && da.dot(*db) <= -cos {
let (ra, rb) = (root(&mut parent, *a), root(&mut parent, *b));
if let Some(slot) = parent.get_mut(ra) {
*slot = rb;
}
}
}
}
}
let mut whole: std::collections::HashMap<usize, bool> = std::collections::HashMap::new();
for &e in measured {
let r = root(&mut parent, e);
let own = smooth.get(e).copied().unwrap_or(false);
whole.entry(r).and_modify(|s| *s &= own).or_insert(own);
}
for &e in measured {
let r = root(&mut parent, e);
if let (Some(slot), Some(&all)) = (smooth.get_mut(e), whole.get(&r)) {
*slot = all;
}
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
use solidcore_record::brep::Surface;
use solidcore_record::{Loop2, Plane, Region2, Seg2, Vec2};
fn circle(radius: f64, count: usize) -> Loop2 {
let step = std::f64::consts::TAU / count as f64;
let k = 4. / 3. * (step / 4.).tan() * radius;
let point = |angle: f64| Vec2::new(angle.cos(), angle.sin()) * radius;
let tangent = |angle: f64| Vec2::new(-angle.sin(), angle.cos()) * k;
Loop2 {
segs: (0..count)
.map(|i| {
let a = i as f64 * step;
let b = (i + 1) as f64 * step;
let p0 = point(a);
let p3 = if i + 1 == count { point(0.) } else { point(b) };
Seg2::Cubic { p0, p1: p0 + tangent(a), p2: p3 - tangent(b), p3 }
})
.collect(),
}
}
fn ring(count: usize) -> Body {
crate::extrude(&Plane::XY, &[Region2 { outer: circle(10., count), holes: vec![circle(9., count).reversed()] }], 0., 3.).unwrap().remove(0)
}
/// A square sheet with a round hole a closed curve cut (its loop one closed edge) is
/// classified without a check refusing the closed edge (a panic the guard would catch).
#[test]
fn a_hole_of_one_closed_edge_is_classified() {
let sheet = crate::patch_region(
&Plane::XY,
&Region2 {
outer: Loop2::polygon(&[Vec2::new(-10., -10.), Vec2::new(10., -10.), Vec2::new(10., 10.), Vec2::new(-10., 10.)]),
holes: vec![],
},
)
.unwrap();
let ring: Vec<Seg2> = Loop2::circle(Vec2::ZERO, 4.).segs;
let tool = crate::SplitTool::Curves { plane: Plane::XY, curves: vec![ring], along: None };
let holed = crate::trim(&sheet, &tool, Vec3::new(9., 9., 0.)).unwrap();
assert!(crate::native::brep_record(&holed).unwrap().edges.iter().any(|e| e.vertices[0] == e.vertices[1]), "a closed edge");
let mesh = holed.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
let (smooth, sharp) = classify(&holed, &mesh, WORK);
assert_eq!((smooth.len(), sharp.len()), (mesh.edges.len(), mesh.edges.len()));
}
#[test]
fn periodic_ring_hides_only_whole_smooth_wall_joins() {
let body = ring(256);
let mesh = body.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
assert_eq!(mesh.edges.len(), 1536);
assert_eq!(mesh.smooth_edges.iter().filter(|f| **f).count(), 512);
for (index, (line, smooth)) in mesh.edges.iter().zip(&mesh.smooth_edges).enumerate() {
let vertical = (line.first().unwrap().z - line.last().unwrap().z).abs() > 2.9;
assert_eq!(*smooth, vertical);
assert!(!(vertical && mesh.sharp_edges[index]), "a tangent join is measured as no crease");
if !vertical {
assert!(mesh.shaded_edge_visible(index));
}
}
// Smoothing flags are display-only: the edges and faces keep the body's identities.
let raw = body.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
assert_eq!(mesh.edges.len(), raw.edges.len());
assert_eq!(mesh.edge_faces, raw.edge_faces);
for (a, b) in mesh.edges.iter().zip(&raw.edges) {
assert_eq!((a.first(), a.last()), (b.first(), b.last()));
}
let faces = |m: &Mesh| m.tri_face.iter().copied().collect::<std::collections::BTreeSet<u32>>();
assert_eq!(faces(&mesh), faces(&raw));
let moved = crate::transform_matrix(&body, [[1., 0., 0., 0.], [0., 0., 1., 0.], [0., -1., 0., 0.], [30., 20., 10., 1.]]).unwrap();
assert_eq!(moved.mesh(&crate::MeshTolerance::chord(0.02)).unwrap().smooth_edges.iter().filter(|f| **f).count(), 512);
}
#[test]
fn authored_split_unknown_adjacency_and_exhausted_work_stay_visible() {
let body = ring(8);
let mesh = body.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
let index = mesh.smooth_edges.iter().position(|f| *f).unwrap();
let split = body.clone().with_split_lines(Some(std::sync::Arc::new(vec![mesh.edges[index].clone()])));
assert!(!flags(&split, &mesh).0[index]);
let mut unknown = mesh.clone();
unknown.edge_faces[index].push(999);
assert!(!flags(&body, &unknown).0[index]);
assert!(classify(&body, &mesh, 0).0.iter().all(|f| !*f));
}
/// A G2 corner patch's sides are G2 to their rounds except near the faces they end on, and
/// SMLib holds each side as two edges: the side is one join, drawn whole, not up to the
/// vertex in its middle where the G2 half begins (the 20 mm box's r3 corner).
#[test]
fn a_seam_split_in_two_edges_is_drawn_whole() {
let body = crate::box_solid(Vec3::ZERO, Vec3::new(20., 20., 20.)).unwrap();
let picks = [Vec3::new(20., 20., 10.), Vec3::new(20., 10., 20.), Vec3::new(10., 20., 20.)];
let g2 = crate::fillet_g2_corners(&body, &picks, 3., &[]).unwrap();
let mesh = g2.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
let rec = crate::native::brep_record(&g2).unwrap();
let patch = rec
.faces
.iter()
.position(|f| !matches!(f.surface, Surface::Plane { .. } | Surface::PlaneThrough { .. } | Surface::Cylinder { .. }))
.unwrap() as u32;
let rounds: Vec<u32> = (0..rec.faces.len() as u32).filter(|f| matches!(rec.faces[*f as usize].surface, Surface::Cylinder { .. })).collect();
assert_eq!(rounds.len(), 3);
for round in rounds {
let side: Vec<usize> =
(0..mesh.edges.len()).filter(|e| mesh.edge_faces[*e].contains(&patch) && mesh.edge_faces[*e].contains(&round)).collect();
assert_eq!(side.len(), 2, "SMLib splits the side in two: {side:?}");
assert!(side.iter().all(|e| mesh.shaded_edge_visible(*e)), "the side to round {round} is drawn whole: {side:?}");
}
}
/// An extruded circle of eight cubics whose first cubic leaves its start turned by `degrees`:
/// the wall join there is a crease of that angle.
fn creased(degrees: f64) -> (Body, Mesh, usize) {
let mut outer = circle(10., 8);
if let Seg2::Cubic { p0, p1, .. } = &mut outer.segs[0] {
p1.x += (p1.y - p0.y) * degrees.to_radians().tan();
}
let body = crate::extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0., 3.).unwrap().remove(0);
let mesh = body.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
let crease = mesh
.edges
.iter()
.position(|line| {
line.first().is_some_and(|p| (p.x - 10.).abs() < 1e-8 && p.y.abs() < 1e-8)
&& line.last().is_some_and(|p| (p.x - 10.).abs() < 1e-8 && p.y.abs() < 1e-8)
&& line.first().zip(line.last()).is_some_and(|(a, b)| (a.z - b.z).abs() > 2.9)
})
.unwrap();
(body, mesh, crease)
}
#[test]
fn a_crease_over_half_a_degree_is_visible_and_one_under_it_is_not() {
let (_, mesh, crease) = creased(1.0);
// The crease's other end bends differently too: only six joins are one smooth surface.
assert_eq!(mesh.smooth_edges.iter().filter(|f| **f).count(), 6);
assert!(!mesh.smooth_edges[crease]);
assert!(mesh.sharp_edges[crease]);
assert!(mesh.shaded_edge_visible(crease));
assert!(mesh.edge_pickable(crease));
// Too small to see, but measured: not drawn in the shading, still a real edge.
for degrees in [0.2, 1e-4] {
let (_, mesh, crease) = creased(degrees);
assert_eq!(mesh.smooth_edges.iter().filter(|f| **f).count(), 8, "{degrees}");
assert!(mesh.sharp_edges[crease], "{degrees}");
assert!(!mesh.shaded_edge_visible(crease), "{degrees}");
assert!(mesh.edge_visible(crease) && mesh.edge_pickable(crease), "{degrees}: a smooth join is only left undrawn");
}
}
#[test]
fn actual_authored_split_of_a_curved_ruled_wall_stays_visible() {
let body = ring(4);
let face = crate::native::brep_record(&body).unwrap().faces.iter().position(|face| matches!(face.surface, Surface::Spline { .. })).unwrap();
let tool = crate::SplitTool::Plane(Plane::new(Vec3::new(7., 0., 0.), Vec3::Y, Vec3::Z).unwrap());
let split = crate::split_faces(&body, &[face], &tool).unwrap();
assert!(split.face_count() > body.face_count());
assert!(!split.split_keep().is_empty());
let mesh = split.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
let authored: Vec<_> =
mesh.edges.iter().enumerate().filter(|(_, line)| crate::heal::on_split_line(line, split.split_keep())).map(|(i, _)| i).collect();
assert!(!authored.is_empty());
for index in authored {
assert!(!mesh.smooth_edges[index]);
assert!(mesh.shaded_edge_visible(index));
}
}
#[test]
fn a_spheres_and_a_cylinders_seams_are_smooth_and_their_rims_creases() {
let sphere = crate::sphere(Vec3::ZERO, 10.).unwrap();
let mesh = sphere.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
let (smooth, sharp) = (mesh.smooth_edges.iter().filter(|f| **f).count(), mesh.sharp_edges.iter().filter(|f| **f).count());
assert!(smooth >= 1 && sharp == 0, "sphere: {smooth} smooth, {sharp} creases");
let cylinder = crate::cylinder(Vec3::ZERO, Vec3::Z, 8., 20.).unwrap();
let mesh = cylinder.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
for (i, line) in mesh.edges.iter().enumerate() {
let vertical = line.first().zip(line.last()).is_some_and(|(a, b)| (a.z - b.z).abs() > 19.);
assert_eq!(mesh.smooth_edges[i], vertical, "edge {i}");
assert_eq!(mesh.sharp_edges[i], !vertical, "edge {i}: a rim is a crease");
}
}
/// A box with its top edges and one upright edge rounded: every round meets its faces and
/// its neighbours tangentially (G1, not G2), so each of those joins is a drawn feature line
/// but no crease; the box's own edges and the miters are creases.
#[test]
fn a_filleted_boxs_tangent_joins_are_drawn_and_its_corners_creases() {
let block = crate::box_solid(Vec3::ZERO, Vec3::new(20., 20., 10.)).unwrap();
let picks = [Vec3::new(10., 0., 10.), Vec3::new(20., 10., 10.), Vec3::new(10., 20., 10.), Vec3::new(0., 10., 10.), Vec3::new(20., 20., 5.)];
let rounded = crate::fillet(&block, &picks, 3.).unwrap();
let mesh = rounded.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
for (i, line) in mesh.edges.iter().enumerate() {
let (Some(a), Some(b)) = (line.first(), line.last()) else { panic!("edge {i} has no points") };
let corner = |p: &Vec3| [p.x, p.y].iter().all(|c| c.abs() < 1e-6 || (c - 20.).abs() < 1e-6);
// The bottom rim, the three square upright edges, and the miters where two top
// rounds meet over a square corner are creases.
let bottom = line.iter().all(|p| p.z.abs() < 1e-6);
let square_upright = corner(a) && corner(b) && (a.z - b.z).abs() > 1.;
let miter = (corner(a) && (b.z - 10.).abs() < 1e-6) || (corner(b) && (a.z - 10.).abs() < 1e-6);
assert!(!mesh.smooth_edges[i] && mesh.shaded_edge_visible(i) && mesh.edge_pickable(i), "edge {i} {a:?}..{b:?} is drawn");
assert_eq!(mesh.sharp_edges[i], bottom || square_upright || miter, "edge {i} {a:?}..{b:?}: only the box's edges are creases");
}
}
/// A plane tangent to a cylinder (a D-shaped prism): one tangent plane, but the curvature
/// jumps from 0 to 1 / radius, so the join is drawn.
#[test]
fn a_plane_tangent_to_a_cylinder_is_drawn() {
let (a, b, c, d) = (Vec2::new(-5., -5.), Vec2::new(5., -5.), Vec2::new(5., 5.), Vec2::new(-5., 5.));
let outer = Loop2 {
segs: vec![
Seg2::Line { a, b },
Seg2::Arc { center: Vec2::new(5., 0.), radius: 5., start: -std::f64::consts::FRAC_PI_2, sweep: std::f64::consts::PI },
Seg2::Line { a: c, b: d },
Seg2::Line { a: d, b: a },
],
};
let body = crate::extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0., 3.).unwrap().remove(0);
let mesh = body.mesh(&crate::MeshTolerance::chord(0.02)).unwrap();
let joins: Vec<usize> = (0..mesh.edges.len())
.filter(|&i| {
let line = &mesh.edges[i];
line.first()
.zip(line.last())
.is_some_and(|(p, q)| (p.x - 5.).abs() < 1e-6 && (p.y.abs() - 5.).abs() < 1e-6 && (p.z - q.z).abs() > 2.9)
})
.collect();
assert_eq!(joins.len(), 2, "{:?}", mesh.edges.iter().map(|l| (l.first(), l.last())).collect::<Vec<_>>());
for i in joins {
assert!(!mesh.smooth_edges[i] && !mesh.sharp_edges[i], "edge {i}: tangent, not curvature continuous, no crease");
assert!(mesh.shaded_edge_visible(i) && mesh.edge_pickable(i));
}
}
#[test]
fn a_degenerate_normal_says_nothing() {
let face = FaceEval {
surface: SurfaceEval::new(&Surface::Sphere {
frame: solidcore_record::brep::Frame { origin: [0.; 3], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] },
radius: 2.,
})
.unwrap(),
side: 1.,
};
assert!(matches!(station(&face, [0.3, std::f64::consts::FRAC_PI_2]), Some(None)), "the pole");
let at = station(&face, [0., 0.]).unwrap().unwrap();
assert!((at.normal - Vec3::X).len() < 1e-12, "{:?}", at.normal);
// A sphere's normal curvature is 1 / radius in every direction.
assert!(at.curvature.is_some_and(|k| (k - 0.5).abs() < 1e-9), "{:?}", at.curvature);
assert!(station(&face, [f64::NAN, 0.]).is_none());
}
}