Fix sketch drag breaking midpoint-constrained line solver (#7635) (#7810)

* claim: #7635

* Keep the drag cursor on the manifold of an ill-conditioned sketch (#7635)

A construction line collapsed to zero length makes its angle row's entries
on that line ~1e7 while the same row's entries on the measured line are ~1.
Dragging an endpoint of the midpoint-pinned line then failed two ways: the
null-space rank analysis, which scaled rows only, hid the small (physically
meaningful) entries below its pivot tolerance and let the measured line
rotate freely; and the cursor's refinement, which demanded a TOL-tight
correction the ill-conditioned system cannot deliver, gave up entirely and
let the drag leave an unsolvable step placed - breaking the perpendicular
and angle constraints.

Equilibrate the null-space Jacobian on both sides (columns by their largest
entry, then rows) so one row's entries share a scale, and let the cursor
keep working from a pose the solver itself calls solved (residual below
ACCEPT) when refinement stalls above TOL, accepting corrected trials at the
same tolerance the final validation uses.

---------

Co-authored-by: Dahak Builds <dahakbuilds@users.noreply.github.com>
This commit is contained in:
Dahak BuildsandDahak Builds authored and GitHub committed 2026-10-28 12:20:40 +00:00
1 parent 1dba7f7f04
commit 64ff25f380
4 files changed
+129 -16

No files matched your search

@@ -181,3 +181,26 @@ fn offset_cases() {
sound(&s);
}
}
/// #7635: the reporter's design - `l1` with its midpoint pinned at the origin, `l2` perpendicular
/// to it at the origin, and a construction line `l3` at the origin constrained horizontal with a
/// 50-degree angle dimension to `l1`. Dragging a free end of `l1` (whose exact target the pinned
/// inclination makes unreachable) used to leave the failed step placed and break the perpendicular
/// and angle constraints; the sketch must stay solved instead.
#[test]
fn dragging_the_midpoint_line_end_keeps_the_sketch_solved() {
let mut s = new_sketch();
add(&mut s, "sketch.line", json!({"points": [[-6.616478376301535, -7.876608451910095], [6.616478376301535, 7.876608451910095]]}));
add(&mut s, "sketch.constraint.midpoint", json!({"point": "origin", "line": "l1"}));
add(&mut s, "sketch.line", json!({"points": [[0.0, 0.0], [-10.656000978748368, 8.951213010548841]]}));
add(&mut s, "sketch.constraint.coincident", json!({"a": "l2.start", "b": "origin"}));
add(&mut s, "sketch.constraint.perpendicular", json!({"a": "l2", "b": "l1"}));
add(&mut s, "sketch.line", json!({"points": [[0.0, 0.0], [10.0, 0.0]], "construction": true}));
add(&mut s, "sketch.constraint.coincident", json!({"a": "l3.start", "b": "origin"}));
add(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "l3", "mode": "horizontal"}));
add(&mut s, "sketch.dimension", json!({"entities": ["l3", "l1"], "type": "angle", "value": "50 deg"}));
let r = s.execute("sketch.drag", &json!({"entity": "l1.end", "from": [6.616478376301535, 7.876608451910095], "to": [10.0, 4.0]})).unwrap();
assert_eq!(r["sketch"]["solved"], json!(true), "the drag left the sketch unsolved: {r}");
s.execute("sketch.drag_end", &json!({})).unwrap();
sound(&s);
}
+42 -16
View File
@@ -15,11 +15,12 @@ const MAX_VARIABLES: usize = 400;
const MAX_STEPS: usize = 96;
const CORRECTION_ITERS: usize = 16;
const TOTAL_CORRECTION_ITERS: usize = 256;
/// Pivot tolerance of the null space, on rows scaled to a largest entry of 1. Redundant
/// constraints (a parallelogram held both parallel and equal on each pair of sides) are
/// dependent only at an exact solution; a pose corrected to `TOL` leaves their rows independent
/// by about that much, and a tighter tolerance counts that as rank and finds no freedom (#4585).
/// The solver's rank analysis, which reports the sketch's degrees of freedom, uses 1e-7 too.
/// Pivot tolerance of the null space, on the Jacobian equilibrated to unit rows and columns.
/// Redundant constraints (a parallelogram held both parallel and equal on each pair of sides)
/// are dependent only at an exact solution; a pose corrected to `TOL` leaves their rows
/// independent by about that much, and a tighter tolerance counts that as rank and finds no
/// freedom (#4585). The solver's rank analysis, which reports the sketch's degrees of freedom,
/// uses 1e-7 too.
const NULL_SPACE_TOL: f64 = 1e-7;
/// Move a point toward `target` using freedom left by the design constraints. `max_step`
@@ -131,14 +132,22 @@ fn move_cursor_towards(
// Held feasibility solves accept up to ACCEPT. A tiny, nearly feasible hard pin can
// precede a failed step; refine it before constructing a tangent, rather than losing
// the cursor objective just because the previous pose is between TOL and ACCEPT.
// An ill-conditioned sketch (a near-zero-length construction line makes its angle row
// unsolvable to TOL, #7635) stalls that refinement between TOL and ACCEPT. The solver
// itself calls such a pose solved, so the cursor keeps working from it and accepts its
// corrected trials at the same tolerance the final validation uses.
let mut trial_tol = TOL;
if initial_residual >= TOL {
let Some((its, residual)) = lm_capped_with_budget(&problem, &lay, &sub, &vars, &mut x, &col, CORRECTION_ITERS, budget.as_deref_mut()) else {
return false;
};
spent += its.max(1);
if !(residual < TOL) {
if residual >= ACCEPT {
return false;
}
if residual >= TOL {
trial_tol = ACCEPT;
}
apply(&mut best, &lay, &x);
if !in_range(&best) || !valid(&problem, &best) {
return false;
@@ -214,7 +223,7 @@ fn move_cursor_towards(
break 'search;
};
spent += its.max(1);
if !(residual < TOL) {
if !(residual < trial_tol) {
if budget.as_ref().is_some_and(|b| b.exhausted()) {
break 'search;
}
@@ -263,27 +272,44 @@ fn in_range(sk: &Sketch) -> bool {
.all(|c| !matches!(c.kind, CurveKind::Circle { r, .. } | CurveKind::Ellipse { r, .. } if !crate::model::radius_in_range(r)))
}
fn null_space(mut j: Mat) -> Vec<Vec<f64>> {
for row in 0..j.rows {
let scale = (0..j.cols).map(|c| j.get(row, c).abs()).fold(0.0_f64, f64::max);
fn null_space(j: Mat) -> Vec<Vec<f64>> {
// Equilibrate before the rank analysis. A near-zero-length construction line makes its
// angle row's entries on that line ~1e7 while the same row's entries on the line it
// measures are ~1: per-row scaling alone hides those (physically meaningful) small
// entries below the pivot tolerance, and the null space then lets the measured line
// rotate freely (#7635). Scaling each column by its largest entry first brings the
// row's entries onto one scale; the null vectors are mapped back afterwards.
let mut col = vec![0.0_f64; j.cols];
for (c, m) in col.iter_mut().enumerate() {
for r in 0..j.rows {
*m = m.max(j.get(r, c).abs());
}
}
let inv: Vec<f64> = col.iter().map(|m| 1.0 / m.max(1.0)).collect();
let mut a = Mat::zeros(j.rows, j.cols);
for r in 0..j.rows {
let scale = (0..j.cols).map(|c| j.get(r, c).abs() * inv[c]).fold(0.0_f64, f64::max);
if scale > 0.0 {
for c in 0..j.cols {
j.set(row, c, j.get(row, c) / scale);
for (c, &ic) in inv.iter().enumerate() {
a.set(r, c, j.get(r, c) * ic / scale);
}
}
}
let pivots = rref(&mut j, NULL_SPACE_TOL);
let pivots = rref(&mut a, NULL_SPACE_TOL);
let mut z: Vec<Vec<f64>> = Vec::new();
for free in (0..j.cols).filter(|c| !pivots.contains(c)) {
let mut v = vec![0.0; j.cols];
for free in (0..a.cols).filter(|c| !pivots.contains(c)) {
let mut v = vec![0.0; a.cols];
if let Some(x) = v.get_mut(free) {
*x = 1.0;
}
for (row, &pivot) in pivots.iter().enumerate() {
if let Some(x) = v.get_mut(pivot) {
*x = -j.get(row, free);
*x = -a.get(row, free);
}
}
for (x, &ic) in v.iter_mut().zip(&inv) {
*x *= ic;
}
for _ in 0..2 {
for q in &z {
let d: f64 = v.iter().zip(q).map(|(a, b)| a * b).sum();
@@ -0,0 +1,62 @@
//! Dragging a sketch whose construction line has collapsed to (near) zero length (#7635).
//!
//! The reporter's design: `l1` with its midpoint pinned at the fixed origin, `l2` perpendicular
//! to `l1` at the origin, and a construction line `l3` coincident with the origin, constrained
//! horizontal, with a 50-degree angle dimension between `l3` and `l1`. `l3`'s ends sit on top of
//! each other, so its angle row's entries on `l3` are ~1e7 while the same row's entries on `l1`
//! are ~1. Dragging an endpoint of `l1` must keep the sketch solved: the cursor may not leave the
//! constraint manifold, and the rank analysis may not hide `l1`'s coupling below its tolerance.
use solidcraft_geom::Vec2;
use crate::{Analysis, ConstraintKind, Hold, Sketch, move_point_towards, solve_with};
fn v(x: f64, y: f64) -> Vec2 {
Vec2::new(x, y)
}
/// The reporter's sketch, at the pose saved in `Sketch bug.solidcraft`: `l3` is a construction
/// line whose ends are ~1e-6 apart at the origin.
fn collapsed_construction_sketch() -> Sketch {
let mut sk = Sketch::new();
let s1 = sk.add_point(v(-6.616478376301535, -7.876608451910095), Some("l1.start")).unwrap();
let e1 = sk.add_point(v(6.616478376301535, 7.876608451910095), Some("l1.end")).unwrap();
let e2 = sk.add_point(v(-10.656000978748368, 8.951213010548841), Some("l2.end")).unwrap();
let s3 = sk.add_point(v(2.814486877637019e-13, -1.946249554158009e-16), Some("l3.start")).unwrap();
let e3 = sk.add_point(v(9.597991615339335e-7, -5.159859446747845e-10), Some("l3.end")).unwrap();
let l1 = sk.add_line_pts(s1, e1, Some("l1")).unwrap();
let l2 = sk.add_line_pts(0, e2, Some("l2")).unwrap();
let l3 = sk.add_line_pts(s3, e3, Some("l3")).unwrap();
sk.add_constraint(ConstraintKind::PointOnCurve { p: 0, c: l1 }, None).unwrap();
sk.add_constraint(ConstraintKind::Midpoint { p: 0, l: l1 }, None).unwrap();
sk.add_constraint(ConstraintKind::Perpendicular { a: l2, b: l1 }, None).unwrap();
sk.add_constraint(ConstraintKind::Horizontal { l: l3 }, None).unwrap();
sk.add_constraint(ConstraintKind::Coincident { p: s3, q: 0 }, None).unwrap();
sk.add_constraint(ConstraintKind::Angle { a: l3, b: l1, value: 50f64.to_radians(), flip: false }, None).unwrap();
sk
}
/// The pose the reporter saved solves.
#[test]
fn the_saved_pose_solves() {
let mut sk = collapsed_construction_sketch();
let rep = solve_with(&mut sk, &Hold::default(), None, Analysis::Full, None);
assert!(rep.ok(), "the saved pose no longer solves: {:?}", rep.failing);
}
/// Dragging `l1.end` off the 50-degree line: the exact target is unreachable (the midpoint and
/// the angle dimension pin `l1`'s inclination), so the cursor must stay on the manifold: the
/// sketch solves afterwards and `l1.end` keeps the inclination the constraints pin.
#[test]
fn dragging_the_midpoint_line_end_keeps_the_sketch_solved() {
let mut sk = collapsed_construction_sketch();
let e1 = 2; // l1.end
let ok = move_point_towards(&mut sk, e1, v(10.0, 4.0), 2.0, None, |_, _| true);
assert!(ok, "the cursor gave up on a solved sketch");
let rep = solve_with(&mut sk, &Hold::default(), None, Analysis::StatusOnly, None);
assert!(rep.ok(), "the drag broke the sketch: {:?}", rep.failing);
// `l1.end` stayed on the 50-degree line through the origin: the angle dimension held.
let at = sk.points[e1].pos;
let off = (at.y.atan2(at.x) - 50f64.to_radians()).abs();
assert!(off < 1e-3, "l1.end went to {at:?} (off its line by {off} rad)");
}
+2
View File
@@ -88,6 +88,8 @@ mod construct_tests;
#[cfg(test)]
mod continuation_tests;
#[cfg(test)]
mod degenerate_line_tests;
#[cfg(test)]
mod ends_tests;
#[cfg(test)]
mod font_tests;