SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: sketch.move_points moves several points, each to its own target (#5961) (#5978)
DuBearteabdf195132be
diff --git a/assets/locales/pending/sketch-move-points.json b/assets/locales/pending/sketch-move-points.jsonnew file mode 100644index 0000000000..525b02aca6--- /dev/null+++ b/assets/locales/pending/sketch-move-points.json@@ -0,0 +1,8 @@+{+ "en": { "cmd.sketch_move_points": "Move Sketch Points" },+ "ar": { "cmd.sketch_move_points": "سحب نقاط الرسم" },+ "he": { "cmd.sketch_move_points": "גרירת נקודות סקיצה" },+ "ja": { "cmd.sketch_move_points": "スケッチ点を移動" },+ "vi": { "cmd.sketch_move_points": "Kéo các điểm phác thảo" },+ "zh": { "cmd.sketch_move_points": "移动草图点" }+}diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rsindex e14110f474..630683777d 100644--- a/crates/engine/src/cmd/sketch.rs+++ b/crates/engine/src/cmd/sketch.rs@@ -208,6 +208,11 @@ pub static COMMANDS: &[CommandSpec] = &[.enabled(in_sketch).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.move_points", "Move Sketch Points", move_points).icon("sketch_move").enabled(in_sketch).params(+ "moves: [{point: ref | near: [x,y], to: [x,y]}] (each point to its own target; `near`: the sketch point closest to it, \+ refused when none lies within `tolerance` or two are as close), tolerance?: mm (default 0.1); sketch? → moved: \+ [{point, to, at, reached}] (`at`: where it ended up after the one solve; `reached`: whether that is `to`)",+ ),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: points and the material point grabbed on a line move toward `to` within the design constraints. When exact placement is impossible, bounded feasible steps minimize cursor distance. Splines slide by to - from; a circle or arc grabbed on its edge takes the radius to `to`. `with?`: [point or curve ids] moves the rest of a selection with the entity as one translation (circles keep their radii). Long moves retain the solution branch; arcs cannot sweep through their starts. Returns `reached`: progress projected onto the requested move (0..1), `at`: the grabbed position for the next frame, and `retry`: budget-limited progress can continue in another frame. `live: true` shares a work budget across held-solve decomposition and cursor correction; ordinary recovery and the final model evaluation retain their existing limits, not a wall-clock deadline. Later features stay stale until `sketch.drag_end`; `dof` stays from before the drag",),@@ -3725,6 +3730,67 @@ fn move_point(s: &mut Session, p: &Value) -> Result<Value> {Ok(json!({"sketch": rep.as_ref().map(report_json)}))}+/// `sketch.move_points`: several points, each dragged to its own target, in one edit (one undo+/// step), then solved; each move's point by reference or by `near` (#5961).+fn move_points(s: &mut Session, p: &Value) -> Result<Value> {+ let cmd = "sketch.move_points";+ let moves =+ p.get("moves").and_then(Value::as_array).filter(|m| !m.is_empty()).ok_or_else(|| bad(cmd, "`moves` must be a list of {point | near, to}"))?;+ let tol = match p.get("tolerance") {+ None | Some(Value::Null) => 0.1,+ Some(_) => num(p, "tolerance").filter(|t| *t > 0.0).ok_or_else(|| bad(cmd, "`tolerance` must be a positive length (mm)"))?,+ };+ let id = sketch_store::target(s, p, cmd)?;+ let state = s.model.result(id).map(|r| r.state.clone());+ let last = state.as_ref().and_then(|state| state.sketch(id));+ let (picked, rep) = edit_solved(s, id, false, Analysis::Freedom, |sk, _| {+ if moves.len() > sk.points.len().max(1) {+ return Err(bad(cmd, "`moves` lists more moves than the sketch has points"));+ }+ // Every point is found before any moves, so `near` reads the sketch as it was.+ let mut picked = Vec::with_capacity(moves.len());+ for (k, m) in moves.iter().enumerate() {+ let to = req_vec2(cmd, m, "to").map_err(|_| bad(cmd, format!("moves[{k}]: `to` must be a point [x, y]")))?;+ let q = match m.get("near") {+ Some(v) => {+ let at = vec2(v).ok_or_else(|| bad(cmd, format!("moves[{k}]: `near` must be a point [x, y]")))?;+ let mut d: Vec<(f64, usize)> = (0..sk.points.len()).filter_map(|i| Some((sk.point(i)?.dist(at), i))).collect();+ d.sort_by(|a, b| a.0.total_cmp(&b.0));+ match d.as_slice() {+ [(best, q), rest @ ..] if *best <= tol => {+ if rest.first().is_some_and(|(next, _)| *next - *best <= 1e-9) {+ return Err(bad(+ cmd,+ format!("moves[{k}]: two sketch points are as close to `near` [{}, {}]; name the point", at.x, at.y),+ ));+ }+ *q+ }+ _ => return Err(bad(cmd, format!("moves[{k}]: no sketch point within {tol} mm of `near` [{}, {}]", at.x, at.y))),+ }+ }+ None => point_ref(sk, m.get("point"), cmd, "point")?,+ };+ picked.push((q, to));+ }+ let mut left = Left::Unsolved;+ for (q, to) in &picked {+ left = drag_entity(sk, Ent::Point(*q), &[], *to, *to, false, last).1.solve_again();+ }+ Ok((picked, left))+ })?;+ let solved = sketch_store::read(&s.doc, id).ok();+ let moved: Vec<Value> = picked+ .iter()+ .map(|(q, to)| {+ let point = solved.and_then(|sk| sk.points.get(*q)).map(|pt| pt.id.clone());+ let at = solved.and_then(|sk| sk.point(*q));+ json!({"point": point, "to": [to.x, to.y], "at": at.map(|a| [a.x, a.y]), "reached": at.is_some_and(|a| a.dist(*to) <= 1e-6)})+ })+ .collect();+ Ok(json!({"moved": moved, "sketch": rep.as_ref().map(report_json)}))+}+fn drag(s: &mut Session, p: &Value) -> Result<Value> {drag_frame(s, p, false).map(|(v, _)| v)}diff --git a/crates/engine/src/cmd/sketch_ux_tests.rs b/crates/engine/src/cmd/sketch_ux_tests.rsindex 8986834e6e..8b6bb1b103 100644--- a/crates/engine/src/cmd/sketch_ux_tests.rs+++ b/crates/engine/src/cmd/sketch_ux_tests.rs@@ -2481,3 +2481,55 @@ fn a_dimension_refuses_a_long_list_of_entities() {// The refused request leaves the design as it was.assert_eq!(serde_json::to_value(&s.doc).unwrap(), before);}++/// #5961: `sketch.move_points` moves several points of a polyline, each to its own target, by id+/// or by `near`, in one undo step; it says where each ended up, refuses a `near` that finds+/// nothing or two points as close, and reports a fixed point that can't move.+#[test]+fn move_points_moves_each_point_to_its_own_target() {+ let mut s = new_sketch();+ run(&mut s, "sketch.line", json!({"points": [[0, 0], [10, 0], [20, 0], [30, 0]]}));+ let undo_before = run(&mut s, "document.inspect", json!({}))["undo"].clone();+ let r = run(&mut s, "sketch.move_points", json!({"moves": [{"point": "l1.end", "to": [10, 5]}, {"near": [20.05, 0], "to": [20, -5]}]}));+ let moved = r["moved"].as_array().unwrap();+ assert_eq!(moved.len(), 2, "{r}");+ assert!(moved.iter().all(|m| m["reached"] == true), "{r}");+ assert_eq!(moved[1]["to"], json!([20.0, -5.0]));+ let sk = sketch(&s);+ let at = |id: &str| sk.point(sk.resolve_point(id).unwrap()).unwrap();+ assert!(at("l1.end").dist(solidcore_record::Vec2::new(10.0, 5.0)) < 1e-9);+ assert!(at("l2.end").dist(solidcore_record::Vec2::new(20.0, -5.0)) < 1e-9);+ assert!(at("l3.end").dist(solidcore_record::Vec2::new(30.0, 0.0)) < 1e-9, "the other points stay");+ // One undo step takes both back.+ let undo_after = run(&mut s, "document.inspect", json!({}))["undo"].as_u64().unwrap();+ assert_eq!(undo_after, undo_before.as_u64().unwrap() + 1);+ run(&mut s, "edit.undo", json!({}));+ assert!(pt(&s, "l1.end").dist(solidcore_record::Vec2::new(10.0, 0.0)) < 1e-9);+ // `near` that finds nothing, or a malformed move, is refused and moves nothing.+ for bad in [+ json!({"moves": [{"near": [100, 100], "to": [0, 0]}]}),+ json!({"moves": [{"near": [10, 0]}]}),+ json!({"moves": []}),+ json!({"moves": [{"point": "l1.end", "to": [1, 1]}], "tolerance": -1}),+ ] {+ let before = sketch(&s);+ assert!(s.execute("sketch.move_points", &bad).is_err(), "{bad}");+ assert_eq!(sketch(&s), before, "{bad}");+ }+ // A fixed point is reported, not silently left where it was.+ run(&mut s, "sketch.constraint.fix", json!({"entities": ["l3.end"]}));+ let r = run(&mut s, "sketch.move_points", json!({"moves": [{"point": "l3.end", "to": [40, 0]}]}));+ assert_eq!(r["moved"][0]["reached"], false, "{r}");+ assert_eq!(r["moved"][0]["at"], json!([30.0, 0.0]), "{r}");+}++/// Two sketch points as close to `near` (two points at one place) can't be told apart: the+/// move is refused.+#[test]+fn move_points_refuses_a_near_that_two_points_answer() {+ let mut s = new_sketch();+ run(&mut s, "sketch.point", json!({"point": [10, 0]}));+ run(&mut s, "sketch.point", json!({"point": [10, 0]}));+ let e = s.execute("sketch.move_points", &json!({"moves": [{"near": [10, 0], "to": [12, 0]}]})).unwrap_err().to_string();+ assert!(e.contains("as close"), "{e}");+}