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.rsindex 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.rsindex 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 [f6let 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.rsindex 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();