Skip to content

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

Sketch: a distance dimension of 0 keeps the sketch fully constrained (#4368) (#4397)

raykholod876f475a6d4
diff --git a/crates/sketch/src/profiling.rs b/crates/sketch/src/profiling.rs
index b8987b8abe..667fddba1b 100644
--- a/crates/sketch/src/profiling.rs
+++ b/crates/sketch/src/profiling.rs
@@ -321,13 +321,17 @@ mod tests {
#[test]
fn measurements_preserve_geometry_and_explain_a_stalled_solve() {
- for x in [0.0, 1e-5] {
+ for (x, stalled) in [(0.0, true), (0.0, false), (1e-5, false)] {
let mut plain = distance(x);
+ if stalled {
+ // Horizontal distances retain the magnitude residual and its zero slope.
+ plain.constraints[0].kind = ConstraintKind::DistanceX { p: 0, q: 1, value: 10.0 };
+ }
let mut measured = plain.clone();
let run = |sk: &mut Sketch| solve_with(sk, &Hold::default(), None, Analysis::StatusOnly, None);
let a = run(&mut plain);
let (b, profile) = crate::construct::switch::without_differential(|| capture(|| run(&mut measured)));
- assert_eq!(serde_json::to_value(a).unwrap(), serde_json::to_value(b).unwrap());
+ assert_eq!(serde_json::to_value(a).unwrap(), serde_json::to_value(&b).unwrap());
assert_eq!(plain, measured);
assert_eq!(profile.counters.solve_calls, 1);
assert_eq!(profile.counters.lm_runs, 1);
@@ -337,13 +341,16 @@ mod tests {
);
assert!(profile.counters.residual_block_evaluations > profile.counters.residual_system_evaluations);
let first = profile.trials.first().unwrap();
- if x == 0.0 {
+ if stalled {
assert_eq!(profile.runs[0].stop_reason, Some(StopReason::NoImprovement));
assert_eq!(first.gradient_inf, Some(0.0));
assert_eq!(first.step_norm, Some(0.0));
assert_eq!(profile.counters.accepted_trials, 0);
} else {
+ assert!(b.ok());
assert_eq!(profile.runs[0].stop_reason, Some(StopReason::ResidualTolerance));
+ assert!(first.gradient_inf.unwrap() > 0.0);
+ assert!(first.step_norm.unwrap() > 0.0);
assert!(profile.counters.accepted_trials > 0);
assert!((first.rho.unwrap() - 1.0).abs() < 1e-6, "the positive radial step is a linear residual");
}
diff --git a/crates/sketch/src/solver.rs b/crates/sketch/src/solver.rs
index 4872af3e91..d0df6aeda0 100644
--- a/crates/sketch/src/solver.rs
+++ b/crates/sketch/src/solver.rs
@@ -572,12 +572,20 @@ fn residuals(s: &State, k: &ConstraintKind, out: &mut Vec<f64>) {
out.push((qq - pp).dot(dir) / len);
}
Fix { .. } => {}
+ // A distance within convergence tolerance of zero means coincidence: two
+ // component rows keep both directions constrained even when the points meet.
+ Distance { p, q, value } if value.abs() <= TOL => {
+ let d = s.p(p) - s.p(q);
+ out.extend([d.x, d.y]);
+ }
Distance { p, q, value } => out.push(s.p(p).dist(s.p(q)) - value),
DistanceX { p, q, value } => out.push((s.p(q).x - s.p(p).x).abs() - value),
DistanceY { p, q, value } => out.push((s.p(q).y - s.p(p).y).abs() - value),
PointLineDistance { p, l, value } => {
let (a, b) = s.line(l);
- out.push(line_dist(s.p(p), a, b).abs() - value);
+ let d = line_dist(s.p(p), a, b);
+ // At zero this is point-on-line; the signed distance retains its slope.
+ out.push(if value.abs() <= TOL { d } else { d.abs() - value });
}
LineCircleDistance { l, c, value, inside } => out.push(s.line_circle_gap(l, c, inside) - value),
PointCircleDistance { p, c, value, inside } => out.push(s.point_circle_gap(p, c, inside) - value),
@@ -876,6 +884,45 @@ fn block_refs(sk: &Sketch, b: &Block) -> Vec<Ref> {
}
}
+/// A positive distance edited from zero needs an opening direction: central differences
+/// of its magnitude cancel at coincidence. Use a unit radial subgradient there, or the
+/// signed line normal. Once separated, ordinary central differences apply again.
+fn distance_opening_slope(s: &State, b: &Block, v: usize) -> Option<f64> {
+ let point = |p: usize, gradient: Vec2| match s.lay.pvar.get(p).copied().flatten() {
+ Some(first) if v == first => gradient.x,
+ Some(first) if v == first + 1 => gradient.y,
+ _ => 0.0,
+ };
+ match b {
+ Block::User(_, ConstraintKind::Distance { p, q, value }) if *value > TOL => {
+ let d = s.p(*q) - s.p(*p);
+ if d.len() > TOL {
+ return None;
+ }
+ // Unequal nonzero components avoid symmetry with axes and 45-degree guides.
+ let direction = d.normalized().unwrap_or(Vec2::new(0.6, 0.8));
+ Some(point(*q, direction) - point(*p, direction))
+ }
+ Block::User(_, ConstraintKind::PointLineDistance { p, l, value }) if *value > TOL => {
+ let (a, b) = s.line(*l);
+ let signed = line_dist(s.p(*p), a, b);
+ if signed.abs() > TOL {
+ return None;
+ }
+ let Some(CurveKind::Line { a: ai, b: bi }) = s.sk.curves.get(*l).map(|c| &c.kind) else { return None };
+ let d = b - a;
+ let length = d.len();
+ if length <= 1e-12 {
+ return None;
+ }
+ let normal = d.perp() * (if signed < 0.0 { -1.0 } else { 1.0 } / length);
+ let along = (s.p(*p) - a).dot(d) / (length * length);
+ Some(point(*p, normal) + point(*ai, normal * (along - 1.0)) - point(*bi, normal * along))
+ }
+ _ => None,
+ }
+}
+
/// Residual vector and Jacobian (rows × all n vars) for the given blocks.
fn system(sk: &Sketch, lay: &Layout, blocks: &[(Block, Vec<usize>)], x: &mut [f64], with_j: bool) -> (Vec<f64>, Option<Mat>, Vec<usize>) {
#[cfg(feature = "solver-profiling")]
@@ -909,6 +956,7 @@ fn system(sk: &Sketch, lay: &Layout, blocks: &[(Block, Vec<usize>)], x: &mut [f6
let rows = plus.len();
for &v in vars {
let Some(x0) = x.get(v).copied() else { continue };
+ let opening = distance_opening_slope(&State { sk, lay, x }, b, v);
let h = 1e-7 * x0.abs().max(1.0);
if let Some(xv) = x.get_mut(v) {
*xv = x0 + h;
@@ -925,7 +973,7 @@ fn system(sk: &Sketch, lay: &Layout, blocks: &[(Block, Vec<usize>)], x: &mut [f6
}
for k in 0..rows {
let d = (plus.get(k).copied().unwrap_or(0.0) - minus.get(k).copied().unwrap_or(0.0)) / (2.0 * h);
- j.set(row + k, v, d);
+ j.set(row + k, v, if k == 0 { opening.unwrap_or(d) } else { d });
}
}
row += rows;
@@ -960,6 +1008,7 @@ fn local_system(
for &v in vars {
let Some(c) = col.get(v).copied().filter(|c| *c < ncols) else { continue };
let Some(x0) = x.get(v).copied() else { continue };
+ let opening = distance_opening_slope(&State { sk, lay, x }, b, v);
let h = 1e-7 * x0.abs().max(1.0);
if let Some(xv) = x.get_mut(v) {
*xv = x0 + h;
@@ -976,7 +1025,7 @@ fn local_system(
}
for k in 0..rows {
let d = (plus.get(k).copied().unwrap_or(0.0) - minus.get(k).copied().unwrap_or(0.0)) / (2.0 * h);
- j.set(row + k, c, d);
+ j.set(row + k, c, if k == 0 { opening.unwrap_or(d) } else { d });
}
}
row += rows;
diff --git a/crates/sketch/src/tests.rs b/crates/sketch/src/tests.rs
index c77a1bae1d..30310855dc 100644
--- a/crates/sketch/src/tests.rs
+++ b/crates/sketch/src/tests.rs
@@ -95,6 +95,112 @@ fn fully_constrained_rectangle() {
assert!(p1.dist(v(55.0, 0.0)) < 1e-7);
}
+#[test]
+fn zero_distance_matches_coincident() {
+ for seed in [false, true] {
+ seeded(seed, || {
+ for fixed in [false, true] {
+ for value in [0.0, 1e-12] {
+ let mut sk = Sketch::new();
+ let p = if fixed { 0 } else { sk.add_point(v(2.0, 3.0), None).unwrap() };
+ let q = sk.add_point(sk.point(p).unwrap(), None).unwrap();
+ let mut equivalent = sk.clone();
+ let id = sk.add_constraint(ConstraintKind::Distance { p, q, value }, None).unwrap();
+ equivalent.add_constraint(ConstraintKind::Coincident { p, q }, None).unwrap();
+ let report = solve(&mut sk);
+ let expected = solve(&mut equivalent);
+ assert!(report.ok() && expected.ok(), "{report:?}, {expected:?}");
+ assert_eq!(report.dof, if fixed { 0 } else { 2 }, "{report:?}");
+ assert_eq!(report.dof, expected.dof);
+ assert_eq!(report.point_determined, expected.point_determined);
+ assert!(!report.redundant.contains(&id), "{report:?}");
+ assert!(determined_by(&sk, 0).is_empty());
+ assert!(sk.point(q).unwrap().dist(equivalent.point(q).unwrap()) < 1e-8);
+ sk.add_constraint(ConstraintKind::Coincident { p, q }, None).unwrap();
+ assert_eq!(solve(&mut sk).redundant.len(), 1);
+ assert_eq!(determined_by(&sk, 1), vec![0]);
+ }
+ }
+ });
+ }
+}
+
+#[test]
+fn zero_distance_to_line_matches_point_on_line() {
+ for seed in [false, true] {
+ seeded(seed, || {
+ for value in [0.0, 1e-12] {
+ for start in [v(2.0, 2.0), v(3.0, 1.0)] {
+ let mut sk = Sketch::new();
+ let l = sk.add_line(v(1.0, 1.0), v(4.0, 4.0), None, None, None).unwrap();
+ sk.curves[l].fixed = true;
+ let p = sk.add_point(start, None).unwrap();
+ let mut equivalent = sk.clone();
+ let id = sk.add_constraint(ConstraintKind::PointLineDistance { p, l, value }, None).unwrap();
+ equivalent.add_constraint(ConstraintKind::PointOnCurve { p, c: l }, None).unwrap();
+ let report = solve(&mut sk);
+ let expected = solve(&mut equivalent);
+ assert!(report.ok() && expected.ok(), "{report:?}, {expected:?}");
+ assert_eq!(report.dof, 1, "{report:?}");
+ assert_eq!(report.dof, expected.dof);
+ assert_eq!(report.point_determined, expected.point_determined);
+ assert!(!report.redundant.contains(&id), "{report:?}");
+ assert!(determined_by(&sk, 0).is_empty());
+ assert!(sk.point(p).unwrap().dist(equivalent.point(p).unwrap()) < 1e-8);
+ sk.add_constraint(ConstraintKind::PointOnCurve { p, c: l }, None).unwrap();
+ assert_eq!(solve(&mut sk).redundant.len(), 1);
+ assert_eq!(determined_by(&sk, 1), vec![0]);
+ }
+ }
+ });
+ }
+}
+
+#[test]
+fn zero_distance_edits_preserve_dimension_rank() {
+ for seed in [false, true] {
+ seeded(seed, || {
+ for point_line in [false, true] {
+ for direction in [Vec2::X, Vec2::Y, v(1.0, -1.0) / 2.0_f64.sqrt()] {
+ let mut sk = Sketch::new();
+ let p = sk.add_point(direction * 5.0, None).unwrap();
+ let kind = if point_line {
+ let along = direction.perp() * 10.0;
+ let l = sk.add_line(along * -1.0, along, None, None, None).unwrap();
+ sk.curves[l].fixed = true;
+ ConstraintKind::PointLineDistance { p, l, value: 5.0 }
+ } else {
+ ConstraintKind::Distance { p: 0, q: p, value: 5.0 }
+ };
+ let id = sk.add_constraint(kind, None).unwrap();
+ let alignment = if direction == Vec2::X {
+ ConstraintKind::HorizontalPoints { p: 0, q: p }
+ } else if direction == Vec2::Y {
+ ConstraintKind::VerticalPoints { p: 0, q: p }
+ } else {
+ let l = sk.add_line(direction * -10.0, direction * 10.0, None, None, None).unwrap();
+ sk.curves[l].fixed = true;
+ ConstraintKind::PointOnCurve { p, c: l }
+ };
+ sk.add_constraint(alignment, None).unwrap();
+ for value in [5.0, 0.0, 5.0] {
+ let old = sk.driving_values();
+ sk.constraints[0].kind.set_value(value);
+ let report = solve_after_value_edit(&mut sk, &old);
+ assert!(report.ok(), "{point_line}, {direction:?}, {value}: {report:?}");
+ assert_eq!(report.dof, 0, "{point_line}, {direction:?}, {value}: {report:?}");
+ assert!(report.point_determined[p]);
+ assert!(!report.redundant.contains(&id), "{report:?}");
+ assert!(determined_by(&sk, 0).is_empty());
+ assert!(constraint_residual(&sk, 0).unwrap() < 1e-6);
+ assert!((sk.point(p).unwrap().len() - value).abs() < 1e-6);
+ }
+ }
+ }
+ });
+ }
+}
+
#[test]
fn under_constrained_reports_dof() {
let mut sk = Sketch::new();