Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Sketch profiles: grid-accelerated splitting and node merging, bounding-box nesting (large sketches several times faster); randomized sketch-editing test (thousands of mixed create/modify/constraint/projection/undo steps: no panics, designs round-trip)

bherbruck4455402eabbc
diff --git a/crates/engine/src/cmd/sketch_constraints.rs b/crates/engine/src/cmd/sketch_constraints.rs
index 25ab797bca..bb0c3b0cc6 100644
--- a/crates/engine/src/cmd/sketch_constraints.rs
+++ b/crates/engine/src/cmd/sketch_constraints.rs
@@ -514,3 +514,7 @@ fn snap(s: &mut Session, p: &Value) -> Result<Value> {
#[cfg(test)]
#[path = "sketch_constraints_tests.rs"]
mod tests;
+
+#[cfg(test)]
+#[path = "sketch_fuzz_tests.rs"]
+mod fuzz;
diff --git a/crates/engine/src/cmd/sketch_fuzz_tests.rs b/crates/engine/src/cmd/sketch_fuzz_tests.rs
new file mode 100644
index 0000000000..facbf6bc2f
--- /dev/null
+++ b/crates/engine/src/cmd/sketch_fuzz_tests.rs
@@ -0,0 +1,100 @@
+//! Random sequences of sketch commands: nothing panics, every sketch stays evaluable, and the
+//! design survives a save/load round trip.
+
+use serde_json::{Value, json};
+
+use crate::{EngineError, Session};
+
+/// Small deterministic generator (xorshift).
+struct Rng(u64);
+
+impl Rng {
+ fn next(&mut self) -> u64 {
+ let mut x = self.0;
+ x ^= x << 13;
+ x ^= x >> 7;
+ x ^= x << 17;
+ self.0 = x;
+ x
+ }
+ fn f(&mut self, lo: f64, hi: f64) -> f64 {
+ lo + (self.next() % 1_000_000) as f64 / 1_000_000.0 * (hi - lo)
+ }
+ fn pick<'a, T>(&mut self, v: &'a [T]) -> Option<&'a T> {
+ if v.is_empty() { None } else { v.get((self.next() as usize) % v.len()) }
+ }
+ fn pt(&mut self) -> Value {
+ json!([(self.f(-50.0, 50.0) * 10.0).round() / 10.0, (self.f(-50.0, 50.0) * 10.0).round() / 10.0])
+ }
+}
+
+fn entities(s: &Session) -> (Vec<String>, Vec<String>, Vec<String>) {
+ let Some(id) = s.active_sketch else { return Default::default() };
+ let st = s.model.state();
+ let Some(ss) = st.sketch(id) else { return Default::default() };
+ let sk = &ss.sketch;
+ let curves = sk.curves.iter().map(|c| c.id.clone()).collect();
+ let points = sk.points.iter().map(|p| p.id.clone()).collect();
+ let cons = sk.constraints.iter().map(|c| c.id.clone()).collect();
+ (curves, points, cons)
+}
+
+#[test]
+fn random_sketch_editing_never_breaks() {
+ for seed in 1..=4u64 {
+ let mut r = Rng(0x9E37_79B9_7F4A_7C15 ^ seed);
+ let mut s = Session::default();
+ let _ = s.execute("PrimitiveBox", &json!({"length": 30, "width": 20, "height": 10}));
+ let _ = s.execute("SketchCreate", &json!({"plane": {"face": [15, 10, 10]}}));
+ for step in 0..150 {
+ let (curves, points, cons) = entities(&s);
+ let c = |r: &mut Rng| r.pick(&curves).cloned().unwrap_or_default();
+ let p = |r: &mut Rng| r.pick(&points).cloned().unwrap_or_default();
+ let (cmd, params) = match r.next() % 34 {
+ 0 => ("DrawPolyline", json!({"points": [r.pt(), r.pt(), r.pt()], "infer": true})),
+ 1 => ("CircleCenterRadius", json!({"center": r.pt(), "radius": r.f(0.5, 20.0)})),
+ 2 => ("ArcCenterTwoPoint", json!({"center": r.pt(), "start": r.pt(), "end": r.pt()})),
+ 3 => ("ShapeRectangleTwoPoint", json!({"p0": r.pt(), "p1": r.pt()})),
+ 4 => ("DrawSpline", json!({"points": [r.pt(), r.pt(), r.pt(), r.pt()]})),
+ 5 => ("CircleElipse", json!({"center": r.pt(), "major": r.pt(), "minor_radius": r.f(0.5, 10.0)})),
+ 6 => ("ConicCurveCmd", json!({"start": r.pt(), "end": r.pt(), "apex": r.pt(), "rho": r.f(0.1, 0.9)})),
+ 7 => ("TrimSketchCmd", json!({"curve": c(&mut r), "at": r.pt()})),
+ 8 => ("ExtendSketchCmd", json!({"curve": c(&mut r), "at": r.pt()})),
+ 9 => ("BreakSketchCmd", json!({"curve": c(&mut r), "at": r.pt()})),
+ 10 => ("FilletSketchCmd", json!({"point": p(&mut r), "radius": r.f(0.1, 5.0)})),
+ 11 => ("ChamferSketchEqualDistance", json!({"point": p(&mut r), "distance": r.f(0.1, 5.0)})),
+ 12 => ("Offset", json!({"curves": [c(&mut r)], "distance": r.f(-5.0, 5.0), "side": r.pt()})),
+ 13 => ("MirrorSketchCommand", json!({"entities": [c(&mut r)], "line": c(&mut r)})),
+ 14 => ("CircularSketchPatternCommand", json!({"entities": [c(&mut r)], "center": r.pt(), "count": 3})),
+ 15 => ("ConstraintCoincident", json!({"a": p(&mut r), "b": p(&mut r)})),
+ 16 => ("ConstraintTangent", json!({"a": c(&mut r), "b": c(&mut r)})),
+ 17 => ("ConstraintParallel", json!({"a": c(&mut r), "b": c(&mut r)})),
+ 18 => ("ConstraintSmooth", json!({"a": c(&mut r), "b": c(&mut r)})),
+ 19 => ("SketchDimension", json!({"entities": [c(&mut r)]})),
+ 20 => ("SketchDimension", json!({"entities": [p(&mut r), p(&mut r)], "driven": r.next().is_multiple_of(2)})),
+ 21 => ("sketch.delete", json!({"entities": [r.pick(&cons).cloned().unwrap_or_else(|| c(&mut r))]})),
+ 22 => ("sketch.move_point", json!({"point": p(&mut r), "to": r.pt()})),
+ 23 => ("ProjectNewCmd", json!({"refs": [{"edge": [r.f(0.0, 30.0), 0.0, 10.0]}]})),
+ 24 => ("sketch.break_link", json!({"entities": [c(&mut r)]})),
+ 25 => ("SketchConstrainer", json!({"entities": [c(&mut r), c(&mut r)]})),
+ 26 => ("SketchAutoConstraintAndDimCmd", json!({})),
+ 27 => ("MTextCmd", json!({"text": "Ab", "at": r.pt(), "height": r.f(1.0, 8.0)})),
+ 28 => ("sketch.toggle_driven", json!({"constraint": r.pick(&cons).cloned().unwrap_or_default()})),
+ 29 => ("ArcTangent", json!({"start": format!("{}.end", c(&mut r)), "end": r.pt()})),
+ 30 => ("SketchScaleCmd", json!({"entities": [c(&mut r)], "base": r.pt(), "factor": r.f(0.5, 2.0)})),
+ 31 => ("UndoCommand", json!({})),
+ 32 => ("ShapeArcSlotThreePoint", json!({"start": r.pt(), "through": r.pt(), "end": r.pt(), "width": r.f(0.5, 4.0)})),
+ _ => ("RedoCommand", json!({})),
+ };
+ if let Err(EngineError::Internal(id, msg)) = s.execute(cmd, &params) {
+ panic!("seed {seed} step {step}: {id} {params}: {msg}");
+ }
+ if s.active_sketch.is_none() {
+ let _ = s.execute("SketchCreate", &json!({"plane": "XY"}));
+ }
+ }
+ // The design round-trips.
+ let back = solvecraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
+ assert_eq!(back, *s.doc, "seed {seed}");
+ }
+}
diff --git a/crates/sketch/src/profiles.rs b/crates/sketch/src/profiles.rs
index 46bda3f019..e1b7525cbb 100644
--- a/crates/sketch/src/profiles.rs
+++ b/crates/sketch/src/profiles.rs
@@ -68,6 +68,45 @@ fn end_param(sh: &Shape, p: Vec2, tol: f64) -> Option<f64> {
}
}
+/// A uniform grid over a set of boxes (about one box per cell), for neighbour queries.
+struct Grid {
+ lo: Vec2,
+ size: f64,
+}
+
+impl Grid {
+ fn new(boxes: &[(Vec2, Vec2)]) -> Grid {
+ let (mut lo, mut hi) = (Vec2::new(f64::INFINITY, f64::INFINITY), Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY));
+ for (a, b) in boxes {
+ lo = Vec2::new(lo.x.min(a.x), lo.y.min(a.y));
+ hi = Vec2::new(hi.x.max(b.x), hi.y.max(b.y));
+ }
+ if !(lo.is_finite() && hi.is_finite()) {
+ return Grid { lo: Vec2::ZERO, size: 1.0 };
+ }
+ let ext = (hi.x - lo.x).max(hi.y - lo.y).max(1e-9);
+ let per_side = (boxes.len() as f64).sqrt().ceil().clamp(1.0, 512.0);
+ Grid { lo, size: ext / per_side }
+ }
+ fn cell(&self, p: Vec2) -> (i64, i64) {
+ (((p.x - self.lo.x) / self.size).floor() as i64, ((p.y - self.lo.y) / self.size).floor() as i64)
+ }
+ /// Cells a box covers; None for boxes spanning too many (they are checked against all).
+ fn cells(&self, b: &(Vec2, Vec2)) -> Option<Vec<(i64, i64)>> {
+ let (c0, c1) = (self.cell(b.0), self.cell(b.1));
+ if (c1.0 - c0.0 + 1).saturating_mul(c1.1 - c0.1 + 1) > 2048 {
+ return None;
+ }
+ let mut out = Vec::new();
+ for x in c0.0..=c1.0 {
+ for y in c0.1..=c1.1 {
+ out.push((x, y));
+ }
+ }
+ Some(out)
+ }
+}
+
fn find(p: &mut [usize], mut i: usize) -> usize {
while let Some(&q) = p.get(i) {
if q == i {
@@ -150,17 +189,7 @@ pub fn find_profiles(sk: &Sketch) -> Vec<Profile> {
Shape::Round { .. } => {}
}
}
- let mut cuts: Vec<Vec<f64>> = vec![Vec::new(); shapes.len()];
- for (i, (_, sh)) in shapes.iter().enumerate() {
- for p in &ends {
- if let Some(t) = sh.param_on(*p, tol)
- && let Some(c) = cuts.get_mut(i)
- {
- c.push(t);
- }
- }
- }
- // Bounding boxes: only shapes whose boxes overlap can cross.
+ // Bounding boxes, and a uniform grid over them: only shapes sharing a cell can meet.
let boxes: Vec<(Vec2, Vec2)> = shapes
.iter()
.map(|(_, sh)| match *sh {
@@ -172,9 +201,69 @@ pub fn find_profiles(sk: &Sketch) -> Vec<Profile> {
(Some((a0, a1)), Some((b0, b1))) => a0.x <= b1.x && b0.x <= a1.x && a0.y <= b1.y && b0.y <= a1.y,
_ => false,
};
- if shapes.len() <= 20_000 {
+ let grid = Grid::new(&boxes);
+ let mut cuts: Vec<Vec<f64>> = vec![Vec::new(); shapes.len()];
+ // End points of other curves lying on each shape.
+ let mut end_cells: std::collections::HashMap<(i64, i64), Vec<usize>> = std::collections::HashMap::new();
+ for (k, p) in ends.iter().enumerate() {
+ end_cells.entry(grid.cell(*p)).or_default().push(k);
+ }
+ let all_ends: Vec<usize> = (0..ends.len()).collect();
+ for (i, (_, sh)) in shapes.iter().enumerate() {
+ let Some(b) = boxes.get(i) else { continue };
+ let cand: Vec<usize> = match grid.cells(b) {
+ Some(cs) => cs.iter().flat_map(|c| end_cells.get(c).map(Vec::as_slice).unwrap_or(&[])).copied().collect(),
+ None => all_ends.clone(),
+ };
+ for k in cand {
+ if let Some(p) = ends.get(k)
+ && let Some(t) = sh.param_on(*p, tol)
+ && let Some(cu) = cuts.get_mut(i)
+ {
+ cu.push(t);
+ }
+ }
+ }
+ let mut shape_cells: std::collections::HashMap<(i64, i64), Vec<usize>> = std::collections::HashMap::new();
+ let mut global: Vec<usize> = Vec::new();
+ for (i, b) in boxes.iter().enumerate() {
+ match grid.cells(b) {
+ Some(cs) => {
+ for c in cs {
+ shape_cells.entry(c).or_default().push(i);
+ }
+ }
+ None => global.push(i),
+ }
+ }
+ let mut partners: Vec<Vec<usize>> = vec![Vec::new(); shapes.len()];
+ for v in shape_cells.values() {
+ for (k, &i) in v.iter().enumerate() {
+ for &j in v.iter().skip(k + 1) {
+ let (lo, hi) = if i < j { (i, j) } else { (j, i) };
+ if let Some(p) = partners.get_mut(lo) {
+ p.push(hi);
+ }
+ }
+ }
+ }
+ for &g in &global {
+ for j in 0..shapes.len() {
+ if j != g {
+ let (lo, hi) = if g < j { (g, j) } else { (j, g) };
+ if let Some(p) = partners.get_mut(lo) {
+ p.push(hi);
+ }
+ }
+ }
+ }
+ for p in &mut partners {
+ p.sort_unstable();
+ p.dedup();
+ }
+ if shapes.len() <= 50_000 {
for i in 0..shapes.len() {
- for j in (i + 1)..shapes.len() {
+ for &j in partners.get(i).map(Vec::as_slice).unwrap_or(&[]) {
if !overlap(i, j) {
continue;
}
@@ -211,12 +300,24 @@ pub fn find_profiles(sk: &Sketch) -> Vec<Profile> {
}
// Pieces → edges between merged nodes.
let mut nodes: Vec<Vec2> = Vec::new();
+ // Grid buckets of `tol`-sized cells: merging looks only at neighbouring cells.
+ let mut grid: std::collections::HashMap<(i64, i64), Vec<usize>> = std::collections::HashMap::new();
+ let cell = |p: Vec2| ((p.x / tol).floor() as i64, (p.y / tol).floor() as i64);
let mut node = |p: Vec2| -> usize {
- if let Some(i) = nodes.iter().position(|q| q.dist(p) <= tol) {
- return i;
+ let (cx, cy) = cell(p);
+ for dx in -1..=1 {
+ for dy in -1..=1 {
+ if let Some(v) = grid.get(&(cx + dx, cy + dy))
+ && let Some(i) = v.iter().copied().find(|i| nodes.get(*i).is_some_and(|q| q.dist(p) <= tol))
+ {
+ return i;
+ }
+ }
}
nodes.push(p);
- nodes.len() - 1
+ let i = nodes.len() - 1;
+ grid.entry((cx, cy)).or_default().push(i);
+ i
};
let mut loops: Vec<(Loop2, Vec<String>, usize)> = Vec::new(); // (ccw loop, curve ids, component)
let mut edges: Vec<Edge> = Vec::new();
@@ -402,8 +503,18 @@ pub fn find_profiles(sk: &Sketch) -> Vec<Profile> {
}
}
- // Nesting: parent = smallest containing loop from another component.
+ // Nesting: parent = smallest containing loop from another component. Bounding boxes rule
+ // out most pairs before the point-in-loop test.
let areas: Vec<f64> = loops.iter().map(|(l, _, _)| l.signed_area().abs()).collect();
+ let boxes: Vec<(Vec2, Vec2)> = loops
+ .iter()
+ .map(|(l, _, _)| {
+ l.polyline(1e-3).iter().fold((Vec2::new(f64::INFINITY, f64::INFINITY), Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY)), |(lo, hi), p| {
+ (Vec2::new(lo.x.min(p.x), lo.y.min(p.y)), Vec2::new(hi.x.max(p.x), hi.y.max(p.y)))
+ })
+ })
+ .collect();
+ let inside_box = |j: usize, p: Vec2| boxes.get(j).is_some_and(|(lo, hi)| p.x >= lo.x && p.x <= hi.x && p.y >= lo.y && p.y <= hi.y);
let mut parent_of: Vec<Option<usize>> = vec![None; loops.len()];
for (i, (li, _, ci)) in loops.iter().enumerate() {
let probe = li.segs.first().map(Seg2::mid).unwrap_or_default();
@@ -411,10 +522,10 @@ pub fn find_profiles(sk: &Sketch) -> Vec<Profile> {
let mut best: Option<(f64, usize)> = None;
for (j, (lj, _, cj)) in loops.iter().enumerate() {
let aj = areas.get(j).copied().unwrap_or(0.0);
- if i == j || ci == cj || aj <= ai {
+ if i == j || ci == cj || aj <= ai || !inside_box(j, probe) || best.is_some_and(|(ba, _)| aj >= ba) {
continue;
}
- if lj.contains(probe) && best.is_none_or(|(ba, _)| aj < ba) {
+ if lj.contains(probe) {
best = Some((aj, j));
}
}
@@ -422,11 +533,19 @@ pub fn find_profiles(sk: &Sketch) -> Vec<Profile> {
*p = best.map(|(_, j)| j);
}
}
+ let mut kids_of: Vec<Vec<usize>> = vec![Vec::new(); loops.len()];
+ for (k, p) in parent_of.iter().enumerate() {
+ if let Some(p) = p
+ && let Some(v) = kids_of.get_mut(*p)
+ {
+ v.push(k);
+ }
+ }
let mut out: Vec<Profile> = loops
.iter()
.enumerate()
.map(|(i, (l, ids, _))| {
- let kids: Vec<usize> = (0..loops.len()).filter(|k| parent_of.get(*k).copied().flatten() == Some(i)).collect();
+ let kids: Vec<usize> = kids_of.get(i).cloned().unwrap_or_default();
let holes: Vec<Loop2> = kids.iter().filter_map(|k| loops.get(*k).map(|(h, _, _)| h.ccw().reversed())).collect();
let hole_curves: Vec<Vec<String>> = kids.iter().filter_map(|k| loops.get(*k).map(|(_, ids, _)| ids.clone())).collect();
let region = Region2 { outer: l.ccw(), holes };