Merge develop 7c9e5ec6 into solidcore

This commit is contained in:
Brett Lawson committed 2026-10-30 16:47:18 +01:00
commit a0dfdeecaf
1 file changed
+95
+95
View File
@@ -241,6 +241,8 @@ fn classify(body: &Body, mesh: &Mesh, mut work: usize) -> (Vec<bool>, Vec<bool>)
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 };
@@ -251,6 +253,7 @@ fn classify(body: &Body, mesh: &Mesh, mut work: usize) -> (Vec<bool>, Vec<bool>)
} 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() };
@@ -266,9 +269,76 @@ fn classify(body: &Body, mesh: &Mesh, mut work: usize) -> (Vec<bool>, Vec<bool>)
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 {
@@ -359,6 +429,31 @@ mod tests {
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) {