Wave 335/509: Tessellation: the band beside a slit and the sag refinement keep the face on both sides of it (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - fcd5f7997 jyviko: Tessellation: a node lying on another chord is untangled like a crossing - 43ad9d0b0 jyviko: Tessellation: a slit (a side the loops run along both ways) bounds the face on neither side - 534dffa96 jyviko: Tessellation: the band beside a slit and the sag refinement keep the face on both sides of it - 7b984936a jyviko: kernel: an emboss's arcs run on their wall's own frame, and its seam is read from the circle's angles Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -9,7 +9,7 @@ use crate::numbered::NumberedRegion;
|
||||
use crate::offset::{Surf, face_edges, surf_of};
|
||||
use crate::{KernelError, Result, guard};
|
||||
use solidcraft_geom::brep::eval::CurveEval;
|
||||
use solidcraft_geom::brep::{Brep, Curve, Frame, Loop, Surface};
|
||||
use solidcraft_geom::brep::{Brep, Curve, Frame, Loop, Surface, form};
|
||||
use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
|
||||
|
||||
fn fail(s: &str) -> KernelError {
|
||||
@@ -40,10 +40,11 @@ fn wall_angles(b: &Brep, face: usize, o: Vec3, axis: Vec3, radial: Vec3, tangent
|
||||
if z.dot(axis).abs() < 1.0 - 1e-9 {
|
||||
continue;
|
||||
}
|
||||
// The circle's parameter is its angle: the wall spans the edge's interval about the
|
||||
// angle of its middle (a whole turn, from the seam, for a wall in one piece).
|
||||
let c = CurveEval::new(e.parameters()).ok()?;
|
||||
let [t0, t1] = e.interval;
|
||||
// The circle's parameter is its angle: the wall spans the edge's angles on the circle
|
||||
// (`interval` is on its NURBS form where it has one) about the angle of its middle (a
|
||||
// whole turn, from the seam, for a wall in one piece).
|
||||
let c = CurveEval::new(&e.curve).ok()?;
|
||||
let [t0, t1] = e.curve_interval()?;
|
||||
let am = angle(c.point(0.5 * (t0 + t1))?, o, axis, radial, tangent);
|
||||
let half = 0.5 * (t1 - t0);
|
||||
return Some((am - half, am + half));
|
||||
@@ -327,9 +328,12 @@ fn emboss_impl(body: &Body, anchor: Option<Vec3>, plane: &Plane, regions: &[Regi
|
||||
let at = o + axis * p.y + (radial * (p.x / r).cos() + tangent * (p.x / r).sin()) * r;
|
||||
return Ok(EmbossOutcome::Anchor(fi, at));
|
||||
}
|
||||
let wall = Wrap { o, axis, radial, tangent, r };
|
||||
let mut asm = Assembly::from_record(&rec)?;
|
||||
let selected = asm.faces.get_mut(fi).and_then(Option::take).ok_or_else(|| fail("face"))?;
|
||||
// The footprint's arcs lie on the wall face and are labelled on its frame, so their NURBS
|
||||
// forms run on the face's own quarter grid and their pcurves there are exact.
|
||||
let label = form::frame_of(&selected.surface);
|
||||
let wall = Wrap { o, axis, radial, tangent, r, label, tol };
|
||||
// The wall's pieces left around the footprints: the face itself, then one per profile
|
||||
// hole (the original radius inside it).
|
||||
let mut base_patches: Vec<Vec<Vec<AUse>>> = vec![selected.loops.clone()];
|
||||
@@ -416,6 +420,9 @@ struct Wrap {
|
||||
radial: Vec3,
|
||||
tangent: Vec3,
|
||||
r: f64,
|
||||
/// The wall face's own frame, which the arcs at its radius are labelled on.
|
||||
label: Option<Frame>,
|
||||
tol: f64,
|
||||
}
|
||||
|
||||
impl Wrap {
|
||||
@@ -441,7 +448,12 @@ impl Wrap {
|
||||
let (ta, tb) = (p.x / self.r, q.x / self.r);
|
||||
let forward = ta < tb;
|
||||
let (interval, ends) = if forward { ([ta, tb], (a, b)) } else { ([tb, ta], (b, a)) };
|
||||
Ok(AUse { edge: asm.edge(Curve::Circle { frame, radius }, interval, ends.0, ends.1)?, forward, given: None })
|
||||
let circle = Curve::Circle { frame, radius };
|
||||
let (circle, interval) = match &self.label {
|
||||
Some(label) if (radius - self.r).abs() <= self.tol => form::on_frame(&circle, interval, label, self.tol).unwrap_or((circle, interval)),
|
||||
_ => (circle, interval),
|
||||
};
|
||||
Ok(AUse { edge: asm.edge(circle, interval, ends.0, ends.1)?, forward, given: None })
|
||||
}
|
||||
|
||||
/// A profile loop wrapped onto the wall: its footprint at the wall's radius and its cap's
|
||||
|
||||
@@ -79,6 +79,16 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range<usize>
|
||||
index.entry(h).or_insert(u32::try_from(i).ok()?);
|
||||
handles.push(h);
|
||||
}
|
||||
// A side the loops run along both ways (a slit, where a face's boundary goes out along a
|
||||
// line its two sides share and back) bounds the face on neither.
|
||||
let mut sides: Vec<(FixedVertexHandle, FixedVertexHandle)> = Vec::new();
|
||||
for r in loops {
|
||||
let n = r.len();
|
||||
for k in 0..n {
|
||||
sides.push((*handles.get(r.start + k)?, *handles.get(r.start + (k + 1) % n)?));
|
||||
}
|
||||
}
|
||||
let slits = slits(&sides);
|
||||
for r in loops {
|
||||
let n = r.len();
|
||||
for k in 0..n {
|
||||
@@ -102,7 +112,7 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range<usize>
|
||||
}
|
||||
if let Some((sag, budget)) = &fill.refine {
|
||||
let constraints = cdt.num_constraints();
|
||||
let added = refine_sag(&mut cdt, sag, *budget, &from);
|
||||
let added = refine_sag(&mut cdt, sag, *budget, &from, &slits);
|
||||
if fill.shape {
|
||||
let params = RefinementParameters::<f64>::new()
|
||||
.keep_constraint_edges()
|
||||
@@ -115,7 +125,7 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range<usize>
|
||||
// Shaping flips sides and adds points of its own; the triangles it leaves may
|
||||
// sag again (a long strip round a cylinder), so the sag is checked once more.
|
||||
if shaped > 0 {
|
||||
refine_sag(&mut cdt, sag, budget.saturating_sub(added + shaped), &from);
|
||||
refine_sag(&mut cdt, sag, budget.saturating_sub(added + shaped), &from, &slits);
|
||||
}
|
||||
}
|
||||
// A split constraint would put a point on the boundary the neighbour does not have.
|
||||
@@ -125,7 +135,7 @@ pub(crate) fn triangulate(boundary: &[[f64; 2]], loops: &[std::ops::Range<usize>
|
||||
}
|
||||
let mut uv: Vec<[f64; 2]> = boundary.to_vec();
|
||||
let mut tris = Vec::new();
|
||||
let region = region(&cdt);
|
||||
let region = region(&cdt, &slits);
|
||||
for face in cdt.inner_faces() {
|
||||
if !region.get(face.index()).copied().unwrap_or(false) {
|
||||
continue;
|
||||
@@ -185,6 +195,8 @@ pub(crate) fn band(points: &[[f64; 2]], n: usize, loops: &[std::ops::Range<usize
|
||||
sides.push((add(&mut cdt, a)?, add(&mut cdt, b)?));
|
||||
}
|
||||
}
|
||||
// The band runs along both sides of a slit (see `triangulate`): its sides bound it on neither.
|
||||
let slits = slits(&sides);
|
||||
for &(a, b) in stairs {
|
||||
sides.push((add(&mut cdt, a)?, add(&mut cdt, b)?));
|
||||
}
|
||||
@@ -197,7 +209,7 @@ pub(crate) fn band(points: &[[f64; 2]], n: usize, loops: &[std::ops::Range<usize
|
||||
}
|
||||
cdt.add_constraint(a, b);
|
||||
}
|
||||
let region = region(&cdt);
|
||||
let region = region(&cdt, &slits);
|
||||
let mut tris = Vec::new();
|
||||
for face in cdt.inner_faces() {
|
||||
if !region.get(face.index()).copied().unwrap_or(false) {
|
||||
@@ -216,7 +228,14 @@ pub(crate) fn band(points: &[[f64; 2]], n: usize, loops: &[std::ops::Range<usize
|
||||
/// the tolerance from the triangle or whose corner normals turn more than the facet angle, and
|
||||
/// under the middle of every non-constraint side that sags more than the tolerance or is
|
||||
/// longer than [`LONG`] times `h`, until none does or `budget` points were added. Returns the points added.
|
||||
fn refine_sag(cdt: &mut Cdt, sag: &Sag, budget: usize, from: &dyn Fn(Point2<f64>) -> [f64; 2]) -> usize {
|
||||
/// `slits`: constraint sides the loops run along both ways, inside the region on both sides.
|
||||
fn refine_sag(
|
||||
cdt: &mut Cdt,
|
||||
sag: &Sag,
|
||||
budget: usize,
|
||||
from: &dyn Fn(Point2<f64>) -> [f64; 2],
|
||||
slits: &std::collections::HashSet<(FixedVertexHandle, FixedVertexHandle)>,
|
||||
) -> usize {
|
||||
let mut added = 0;
|
||||
let mut cache: HashMap<FixedVertexHandle, Option<(Vec3, Option<Vec3>)>> = HashMap::new();
|
||||
// The widest turn between two corner normals.
|
||||
@@ -232,7 +251,7 @@ fn refine_sag(cdt: &mut Cdt, sag: &Sag, budget: usize, from: &dyn Fn(Point2<f64>
|
||||
(sag.eval)(q[0], q[1])
|
||||
})
|
||||
};
|
||||
let region = region(cdt);
|
||||
let region = region(cdt, slits);
|
||||
for face in cdt.inner_faces() {
|
||||
if !region.get(face.index()).copied().unwrap_or(false) {
|
||||
continue;
|
||||
@@ -304,18 +323,35 @@ fn refine_sag(cdt: &mut Cdt, sag: &Sag, budget: usize, from: &dyn Fn(Point2<f64>
|
||||
added
|
||||
}
|
||||
|
||||
/// The sides a boundary runs along an even number of times (a slit: out along a line and back),
|
||||
/// each as its vertices in index order: the region lies on both sides of them.
|
||||
fn slits(sides: &[(FixedVertexHandle, FixedVertexHandle)]) -> std::collections::HashSet<(FixedVertexHandle, FixedVertexHandle)> {
|
||||
let mut runs: HashMap<(FixedVertexHandle, FixedVertexHandle), usize> = HashMap::new();
|
||||
for &(a, b) in sides {
|
||||
if a != b {
|
||||
*runs.entry(if a.index() < b.index() { (a, b) } else { (b, a) }).or_insert(0) += 1;
|
||||
}
|
||||
}
|
||||
runs.into_iter().filter(|(_, n)| n % 2 == 0).map(|(e, _)| e).collect()
|
||||
}
|
||||
|
||||
/// Per face (by index): inside the region the constraint loops bound. A flood fill from the
|
||||
/// outer face that flips parity each time it crosses a constraint edge (holes are out), linear
|
||||
/// in the number of triangles.
|
||||
fn region(cdt: &Cdt) -> Vec<bool> {
|
||||
/// outer face that flips parity each time it crosses a constraint edge (holes are out), but for
|
||||
/// the sides in `slits` (run along both ways, the region on both sides), linear in the number of
|
||||
/// triangles.
|
||||
fn region(cdt: &Cdt, slits: &std::collections::HashSet<(FixedVertexHandle, FixedVertexHandle)>) -> Vec<bool> {
|
||||
use spade::handles::{FixedFaceHandle, InnerTag};
|
||||
let counts = |e: spade::handles::DirectedEdgeHandle<'_, _, _, _, _>| {
|
||||
let [a, b] = e.vertices().map(|v| v.fix());
|
||||
e.is_constraint_edge() && !slits.contains(&if a.index() < b.index() { (a, b) } else { (b, a) })
|
||||
};
|
||||
let mut parity: Vec<Option<bool>> = vec![None; cdt.num_all_faces()];
|
||||
let mut todo: Vec<(FixedFaceHandle<InnerTag>, bool)> = Vec::new();
|
||||
for e in cdt.convex_hull() {
|
||||
// Hull edges have the outer face on one side; the other side is an inner face.
|
||||
for side in [e, e.rev()] {
|
||||
if let Some(inner) = side.face().as_inner() {
|
||||
todo.push((inner.fix(), e.is_constraint_edge()));
|
||||
todo.push((inner.fix(), counts(e)));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -326,7 +362,7 @@ fn region(cdt: &Cdt) -> Vec<bool> {
|
||||
}
|
||||
for e in cdt.face(h).adjacent_edges() {
|
||||
if let Some(next) = e.rev().face().as_inner() {
|
||||
todo.push((next.fix(), odd ^ e.is_constraint_edge()));
|
||||
todo.push((next.fix(), odd ^ counts(e)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1133,7 +1133,8 @@ fn graded(a: [f64; 2], b: [f64; 2], sa: f64, sb: f64, h: f64, speed: [f64; 2], f
|
||||
all.into_iter().filter(|t| *t > 0.0 && *t < 1.0).collect()
|
||||
}
|
||||
|
||||
/// Every boundary segment (consecutive nodes of a loop) is the side of exactly one triangle:
|
||||
/// Every boundary segment (consecutive nodes of a loop) is the side of exactly one triangle (two
|
||||
/// for a slit the loops run along both ways):
|
||||
/// the face covers its boundary with nothing missing or doubled, so it meets its neighbours
|
||||
/// exactly. Some boundary nodes are one vertex, a side ending on any of them the same side: pole
|
||||
/// copies of one node (consecutive in a loop, at one point, the segment between them of no
|
||||
@@ -1186,12 +1187,19 @@ fn closed_boundary(ranges: &[std::ops::Range<usize>], fixed: &[Vec3], uvs: &[[f6
|
||||
}
|
||||
}
|
||||
}
|
||||
ranges.iter().all(|r| {
|
||||
(0..r.len()).all(|k| {
|
||||
// Each boundary side has a triangle for every time the loops run along it: one, or two for
|
||||
// a slit (a side run out and back, where the face meets itself along a line: a hole's wall
|
||||
// touching the wall round it), one triangle either side.
|
||||
let mut runs: HashMap<(u32, u32), u32> = HashMap::new();
|
||||
for r in ranges {
|
||||
for k in 0..r.len() {
|
||||
let (a, b) = segment(r, k);
|
||||
side(a, b).is_none_or(|k| sides.get(&k).copied() == Some(1))
|
||||
})
|
||||
})
|
||||
if let Some(k) = side(a, b) {
|
||||
*runs.entry(k).or_default() += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
runs.iter().all(|(k, n)| sides.get(k).copied() == Some(*n))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -95,6 +95,19 @@ pub(crate) fn crossing(s: &EvalSurface, reach: f64, loops: &[seam::Loop]) -> Vec
|
||||
out.push(x.at);
|
||||
out.push(y.at);
|
||||
}
|
||||
// A node of one chord lying on the other (inside it, not at its ends) is no crossing,
|
||||
// but no triangulation can keep both as constraints either: where two curves leave a
|
||||
// vertex they touch at along one tangent (a circle touching another from inside), the
|
||||
// inner one's node can fall on the outer one's chord (with the outer chord twice the
|
||||
// inner, exactly so but for the next order). The chord the node lies on is halved.
|
||||
// (Not where the two chords run along one line: a seam's two uses, a period apart,
|
||||
// lie on each other as copies.)
|
||||
if !along(x.a, x.b, y.a, y.b) && [y.a, y.b].iter().any(|q| on(x.a, x.b, *q)) {
|
||||
out.push(x.at);
|
||||
}
|
||||
if !along(y.a, y.b, x.a, x.b) && [x.a, x.b].iter().any(|q| on(y.a, y.b, *q)) {
|
||||
out.push(y.at);
|
||||
}
|
||||
}
|
||||
}
|
||||
out.sort_unstable();
|
||||
@@ -102,6 +115,28 @@ pub(crate) fn crossing(s: &EvalSurface, reach: f64, loops: &[seam::Loop]) -> Vec
|
||||
out
|
||||
}
|
||||
|
||||
/// Whether `q` lies on the segment `ab` within [`STRADDLE`] (of the segment's squared length,
|
||||
/// off its line) strictly between its ends (not at either, by the same measure along it).
|
||||
fn on(a: [f64; 2], b: [f64; 2], q: [f64; 2]) -> bool {
|
||||
let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
|
||||
let len2 = dx * dx + dy * dy;
|
||||
if !(len2 > 0.0) {
|
||||
return false;
|
||||
}
|
||||
let (qx, qy) = (q[0] - a[0], q[1] - a[1]);
|
||||
let off = (dx * qy - dy * qx).abs();
|
||||
let along = (dx * qx + dy * qy) / len2;
|
||||
off <= 1e3 * STRADDLE * len2 && along > 1e-6 && along < 1.0 - 1e-6
|
||||
}
|
||||
|
||||
/// Whether `c` and `d` both lie on the line of `ab` (within [`on`]'s measure).
|
||||
fn along(a: [f64; 2], b: [f64; 2], c: [f64; 2], d: [f64; 2]) -> bool {
|
||||
let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
|
||||
let len2 = dx * dx + dy * dy;
|
||||
let off = |q: [f64; 2]| (dx * (q[1] - a[1]) - dy * (q[0] - a[0])).abs();
|
||||
len2 > 0.0 && off(c) <= 1e3 * STRADDLE * len2 && off(d) <= 1e3 * STRADDLE * len2
|
||||
}
|
||||
|
||||
/// Whether the segments `ab` and `cd` cross: each one's ends strictly either side of the other.
|
||||
fn cross(a: [f64; 2], b: [f64; 2], c: [f64; 2], d: [f64; 2]) -> bool {
|
||||
let orient = |p: [f64; 2], q: [f64; 2], r: [f64; 2]| (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
|
||||
|
||||
@@ -669,6 +669,39 @@ fn loops_touching_at_a_shared_vertex_bound_the_face() {
|
||||
assert!(closed_boundary(&ranges, &fixed, &uvs, &triangles), "the triangles follow both holes through their shared vertex");
|
||||
}
|
||||
|
||||
/// A face meeting itself along a line (a hole's wall tangent inside the wall round it, cut from
|
||||
/// the boss side's top rim down to the hole's bottom): its loop runs up the slit and back down
|
||||
/// it, with the face on both sides. The iso-line grid's band beside the slit is the face on
|
||||
/// either side of it, and the triangles follow the slit both ways and cover the whole square.
|
||||
#[test]
|
||||
fn a_slit_in_a_trimmed_face_has_the_face_on_both_sides() {
|
||||
// The square [0, 8] × [0, 4], its loop starting at the slit's tip (3, 1) up to the top, round
|
||||
// the square and back down the slit.
|
||||
let mut uvs: Vec<[f64; 2]> = (1..=4).map(|k| [3.0, k as f64]).collect();
|
||||
uvs.extend((0..3).rev().map(|k| [k as f64, 4.0]));
|
||||
uvs.extend((0..4).rev().map(|k| [0.0, k as f64]));
|
||||
uvs.extend((1..=8).map(|k| [k as f64, 0.0]));
|
||||
uvs.extend((1..=4).map(|k| [8.0, k as f64]));
|
||||
uvs.extend((3..8).rev().map(|k| [k as f64, 4.0]));
|
||||
uvs.extend((2..4).rev().map(|k| [3.0, k as f64]));
|
||||
let fixed: Vec<Vec3> = uvs.iter().map(|q| Vec3::new(q[0], q[1], 0.0)).collect();
|
||||
let ranges = [std::ops::Range { start: 0, end: uvs.len() }];
|
||||
let traces = motorcycle::traces(&uvs, &ranges, [1.0, 1.0], 0.0);
|
||||
let lines = |n: usize, top: f64| (0..=n).map(|k| top * k as f64 / n as f64).collect::<Vec<f64>>();
|
||||
let Some((extra, triangles)) = cutgrid::cut_grid(&uvs, &ranges, &lines(16, 8.0), &lines(8, 4.0), &traces, [1.0, 1.0]) else { panic!("meshes") };
|
||||
assert!(closed_boundary(&ranges, &fixed, &uvs, &triangles), "the triangles follow the slit both ways");
|
||||
let mut all = uvs.clone();
|
||||
all.extend(extra);
|
||||
let area: f64 = triangles
|
||||
.iter()
|
||||
.map(|t| {
|
||||
let [a, b, c] = t.map(|i| all[i as usize]);
|
||||
0.5 * ((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]))
|
||||
})
|
||||
.sum();
|
||||
assert!((area - 32.0).abs() < 1e-12, "area {area}");
|
||||
}
|
||||
|
||||
/// A face whose loop is a thin lune meshes: a half disc of radius 2.5 less a circle through the
|
||||
/// same ends 0.03 mm inside it at the middle, its inner side split at 11.25°. Each edge is
|
||||
/// sampled to the 0.1 mm chord on its own: the outer arc's chords (every 22.5°) sag 0.048 mm,
|
||||
@@ -1001,3 +1034,22 @@ fn triangles_standing_across_a_curved_sheet_are_flipped_along_it() {
|
||||
assert!(sides.contains(&(2, 3)) && !sides.contains(&(0, 1)), "{tris:?}");
|
||||
assert!(after < 0.5 * before, "{before} -> {after}");
|
||||
}
|
||||
|
||||
/// A disc with a boss standing on it tangent inside its rim: the disc's top is a ring whose inner
|
||||
/// circle touches the outer one, one loop through the touching vertex. There both circles leave
|
||||
/// along one tangent, and with the outer chord twice the inner (as their samplings fall) the inner
|
||||
/// circle's first node lies on the outer's last chord: no triangulation keeps both. That chord is
|
||||
/// halved, and the ring meshes strictly, to its area (300 pi), not the inner disc's.
|
||||
#[test]
|
||||
fn a_ring_touching_itself_at_a_vertex_meshes_strictly() {
|
||||
use solidcraft_geom::{Loop2, Plane, Region2, Vec2};
|
||||
let prism = |c: Vec2, r: f64, z0: f64, z1: f64| {
|
||||
ok(crate::extrude(&Plane::XY, &[Region2 { outer: Loop2::circle(c, r), holes: vec![] }], z0, z1)).pop().unwrap()
|
||||
};
|
||||
let stepped =
|
||||
ok(crate::boolean(&prism(Vec2::ZERO, 20.0, 0.0, 5.0), &prism(Vec2::new(10.0, 0.0), 10.0, 5.0, 15.0), crate::BoolOp::Union)).unwrap();
|
||||
let (_, stats) = ok(plan(&record(&stepped), 1e-4, None));
|
||||
assert!(stats.lenient.is_empty(), "{:?}", stats.lenient.iter().map(|r| &r.reason).collect::<Vec<_>>());
|
||||
let ring = ok(stepped.faces(1e-4)).into_iter().find(|f| (f.centroid.z - 5.0).abs() < 1e-6).unwrap();
|
||||
assert!((ring.area - 300.0 * PI).abs() < 0.05, "ring area {}", ring.area);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user