SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: use a lookup map for curves in pattern upkeep (#10524)
kaltenbrunnermarkus71624cf7fa23
diff --git a/crates/sketch/examples/solve_bench.rs b/crates/sketch/examples/solve_bench.rsindex cf31f9c784..19ee338482 100644--- a/crates/sketch/examples/solve_bench.rs+++ b/crates/sketch/examples/solve_bench.rs@@ -6,7 +6,9 @@use std::time::Instant;use solidcraft_geom::Vec2;-use solidcraft_sketch::{Analysis, Budget, ConstraintKind, Hold, Sketch, SolveReport, solve, solve_with};+use solidcraft_sketch::{+ Analysis, Budget, ConstraintKind, Hold, PatternAlignment, Sketch, SketchPattern, SketchPatternKind, SolveReport, solve, solve_with,+};/// A small deterministic generator for the start offsets.struct Lcg(u64);@@ -66,6 +68,33 @@ fn strip(n: usize) -> Result<(Sketch, usize), Box<dyn std::error::Error>> {Ok((sk, bottom[0]))}+/// A slot (two arcs joined by two lines) copied `count` times around the origin by a circular+/// pattern. Returns the sketch and the seed's first arc start point.+fn slot_pattern(count: usize) -> Result<(Sketch, usize), Box<dyn std::error::Error>> {+ let mut sk = Sketch::new();+ let center = sk.add_point(Vec2::ZERO, None)?;+ sk.add_constraint(ConstraintKind::Fix { p: center }, None)?;+ let (c0, c1) = (Vec2::new(200.0, 0.0), Vec2::new(210.0, 0.0));+ let p = [c0 + Vec2::new(0.0, -2.0), c0 + Vec2::new(0.0, 2.0), c1 + Vec2::new(0.0, -2.0), c1 + Vec2::new(0.0, 2.0)];+ let pts: Vec<usize> = p.iter().map(|q| sk.add_point(*q, None)).collect::<Result<_, _>>()?;+ let left = sk.add_arc(c0, p[1], p[0], [None, Some(pts[1]), Some(pts[0])], None)?;+ let right = sk.add_arc(c1, p[2], p[3], [None, Some(pts[2]), Some(pts[3])], None)?;+ let bottom = sk.add_line_pts(pts[0], pts[2], None)?;+ let top = sk.add_line_pts(pts[1], pts[3], None)?;+ let entities = [left, right, bottom, top].iter().filter_map(|i| sk.curves.get(*i).map(|c| c.id.clone())).collect();+ let center_id = sk.points.get(center).map(|q| q.id.clone()).ok_or("missing center")?;+ let kind = SketchPatternKind::Circular { center: center_id, count, angle: 360.0, alignment: PatternAlignment::Right, reversed: false };+ let id = sk.fresh("pat")?;+ sk.patterns.push(SketchPattern { id, entities, kind: kind.clone(), count_expression: None, instances: vec![], expressions: Default::default() });+ sk.update_pattern(0, kind)?;+ Ok((sk, pts[1]))+}++/// A hash of the whole sketch, every number to the bit, to compare solver output between builds.+fn fingerprint(sk: &Sketch) -> u64 {+ format!("{sk:?}").bytes().fold(0xcbf29ce484222325, |h, b| (h ^ u64::from(b)).wrapping_mul(0x100000001b3))+}+/// Best of `reps` solves of a copy of `sk` (ms) and the last report.fn time(sk: &Sketch, reps: usize, f: impl Fn(&mut Sketch) -> SolveReport) -> (f64, SolveReport) {let mut best = f64::MAX;@@ -104,5 +133,30 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {let (full, _) = time(&sk, 5, solve);println!("| {n} rectangles | {} | {frame:.2} ({:?}) | {full:.2} |", sk.points.len(), rep.status);}+ println!();+ println!("| circular slot pattern | curves | points | drag frame on another line ms | drag frame on the seed ms | output |");+ println!("|---|---|---|---|---|---|");+ for count in [100usize, 500] {+ let (mut sk, seed) = slot_pattern(count)?;+ let a = sk.add_point(Vec2::new(-500.0, -500.0), None)?;+ let b = sk.add_point(Vec2::new(-480.0, -500.0), None)?;+ let l = sk.add_line_pts(a, b, None)?;+ sk.add_constraint(ConstraintKind::Horizontal { l }, None)?;+ let drag = |point: usize| -> (f64, u64) {+ let mut start = sk.clone();+ if let Some(p) = start.points.get_mut(point) {+ p.pos += Vec2::new(0.5, 0.3);+ }+ let hold = Hold { points: vec![point], radii: vec![] };+ let frame = |k: &mut Sketch| solve_with(k, &hold, None, Analysis::StatusOnly, Some(&mut Budget::frame()));+ let (ms, _) = time(&start, 5, frame);+ frame(&mut start);+ (ms, fingerprint(&start))+ };+ let (other, other_out) = drag(b);+ // Solving the whole pattern takes seconds at 500 copies.+ let (on_seed, seed_out) = if count <= 100 { drag(seed) } else { (f64::NAN, 0) };+ println!("| {count} slots | {} | {} | {other:.2} | {on_seed:.2} | {other_out:016x} {seed_out:016x} |", sk.curves.len(), sk.points.len());+ }Ok(())}diff --git a/crates/sketch/src/model.rs b/crates/sketch/src/model.rsindex f3acc923de..3b32a43045 100644--- a/crates/sketch/src/model.rs+++ b/crates/sketch/src/model.rs@@ -827,9 +827,13 @@ impl Sketch {}pub fn point_index(&self, id: &str) -> Option<usize> {+ #[cfg(test)]+ crate::tests::count_id_search();self.points.iter().position(|p| p.id == id)}pub fn curve_index(&self, id: &str) -> Option<usize> {+ #[cfg(test)]+ crate::tests::count_id_search();self.curves.iter().position(|c| c.id == id)}pub fn point(&self, i: usize) -> Option<Vec2> {diff --git a/crates/sketch/src/pattern.rs b/crates/sketch/src/pattern.rsindex 7f98347e48..efa3650b0f 100644--- a/crates/sketch/src/pattern.rs+++ b/crates/sketch/src/pattern.rs@@ -334,15 +334,31 @@ impl Sketch {/// Conic rho is an authored shape parameter rather than a solver unknown. Like its/// defining points, the copies follow the seed's shape when that parameter is edited.pub(crate) fn refresh_pattern_shapes(&mut self) {- if !self.curves.iter().any(|c| matches!(c.kind, CurveKind::Conic { .. } | CurveKind::Arc { .. })) {+ if self.patterns.is_empty() || !self.curves.iter().any(|c| matches!(c.kind, CurveKind::Conic { .. } | CurveKind::Arc { .. })) {return;}- for pattern in &self.patterns {- let sources: Vec<_> = pattern.entities.iter().filter_map(|id| self.curve_index(id)).collect();- for instance in &pattern.instances {- for (seed, copy) in sources.iter().zip(&instance.curves) {+ // This runs before every solve, drag frames included. Ids resolve through maps built+ // once here: a linear search per copy cost patterns × copies × seeds × curves string+ // comparisons, which dominated dragging anything in a sketch with a large pattern.+ // Only curve shapes change below, so the indices stay valid throughout.+ let (sources, copies): (Vec<Vec<usize>>, Vec<Vec<Vec<Option<usize>>>>) = {+ let curves = first_index(self.curves.iter().map(|c| c.id.as_str()));+ self.patterns+ .iter()+ .map(|pattern| {+ (+ pattern.entities.iter().filter_map(|id| curves.get(id.as_str()).copied()).collect(),+ pattern.instances.iter().map(|i| i.curves.iter().map(|id| curves.get(id.as_str()).copied()).collect()).collect(),+ )+ })+ .unzip()+ };+ let points = first_index(self.points.iter().map(|p| p.id.as_str()));+ for ((pattern, sources), copies) in self.patterns.iter().zip(&sources).zip(&copies) {+ for (instance, copies) in pattern.instances.iter().zip(copies) {+ for (seed, copy) in sources.iter().zip(copies) {if let Some(CurveKind::Conic { rho, .. }) = self.curves.get(*seed).map(|c| &c.kind)- && let Some(copy) = self.curve_index(copy)+ && let Some(copy) = *copy{let rho = *rho;if let Some(CurveKind::Conic { rho: slot, .. }) = self.curves.get_mut(copy).map(|c| &mut c.kind) {@@ -355,9 +371,9 @@ impl Sketch {self.points.get(p).and_then(|p| instance.points.iter().find(|(id, _)| *id == p.id))- .and_then(|(_, id)| self.point_index(id))+ .and_then(|(_, id)| points.get(id.as_str()).copied())};- if let (Some(c), Some(a), Some(b), Some(copy)) = (mapped(c), mapped(a), mapped(b), self.curve_index(copy))+ if let (Some(c), Some(a), Some(b), Some(copy)) = (mapped(c), mapped(a), mapped(b), *copy)&& let Some(curve) = self.curves.get_mut(copy){curve.kind = CurveKind::Arc { c, a, b };@@ -561,3 +577,12 @@ fn rotate(c: Vec2, ang: f64) -> impl Fn(Vec2) -> Vec2 {c + Vec2::new(d.x * co - d.y * s, d.x * s + d.y * co)}}++/// Each id's first index, as `position` finds it.+fn first_index<'a>(ids: impl Iterator<Item = &'a str>) -> std::collections::HashMap<&'a str, usize> {+ let mut map = std::collections::HashMap::new();+ for (i, id) in ids.enumerate() {+ map.entry(id).or_insert(i);+ }+ map+}diff --git a/crates/sketch/src/tests.rs b/crates/sketch/src/tests.rsindex 2dce5a775c..26c6933449 100644--- a/crates/sketch/src/tests.rs+++ b/crates/sketch/src/tests.rs@@ -25,6 +25,15 @@ impl Lcg {}}+thread_local! {+ static ID_SEARCHES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };+}++/// A linear search for a point or curve by id on this thread.+pub(crate) fn count_id_search() {+ ID_SEARCHES.with(|c| c.set(c.get() + 1));+}+/// Run `f` with the constructive seed on or off, without the seed-on/seed-off comparison (for/// tests that measure the difference).pub(crate) fn seeded<T>(on: bool, f: impl FnOnce() -> T) -> T {@@ -1471,3 +1480,31 @@ fn a_held_solve_that_cannot_succeed_stops_once_it_stalls() {// A solve whose report names the violated constraints still iterates to the end.assert!(solve(Analysis::Full) >= 500);}++/// Pattern upkeep runs before every solve, each drag frame included. It once looked up every+/// copy and its arc points by a linear search over all ids, so dragging anything in a sketch+/// with a large pattern of arcs spent most of each frame there; its searches must not grow+/// with the copies. The copies still follow their seed's arc direction.+#[test]+fn pattern_upkeep_does_not_search_ids_per_copy() {+ let mut sk = Sketch::new();+ let center = sk.add_point(v(0.0, 0.0), None).unwrap();+ let arc = sk.add_arc(v(20.0, 0.0), v(23.0, 0.0), v(20.0, 3.0), [None, None, None], None).unwrap();+ let entities = vec![sk.curves[arc].id.clone()];+ let kind = SketchPatternKind::Circular {+ center: sk.points[center].id.clone(),+ count: 50,+ angle: 360.0,+ alignment: PatternAlignment::Right,+ reversed: false,+ };+ let id = sk.fresh("pat").unwrap();+ sk.patterns.push(SketchPattern { id, entities, kind: kind.clone(), count_expression: None, instances: vec![], expressions: Default::default() });+ sk.update_pattern(0, kind).unwrap();+ assert_eq!(sk.curves.len(), 50);+ sk.curves[arc].reversed = true;+ ID_SEARCHES.with(|c| c.set(0));+ sk.refresh_pattern_shapes();+ assert_eq!(ID_SEARCHES.with(std::cell::Cell::get), 0, "id searches in pattern upkeep");+ assert!(sk.curves.iter().all(|c| c.reversed));+}