Sketch drag: a step that throws points far from the sketch, or presses a line to no length, counts as failed (#8600)

* Sketch drag: a step that throws points far from the sketch counts as failed

A held step of a drag that moved a point more than 1000 times the sketch's
size plus the drag's way was taken as solved, so a drag could leave points
around 1.4e6 mm away while reporting it reached the cursor. Such a step now
fails like one the solver cannot solve, and the cursor correction refuses it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Sketch drag: a step that presses a line to no length counts as failed too

An end dragged past the point where its line would have to turn over (a
line held at its midpoint and by an angle, dragged past the midpoint; a
rectangle's corner dragged across the opposite side) pressed the line to no
length, where it has no direction left for its constraints. A step leaving a
line under 1/1000 of its length at the drag's start now fails like one that
throws points far away, so the drag stops just short of it (48 such drags in
4000 random sketches, none with this).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
semmelrindeandClaude Opus 5.5 authored and GitHub committed 2026-10-31 16:45:35 +00:00
1 parent 0fb2e9b06b
commit c392791f2c
2 files changed
+105 -1

No files matched your search

+55 -1
View File
@@ -48,6 +48,10 @@ const SWEEP_EPS: f64 = 1e-6;
const SHRINK_FROM: f64 = 1e-3;
const SHRINK_TO: f64 = 1e-4;
/// A step that moves some point further than this many times the sketch's size and the
/// drag's way has thrown the geometry to a far solution: it is taken as failed.
const FLUNG: f64 = 1000.0;
/// What a drag moves, from where it is (`t = 0`) to where the cursor puts it (`t = 1`).
enum Path {
/// Points slide by `d` (a dragged point by its way to the cursor).
@@ -176,6 +180,10 @@ pub(super) fn drag_entity(
let line_grab = if with.is_empty() { LineGrab::new(sk, e, from) } else { None };
let start = line_grab.and_then(|g| g.point(sk)).or_else(|| if let Ent::Point(q) = e { sk.point(q) } else { None });
let mut frame = live.then(frame_budget);
let reach = FLUNG * (extent(sk) + path.length()).max(1.0);
// The sketch as the drag found it: no step may press one of its lines to no length.
let mut as_found = Geometry::default();
as_found.take(sk);
// Only success matters to these solves: the degrees of freedom of a sketch with the entity
// held are not the sketch's. Each is seeded on the last solved state (`last`), so what the
// constraints pin down keeps the orientation it had there. A failed or wrapping step is
@@ -211,6 +219,8 @@ pub(super) fn drag_entity(
Step::Failed
} else if last.sweep_wrapped(sk) {
Step::Wrapped
} else if last.flung(sk, reach) || as_found.squashed(sk) {
Step::Failed
} else {
return Step::Solved;
};
@@ -342,7 +352,11 @@ pub(super) fn drag_entity(
let valid = |before: &Sketch, after: &Sketch| {
let mut geometry = Geometry::default();
geometry.take(before);
!geometry.sweep_wrapped(after) && !geometry.shrank(after) && solidcraft_sketch::fillets_kept(before, after)
!geometry.sweep_wrapped(after)
&& !geometry.shrank(after)
&& !geometry.flung(after, reach)
&& !as_found.squashed(after)
&& solidcraft_sketch::fillets_kept(before, after)
};
let followed = match (e, line_grab) {
(Ent::Point(q), _) => solidcraft_sketch::move_point_towards(sk, q, to, max_step, frame.as_mut(), valid),
@@ -582,6 +596,23 @@ impl Geometry {
}
}
/// Did the step press a line to (nearly) no length: under 1/1000 of what it had when this
/// geometry was taken? A line with no length has no direction left for the constraints on
/// it, so an end dragged past the point where its line would have to turn over stops there.
fn squashed(&self, sk: &Sketch) -> bool {
self.curves.iter().any(|(kind, _)| {
let CurveKind::Line { a, b } = *kind else { return false };
let (Some(a0), Some(b0)) = (self.pos.get(a), self.pos.get(b)) else { return false };
let before = a0.dist(*b0);
before > 1e-3 && sk.point(a).zip(sk.point(b)).is_some_and(|(a1, b1)| a1.dist(b1) < before * 1e-3)
})
}
/// Did the step throw some point further than `reach` (or to no number at all)?
fn flung(&self, sk: &Sketch, reach: f64) -> bool {
sk.points.iter().zip(&self.pos).any(|(p, was)| !(p.pos.dist(*was) <= reach))
}
/// Did the step drive some arc's end through its start: the sweep jumped through 0 / a full
/// turn, or ran from clear of them onto one? An arc already that close may still move.
/// Measured on the arc's ends as they were before the step (a solve may swap them).
@@ -827,6 +858,29 @@ impl Group<'_> {
}
}
/// The size of the sketch: the diagonal of its points' box and its circles' diameters.
fn extent(sk: &Sketch) -> f64 {
let (lo, hi) = sk
.points
.iter()
.map(|p| p.pos)
.filter(|p| p.x.is_finite() && p.y.is_finite())
.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)))
});
let radius = sk
.curves
.iter()
.filter_map(|c| match c.kind {
CurveKind::Circle { r, .. } | CurveKind::Ellipse { r, .. } => Some(r.abs()),
_ => None,
})
.filter(|r| r.is_finite())
.fold(0.0, f64::max);
let diagonal = if lo.x <= hi.x { lo.dist(hi) } else { 0.0 };
diagonal + 2.0 * radius
}
/// The smallest size that can make a constrained shape take another solution (of the geometry
/// in `group`, or of the whole sketch), or infinity when there is none: every length the
/// constraints hold. That is driving length dimensions (offsets along an axis or from a line
+50
View File
@@ -446,3 +446,53 @@ fn a_linkage_held_by_redundant_parallelograms_follows_the_cursor() {
assert!(parallelogram_error(&s) < 1e-6);
}
}
#[test]
fn a_drag_that_would_fling_points_far_away_leaves_them_near_the_sketch() {
let mut s = solidcraft_engine::Session::default();
for (id, params) in [
("sketch.create", json!({"plane":"XY"})),
("sketch.line", json!({"points":[[2,-27],[-2,22],[-10,-10],[2,13]]})),
("sketch.rectangle.two_point", json!({"p0":[-12,1],"p1":[-18,28]})),
("sketch.line", json!({"points":[[6,-21],[-12,-27],[-25,-29],[16,5]]})),
("sketch.rectangle.two_point", json!({"p0":[-21,0],"p1":[-23,-3]})),
("sketch.line", json!({"points":[[24,23],[-7,7],[0,29],[-6,-7]]})),
("sketch.dimension", json!({"entities":["l16","l12"],"type":"angle","value":31})),
] {
s.execute(id, &params).unwrap();
}
s.execute("sketch.drag", &json!({"entity":"p8","from":[-23.0,-0.534780330115472],"to":[23,-8]})).unwrap();
for i in 0..30 {
let Ok(p) = four_bar::point(&s, &format!("p{i}")) else { continue };
assert!(p.len() < 1000.0, "p{i} was thrown to {p:?}");
}
}
/// A line held at its midpoint, with an angle to a horizontal line from there: its end dragged
/// past the midpoint, where the line would have to turn over, pressed it to no length (the angle
/// then held no direction). The drag now stops just short of that, the line still pointing the
/// way the angle says.
#[test]
fn an_end_dragged_past_its_lines_midpoint_leaves_the_line_a_length() {
for live in [false, true] {
let mut s = solidcraft_engine::Session::default();
for (id, params) in [
("sketch.create", json!({"plane":"XY"})),
("sketch.line", json!({"points":[[-10,-6],[10,6]],"infer":false})),
("sketch.constraint.midpoint", json!({"line":"l1","point":"origin"})),
("sketch.line", json!({"points":["origin",[15,0]],"infer":false})),
("sketch.constraint.horizontal_vertical", json!({"line":"l2"})),
("sketch.dimension", json!({"entities":["l1","l2"],"type":"angle"})),
("sketch.drag", json!({"entity":"l1.start","from":[-10,-6],"to":[12,4],"live":live})),
] {
s.execute(id, &params).unwrap();
}
if live {
s.execute("sketch.drag_end", &json!({})).unwrap();
}
let (a, b) = (four_bar::point(&s, "l1.start").unwrap(), four_bar::point(&s, "l1.end").unwrap());
assert!(a.dist(b) > 1e-3, "l1 is left {} mm long (live {live})", a.dist(b));
let d = b - a;
assert!((d.y.atan2(d.x) - 6f64.atan2(10.0)).abs() < 1e-6, "l1 turned to {d:?} (live {live})");
}
}