Sketch drag: keep the far end of a tangent line still (#4925)

Dragging one end of a line tangent to a circle or arc let the solver move the
line's other end too, sometimes far ("goes flying"): only the dragged point was
held, and the least-squares step spread the change over the free points. The
drag now first tries holding the line's far end as well, and falls back to the
old solve only when that can't be met. Dragging the end of a tangent line to
(5, 12) moved its other end 0.399 mm on 0.19.0; it now stays put.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dudedagger42
2026-10-24 21:20:15 +00:00
committed by GitHub
parent 96661111f9
commit a2ae3ffbe0
2 changed files with 75 additions and 1 deletions
+47 -1
View File
@@ -155,6 +155,12 @@ pub(super) fn drag_entity(
let Some((path, hold, n, short)) = prepare(sk, e, with, from, to) else {
return (Dragged::default(), Left::Unsolved);
};
// A point dragged alone that ends tangent lines: each step first tries with their other ends
// held too, and only when that can't be solved lets them move. Unheld, the solver spread its
// correction over every free point, so the line's far end moved (towards the dragged one)
// where the curve it is tangent to could have taken the change, as holding that end by hand
// showed.
let keep = keep_line_ends(sk, e, with, &hold);
#[cfg(test)]
let (n, short) = (n.min(step_cap::get()), short.min(step_cap::get()));
let moving: Vec<_> = path.points().filter_map(|q| Some((q, sk.point(q)?))).collect();
@@ -172,7 +178,15 @@ pub(super) fn drag_entity(
let mut own = Budget::full();
let budget = frame.as_mut().unwrap_or(&mut own);
let spent = budget.spent();
let ok = counted_solve(sk, &hold, Some(&last.pos), Analysis::StatusOnly, Some(&mut *budget)).ok();
let kept = keep.as_ref().is_some_and(|keep| {
let ok = counted_solve(sk, keep, Some(&last.pos), Analysis::StatusOnly, Some(&mut *budget)).ok() && !last.sweep_wrapped(sk);
if !ok {
last.restore(sk);
path.apply(sk, t);
}
ok
});
let ok = kept || counted_solve(sk, &hold, Some(&last.pos), Analysis::StatusOnly, Some(&mut *budget)).ok();
solves.count += 1;
solves.work += budget.spent() - spent;
solves.cut |= budget.exhausted();
@@ -477,6 +491,38 @@ pub(super) fn drag_steps(sk: &Sketch, e: Ent, from: Vec2, to: Vec2) -> usize {
/// A drag's path, what its solves hold and its number of steps (and of short steps, see
/// `SHORT_STEP_FRACTION`), or `None` if it cannot move.
/// `hold` plus the far ends of the tangent lines a lone dragged point ends (not locked ones, nor the
/// point itself), or `None` when there are none.
fn keep_line_ends(sk: &Sketch, e: Ent, with: &[Ent], hold: &Hold) -> Option<Hold> {
let Ent::Point(q) = e else { return None };
if !with.is_empty() {
return None;
}
let locked = sk.locked_points();
let mut keep = hold.clone();
// Only lines tangent to a curve: there the far end is what the solver chose to move, where a
// free curve could take the change. Other drags keep their one solve a frame.
let tangent = |line: usize| sk.constraints.iter().any(|k| matches!(k.kind, ConstraintKind::Tangent { a, b } if a == line || b == line));
for (i, c) in sk.curves.iter().enumerate() {
if let CurveKind::Line { a, b } = c.kind {
if !tangent(i) {
continue;
}
let far = if a == q {
b
} else if b == q {
a
} else {
continue;
};
if far != q && !locked.get(far).copied().unwrap_or(true) && !keep.points.contains(&far) {
keep.points.push(far);
}
}
}
(keep.points.len() > hold.points.len()).then_some(keep)
}
fn prepare(sk: &Sketch, e: Ent, with: &[Ent], from: Vec2, to: Vec2) -> Option<(Path, Hold, usize, usize)> {
if !(from.is_finite() && to.is_finite()) {
return None;
+28
View File
@@ -1666,3 +1666,31 @@ fn cancel_refuses_once_undo_has_gone_back_past_where_the_sketch_was_opened() {
assert!(e.contains("Undo"), "{e}");
assert_eq!(s.doc.to_json(), before, "nothing changed");
}
/// A line tangent to a free circle, one end dragged off the line: the other end stays where it
/// is and the circle takes the change (it moved the far end, by 0.4 mm towards the dragged one
/// for a 5 mm pull, though nothing needed it to).
#[test]
fn dragging_an_end_of_a_tangent_line_leaves_its_other_end_still() {
let mut s = new_sketch();
let c = run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 10}))["curves"][0].as_str().unwrap().to_string();
let l = run(&mut s, "sketch.line", json!({"points": [[-20, 10], [20, 10]], "infer": false, "connect": false}))["curves"][0]
.as_str()
.unwrap()
.to_string();
run(&mut s, "sketch.constraint.tangent", json!({"a": l, "b": c}));
let at = |s: &Session, id: &str| {
let sk = sketch(s);
sk.resolve_point(id).and_then(|i| sk.point(i)).unwrap()
};
let start = at(&s, &format!("{l}.start"));
drag(&mut s, &format!("{l}.end"), [20.0, 10.0], [5.0, 12.0]);
assert!(at(&s, &format!("{l}.start")).dist(start) < 1e-7, "the far end moved: {:?}", at(&s, &format!("{l}.start")));
assert!(
at(&s, &format!("{l}.end")).dist(solidcraft_geom::Vec2::new(5.0, 12.0)) < 1e-6,
"the end went where dragged: {:?}",
at(&s, &format!("{l}.end"))
);
let si = run(&mut s, "sketch.inspect", json!({}));
assert!(si["failing"].as_array().is_some_and(Vec::is_empty), "still tangent: {si}");
}