SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch drag: a step that throws points far from the sketch, or presses a line to no length, counts as failed (#8600)
semmelrindec392791f2ca4
diff --git a/crates/engine/src/cmd/sketch_drag.rs b/crates/engine/src/cmd/sketch_drag.rsindex e039c330ca..f8920ed8bd 100644--- a/crates/engine/src/cmd/sketch_drag.rs+++ b/crates/engine/src/cmd/sketch_drag.rs@@ -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 linediff --git a/crates/engine/tests/sketch_drag_target.rs b/crates/engine/tests/sketch_drag_target.rsindex d425c03c4b..1d72ac72a0 100644--- a/crates/engine/tests/sketch_drag_target.rs+++ b/crates/engine/tests/sketch_drag_target.rs@@ -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, ¶ms).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, ¶ms).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})");+ }+}