SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Edge division: evaluate each point once (#1560)
rlartotdaf618c34440
diff --git a/crates/kernel/src/edge_polyline_tests.rs b/crates/kernel/src/edge_polyline_tests.rsnew file mode 100644index 0000000000..88d068e9df--- /dev/null+++ b/crates/kernel/src/edge_polyline_tests.rs@@ -0,0 +1,159 @@+//! The vendored edge division evaluates each parameter once (the ends of a piece are carried+//! along, its midpoint is the probe and an end of both halves). Regressions against the division+//! as it was, which evaluated both ends of every piece again: the polylines must be the same, bit+//! for bit, including the fallbacks for samples that do not evaluate.+#![allow(clippy::unwrap_used, clippy::panic)]+use std::sync::Arc;+use std::sync::atomic::{AtomicUsize, Ordering};++use solidcraft_geom::Vec3;+use truck_meshalgo::prelude::PolylineCurve;+use truck_meshalgo::tessellation::{Deflection, TrySubs, bounded_polyline};+use truck_modeling::{BoundedCurve, Curve, EuclideanSpace, MetricSpace, ParameterDivision1D, ParameterRange, ParametricCurve, Point3, Vector3};++use crate::*;++/// A curve that counts its evaluations.+#[derive(Clone)]+struct Counted {+ curve: Curve,+ calls: Arc<AtomicUsize>,+}++impl Counted {+ fn new(curve: &Curve) -> Self {+ Counted { curve: curve.clone(), calls: Arc::default() }+ }++ fn calls(&self) -> usize {+ self.calls.load(Ordering::Relaxed)+ }+}++impl ParametricCurve for Counted {+ type Point = Point3;+ type Vector = Vector3;+ fn subs(&self, t: f64) -> Point3 {+ self.calls.fetch_add(1, Ordering::Relaxed);+ self.curve.subs(t)+ }+ fn der(&self, t: f64) -> Vector3 {+ self.curve.der(t)+ }+ fn der2(&self, t: f64) -> Vector3 {+ self.curve.der2(t)+ }+ fn parameter_range(&self) -> ParameterRange {+ self.curve.parameter_range()+ }+ fn period(&self) -> Option<f64> {+ self.curve.period()+ }+}++impl BoundedCurve for Counted {}++/// The division samples through `TrySubs`: count those evaluations.+impl TrySubs for Counted {+ fn try_subs(&self, t: f64) -> Option<Point3> {+ self.calls.fetch_add(1, Ordering::Relaxed);+ TrySubs::try_subs(&self.curve, t)+ }+ fn approx_subs(&self, t: f64) -> Point3 {+ self.calls.fetch_add(1, Ordering::Relaxed);+ TrySubs::approx_subs(&self.curve, t)+ }+}++impl ParameterDivision1D for Counted {+ type Point = Point3;+ fn parameter_division(&self, range: (f64, f64), tol: f64) -> (Vec<f64>, Vec<Point3>) {+ self.curve.parameter_division(range, tol)+ }+}++/// `bounded_polyline` before it carried the end points: 4 evaluations per piece (both ends, the+/// probe and the midpoint), with the same fallbacks for samples that do not evaluate.+fn reference(curve: &Counted, range: (f64, f64), d: Deflection) -> PolylineCurve<Point3> {+ const MAX_EDGE_POINTS: usize = 20_000;+ let (tol, turn2) = (d.chord, d.turn2());+ let end = |t: f64| curve.try_subs(t).unwrap_or_else(|| curve.approx_subs(t));+ let probe = |t: f64| curve.try_subs(t).unwrap_or(Point3::new(f64::NAN, f64::NAN, f64::NAN));+ let mut out = vec![end(range.0)];+ let mut stack: Vec<(f64, f64, usize)> = vec![(range.0, range.1, 0)];+ while let Some((a, b, depth)) = stack.pop() {+ let (pa, pb) = (end(a), end(b));+ let t = a + (b - a) * 0.4729;+ let chord = pa + (pb - pa) * 0.4729;+ let d2 = probe(t).distance2(chord);+ let tm = 0.5 * (a + b);+ let dm = probe(tm).distance2(pa.midpoint(pb));+ let flat = !(d2 >= tol * tol || dm >= tol * tol);+ let flat = flat && !d.turns(turn2, d2.max(dm), pa.distance2(pb));+ if flat || depth >= 24 || out.len() + stack.len() >= MAX_EDGE_POINTS {+ out.push(pb);+ } else {+ stack.push((tm, b, depth + 1));+ stack.push((a, tm, depth + 1));+ }+ }+ PolylineCurve(out)+}++/// Divides `curve` both ways and checks the points, their order and the evaluations; returns+/// the polyline.+fn same_division(curve: &Curve, d: Deflection) -> Vec<Point3> {+ let range = curve.range_tuple();+ let (before, after) = (Counted::new(curve), Counted::new(curve));+ let old = reference(&before, range, d).0;+ let new = bounded_polyline(&after, range, d).0;+ let bits = |p: &Point3| [p.x.to_bits(), p.y.to_bits(), p.z.to_bits()];+ assert_eq!(old.len(), new.len(), "{d:?}");+ for (i, (p, q)) in old.iter().zip(&new).enumerate() {+ assert_eq!(bits(p), bits(q), "point {i} of {}: {p:?} before, {q:?} now ({d:?})", new.len());+ }+ // Every piece is kept (one point) or halved: n points come from 2n - 3 pieces.+ let pieces = 2 * new.len() - 3;+ assert_eq!(before.calls(), 1 + 4 * pieces);+ assert_eq!(after.calls(), 2 + 2 * pieces);+ new+}++/// The chord tolerance alone (booleans), then with the display's facet angle.+fn deflections(tol: f64) -> [Deflection; 2] {+ [Deflection::chord(tol), Deflection { chord: tol, angle: DISPLAY_ANGLE, floor: tol * 0.05, rulings: true }]+}++#[test]+fn intersection_curves_of_a_drilled_cylinder_divide_as_before() {+ // The radial hole of a clamping hub: both cylinders are NURBS, so each point of the edges+ // is two grid searches.+ let hub = cylinder(Vec3::new(0.0, 0.0, -10.0), Vec3::Z, 8.0, 20.0).unwrap();+ let drill = cylinder(Vec3::new(-12.0, 0.0, 1.5), Vec3::X, 1.25, 24.0).unwrap();+ let drilled = boolean(&hub, &drill, BoolOp::Cut).unwrap().unwrap();+ let curves: Vec<Curve> = drilled.solid.edge_iter().map(|e| e.curve()).filter(|c| matches!(c, Curve::IntersectionCurve(_))).collect();+ assert!(curves.len() >= 2, "{} intersection curves", curves.len());+ // One curve with each deflection (each division takes about half a second here).+ for (curve, d) in curves.iter().zip(deflections(0.01)) {+ let points = same_division(curve, d);+ assert!(points.len() > 8, "{} points ({d:?})", points.len());+ // On the drill's wall.+ for p in &points {+ let r = (p.y * p.y + (p.z - 1.5) * (p.z - 1.5)).sqrt();+ assert!((r - 1.25).abs() < 1e-3, "{p:?} at {r} from the drill's axis");+ }+ }+}++#[test]+fn circle_divides_as_before() {+ let body = cylinder(Vec3::ZERO, Vec3::Z, 5.0, 10.0).unwrap();+ let circle = body.solid.edge_iter().map(|e| e.curve()).find(|c| !matches!(c, Curve::Line(_))).unwrap();+ for d in deflections(0.001) {+ let points = same_division(&circle, d);+ assert!(points.len() > 18, "{} points ({d:?})", points.len());+ for p in &points {+ assert!(((p.x * p.x + p.y * p.y).sqrt() - 5.0).abs() < 1e-9, "{p:?}");+ }+ }+}diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex 46c4a087fa..77ae5f6e73 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -30,6 +30,8 @@ mod clearance;mod coplanar;mod curveblend;mod delete_face;+#[cfg(test)]+mod edge_polyline_tests;mod emboss;mod face_params;#[cfg(test)]diff --git a/docs/perf.md b/docs/perf.mdindex ad0cd72743..cd6f35c9aa 100644--- a/docs/perf.md+++ b/docs/perf.md@@ -1,5 +1,54 @@# Design loading+## Edges made by booleans: each point evaluated once (2026-10-16)++A boolean meshes both operands with truck-meshalgo, which first divides every edge into a+polyline (`bounded_polyline`, vendored). An edge that an earlier boolean made is an+intersection curve. Each of its points is found by a grid search on each of the two surfaces,+51 × 51 evaluations of a NURBS surface each, before Newton. The division evaluated both ends of+every piece again, so 2 of its 4 evaluations per piece repeated a point it already had.+Profiles of `main` (01b1b705) on the machine below put the division at 42 % of the CPU time+of opening the rover, 58 % of `bench-agent` and 82-85 % of a drilled hub or a union of tubes.++Each piece now carries the points of its ends, and its midpoint is both the probe and an end of+both halves: 2 evaluations per piece. The fallbacks for samples that do not evaluate (#1364) are+kept: a midpoint that fails is NaN as a probe and the curve's approximation as an end, exactly as+before. The polyline is the same, bit for bit: `edge_polyline_tests` compares it with the+previous division (points, order and number of evaluations) on the intersection curves of a+drilled cylinder and on a circle.++Release `solidcraft-cli` from `main` (73493b94) and the same with the change, 3 alternating+pairs (before/after, after/before, before/after), each run a new process timed with+`/usr/bin/time -v`, started once the 1-minute load average was below 2.5. Medians, with the+range of the 3 runs. 2018 laptop: Intel Core i7-8565U (4 cores / 8 threads, 15 W), 7.4 GB,+Ubuntu (Linux 7.0), on mains power:++| Run | Evaluation | Meshes | Wall time | CPU time | Peak RSS |+|---|---:|---:|---:|---:|---:|+| `bench-open`, `examples/acceptance/sensor_enclosure.json` | 3,203 → 3,089 ms | 6 → 6 ms | 3.2 → 3.1 s | 8.7 → 8.5 s | 91 → 91 MB |+| `bench-open`, a hub barrel with one radial hole cut through it | 966 → 817 ms | 878 → 481 ms | 1.9 → 1.4 s (-24 %) | 4.4 → 2.8 s (-37 %) | 27 → 30 MB |+| `bench-open`, the frame of the `bench-agent` bicycle (one union of tilted tubes) | 8,204 → 6,277 ms | 1,711 → 893 ms | 9.9 → 7.2 s (-28 %) | 33.3 → 20.6 s (-38 %) | 44 → 46 MB |+| `bench-open`, a rover (3,324 features, 1,395 bodies) | 26,783 → 22,792 ms | 7,960 → 6,046 ms | 35.7 → 29.8 s (-17 %) | 129.0 → 101.9 s (-21 %) | 2,076 → 2,079 MB |+| `bench-agent` (build 33.5 → 30.2 s, -10 %) | 10,553 → 8,565 ms | 2,778 → 2,081 ms | 47.6 → 41.1 s (-14 %) | 124.0 → 91.0 s (-27 %) | 1,428 → 1,432 MB |++`bench-agent`'s evaluation and meshes are those of reopening the saved design. CPU time is the+steadier measure on this 15 W processor: its before and after ranges are apart for the four+cases with boolean edges (the hub 3.0-4.4 s before, 2.5-2.9 s after; the rover 113.6-133.5 s,+101.0-102.5 s), while the first pair's "before" run, which started on a cool processor, overlaps+the "after" wall times of the two short cases. The sensor enclosure does not change: its time goes+to grid searches in face meshing, which this does not touch. An earlier series on `main`+(8535d229), on a quieter machine, gave -38 %, -35 %, -18 % and -16 % of wall time for the same+four cases. The CPU time saved is close to half the division's share in the profile. The mesh+phase gains as well, so these display meshes also call the reference mesher somewhere (where is+not traced here; `tess::edges`, the display plans' own edge division, already evaluated each+point once). In the rover, the second shell (which names every body's faces, so meshes them all)+goes from 7.8 s to 5.7 s.++No model changed. `solidcraft-cli eval` of the five designs (the bicycle as `bench-agent` saved+it) is the same with both binaries apart from the per-feature milliseconds: bodies, volumes,+areas, centres, bounding boxes, topology counts and warnings. `bench-open` meshes the same+triangle counts, and the bicycles both binaries save differ only in the document's name.+## STEP assemblies: a repeated part is meshed once (2026-10-14)The reader already converts each B-rep item once and keeps it for the instances that list itdiff --git a/vendor/README.md b/vendor/README.mdindex eff274ac77..62cd65e60d 100644--- a/vendor/README.md+++ b/vendor/README.md@@ -108,6 +108,11 @@ Changes:point that does not evaluate counts as flat instead of recursing). Surface grids refine onlythe direction that bends, and a ruling left undivided gets cells comparable to the otherdirection (long triangles from a trim loop to the grid's far ends cut through cylinders).+- `tessellation/triangulation.rs`: an edge's division evaluates each parameter once. A piece+ carries the points of its ends and its midpoint is an end of both halves: 2 evaluations per+ piece instead of 4, and the same polyline (a point of an intersection curve costs two grid+ searches of its surfaces). `bounded_polyline` and `Deflection::turn2`/`turns` are public but+ hidden, for the kernel's regression against the old division.- `tessellation/mod.rs`, `tessellation/triangulation.rs`, for display: a `Deflection` is thechord tolerance plus an optional bound on the angle one facet spans, and`RoundMeshableShape::robust_triangulation_within` divides by it: an edge or a grid directiondiff --git a/vendor/truck-meshalgo/src/tessellation/mod.rs b/vendor/truck-meshalgo/src/tessellation/mod.rsindex f9d64f02ae..1bcfd8a71a 100644--- a/vendor/truck-meshalgo/src/tessellation/mod.rs+++ b/vendor/truck-meshalgo/src/tessellation/mod.rs@@ -25,6 +25,13 @@ pub fn preview_face<S: RobustMeshableSurface>(surface: &S, loops: &[Vec<Point3>]triangulation::preview_face(surface, loops, steps)}+/// SolidCraft: an edge's polyline as the meshers divide it (at most 20 000 points). Exposed for+/// the kernel's regressions in the workspace CI.+#[doc(hidden)]+pub fn bounded_polyline<C: PolylineableCurve>(curve: &C, range: (f64, f64), d: Deflection) -> PolylineCurve {+ triangulation::bounded_polyline(curve, range, d)+}+/// SolidCraft: sampling a curve that may fail to evaluate. truck's `IntersectionCurve::subs`/// unwraps the projection of its leader's point onto both surfaces, which does not converge/// everywhere; the mesher samples through this trait so that a failed sample is data, not a panic.@@ -145,8 +152,9 @@ impl Deflection {/// The squared sag over squared length above which a facet turns more than `angle`: a/// chord spanning `a` of a circle sags `tan(a / 4) / 2` of its length. Infinite without- /// an angle bound.- pub(super) fn turn2(&self) -> f64 {+ /// an angle bound. SolidCraft: public for the kernel's regressions.+ #[doc(hidden)]+ pub fn turn2(&self) -> f64 {match self.angular() && self.angle < std::f64::consts::PI {true => (f64::tan(self.angle / 4.0) / 2.0).powi(2),false => f64::INFINITY,@@ -154,8 +162,9 @@ impl Deflection {}/// Whether the angle bound splits a facet of squared sag `sag2` and squared length `len2`- /// (`turn2` from [`Deflection::turn2`]).- pub(super) fn turns(&self, turn2: f64, sag2: f64, len2: f64) -> bool {+ /// (`turn2` from [`Deflection::turn2`]). SolidCraft: public for the kernel's regressions.+ #[doc(hidden)]+ pub fn turns(&self, turn2: f64, sag2: f64, len2: f64) -> bool {turn2.is_finite() && sag2 > self.floor * self.floor && sag2 > turn2 * len2}}diff --git a/vendor/truck-meshalgo/src/tessellation/triangulation.rs b/vendor/truck-meshalgo/src/tessellation/triangulation.rsindex 773f8f41b7..3049e38934 100644--- a/vendor/truck-meshalgo/src/tessellation/triangulation.rs+++ b/vendor/truck-meshalgo/src/tessellation/triangulation.rs@@ -861,30 +861,34 @@ pub(super) fn face_cap(faces: usize) -> usize {/// bisection depth of 24; a midpoint that does not evaluate (NaN) counts as flat (truck's/// version recursed on it 100 levels deep, which never finishes). A piece within the chord/// tolerance is still halved while it turns more than the deflection's angle.-fn bounded_polyline<C: PolylineableCurve>(curve: &C, range: (f64, f64), d: Deflection) -> PolylineCurve {+pub(super) fn bounded_polyline<C: PolylineableCurve>(curve: &C, range: (f64, f64), d: Deflection) -> PolylineCurve {let (tol, turn2) = (d.chord, d.turn2());// A sample that does not evaluate (an intersection curve whose projection fails): an interval// end falls back to the curve's approximation so the polyline stays finite; an interior probe- // is NaN, which counts as flat.+ // is NaN, which counts as flat. Each parameter is evaluated once: a piece carries the points+ // of its ends, and its midpoint, an end of both halves, serves as probe and as end (a point of+ // an intersection curve costs two grid searches).let end = |t: f64| curve.try_subs(t).unwrap_or_else(|| curve.approx_subs(t));- let probe = |t: f64| curve.try_subs(t).unwrap_or(Point3::new(f64::NAN, f64::NAN, f64::NAN));- let mut out = vec![end(range.0)];- let mut stack: Vec<(f64, f64, usize)> = vec![(range.0, range.1, 0)];- while let Some((a, b, depth)) = stack.pop() {- let (pa, pb) = (end(a), end(b));+ let nan = Point3::new(f64::NAN, f64::NAN, f64::NAN);+ let (p0, p1) = (end(range.0), end(range.1));+ let mut out = vec![p0];+ let mut stack: Vec<(f64, f64, Point3, Point3, usize)> = vec![(range.0, range.1, p0, p1, 0)];+ while let Some((a, b, pa, pb, depth)) = stack.pop() {let t = a + (b - a) * 0.4729;let chord = pa + (pb - pa) * 0.4729;- let d2 = probe(t).distance2(chord);+ let d2 = curve.try_subs(t).unwrap_or(nan).distance2(chord);let tm = 0.5 * (a + b);- let dm = probe(tm).distance2(pa.midpoint(pb));+ let sm = curve.try_subs(tm);+ let dm = sm.unwrap_or(nan).distance2(pa.midpoint(pb));let flat = !(d2 >= tol * tol || dm >= tol * tol);let flat = flat && !d.turns(turn2, d2.max(dm), pa.distance2(pb));if flat || depth >= 24 || out.len() + stack.len() >= MAX_EDGE_POINTS {out.push(pb);} else {+ let pm = sm.unwrap_or_else(|| curve.approx_subs(tm));// Right half after the left one (stack order).- stack.push((tm, b, depth + 1));- stack.push((a, tm, depth + 1));+ stack.push((tm, b, pm, pb, depth + 1));+ stack.push((a, tm, pa, pm, depth + 1));}}PolylineCurve(out)