forked from 1b-agent/fieldcraft-upstream
jyvikoandClaude Opus 5.5
464417d84d
Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_01UhhZMBTviDQxZvwnyP89fo
352 lines
16 KiB
Rust
352 lines
16 KiB
Rust
use super::complex::*;
|
||
use super::measure;
|
||
use super::ops::*;
|
||
use crate::predicates::Point3;
|
||
|
||
/// A cube [0, 1]³ split into six tetrahedra around the diagonal 0–6, boundary faces tagged by
|
||
/// cube side (0..6).
|
||
pub(crate) fn cube() -> TetComplex {
|
||
let p: Vec<[f64; 3]> = (0..8).map(|i| [(i & 1) as f64, ((i >> 1) & 1) as f64, ((i >> 2) & 1) as f64]).collect();
|
||
// Vertex i = (x, y, z) bits; diagonal 0 → 7.
|
||
let raw = [[0, 1, 3, 7], [0, 3, 2, 7], [0, 2, 6, 7], [0, 6, 4, 7], [0, 4, 5, 7], [0, 5, 1, 7]];
|
||
let pts: Vec<Point3> = p.iter().map(|c| Point3::try_from(*c).unwrap()).collect();
|
||
let tets: Vec<[u32; 4]> = raw
|
||
.iter()
|
||
.map(|t| {
|
||
let t = t.map(|v: usize| v as u32);
|
||
let x = t.map(|v| pts[v as usize].coords());
|
||
if measure::volume6(&x) > 0.0 { t } else { [t[1], t[0], t[2], t[3]] }
|
||
})
|
||
.collect();
|
||
let side = |f: [u32; 3]| -> Option<u32> {
|
||
let c = f.map(|v| p[v as usize]);
|
||
for axis in 0..3 {
|
||
for (s, val) in [(0, 0.0), (1, 1.0)] {
|
||
if c.iter().all(|q| q[axis] == val) {
|
||
return Some((axis * 2 + s) as u32);
|
||
}
|
||
}
|
||
}
|
||
None
|
||
};
|
||
let mut boundary = Vec::new();
|
||
for (t, vs) in tets.iter().enumerate() {
|
||
for k in 0..4 {
|
||
if let Some(tag) = side(face_toward(*vs, k)) {
|
||
boundary.push((t as u32, k, tag));
|
||
}
|
||
}
|
||
}
|
||
let kinds = vec![VertexKind::Corner; 8];
|
||
TetComplex::new(&p, kinds, &tets, &boundary, &[], 1000, 10_000).unwrap()
|
||
}
|
||
|
||
fn volume(cx: &TetComplex) -> f64 {
|
||
cx.live_tets().map(|(_, vs)| measure::volume6(&cx.coords(vs).unwrap()) / 6.0).sum()
|
||
}
|
||
|
||
#[test]
|
||
fn cube_builds_and_rings() {
|
||
let mut cx = cube();
|
||
assert_eq!(cx.live_count(), 6);
|
||
assert!((volume(&cx) - 1.0).abs() < 1e-15);
|
||
let ring = cx.edge_ring(0, 7).unwrap().unwrap();
|
||
assert!(ring.closed);
|
||
assert_eq!(ring.verts.len(), 6);
|
||
assert_eq!(ring.tets.len(), 6);
|
||
let ring = cx.edge_ring(0, 1).unwrap().unwrap();
|
||
assert!(!ring.closed);
|
||
assert_eq!(ring.verts.len(), ring.tets.len() + 1);
|
||
}
|
||
|
||
#[test]
|
||
fn interior_insertion_and_rollback() {
|
||
let mut cx = cube();
|
||
cx.journal.recording = true;
|
||
let start = cx.journal.steps.len();
|
||
let p = Point3::try_from([0.5, 0.5, 0.5]).unwrap();
|
||
let t = match cx.walk(0, &p, 100).unwrap().unwrap() {
|
||
Walk::Inside(t) => t,
|
||
w => panic!("{w:?}"),
|
||
};
|
||
let v = insert_delaunay(&mut cx, p, VertexKind::Interior, Site::Interior(t), 1000).unwrap().unwrap();
|
||
assert!(cx.is_used(v));
|
||
assert!((volume(&cx) - 1.0).abs() < 1e-15);
|
||
assert!(cx.live_count() > 6);
|
||
cx.rollback(start).unwrap();
|
||
cx.validate().unwrap();
|
||
assert_eq!(cx.live_count(), 6);
|
||
assert_eq!(cx.point_count(), 8);
|
||
assert!((volume(&cx) - 1.0).abs() < 1e-15);
|
||
}
|
||
|
||
#[test]
|
||
fn boundary_face_insertion_keeps_tags() {
|
||
let mut cx = cube();
|
||
// A point on the z = 0 side.
|
||
let p = Point3::try_from([0.3, 0.6, 0.0]).unwrap();
|
||
let mut site = None;
|
||
for (t, _) in cx.live_tets().collect::<Vec<_>>() {
|
||
let vs = cx.tet(t).unwrap();
|
||
for k in 0..4 {
|
||
if cx.adj(t).unwrap()[k] == NONE && cx.tags(t).unwrap()[k] == 4 {
|
||
let f = face_toward(vs, k).map(|v| cx.xyz(v).unwrap());
|
||
// inside the triangle in xy
|
||
let s = |a: [f64; 3], b: [f64; 3]| (b[0] - a[0]) * (0.6 - a[1]) - (b[1] - a[1]) * (0.3 - a[0]);
|
||
let signs = [s(f[0], f[1]), s(f[1], f[2]), s(f[2], f[0])];
|
||
if signs.iter().all(|x| *x > 0.0) || signs.iter().all(|x| *x < 0.0) {
|
||
site = Some(Site::Face(t, k));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let v = insert_delaunay(&mut cx, p, VertexKind::Face(4), site.unwrap(), 1000).unwrap().unwrap();
|
||
assert!(cx.is_used(v));
|
||
assert!((volume(&cx) - 1.0).abs() < 1e-15);
|
||
let c = cx.compact().unwrap();
|
||
let area: f64 = c
|
||
.boundary
|
||
.iter()
|
||
.filter(|b| b.2 == 4)
|
||
.map(|&(t, k, _)| {
|
||
let f = face_toward(c.tets[t as usize], k).map(|v| c.points[v as usize]);
|
||
0.5 * measure::norm(measure::cross(measure::sub(f[1], f[0]), measure::sub(f[2], f[0])))
|
||
})
|
||
.sum();
|
||
assert!((area - 1.0).abs() < 1e-15, "{area}");
|
||
}
|
||
|
||
#[test]
|
||
fn edge_and_face_removal_keep_the_mesh_valid() {
|
||
let mut cx = cube();
|
||
let p = Point3::try_from([0.5, 0.45, 0.55]).unwrap();
|
||
let Walk::Inside(t) = cx.walk(0, &p, 100).unwrap().unwrap() else { panic!() };
|
||
insert_delaunay(&mut cx, p, VertexKind::Interior, Site::Interior(t), 1000).unwrap().unwrap();
|
||
let mut changed = 0;
|
||
for _ in 0..3 {
|
||
let edges = edges_of(&cx, &cx.live_tets().map(|(t, _)| t).collect::<Vec<_>>()).unwrap();
|
||
for (a, b) in edges {
|
||
if cx.edge_tet(a, b).unwrap().is_some() && remove_edge(&mut cx, a, b).unwrap() {
|
||
changed += 1;
|
||
}
|
||
}
|
||
let tets: Vec<u32> = cx.live_tets().map(|(t, _)| t).collect();
|
||
for t in tets {
|
||
for k in 0..4 {
|
||
if cx.is_live(t) && remove_face(&mut cx, t, k).unwrap() {
|
||
changed += 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
assert!(changed > 0);
|
||
cx.validate().unwrap();
|
||
assert!((volume(&cx) - 1.0).abs() < 1e-14);
|
||
for (_, vs) in cx.live_tets() {
|
||
assert_eq!(cx.orient(vs).unwrap(), crate::predicates::Sign::Positive);
|
||
}
|
||
}
|
||
|
||
mod pipeline {
|
||
use super::super::geometry::AnalyticSurface;
|
||
use super::super::{Order, QualityOptions, quality_mesh};
|
||
use crate::cdt::tests::{cube, surface, uv_sphere};
|
||
use crate::cdt::{CdtOptions, tetrahedralize};
|
||
use crate::surface::{BoundarySurface, SurfaceOptions};
|
||
|
||
/// A 10 mm cube with one B-rep face per side.
|
||
fn box_surface() -> BoundarySurface {
|
||
let (p, t) = cube();
|
||
let p: Vec<[f64; 3]> = p.iter().map(|c| c.map(|x| 10.0 * x)).collect();
|
||
let s = surface(&p, &t, [5.0; 3]);
|
||
// One face tag per side: the side's axis and end.
|
||
let faces: Vec<u32> = s
|
||
.triangles()
|
||
.iter()
|
||
.map(|t| {
|
||
let c = t.map(|v| s.points()[v as usize]);
|
||
(0..3).find_map(|k| [0.0, 10.0].iter().position(|&x| c.iter().all(|q| q[k] == x)).map(|e| (2 * k + e) as u32)).unwrap()
|
||
})
|
||
.collect();
|
||
BoundarySurface::new(s.points(), s.triangles(), &faces, &SurfaceOptions::default()).unwrap()
|
||
}
|
||
|
||
/// A point of a side's plane past the side's edge is off the face, however large the side's
|
||
/// triangles: the fillet box's nodes landed on the untrimmed planes, keeping the sharp
|
||
/// corners (#402, #418).
|
||
#[test]
|
||
fn a_plane_is_trimmed_to_its_face() {
|
||
let s = box_surface();
|
||
let analytic = (0..6)
|
||
.map(|f: usize| {
|
||
let (k, e) = (f / 2, f % 2);
|
||
let mut normal = [0.0; 3];
|
||
normal[k] = if e == 0 { -1.0 } else { 1.0 };
|
||
let mut point = [0.0; 3];
|
||
point[k] = 10.0 * e as f64;
|
||
Some(crate::tet::geometry::AnalyticSurface::Plane { normal, point })
|
||
})
|
||
.collect();
|
||
let t = crate::tet::geometry::Tessellation::new(&s, analytic);
|
||
let q = t.project_trimmed(0, [0.5, 11.0, 5.0]).unwrap();
|
||
assert!(crate::vec3::dist(q, [0.0, 10.0, 5.0]) < 1e-9, "{q:?}");
|
||
let q = t.project_trimmed(0, [0.5, 9.0, 5.0]).unwrap();
|
||
assert!(crate::vec3::dist(q, [0.0, 9.0, 5.0]) < 1e-9, "{q:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_box_is_refined_improved_and_deterministic() {
|
||
let s = box_surface();
|
||
let cdt = tetrahedralize(&s, &CdtOptions::default()).unwrap();
|
||
let o = QualityOptions { size: Some(2.5), ..QualityOptions::default() };
|
||
let a = quality_mesh(&s, &cdt, Vec::new(), &o).unwrap();
|
||
let r = &a.report;
|
||
assert!(r.output.tets > 100, "{r:?}");
|
||
assert_eq!(r.output.inadmissible, 0);
|
||
assert_eq!(r.output.slivers, 0, "{r:?}");
|
||
assert!(r.output.min_dihedral > 25.0 && r.output.max_dihedral < 155.0, "{r:?}");
|
||
// Flat faces: the volume is the box's, and each side keeps its tag on its own plane.
|
||
assert!((r.volume - 1000.0).abs() < 1e-9, "{}", r.volume);
|
||
for b in &a.boundary {
|
||
let t: [u32; 4] = a.elements[b.tet as usize].clone().try_into().unwrap();
|
||
let f = super::super::complex::face_toward(t, b.opposite as usize).map(|v| a.points[v as usize]);
|
||
let (k, end) = ((b.face / 2) as usize, if b.face % 2 == 0 { 0.0 } else { 10.0 });
|
||
assert!(f.iter().all(|p| p[k] == end), "face {} at {f:?}", b.face);
|
||
}
|
||
// The same input gives the same mesh, bit for bit.
|
||
let b = quality_mesh(&s, &cdt, Vec::new(), &o).unwrap();
|
||
assert_eq!(a, b);
|
||
}
|
||
|
||
/// Refinement splitting a face edge whose midpoint lies inside a feature edge's diametral
|
||
/// sphere splits the feature edge instead (#303): otherwise each split halves the distance
|
||
/// of the face vertices to the curve and they pile up against it.
|
||
#[test]
|
||
fn a_face_edge_split_that_encroaches_a_curve_splits_the_curve() {
|
||
use super::super::complex::{NONE, VertexKind, face_toward};
|
||
use super::super::geometry::Tessellation;
|
||
use super::super::ops::{Site, insert_delaunay};
|
||
use super::super::refine::{Context, MAX_CAVITY, split_edge};
|
||
use super::super::{complex_from_cdt, measure};
|
||
use crate::predicates::Point3;
|
||
use crate::size::UniformSize;
|
||
// Whether `p` lies in triangle `f` of the z = 0 plane.
|
||
let contains = |f: [[f64; 3]; 3], p: [f64; 3]| {
|
||
let side = |a: [f64; 3], b: [f64; 3]| (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
|
||
let s = [side(f[0], f[1]), side(f[1], f[2]), side(f[2], f[0])];
|
||
s.iter().all(|&x| x >= 0.0) || s.iter().all(|&x| x <= 0.0)
|
||
};
|
||
let s = box_surface();
|
||
let cdt = tetrahedralize(&s, &CdtOptions::default()).unwrap();
|
||
let (mut cx, curve_faces) = complex_from_cdt(&s, &cdt, &QualityOptions::default()).unwrap();
|
||
let (geometry, size) = (Tessellation::new(&s, Vec::new()), UniformSize(5.0));
|
||
let ctx = Context { size: &size, geometry: &geometry, curve_faces: &curve_faces };
|
||
// A curve edge on the z = 0 side, and a face vertex beside it on that side.
|
||
let ((a, b), _) = cx.curve_edges().into_iter().find(|&((a, b), _)| [a, b].iter().all(|&v| cx.xyz(v).unwrap()[2] == 0.0)).unwrap();
|
||
let (xa, xb) = (cx.xyz(a).unwrap(), cx.xyz(b).unwrap());
|
||
let len = measure::dist(xa, xb);
|
||
let centre = [5.0, 5.0, 0.0];
|
||
let mid = measure::mid(xa, xb);
|
||
let inward = measure::scale(measure::sub(centre, mid), 0.3 * len / measure::dist(centre, mid));
|
||
let q = Point3::try_from(measure::add(mid, inward)).unwrap();
|
||
let (t, k) = cx
|
||
.live_tets()
|
||
.flat_map(|(t, vs)| (0..4).map(move |k| (t, vs, k)))
|
||
.find(|&(t, vs, k)| {
|
||
cx.adj(t).unwrap()[k] == NONE && cx.tags(t).unwrap()[k] == 4 && contains(face_toward(vs, k).map(|v| cx.xyz(v).unwrap()), q.coords())
|
||
})
|
||
.map(|(t, _, k)| (t, k))
|
||
.unwrap();
|
||
let v = insert_delaunay(&mut cx, q, VertexKind::Face(4), Site::Face(t, k), MAX_CAVITY).unwrap().unwrap();
|
||
assert!(cx.edge_tet(v, a).unwrap().is_some());
|
||
let w = split_edge(&mut cx, &ctx, v, a, 4, 0.0).unwrap().unwrap();
|
||
assert!(matches!(cx.kind(w), VertexKind::Curve(_)), "{:?}", cx.kind(w));
|
||
assert!(measure::dist(cx.xyz(w).unwrap(), mid) < 1e-9);
|
||
cx.validate().unwrap();
|
||
}
|
||
|
||
#[test]
|
||
fn a_seeded_edge_gets_the_seeded_spacing_and_the_size_grows_from_it() {
|
||
use crate::seeds::EdgeSeed;
|
||
use fieldcraft_model::SeedConstraint;
|
||
let s = box_surface();
|
||
let cdt = tetrahedralize(&s, &CdtOptions::default()).unwrap();
|
||
let edge = vec![[0.0, 0.0, 0.0], [10.0, 0.0, 0.0]];
|
||
let seed = EdgeSeed { name: "front".into(), points: edge, tolerance: 0.0, count: 16, bias: None, constraint: SeedConstraint::Exact };
|
||
let plain = QualityOptions { size: Some(5.0), seeds: vec![EdgeSeed { count: 1, ..seed.clone() }], ..QualityOptions::default() };
|
||
let seeded = QualityOptions { seeds: vec![seed], ..plain.clone() };
|
||
let a = quality_mesh(&s, &cdt, Vec::new(), &plain).unwrap();
|
||
let b = quality_mesh(&s, &cdt, Vec::new(), &seeded).unwrap();
|
||
let (na, nb) = (a.report.seeds[0].2, b.report.seeds[0].2);
|
||
// Unseeded, the 10 mm edge gets about two 5 mm elements; seeded, about sixteen.
|
||
assert!(na <= 4, "{na}");
|
||
assert_eq!(nb, 16);
|
||
assert_eq!(b.report.seeds[0].1, 16);
|
||
assert!(b.report.output.tets > a.report.output.tets && b.report.output.inadmissible == 0);
|
||
// Biased: the mesh's nodes on the edge are the seed's.
|
||
let bias = Some(fieldcraft_model::Bias { ratio: 4.0, toward: fieldcraft_model::BiasToward::Start });
|
||
let biased = QualityOptions { seeds: vec![EdgeSeed { count: 8, bias, ..seeded.seeds[0].clone() }], ..plain.clone() };
|
||
let c = quality_mesh(&s, &cdt, Vec::new(), &biased).unwrap();
|
||
let mut x: Vec<f64> = c.points.iter().filter(|p| p[1].abs() < 1e-9 && p[2].abs() < 1e-9).map(|p| p[0]).collect();
|
||
x.sort_by(f64::total_cmp);
|
||
let want: Vec<f64> = biased.seeds[0].fractions(8, false).iter().map(|f| 10.0 * f).collect();
|
||
assert_eq!(x.len(), want.len(), "{x:?}");
|
||
assert!(x.iter().zip(&want).all(|(a, b)| (a - b).abs() < 1e-9), "{x:?} {want:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_sphere_keeps_its_boundary_on_the_sphere_to_second_order() {
|
||
let (p, t) = uv_sphere(10, 20);
|
||
let p: Vec<[f64; 3]> = p.iter().map(|c| c.map(|x| 5.0 * x)).collect();
|
||
let s = surface(&p, &t, [0.0; 3]);
|
||
let faces = vec![0u32; s.triangles().len()];
|
||
let s = BoundarySurface::new(s.points(), s.triangles(), &faces, &SurfaceOptions::default()).unwrap();
|
||
let cdt = tetrahedralize(&s, &CdtOptions::default()).unwrap();
|
||
let sphere = vec![Some(AnalyticSurface::Sphere { center: [0.0; 3], radius: 5.0 })];
|
||
let o = QualityOptions { size: Some(1.5), order: Order::Quadratic, ..QualityOptions::default() };
|
||
let m = quality_mesh(&s, &cdt, sphere, &o).unwrap();
|
||
assert_eq!(m.kind, fieldcraft_model::ElementKind::Tet10);
|
||
assert_eq!(m.report.straightened, 0);
|
||
// Every node of a boundary face, corners and mid-edge nodes, lies on the sphere.
|
||
let mut on = 0;
|
||
for b in &m.boundary {
|
||
let e = &m.elements[b.tet as usize];
|
||
let k = b.opposite as usize;
|
||
let corners: Vec<usize> = (0..4).filter(|&i| i != k).collect();
|
||
let mids =
|
||
[(0, 1), (1, 2), (2, 0), (0, 3), (1, 3), (2, 3)].iter().enumerate().filter(|(_, (i, j))| *i != k && *j != k).map(|(n, _)| 4 + n);
|
||
for i in corners.into_iter().chain(mids) {
|
||
let q = m.points[e[i] as usize];
|
||
let r = (q[0] * q[0] + q[1] * q[1] + q[2] * q[2]).sqrt();
|
||
assert!((r - 5.0).abs() < 1e-9, "a boundary node {i} of {e:?} at {q:?}, radius {r}; report {:?}", m.report);
|
||
on += 1;
|
||
}
|
||
}
|
||
assert!(on > 0);
|
||
assert!(m.report.output.min_dihedral > 15.0, "{:?}", m.report.output);
|
||
// Every element passes the certified check of the gate.
|
||
for e in &m.elements {
|
||
let xyz: Vec<[f64; 3]> = e.iter().map(|&v| m.points[v as usize]).collect();
|
||
let v = crate::quality::element_validity(fieldcraft_model::ElementKind::Tet10, &xyz).unwrap();
|
||
assert_eq!(v.validity, crate::quality::Validity::Valid);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn caps_stop_the_stage_without_panicking() {
|
||
let s = box_surface();
|
||
let cdt = tetrahedralize(&s, &CdtOptions::default()).unwrap();
|
||
for o in [
|
||
QualityOptions { size: Some(1e-3), max_points: 200, ..QualityOptions::default() },
|
||
QualityOptions { size: Some(0.5), max_tets: 500, ..QualityOptions::default() },
|
||
QualityOptions { size: Some(f64::NAN), ..QualityOptions::default() },
|
||
QualityOptions { size: Some(-1.0), ..QualityOptions::default() },
|
||
] {
|
||
match quality_mesh(&s, &cdt, Vec::new(), &o) {
|
||
Ok(m) => assert!(!m.report.stopped.is_empty(), "{:?}", m.report),
|
||
Err(e) => assert!(matches!(e, crate::Error::Limit(_) | crate::Error::Invalid(_)), "{e}"),
|
||
}
|
||
}
|
||
}
|
||
}
|