SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
doc: keep a level piece's number when its centre's low bits move (#1073)
Yuu1e1722b7e152
diff --git a/crates/doc/src/naming.rs b/crates/doc/src/naming.rsindex b8848bf2fc..d5d2d473ab 100644--- a/crates/doc/src/naming.rs+++ b/crates/doc/src/naming.rs@@ -511,7 +511,22 @@ fn number_pieces(names: &mut [String], pts: &[Vec<Vec3>], mark: char) {}};let mut order = cs.clone();- order.sort_by(|a, b| key(a.1).partial_cmp(&key(b.1)).unwrap_or(std::cmp::Ordering::Equal));+ // Pieces lying almost level along the sort axis differ only in the last bits of their centre:+ // the centre is the mean of a tessellated boundary, and that depends on where the loop's+ // polyline starts, which can differ between processes. Comparing the keys with a tolerance+ // makes those pieces equal, so the stable sort keeps the order they arrived in and a name+ // keeps its number across runs (solidcraft#569). total_cmp keeps a NaN deterministic.+ let tol = ext.x.max(ext.y).max(ext.z).max(1.0) * 1e-9;+ let bucket = |c: Vec3| {+ let k = key(c);+ // Rounding onto the grid, rather than comparing with a tolerance, is what keeps this a+ // total order: `a` and `b` in one bucket and `b` and `c` in the next must not leave `a`+ // and `c` in different ones, or the sort has no order to work with. Since Rust 1.81+ // `sort_by` may panic on a comparator that is not one. Two pieces can still flip when+ // they straddle a bucket edge; that is the price of a key that ignores their low bits.+ ((k.0 / tol).round() as i64, (k.1 / tol).round() as i64, (k.2 / tol).round() as i64)+ };+ order.sort_by_key(|a| bucket(a.1));for (k, (j, _)) in order.iter().enumerate() {if let Some(slot) = names.get_mut(*j) {*slot = format!("{n}{mark}{}", k + 1);@@ -760,6 +775,45 @@ pub fn face_on_body(body: &ModelBody, name: &str, p: Vec3) -> Option<(usize, Vec#[cfg(test)]mod tests {+ /// Pieces lying almost level along the sort axis must keep the order they arrived in, whatever+ /// the low bits of their centres do. The centre is the mean of a tessellated boundary, so those+ /// bits depend on where the loop's polyline starts and can differ between processes — which is+ /// how a name's number used to swap between runs (solidcraft#569).+ #[test]+ fn level_pieces_keep_their_input_order() {+ let piece = |dx: f64| vec![Vec3::new(10.0 + dx, 0.0, 0.0), Vec3::new(10.0 + dx, 0.0, 5.0)];+ for (first, second) in [(0.0, 1e-12), (1e-12, 0.0)] {+ let mut names = vec!["f".to_string(), "f".to_string()];+ let pts = vec![piece(first), piece(second)];+ number_pieces(&mut names, &pts, '#');+ assert_eq!(names, vec!["f#1".to_string(), "f#2".to_string()], "input order not kept for {first} then {second}");+ }+ }++ /// Three pieces spaced just under the tolerance apart: `a` and `b` in one bucket and `b` and `c`+ /// in the next, so a tolerance comparison would call `a≈b` and `b≈c` while `a<c` — the+ /// non-transitivity that leaves `sort_by` without a total order to work with. The key must order+ /// them by bucket, and within a bucket by the order they arrived in.+ #[test]+ fn pieces_just_under_the_tolerance_apart_still_have_a_total_order() {+ let piece = |dx: f64| vec![Vec3::new(10.0 + dx, 0.0, 0.0), Vec3::new(10.0 + dx, 0.0, 5.0)];+ // The grid is the spread of the centres floored at 1e-9; these centres span under 1.0, so it+ // is 1e-9 and the three offsets below sit in buckets 0, 0 and 1.+ let grid = 1e-9;+ let step = grid * 0.4;+ for ((a, b, c), want) in [+ ((0.0, step, 2.0 * step), ["f#1", "f#2", "f#3"]),+ ((2.0 * step, step, 0.0), ["f#3", "f#1", "f#2"]),+ ((0.0, 2.0 * step, step), ["f#1", "f#3", "f#2"]),+ ((step, 0.0, 2.0 * step), ["f#1", "f#2", "f#3"]),+ ] {+ let mut names = vec!["f".to_string(); 3];+ let pts = [a, b, c].iter().map(|d| piece(*d)).collect::<Vec<_>>();+ number_pieces(&mut names, &pts, '#');+ assert_eq!(names, want, "wrong order for offsets {a} {b} {c}");+ }+ }+use super::*;/// A cone's tip repeats its apex vertex, so a triangle can have a zero-length edge. The nearest