SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Fix constrained point dragging within the shared frame budget (#1976) (#1977)
takuto-NA3a9b053f5b05
diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rsindex f97f4575fc..34468fcd03 100644--- a/crates/engine/src/cmd/sketch.rs+++ b/crates/engine/src/cmd/sketch.rs@@ -179,7 +179,7 @@ pub static COMMANDS: &[CommandSpec] = &[.params("entities: [curve, point or constraint ids]"),CommandSpec::new("sketch.move_point", "Drag Sketch Point", move_point).icon("sketch_move").enabled(in_sketch).params("point: ref, to: [x,y]"),CommandSpec::new("sketch.drag", "Drag Sketch Geometry", drag).icon("sketch_move").enabled(in_sketch).live(drag_live).params(- "entity: point or curve, from: [x,y] where it was grabbed, to: [x,y], live?: bool: a point goes to `to`, a line (spline, conic) slides by to - from, a circle or arc grabbed on its edge takes the radius to `to`; the rest moves as little as it can and keeps its solution branch (a long move is followed in short steps, each solved with the entity held; a step that cannot be solved that way is approached as far as it can be and the next ones tried; when none past it solves, the last one is left to the sketch's ordinary solve, which may pull it back or leave the sketch unsolved; a step that would sweep an arc through its start is undone and the drag ends there). Returns `reached`: how much of the way from `from` to `to` the geometry followed (0..1), and `at`: where the grabbed spot went (`from` moved as the dragged points did), the `from` of the next move. `live: true` (each frame of an interactive drag) solves the sketch once and leaves the features after it as they were (stale) until `sketch.drag_end` or any command that reads the model; `dof` is then the one from before the drag",+ "entity: point or curve, from: [x,y] where it was grabbed, to: [x,y], live?: bool: a point moves toward `to` within the design constraints; when exact cursor placement is impossible, bounded feasible steps minimize cursor distance while keeping design constraints mandatory. A line (spline, conic) slides by to - from; a circle or arc grabbed on its edge takes the radius to `to`. Long moves use continuation to retain the solution branch, and a step that would sweep an arc through its start is rejected. Returns `reached`: progress along the requested move (0..1; feasible point motion projects its actual displacement onto that move), and `at`: where the grabbed spot went (`from` moved as the dragged points did), the `from` of the next move. `live: true` solves the sketch and leaves later features stale until `sketch.drag_end` or a command that reads the model; `dof` is then the one from before the drag",),CommandSpec::new("sketch.drag_end", "End Sketch Drag", drag_end).icon("sketch_move").enabled(in_sketch).doc_only().params("constraint?: {command: a sketch.constraint.* id, params}: ends a drag made of `sketch.drag` `live: true` frames: adds the constraint it let go on (not kept if it over-constrains the sketch), then evaluates the whole model once; returns the constraint's result and the sketch's solved state and degrees of freedom",diff --git a/crates/engine/src/cmd/sketch_drag.rs b/crates/engine/src/cmd/sketch_drag.rsindex 9e175e9ba2..8899230325 100644--- a/crates/engine/src/cmd/sketch_drag.rs+++ b/crates/engine/src/cmd/sketch_drag.rs@@ -104,29 +104,31 @@ impl Path {}}-/// Drag: the grabbed entity follows the cursor exactly (a point goes to it; a line or spline+/// Drag: the grabbed entity follows the cursor where possible (a point moves toward it; a line or spline/// slides by the cursor's move; a circle or arc grabbed on its edge changes radius about its/// centre; a conic grabbed on its curve reads its fullness, `rho`, off the cursor) and the rest/// of the sketch moves as little as it can, staying on the/// solution it started on. Fixed geometry stays. A step that cannot be solved with the entity/// held (the path crosses where the geometry cannot reach) is approached by halving the way to/// it, and the next steps are tried from the last solved state, the last of them being the whole-/// remaining move. When none past it solves, the first failed step stays placed but unsolved:+/// remaining move. A point whose exact pin fails instead minimizes cursor distance in the+/// design's remaining freedom, retaining only corrected, feasible poses. For other entities,+/// when none past it solves, the first failed step stays placed but unsolved:/// the edit's ordinary, non-strict solve that follows (seeded on the last solved state, see/// [`Left::MovedFrom`]) then pulls it back (fully constrained geometry) or leaves the sketch/// unsolved for the user to see. A step that would sweep an arc through its own start is undone/// and the drag ends there. Returns how far it got and what it leaves for the edit's solve/// ([`Left::Solved`]: the held solve of the last step it kept left the sketch solved).///-/// `live`: one frame of an interactive drag, whose held solves share one frame's decomposition-/// budget ([`Budget::frame`]); otherwise each has a solve's own.+/// `live`: one frame of an interactive drag, whose held solves and cursor correction share+/// one frame's work budget ([`Budget::frame`]); otherwise each has a solve's own.pub(super) fn drag_entity(sk: &mut Sketch, e: Ent, from: Vec2, to: Vec2, live: bool) -> (Dragged, Left) {let Some((path, hold, n, short)) = prepare(sk, e, from, to) else {return (Dragged { reached: 0.0, moving: Vec::new() }, Left::Unsolved);};#[cfg(test)]let (n, short) = (n.min(step_cap::get()), short.min(step_cap::get()));- let moving = path.points().filter_map(|q| Some((q, sk.point(q)?))).collect();+ let moving: Vec<_> = path.points().filter_map(|q| Some((q, sk.point(q)?))).collect();let mut frame = live.then(frame_budget);// 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@@ -211,6 +213,41 @@ pub(super) fn drag_entity(sk: &mut Sketch, e: Ent, from: Vec2, to: Vec2, live: bfailed = Some(t);}}+ // First retain held continuation across unreachable stretches of an otherwise reachable+ // path (for example an arm dragged through the hole around its shoulder). If it cannot+ // arrive, optimize the full cursor target without relaxing the design constraints.+ if failed.is_some()+ && let Ent::Point(q) = e+ {+ let (points, radii) = sk.coupled(&hold.points, &hold.radii);+ let size = smallest_size(sk, &hold, Some(Group { points: &points, radii: &radii }));+ let max_step = (size * SHORT_STEP_FRACTION).min(path.length()).max(MIN_STEP);+ #[cfg(test)]+ let spent = frame.as_ref().map_or(0, Budget::spent);+ let followed = solidcraft_sketch::move_point_towards(sk, q, to, max_step, frame.as_mut(), |before, after| {+ let mut geometry = Geometry::default();+ geometry.take(before);+ !geometry.sweep_wrapped(after)+ });+ #[cfg(test)]+ if let Some(budget) = &frame {+ solves.work += budget.spent() - spent;+ solves.cut |= budget.exhausted();+ }+ if followed {+ #[cfg(test)]+ last_drag::set(solves);+ let reached = moving+ .iter()+ .find(|(p, _)| *p == q)+ .and_then(|(_, start)| {+ let d = to - *start;+ sk.point(q).map(|at| if at.dist(to) < 1e-6 || d.dot(d) == 0.0 { 1.0 } else { ((at - *start).dot(d) / d.dot(d)).clamp(0.0, 1.0) })+ })+ .unwrap_or(0.0);+ return (Dragged { reached, moving }, Left::Solved);+ }+ }#[cfg(test)]last_drag::set(solves);let left = match failed {@@ -225,8 +262,8 @@ pub(super) fn drag_entity(sk: &mut Sketch, e: Ent, from: Vec2, to: Vec2, live: b(Dragged { reached: good, moving }, left)}-/// The held solves of one drag: how many, the decomposition work they did, and whether one ran-/// out of budget.+/// The held solves of one drag: how many, their shared work (including cursor correction),+/// and whether it ran out of budget.#[derive(Clone, Copy, Debug, Default, PartialEq)]pub(super) struct Solves {pub count: usize,diff --git a/crates/engine/src/cmd/sketch_ux_tests.rs b/crates/engine/src/cmd/sketch_ux_tests.rsindex 0e1c183011..c637d3bd7a 100644--- a/crates/engine/src/cmd/sketch_ux_tests.rs+++ b/crates/engine/src/cmd/sketch_ux_tests.rs@@ -1524,3 +1524,22 @@ fn the_first_dimension_does_not_scale_a_sketch_that_has_a_size() {let out = run(&mut s, "sketch.dimension", json!({"entities": ["l1", "l2"], "value": "60 deg", "scale_sketch": true}));assert!(out.get("scaled").is_none(), "{out}");}++/// The cursor fallback shares the held solves' frame budget; a scripted drag can finish later.+#[test]+fn cursor_fallback_respects_an_exhausted_live_frame_budget() {+ let mut s = new_sketch();+ run(&mut s, "sketch.line", json!({"points": [[0, 0], [-10, 0]], "ids": ["crank"], "infer": false}));+ run(&mut s, "sketch.dimension", json!({"entities": ["crank"], "value": 10}));+ let target = v(-10.0, 16.0);+ let nearest = target * (10.0 / target.len());+ super::drag::last_drag::with_frame_work(0, || {+ run(&mut s, "sketch.drag", json!({"entity": "crank.end", "from": [-10, 0], "to": [target.x, target.y], "live": true}));+ });+ let at = pt(&s, "crank.end");+ assert!(at.dist(nearest) > 1.0, "an exhausted frame must not start unbudgeted cursor work: {at:?}");+ assert!((at.len() - 10.0).abs() < 1e-6);+ assert!(s.model.state().sketch(s.active_sketch.unwrap()).unwrap().report.ok());+ run(&mut s, "sketch.drag", json!({"entity": "crank.end", "from": [at.x, at.y], "to": [target.x, target.y], "live": false}));+ assert!(pt(&s, "crank.end").dist(nearest) < 1e-4, "scripted motion retains the full cursor objective");+}diff --git a/crates/engine/tests/sketch_drag_target.rs b/crates/engine/tests/sketch_drag_target.rsnew file mode 100644index 0000000000..e7d1a9ca95--- /dev/null+++ b/crates/engine/tests/sketch_drag_target.rs@@ -0,0 +1,107 @@+//! Cursor distance is minimized within the design's freedom; lengths stay mandatory.+#[path = "support/four_bar.rs"]+mod four_bar;++use serde_json::json;+use solidcraft_geom::Vec2;++fn drag(s: &mut solidcraft_engine::Session, target: Vec2) {+ let from = four_bar::point(s, "crank.end").unwrap();+ s.execute("sketch.drag", &json!({"entity":"crank.end","from":[from.x,from.y],"to":[target.x,target.y],"live":true})).unwrap();+}++#[test]+fn four_bar_large_off_locus_drag_reaches_the_closest_feasible_point() {+ for target in [Vec2::new(-10.0, 8.0), Vec2::new(-10.0, -8.0), Vec2::new(20.0, 20.0), Vec2::new(20.0, 0.0), Vec2::new(1000.0, -1000.0)] {+ let mut s = four_bar::session().unwrap();+ let side = four_bar::branch(&s).unwrap();+ drag(&mut s, target);+ let actual = four_bar::point(&s, "crank.end").unwrap();+ let nearest = target * (10.0 / target.len());+ assert!(actual.dist(nearest) < 1e-4, "target {target:?}, actual {actual:?}, expected {nearest:?}");+ assert!(four_bar::length_error(&s).unwrap() < 1e-6);+ assert_eq!(four_bar::branch(&s).unwrap(), side);+ let state = s.model.state();+ let report = &state.sketch(s.active_sketch.unwrap()).unwrap().report;+ assert!(report.ok());+ assert_eq!(report.dof, 1);+ s.execute("sketch.drag_end", &json!({})).unwrap();+ assert!(four_bar::point(&s, "crank.end").unwrap().dist(nearest) < 1e-4);+ s.execute("edit.undo", &json!({})).unwrap();+ assert!(four_bar::point(&s, "crank.end").unwrap().dist(Vec2::new(-10.0, 0.0)) < 1e-7);+ }+}++#[test]+fn four_bar_reverse_motion_and_stationary_cursor_do_not_drift() {+ let mut s = four_bar::session().unwrap();+ let side = four_bar::branch(&s).unwrap();+ for target in [Vec2::new(-10.0, 16.0), Vec2::new(-10.0, -16.0), Vec2::new(0.0, 25.0), Vec2::new(0.0, -25.0)] {+ drag(&mut s, target);+ let at = four_bar::point(&s, "crank.end").unwrap();+ assert!(+ at.dist(target * (10.0 / target.len())) < 1e-4,+ "target {target:?}, actual {at:?}, length error {}",+ four_bar::length_error(&s).unwrap()+ );+ for _ in 0..8 {+ drag(&mut s, target);+ assert!(four_bar::point(&s, "crank.end").unwrap().dist(at) < 1e-4);+ assert!(four_bar::length_error(&s).unwrap() < 1e-6);+ assert_eq!(four_bar::branch(&s).unwrap(), side);+ }+ }+}++#[test]+fn four_bar_one_event_and_split_moves_agree_and_keep_the_branch() {+ let target = Vec2::new(-10.0, 16.0);+ let mut single = four_bar::session().unwrap();+ let mut split = four_bar::session().unwrap();+ let start = four_bar::point(&single, "crank.end").unwrap();+ let side = four_bar::branch(&single).unwrap();+ drag(&mut single, target);+ for i in 1..=16 {+ drag(&mut split, start + (target - start) * (i as f64 / 16.0));+ assert!(four_bar::length_error(&split).unwrap() < 1e-6);+ assert_eq!(four_bar::branch(&split).unwrap(), side);+ }+ assert!(four_bar::point(&single, "crank.end").unwrap().dist(four_bar::point(&split, "crank.end").unwrap()) < 1e-4);+}++#[test]+fn four_bar_live_cursor_motion_updates_driven_dimensions_before_release() {+ let mut s = four_bar::session().unwrap();+ s.execute("sketch.dimension", &json!({"entities": ["crank"], "type": "horizontal", "driven": true})).unwrap();+ let id = s.active_sketch.unwrap();+ let dimension = s.doc.sketch(id).unwrap().constraints.last().unwrap().id.clone();+ drag(&mut s, Vec2::new(-10.0, 8.0));+ let at = four_bar::point(&s, "crank.end").unwrap();+ assert!(at.dist(Vec2::new(-10.0, 8.0) * (10.0 / 164.0_f64.sqrt())) < 1e-4);+ let state = s.model.state();+ for sketch in [s.doc.sketch(id).unwrap(), &state.sketch(id).unwrap().sketch] {+ let c = sketch.constraints.iter().find(|c| c.id == dimension).unwrap();+ assert!(c.driven);+ assert!((c.kind.value().unwrap() - at.x.abs()).abs() < 1e-6, "reference dimension must measure the final live pose: {:?}", c.kind);+ }+}++#[test]+fn four_bar_other_joint_follows_the_rocker_arc_and_its_limits() {+ let base = Vec2::new(42.0, 0.0);+ let lo = -(-1264.0_f64 / 1680.0).acos();+ let hi = -(0.2_f64).acos();+ for angle in [-2.6_f64, -2.1, -1.5, -1.1] {+ let mut s = four_bar::session().unwrap();+ let side = four_bar::branch(&s).unwrap();+ let from = four_bar::point(&s, "coupler.end").unwrap();+ let target = base + Vec2::new(angle.cos(), angle.sin()) * 60.0;+ let nearest = base + Vec2::new(angle.clamp(lo, hi).cos(), angle.clamp(lo, hi).sin()) * 20.0;+ s.execute("sketch.drag", &json!({"entity":"coupler.end","from":[from.x,from.y],"to":[target.x,target.y],"live":true})).unwrap();+ assert!(four_bar::point(&s, "coupler.end").unwrap().dist(nearest) < 1e-4, "angle {angle}");+ assert!(four_bar::length_error(&s).unwrap() < 1e-6);+ assert_eq!(four_bar::branch(&s).unwrap(), side);+ s.execute("sketch.drag_end", &json!({})).unwrap();+ assert!(four_bar::point(&s, "coupler.end").unwrap().dist(nearest) < 1e-4);+ }+}diff --git a/crates/engine/tests/support/four_bar.rs b/crates/engine/tests/support/four_bar.rsnew file mode 100644index 0000000000..8ec6366f28--- /dev/null+++ b/crates/engine/tests/support/four_bar.rs@@ -0,0 +1,45 @@+//! Public-safe 10/40/20/42 mm linkage, matching the reported one-degree-of-freedom sketch.+use serde_json::json;+use solidcraft_engine::Session;+use solidcraft_geom::Vec2;++pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;++pub fn session() -> Result<Session> {+ let mut s = Session::default();+ s.execute("sketch.create", &json!({"plane":"XZ"}))?;+ let x = -10.0 + (1600.0 - 400.0 + 52.0 * 52.0) / 104.0;+ let y = -(1600.0_f64 - (x + 10.0) * (x + 10.0)).sqrt();+ s.execute("sketch.line", &json!({"points":[[0,0],[-10,0],[x,y],[42,0]],"ids":["crank","coupler","rocker"],"infer":false}))?;+ s.execute("sketch.line", &json!({"points":["crank.start","rocker.end"],"ids":["ground"],"infer":false}))?;+ for (line, length) in [("crank", 10.0), ("coupler", 40.0), ("rocker", 20.0), ("ground", 42.0)] {+ s.execute("sketch.dimension", &json!({"entities":[line],"value":length}))?;+ }+ s.execute("sketch.constraint.horizontal_vertical", &json!({"line":"ground"}))?;+ Ok(s)+}++pub fn point(s: &Session, name: &str) -> Result<Vec2> {+ let sk = s.doc.sketch(s.active_sketch.ok_or("missing active sketch")?)?;+ sk.resolve_point(name).and_then(|p| sk.point(p)).ok_or_else(|| format!("missing point {name}").into())+}++pub fn length_error(s: &Session) -> Result<f64> {+ let mut error = 0.0_f64;+ for (a, b, length) in [+ ("crank.start", "crank.end", 10.0),+ ("coupler.start", "coupler.end", 40.0),+ ("rocker.start", "rocker.end", 20.0),+ ("ground.start", "ground.end", 42.0),+ ] {+ error = error.max((point(s, a)?.dist(point(s, b)?) - length).abs());+ }+ error = error.max(point(s, "crank.start")?.len());+ error = error.max(point(s, "ground.end")?.dist(Vec2::new(42.0, 0.0)));+ Ok(error)+}++pub fn branch(s: &Session) -> Result<f64> {+ let a = point(s, "crank.end")?;+ Ok((point(s, "rocker.end")? - a).cross(point(s, "coupler.end")? - a).signum())+}diff --git a/crates/sketch/src/cursor.rs b/crates/sketch/src/cursor.rsnew file mode 100644index 0000000000..36bdf923db--- /dev/null+++ b/crates/sketch/src/cursor.rs@@ -0,0 +1,296 @@+//! Feasible cursor motion: optimize only within the design Jacobian's null space, then+//! retract to the constraint manifold. Mouse error never competes with design residuals.+use super::{+ ACCEPT, Hold, Layout, State, TOL, build_blocks, columns, initial_x, layout, lm_capped_with_budget, local_system, max_abs, points_on_curves,+ residual_work, system, within_budget,+};+use crate::{+ Budget, CurveKind, Sketch,+ linalg::{Mat, rref},+ union_find::{find, union},+};+use solidcraft_geom::Vec2;++const MAX_VARIABLES: usize = 400;+const MAX_STEPS: usize = 96;+const CORRECTION_ITERS: usize = 16;+const TOTAL_CORRECTION_ITERS: usize = 256;++/// Move a point toward `target` using freedom left by the design constraints. `max_step`+/// bounds the full variable displacement before constraint correction; `valid` can reject+/// a corrected candidate (for example, an arc crossing its own start). Only feasible,+/// cursor-improving candidates are committed. False leaves the sketch unchanged when the+/// input is unsolved, invalid or outside the dense-work limit. Work is bounded; true may+/// retain the best feasible pose when the iteration or optional shared frame-work budget is+/// exhausted. The work budget includes Jacobian, null-space and LM arithmetic, not wall time.+pub fn move_point_towards(+ sk: &mut Sketch,+ point: usize,+ target: Vec2,+ max_step: f64,+ mut budget: Option<&mut Budget>,+ valid: impl Fn(&Sketch, &Sketch) -> bool,+) -> bool {+ let setup_work = sk.points.len().saturating_add(sk.curves.len()).saturating_add(sk.constraints.len()).max(1);+ if !within_budget(&mut budget, setup_work) {+ return false;+ }+ if !crate::model::in_range(target) || !max_step.is_finite() || max_step <= 0.0 || !in_range(sk) {+ return false;+ }+ let problem = sk.clone();+ let lay = layout(&problem, &Hold::default());+ let Some(px) = lay.pvar.get(point).copied().flatten() else { return false };+ let (blocks, _) = build_blocks(&problem, &lay, &points_on_curves(&problem));+ let mut parent: Vec<usize> = (0..lay.n).collect();+ union(&mut parent, px, px + 1);+ for (_, vars) in &blocks {+ if let Some(&first) = vars.first() {+ for &v in vars.iter().skip(1) {+ union(&mut parent, first, v);+ }+ }+ }+ let root = find(&mut parent, px);+ let vars: Vec<usize> = (0..lay.n).filter(|v| find(&mut parent, *v) == root).collect();+ if vars.len() > MAX_VARIABLES {+ return false;+ }+ let sub: Vec<_> =+ blocks.iter().filter(|(_, v)| v.iter().any(|i| vars.binary_search(i).is_ok())).map(|(b, v)| (super::copy_block(b), v.clone())).collect();+ // Reserve both initial and final all-block validation before starting cursor work.+ // An exhausted search can then keep its best feasible pose, including unrelated blocks.+ if !within_budget(&mut budget, residual_work(&lay, &blocks).saturating_mul(2)) {+ return false;+ }+ let mut x = initial_x(&problem, &lay);+ let initial_residual = max_abs(&system(&problem, &lay, &blocks, &mut x, false).0);+ if initial_residual >= ACCEPT {+ return false;+ }+ let mut col = vec![usize::MAX; lay.n];+ columns(&mut col, &vars, &vars);+ let (Some(ix), Some(iy)) = (vars.iter().position(|v| *v == px), vars.iter().position(|v| *v == px + 1)) else { return false };+ let mut best = problem.clone();+ let mut spent = 0;+ // 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.+ 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) {+ return false;+ }+ apply(&mut best, &lay, &x);+ if !in_range(&best) || !valid(&problem, &best) {+ return false;+ }+ }+ let mut gain = 1.0_f64;+ for _ in 0..MAX_STEPS {+ let at = State { sk: &problem, lay: &lay, x: &x }.p(point);+ let error = target - at;+ if error.len() < 1e-7 || spent >= TOTAL_CORRECTION_ITERS {+ break;+ }+ let n = vars.len();+ let jacobian_work = residual_work(&lay, &sub).saturating_mul(n.saturating_mul(2).saturating_add(1));+ if !within_budget(&mut budget, jacobian_work) {+ break;+ }+ let (_, j, _) = local_system(&problem, &lay, &sub, &mut x, &col, n);+ let null_work = n.saturating_mul(n).saturating_mul(j.rows.saturating_add(n));+ if !within_budget(&mut budget, null_work) {+ break;+ }+ let z = null_space(j);+ if z.is_empty() {+ break;+ }+ let mut direction = target_step(&z, ix, iy, error);+ let norm = length(&direction);+ // Adapt to curvature of the reachable locus. Inside a circle the Gauss-Newton+ // cursor step can be arbitrarily small although useful freedom remains.+ let scale = if norm > 0.0 { gain.min(max_step / norm) } else { gain };+ for v in &mut direction {+ *v *= scale;+ }+ let mut directions = vec![(direction, false)];+ // A cursor across a circular locus has (nearly) zero first derivative at the+ // farthest point. If line search stalls, probe both tangent directions. Testing+ // only an exactly zero gradient would strand reversed drags after rounding.+ let influence = |v: &&Vec<f64>| v.get(ix).copied().unwrap_or(0.0).hypot(v.get(iy).copied().unwrap_or(0.0));+ let mut probes: Vec<_> = z.iter().collect();+ probes.sort_by(|a, b| influence(b).total_cmp(&influence(a)));+ for v in probes.into_iter().take(2) {+ directions.push((v.iter().map(|x| x * max_step).collect(), true));+ directions.push((v.iter().map(|x| -x * max_step).collect(), true));+ }+ let old_cost = error.dot(error);+ let mut accepted = None;+ 'search: for (direction, probe) in directions {+ if length(&direction) < 1e-12 {+ continue;+ }+ for backtrack in 0..if probe { 1 } else { 8 } {+ if spent >= TOTAL_CORRECTION_ITERS {+ break 'search;+ }+ let alpha = 0.5_f64.powi(backtrack);+ let mut trial = x.clone();+ for (&v, d) in vars.iter().zip(&direction) {+ if let Some(t) = trial.get_mut(v) {+ *t += alpha * d;+ }+ }+ let Some((its, residual)) = lm_capped_with_budget(+ &problem,+ &lay,+ &sub,+ &vars,+ &mut trial,+ &col,+ CORRECTION_ITERS.min(TOTAL_CORRECTION_ITERS - spent),+ budget.as_deref_mut(),+ ) else {+ break 'search;+ };+ spent += its.max(1);+ if !(residual < TOL) {+ if budget.as_ref().is_some_and(|b| b.exhausted()) {+ break 'search;+ }+ continue;+ }+ let next = State { sk: &problem, lay: &lay, x: &trial }.p(point);+ let cost = (target - next).dot(target - next);+ if !cost.is_finite() || cost >= old_cost - 1e-14 * old_cost.max(1.0) {+ continue;+ }+ if !within_budget(&mut budget, setup_work.saturating_mul(4)) {+ break 'search;+ }+ let mut candidate = best.clone();+ apply(&mut candidate, &lay, &trial);+ if !in_range(&candidate) || !valid(&best, &candidate) {+ continue;+ }+ accepted = Some((trial, candidate, ((if probe { 1.0 } else { scale }) * alpha * 1.5).clamp(1e-8, 1e8)));+ break 'search;+ }+ }+ let Some((next, candidate, next_gain)) = accepted else { break };+ x = next;+ best = candidate;+ gain = next_gain;+ }+ // Full constraint validation includes constant blocks and disconnected components.+ if max_abs(&system(&best, &lay, &blocks, &mut x, false).0) >= ACCEPT {+ return false;+ }+ super::refresh_driven_dimensions(&mut best);+ *sk = best;+ true+}++fn length(v: &[f64]) -> f64 {+ v.iter().map(|x| x * x).sum::<f64>().sqrt()+}++fn in_range(sk: &Sketch) -> bool {+ sk.points.iter().all(|p| crate::model::in_range(p.pos))+ && sk+ .curves+ .iter()+ .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);+ if scale > 0.0 {+ for c in 0..j.cols {+ j.set(row, c, j.get(row, c) / scale);+ }+ }+ }+ let pivots = rref(&mut j, 1e-9);+ 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];+ 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);+ }+ }+ for _ in 0..2 {+ for q in &z {+ let d: f64 = v.iter().zip(q).map(|(a, b)| a * b).sum();+ for (a, b) in v.iter_mut().zip(q) {+ *a -= d * b;+ }+ }+ }+ let norm = length(&v);+ if norm.is_finite() && norm > 1e-10 {+ for x in &mut v {+ *x /= norm;+ }+ z.push(v);+ }+ }+ z+}++fn target_step(z: &[Vec<f64>], ix: usize, iy: usize, error: Vec2) -> Vec<f64> {+ let mut a = 0.0;+ let mut b = 0.0;+ let mut c = 0.0;+ for q in z {+ let x = q.get(ix).copied().unwrap_or(0.0);+ let y = q.get(iy).copied().unwrap_or(0.0);+ a += x * x;+ b += x * y;+ c += y * y;+ }+ let high = 0.5 * (a + c + (a - c).hypot(2.0 * b));+ let low = if high > 0.0 { (a * c - b * b).max(0.0) / high } else { 0.0 };+ let axis = if a >= c { Vec2::new(high - c, b) } else { Vec2::new(b, high - a) }.normalized().unwrap_or(if a >= c { Vec2::X } else { Vec2::Y });+ let other = Vec2::new(-axis.y, axis.x);+ let mut u = if high > 1e-12 { axis * (axis.dot(error) / high) } else { Vec2::ZERO };+ if low > high * 1e-8 {+ u += other * (other.dot(error) / low);+ }+ let mut step = vec![0.0; z.first().map_or(0, Vec::len)];+ for q in z {+ let d = q.get(ix).copied().unwrap_or(0.0) * u.x + q.get(iy).copied().unwrap_or(0.0) * u.y;+ for (x, v) in step.iter_mut().zip(q) {+ *x += d * v;+ }+ }+ step+}++fn apply(sk: &mut Sketch, lay: &Layout, x: &[f64]) {+ for (i, p) in sk.points.iter_mut().enumerate() {+ if let Some(v) = lay.pvar.get(i).copied().flatten()+ && let (Some(a), Some(b)) = (x.get(v), x.get(v + 1))+ {+ p.pos = Vec2::new(*a, *b);+ }+ }+ for (i, c) in sk.curves.iter_mut().enumerate() {+ if let Some(v) = lay.rvar.get(i).copied().flatten()+ && let Some(value) = x.get(v)+ && let CurveKind::Circle { r, .. } | CurveKind::Ellipse { r, .. } = &mut c.kind+ {+ *r = *value;+ }+ }+}diff --git a/crates/sketch/src/decompose.rs b/crates/sketch/src/decompose.rsindex a91bb921cf..58afd2272e 100644--- a/crates/sketch/src/decompose.rs+++ b/crates/sketch/src/decompose.rs@@ -75,9 +75,9 @@ pub(crate) const MAX_WORK: usize = 20_000_000;/// frame (see [`Budget::exhausted`]).pub(crate) const FRAME_WORK: usize = 1_000_000;-/// Work the seed's cluster decomposition may do, shared by the solves it is passed to (the held-/// solves of one drag frame): each decomposition is bounded by what is left, and charges what it-/// did.+/// Work shared by the held solves and feasible cursor correction of one drag frame. Cluster+/// decomposition charges membership scans; cursor correction reserves estimates of dense+/// arithmetic before starting it. These deterministic units approximate time, not a deadline.#[derive(Clone, Copy, Debug, PartialEq, Eq)]pub struct Budget {left: usize,@@ -86,7 +86,7 @@ pub struct Budget {}impl Budget {- /// A budget of `work` units (a unit is one membership scan of the merge search).+ /// A budget of `work` units: membership scans or estimated dense arithmetic operations.pub fn new(work: usize) -> Budget {Budget { left: work, spent: 0, cut: false }}@@ -98,8 +98,7 @@ impl Budget {pub fn frame() -> Budget {Budget::new(FRAME_WORK)}- /// Some decomposition stopped because the budget ran out: what it would have placed was- /// left to LM, from where it was.+ /// Some decomposition or cursor work stopped because the budget ran out.pub fn exhausted(&self) -> bool {self.cut}@@ -110,6 +109,17 @@ impl Budget {pub(crate) fn left(&self) -> usize {self.left}+ /// Reserve estimated dense arithmetic before starting it. Unlike a decomposition scan,+ /// a dense operation can be large, so it must not overshoot the remaining work.+ pub(crate) fn try_charge(&mut self, work: usize) -> bool {+ if work > self.left {+ self.cut = true;+ return false;+ }+ self.charge(work, false);+ true+ }+/// Charge a decomposition's `work`; `cut` when it stopped at the budget.pub(crate) fn charge(&mut self, work: usize, cut: bool) {self.left = self.left.saturating_sub(work);diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rsindex aa941345d0..60ba5da577 100644--- a/crates/sketch/src/lib.rs+++ b/crates/sketch/src/lib.rs@@ -62,8 +62,8 @@ pub use profiles::{};pub use shape::{Shape, intersections};pub use solver::{- Analysis, CONSISTENT, DrivingValues, Hold, SolveReport, SolveStatus, constraint_residual, determined_by, measure_dimension, solve,- solve_after_edit, solve_after_value_edit, solve_holding, solve_with,+ Analysis, CONSISTENT, DrivingValues, Hold, SolveReport, SolveStatus, constraint_residual, determined_by, measure_dimension, move_point_towards,+ solve, solve_after_edit, solve_after_value_edit, solve_holding, solve_with,};pub use text::{MAX_TEXT_CHARS, TextAlign, TextStyle, text_geometry, text_geometry_in, text_geometry_styled};pub use thin::{MAX_THIN_SEGMENTS, thin_wall_regions};diff --git a/crates/sketch/src/solver.rs b/crates/sketch/src/solver.rsindex bd8974955d..3c1dfa8258 100644--- a/crates/sketch/src/solver.rs+++ b/crates/sketch/src/solver.rs@@ -21,6 +21,10 @@ use crate::linalg::{Mat, determined_vars, solve as lin_solve};use crate::model::{ConstraintKind, CurveKind, Sketch};use crate::union_find::{find, union};+#[path = "cursor.rs"]+mod cursor;+pub use cursor::move_point_towards;+#[path = "redundancy.rs"]mod redundancy;pub use redundancy::{CONSISTENT, constraint_residual, determined_by};@@ -945,6 +949,26 @@ fn lm_capped(col: &[usize],max_iters: usize,) -> (usize, f64) {+ // Without a work budget the initial residual is always evaluated.+ lm_capped_with_budget(sk, lay, blocks, vars, x, col, max_iters, None).unwrap_or((0, f64::INFINITY))+}++/// Deterministic work units, shared with the frame's decomposition budget. Estimates bound+/// dense arithmetic; they are not a wall-clock deadline. None means no residual was evaluated.+fn lm_capped_with_budget(+ sk: &Sketch,+ lay: &Layout,+ blocks: &[(Block, Vec<usize>)],+ vars: &[usize],+ x: &mut Vec<f64>,+ col: &[usize],+ max_iters: usize,+ mut budget: Option<&mut Budget>,+) -> Option<(usize, f64)> {+ let evaluation_work = if budget.is_some() { residual_work(lay, blocks) } else { 0 };+ if !within_budget(&mut budget, evaluation_work) {+ return None;+ }let n = vars.len();#[cfg(test)]lm_vars::add(n);@@ -953,7 +977,12 @@ fn lm_capped(let mut f = norm2(&r);for it in 0..max_iters {if max_abs(&r) < TOL {- return (it, max_abs(&r));+ return Some((it, max_abs(&r)));+ }+ let normal_work =+ n.saturating_mul(n).saturating_mul(r.len()).saturating_add(evaluation_work.saturating_mul(n.saturating_mul(2).saturating_add(1)));+ if !within_budget(&mut budget, normal_work) {+ return Some((it, max_abs(&r)));}let (_, j, _) = local_system(sk, lay, blocks, x, col, n);// Normal equations of this component.@@ -979,7 +1008,11 @@ fn lm_capped(// the point sliding along it.) A point held on a curve is cheaper still, so it slides// rather than the curve's ends moving.let weight: Vec<f64> = vars.iter().map(|&v| if lay.slide.get(v).copied().unwrap_or(false) { SLIDE_WEIGHT } else { 1.0 }).collect();- for _ in 0..30 {+ for _attempt in 0..30 {+ let linear_work = n.saturating_mul(n).saturating_mul(n).saturating_add(evaluation_work);+ if !within_budget(&mut budget, linear_work) {+ return Some((it, max_abs(&r)));+ }let mut m = a.clone();for (i, w) in weight.iter().enumerate() {m.add(i, i, lambda * w + 1e-12);@@ -1011,10 +1044,18 @@ fn lm_capped(}}if !improved {- return (it, max_abs(&r));+ return Some((it, max_abs(&r)));}}- (max_iters, max_abs(&r))+ Some((max_iters, max_abs(&r)))+}++fn within_budget(budget: &mut Option<&mut Budget>, work: usize) -> bool {+ budget.as_deref_mut().is_none_or(|b| b.try_charge(work))+}++fn residual_work(lay: &Layout, blocks: &[(Block, Vec<usize>)]) -> usize {+ blocks.iter().fold(lay.n.max(1), |work, (_, vars)| work.saturating_add(vars.len().max(1)))}/// The variables LM was given and its runs on this thread, for tests that count what the@@ -2222,17 +2263,7 @@ fn solve_inner(Some(v) => vdet(Some(v)) && vdet(Some(v + 1)),None => true,};- // Driven dimensions measure the solved geometry.- let fixed_lay = Layout { pvar: vec![None; sk.points.len()], rvar: vec![None; sk.curves.len()], n: 0, points: 0, slide: Vec::new() };- let measured: Vec<Option<f64>> =- sk.constraints.iter().map(|c| if c.driven { measure(&State { sk, lay: &fixed_lay, x: &[] }, &c.kind) } else { None }).collect();- for (c, m) in sk.constraints.iter_mut().zip(measured) {- if let Some(v) = m- && v.is_finite()- {- c.kind.set_value(v);- }- }+ refresh_driven_dimensions(sk);let (dof, point_determined, curve_determined) = match analysis {Analysis::Full => (lay.n.saturating_sub(rank),@@ -2255,6 +2286,21 @@ fn solve_inner(}}+/// Geometry can also be finalized by feasible cursor motion, without another solve.+/// Both paths must measure reference dimensions from the pose they publish.+fn refresh_driven_dimensions(sk: &mut Sketch) {+ let fixed_lay = Layout { pvar: vec![None; sk.points.len()], rvar: vec![None; sk.curves.len()], n: 0, points: 0, slide: Vec::new() };+ let measured: Vec<Option<f64>> =+ sk.constraints.iter().map(|c| if c.driven { measure(&State { sk, lay: &fixed_lay, x: &[] }, &c.kind) } else { None }).collect();+ for (c, m) in sk.constraints.iter_mut().zip(measured) {+ if let Some(v) = m+ && v.is_finite()+ {+ c.kind.set_value(v);+ }+ }+}+#[cfg(test)]mod continuation_unit_tests {use super::*;diff --git a/crates/sketch/tests/cursor_target.rs b/crates/sketch/tests/cursor_target.rsnew file mode 100644index 0000000000..ae2fc8b448--- /dev/null+++ b/crates/sketch/tests/cursor_target.rs@@ -0,0 +1,160 @@+//! Analytic cursor oracle plus feasibility checks on every accepted continuation step.+use solidcraft_geom::Vec2;+use solidcraft_sketch::{ConstraintKind, Sketch, move_point_towards, solve};++fn linkage() -> (Sketch, usize, usize) {+ let mut sk = Sketch::new();+ let a = sk.add_point(Vec2::new(-10.0, 0.0), None).unwrap();+ let x = -10.0 + (1600.0 - 400.0 + 52.0 * 52.0) / 104.0;+ let c = sk.add_point(Vec2::new(x, -(1600.0_f64 - (x + 10.0).powi(2)).sqrt()), None).unwrap();+ let b = sk.add_point(Vec2::new(42.0, 0.0), None).unwrap();+ sk.points[b].fixed = true;+ for (p, q, value) in [(0, a, 10.0), (a, c, 40.0), (c, b, 20.0)] {+ sk.add_constraint(ConstraintKind::Distance { p, q, value }, None).unwrap();+ }+ assert!(solve(&mut sk).ok());+ (sk, a, c)+}++#[test]+fn circle_oracle_all_directions_and_large_targets() {+ for radius in [1.0, 12.8, 28.3, 100.0, 1000.0] {+ for i in 0..24 {+ let (mut sk, a, c) = linkage();+ let angle = std::f64::consts::TAU * i as f64 / 24.0;+ let target = Vec2::new(angle.cos(), angle.sin()) * radius;+ let nearest = target * (10.0 / radius);+ assert!(move_point_towards(&mut sk, a, target, 1.25, None, |before, after| {+ assert!(after.points[a].pos.dist(target) < before.points[a].pos.dist(target));+ assert!((after.points[a].pos.len() - 10.0).abs() < 1e-9);+ assert!((after.points[a].pos.dist(after.points[c].pos) - 40.0).abs() < 1e-9);+ assert!((after.points[c].pos.dist(Vec2::new(42.0, 0.0)) - 20.0).abs() < 1e-9);+ (Vec2::new(42.0, 0.0) - after.points[a].pos).cross(after.points[c].pos - after.points[a].pos) < 0.0+ }));+ assert!(sk.points[a].pos.dist(nearest) < 1e-4, "radius {radius}, angle {angle}, actual {:?}, nearest {nearest:?}", sk.points[a].pos);+ }+ }+}++#[test]+fn fixed_axis_and_rejected_candidates_keep_design_constraints() {+ let mut sk = Sketch::new();+ let a = sk.add_point(Vec2::new(10.0, 0.0), None).unwrap();+ let l = sk.add_line_pts(0, a, None).unwrap();+ sk.add_constraint(ConstraintKind::Horizontal { l }, None).unwrap();+ assert!(move_point_towards(&mut sk, a, Vec2::new(20.0, 10.0), 2.0, None, |_, _| true));+ assert!(sk.points[a].pos.dist(Vec2::new(20.0, 0.0)) < 1e-5, "{:?}", sk.points[a].pos);+ let before = sk.clone();+ assert!(move_point_towards(&mut sk, a, Vec2::new(-20.0, 10.0), 2.0, None, |_, _| false));+ assert_eq!(sk, before);+ assert!(!move_point_towards(&mut sk, usize::MAX, Vec2::ZERO, 1.0, None, |_, _| true));+ assert!(!move_point_towards(&mut sk, a, Vec2::new(f64::NAN, 0.0), 1.0, None, |_, _| true));+ assert_eq!(sk, before);+ sk.points[a].pos.x = f64::NAN;+ assert!(!move_point_towards(&mut sk, a, Vec2::ZERO, 1.0, None, |_, _| true));+ assert!(sk.points[a].pos.x.is_nan());+}++#[test]+fn reversing_across_a_nearly_stationary_extremum_keeps_following() {+ let (mut sk, a, _) = linkage();+ for target in [Vec2::new(-10.0, 16.0), Vec2::new(-10.0, -16.0), Vec2::new(0.0, 25.0), Vec2::new(0.0, -25.0)] {+ assert!(move_point_towards(&mut sk, a, target, 1.25, None, |_, _| true));+ assert!(sk.points[a].pos.dist(target * (10.0 / target.len())) < 1e-4, "target {target:?}, actual {:?}", sk.points[a].pos);+ }+}++#[test]+fn accepted_constraint_roundoff_is_refined_before_following_the_cursor() {+ let (mut sk, a, _) = linkage();+ sk.points[a].pos.x -= 1e-8;+ let target = Vec2::new(-10.0, 8.0);+ assert!(move_point_towards(&mut sk, a, target, 1.25, None, |_, _| true));+ assert!(sk.points[a].pos.dist(target * (10.0 / target.len())) < 1e-4);+ assert!((sk.points[a].pos.len() - 10.0).abs() < 1e-9);+}++#[test]+fn a_cursor_at_the_pivot_does_not_choose_a_pose_from_roundoff() {+ let (mut sk, a, _) = linkage();+ let before = sk.clone();+ assert!(move_point_towards(&mut sk, a, Vec2::ZERO, 1.25, None, |_, _| true));+ assert!(sk.points[a].pos.dist(before.points[a].pos) < 1e-5, "{:?}", sk.points[a].pos);+}++#[test]+fn cursor_motion_refreshes_driven_dimensions_without_a_followup_solve() {+ let (mut sk, a, _) = linkage();+ sk.add_constraint(ConstraintKind::DistanceX { p: 0, q: a, value: 10.0 }, None).unwrap();+ sk.constraints.last_mut().unwrap().driven = true;+ assert!(move_point_towards(&mut sk, a, Vec2::new(-10.0, 8.0), 1.25, None, |_, _| true));+ let value = sk.constraints.last().unwrap().kind.value().unwrap();+ assert!((value - sk.points[a].pos.x.abs()).abs() < 1e-6, "reference {value} does not measure {:?}", sk.points[a].pos);+}++#[test]+fn the_other_moving_joint_reaches_its_rocker_arc_and_motion_limits() {+ let base = Vec2::new(42.0, 0.0);+ let lo = -(-1264.0_f64 / 1680.0).acos(); // |OC| >= 40 - 10+ let hi = -(0.2_f64).acos(); // |OC| <= 40 + 10+ for angle in [-2.6_f64, -2.1, -1.5, -1.1] {+ let (mut sk, a, c) = linkage();+ let target = base + Vec2::new(angle.cos(), angle.sin()) * 60.0;+ let nearest = base + Vec2::new(angle.clamp(lo, hi).cos(), angle.clamp(lo, hi).sin()) * 20.0;+ assert!(move_point_towards(&mut sk, c, target, 1.25, None, |_, after| {+ (base - after.points[a].pos).cross(after.points[c].pos - after.points[a].pos) < 0.0+ }));+ assert!(sk.points[c].pos.dist(nearest) < 1e-4, "angle {angle}, actual {:?}, nearest {nearest:?}", sk.points[c].pos);+ assert!((sk.points[a].pos.len() - 10.0).abs() < 1e-9);+ assert!((sk.points[a].pos.dist(sk.points[c].pos) - 40.0).abs() < 1e-9);+ assert!((sk.points[c].pos.dist(base) - 20.0).abs() < 1e-9);+ }+}++#[test]+fn zero_cursor_budget_does_not_start_optimization() {+ let (mut sk, a, _) = linkage();+ let before = sk.clone();+ let mut budget = solidcraft_sketch::Budget::new(0);+ assert!(!move_point_towards(&mut sk, a, Vec2::new(-10.0, 16.0), 1.25, Some(&mut budget), |_, _| {+ panic!("an exhausted budget must not evaluate candidates")+ }));+ assert_eq!(sk, before);+ assert_eq!(budget.spent(), 0);+ assert!(budget.exhausted());+}++#[test]+fn a_cursor_budget_stop_keeps_the_best_corrected_pose_and_reference_dimensions() {+ let target = Vec2::new(-10.0, 16.0);+ let nearest = target * (10.0 / target.len());+ let mut stopped_after_progress = false;+ for work in [128, 256, 512, 1024, 2048, 4096, 8192, 16384] {+ let (mut sk, a, c) = linkage();+ sk.add_constraint(ConstraintKind::DistanceX { p: 0, q: a, value: 10.0 }, None).unwrap();+ sk.constraints.last_mut().unwrap().driven = true;+ let before = sk.clone();+ let mut budget = solidcraft_sketch::Budget::new(work);+ // The validation callback is Fn: Cell records whether a corrected step was accepted.+ let calls = std::cell::Cell::new(0);+ let moved = move_point_towards(&mut sk, a, target, 1.25, Some(&mut budget), |_, after| {+ calls.set(calls.get() + 1);+ assert!((after.points[a].pos.len() - 10.0).abs() < 1e-9);+ assert!((after.points[a].pos.dist(after.points[c].pos) - 40.0).abs() < 1e-9);+ assert!((after.points[c].pos.dist(Vec2::new(42.0, 0.0)) - 20.0).abs() < 1e-9);+ true+ });+ assert!(budget.spent() <= work, "{budget:?}");+ if !moved {+ assert_eq!(sk, before);+ continue;+ }+ assert!((sk.points[a].pos.len() - 10.0).abs() < 1e-9);+ assert!((sk.constraints.last().unwrap().kind.value().unwrap() - sk.points[a].pos.x.abs()).abs() < 1e-6);+ if calls.get() > 0 && budget.exhausted() && sk.points[a].pos.dist(nearest) > 1e-4 {+ assert!(sk.points[a].pos.dist(target) < before.points[a].pos.dist(target));+ stopped_after_progress = true;+ }+ }+ assert!(stopped_after_progress, "exercise exhaustion after a feasible cursor improvement");+}