From fb811fbf21f28c8dc56062f3289fc8863cb23401 Mon Sep 17 00:00:00 2001 From: SS-EN <84559909+SS-EN@users.noreply.github.com> Date: Tue, 20 Oct 2026 14:20:12 +0000 Subject: [PATCH] Sketch trim: drag a path across curves to trim every piece it crosses (#3182) `sketch.trim.path {points, dry_run?}` walks a polyline and, at each place it crosses a curve trim may change, removes that piece exactly as `sketch.trim` would there, in the order crossed and in one undo step. A piece already gone is not trimmed again; projected geometry, infinite lines, offset outputs and pieces trim refuses are passed over (reported in `skipped`). It returns each trim's result and each removed piece as a polyline; `dry_run` reports them without changing the design. With Trim on, a press and drag in the viewport draws that path: the pieces it would remove light up (a dry run of the command) and letting go runs it. A click still trims the one piece under it. Co-authored-by: Claude Opus 5.5 --- assets/locales/en.json | 1 + assets/locales/ja.json | 1 + assets/locales/zh.json | 1 + crates/engine/src/cmd/sketch_freeform.rs | 7 +- crates/engine/src/cmd/sketch_modify.rs | 248 ++++++++++++++---- .../engine/src/cmd/sketch_trim_path_tests.rs | 192 ++++++++++++++ crates/ui-egui/src/sketch_tools.rs | 90 ++++++- .../ui-egui/src/sketch_trim_drag_ui_tests.rs | 151 +++++++++++ crates/ui-egui/src/viewport.rs | 41 ++- docs/book/src/guide/sketching.md | 4 +- 10 files changed, 678 insertions(+), 58 deletions(-) create mode 100644 crates/engine/src/cmd/sketch_trim_path_tests.rs create mode 100644 crates/ui-egui/src/sketch_trim_drag_ui_tests.rs diff --git a/assets/locales/en.json b/assets/locales/en.json index 77c030df3..c00d6af87 100644 --- a/assets/locales/en.json +++ b/assets/locales/en.json @@ -613,6 +613,7 @@ "cmd.sketch_spline_fit_point": "Fit Point Spline", "cmd.sketch_spun_profile": "Spun Profile", "cmd.sketch_toggle_driven": "Toggle Driven Dimension", + "cmd.sketch_trim_path": "Trim Along Path", "cmd.solid_align": "Align", "cmd.solid_boundary_fill": "Boundary Fill", "cmd.solid_bounding_solid": "Bounding Solid", diff --git a/assets/locales/ja.json b/assets/locales/ja.json index d6f0ace30..97bff3386 100644 --- a/assets/locales/ja.json +++ b/assets/locales/ja.json @@ -613,6 +613,7 @@ "cmd.sketch_spline_fit_point": "通過点スプライン", "cmd.sketch_spun_profile": "回転プロファイル", "cmd.sketch_toggle_driven": "従動寸法の切り替え", + "cmd.sketch_trim_path": "パスに沿ってトリム", "cmd.solid_align": "整列", "cmd.solid_boundary_fill": "境界フィル", "cmd.solid_bounding_solid": "バウンディング ソリッド", diff --git a/assets/locales/zh.json b/assets/locales/zh.json index f236bdb8d..c31f08a81 100644 --- a/assets/locales/zh.json +++ b/assets/locales/zh.json @@ -613,6 +613,7 @@ "cmd.sketch_spline_fit_point": "拟合点样条曲线", "cmd.sketch_spun_profile": "旋转轮廓", "cmd.sketch_toggle_driven": "切换被驱动尺寸", + "cmd.sketch_trim_path": "沿路径修剪", "cmd.solid_align": "对齐", "cmd.solid_boundary_fill": "边界填充", "cmd.solid_bounding_solid": "包围实体", diff --git a/crates/engine/src/cmd/sketch_freeform.rs b/crates/engine/src/cmd/sketch_freeform.rs index cd47682c7..6d8763a33 100644 --- a/crates/engine/src/cmd/sketch_freeform.rs +++ b/crates/engine/src/cmd/sketch_freeform.rs @@ -280,8 +280,13 @@ fn modify(sk: &mut Sketch, ci: usize, at: Vec2, remove: bool, points: Option<&[V } } let ids: Vec = made.iter().filter_map(|c| sk.curves.get(*c).map(|c| c.id.clone())).collect(); + // The removed piece, for previews (`sketch.trim.path`). + let removed: Vec<[f64; 2]> = gone + .and_then(|k| intervals.get(k)) + .map(|(a, b, ..)| span(&segs, *a, *b).iter().flat_map(|s| s.polyline(1e-3)).map(|q| [q.x, q.y]).collect()) + .unwrap_or_default(); sk.remove_curves(&[ci]); let unused: Vec = cut_pt.iter().map(|x| x.1).filter(|pi| !sk.curves.iter().any(|c| c.kind.uses(*pi))).collect(); sk.remove_points(&unused); - Ok(json!({"curves": ids})) + Ok(json!({"curves": ids, "removed": removed})) } diff --git a/crates/engine/src/cmd/sketch_modify.rs b/crates/engine/src/cmd/sketch_modify.rs index 1561ed31f..bf74a90d7 100644 --- a/crates/engine/src/cmd/sketch_modify.rs +++ b/crates/engine/src/cmd/sketch_modify.rs @@ -59,6 +59,13 @@ pub static COMMANDS: &[CommandSpec] = &[ .key("T") .enabled(in_sketch) .params(concat!("curve: id, at: [x,y] (the piece to remove: between the nearest intersections around it)", created_doc!())), + CommandSpec::new("sketch.trim.path", "Trim Along Path", trim_path) + .icon("trim") + .enabled(in_sketch) + .params(concat!( + "points: [[x,y]…] (2…2000 positions: a path drawn across the sketch). Every piece the path crosses is removed as `sketch.trim` removes the piece at that crossing, in the order the path crosses them; a piece crossed again after it is gone is not trimmed twice; projected geometry, infinite lines, offset outputs and pieces trim refuses are passed over (why in `skipped`). dry_run?: bool (report without changing the design). One undo step → trimmed: [each trim's result], removed: [[[x,y]…]] (each removed piece as a polyline)", + created_doc!() + )), CommandSpec::new("sketch.extend", "Extend", extend) .at("SKETCH", "MODIFY") .icon("extend") @@ -343,65 +350,194 @@ fn trim(s: &mut Session, p: &Value) -> Result { let at = req_vec2(cmd, p, "at")?; let (out, info) = edit(s, p, cmd, false, |sk, doc| { let ci = curve_arg(sk, p, cmd)?; - let id = sk.curves.get(ci).map(|c| c.id.clone()).unwrap_or_default(); - if sk.curves.get(ci).is_some_and(|c| c.infinite) { - return Err(bad(cmd, "an infinite line has no ends to trim back to: make it a normal line first")); - } - if sk.curves.get(ci).is_some_and(|c| c.kind.is_freeform()) { - let r = super::sketch_freeform::trim_or_break(sk, ci, at, true, cmd)?; - doc.prune_model_params(); - return Ok(json!({"trimmed": id, "pieces": r["curves"]})); - } - let sh = sk.shape(ci).ok_or_else(|| bad(cmd, "curve"))?; - let tq = sh.param(sh.project(at)); - let (cuts, full) = bracket(sk, ci, tq); - if cuts.is_empty() { - // Nothing crosses it: the whole curve goes. - sk.remove_curves(&[ci]); - doc.prune_model_params(); - return Ok(json!({"deleted": id})); - } - release_extent(sk, ci); - let ts: Vec = cuts.iter().map(|c| c.0).collect(); - let (pieces, pts) = split_at(sk, ci, &ts)?; - // The piece containing tq. - let k = if full { - let (a, b) = (ts[0], ts[1]); - if tq > a && tq < b { 0 } else { 1 } - } else { - ts.iter().filter(|t| **t < tq).count() - }; - for (pi, c) in pts.iter().zip(&cuts) { - pin(sk, *pi, c.2)?; - } - let gone = pieces.get(k).copied().ok_or_else(|| bad(cmd, "piece"))?; - let keep: Vec = pieces.iter().copied().filter(|x| *x != gone).collect(); - // The original curve keeps its id (and constraints): swap geometry into it if needed. - let gone = match keep.first() { - Some(&other) if gone == ci => { - let ka = sk.curves.get(ci).map(|c| c.kind.clone()); - let kb = sk.curves.get(other).map(|c| c.kind.clone()); - if let (Some(ka), Some(kb)) = (ka, kb) { - if let Some(c) = sk.curves.get_mut(ci) { - c.kind = kb; - } - if let Some(c) = sk.curves.get_mut(other) { - c.kind = ka; - } - } - other - } - _ => gone, - }; - let keep: Vec = pieces.iter().copied().filter(|x| *x != gone).collect(); - tie(sk, &keep)?; - sk.remove_curves(&[gone]); + let (out, _) = remove_piece(sk, ci, at, cmd)?; doc.prune_model_params(); - Ok(json!({"trimmed": id})) + Ok(out) })?; Ok(json!({"result": out, "sketch": info})) } +/// Remove the piece of curve `ci` around `at`: between the nearest intersections on either +/// side, or the whole curve when nothing crosses it. Returns what `sketch.trim` reports and the +/// removed piece as a polyline. +fn remove_piece(sk: &mut Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<(Value, Vec)> { + let id = sk.curves.get(ci).map(|c| c.id.clone()).unwrap_or_default(); + if sk.curves.get(ci).is_some_and(|c| c.infinite) { + return Err(bad(cmd, "an infinite line has no ends to trim back to: make it a normal line first")); + } + if sk.curves.get(ci).is_some_and(|c| c.kind.is_freeform()) { + let whole = sk.polyline(ci); + let r = super::sketch_freeform::trim_or_break(sk, ci, at, true, cmd)?; + let removed = match r.get("removed").and_then(Value::as_array) { + Some(pts) => pts.iter().filter_map(|q| Some(Vec2::new(q.get(0)?.as_f64()?, q.get(1)?.as_f64()?))).collect(), + None => whole, + }; + return Ok((json!({"trimmed": id, "pieces": r["curves"]}), removed)); + } + let sh = sk.shape(ci).ok_or_else(|| bad(cmd, "curve"))?; + let tq = sh.param(sh.project(at)); + let (cuts, full) = bracket(sk, ci, tq); + if cuts.is_empty() { + // Nothing crosses it: the whole curve goes. + let removed = sk.polyline(ci); + sk.remove_curves(&[ci]); + return Ok((json!({"deleted": id}), removed)); + } + release_extent(sk, ci); + let ts: Vec = cuts.iter().map(|c| c.0).collect(); + let (pieces, pts) = split_at(sk, ci, &ts)?; + // The piece containing tq. + let k = if full { + let (a, b) = (ts[0], ts[1]); + if tq > a && tq < b { 0 } else { 1 } + } else { + ts.iter().filter(|t| **t < tq).count() + }; + for (pi, c) in pts.iter().zip(&cuts) { + pin(sk, *pi, c.2)?; + } + let gone = pieces.get(k).copied().ok_or_else(|| bad(cmd, "piece"))?; + let keep: Vec = pieces.iter().copied().filter(|x| *x != gone).collect(); + // The original curve keeps its id (and constraints): swap geometry into it if needed. + let gone = match keep.first() { + Some(&other) if gone == ci => { + let ka = sk.curves.get(ci).map(|c| c.kind.clone()); + let kb = sk.curves.get(other).map(|c| c.kind.clone()); + if let (Some(ka), Some(kb)) = (ka, kb) { + if let Some(c) = sk.curves.get_mut(ci) { + c.kind = kb; + } + if let Some(c) = sk.curves.get_mut(other) { + c.kind = ka; + } + } + other + } + _ => gone, + }; + let keep: Vec = pieces.iter().copied().filter(|x| *x != gone).collect(); + tie(sk, &keep)?; + let removed = sk.polyline(gone); + sk.remove_curves(&[gone]); + Ok((json!({"trimmed": id}), removed)) +} + +/// Most crossings one `sketch.trim.path` trims (each one splits a curve, so this also caps the +/// work a hostile path can ask for). +const MAX_PATH_TRIMS: usize = 500; +/// Most positions in a trim path. +const MAX_PATH_POINTS: usize = 2_000; + +/// The first place along `path` after `after` (segment, parameter along it) where the path +/// crosses a curve that a trim may change: (segment, parameter, curve, the crossing point). Crossings are found on the +/// curves' display polylines; the trim projects them onto the exact curve. +fn next_crossing(sk: &Sketch, path: &[Vec2], after: (usize, f64)) -> Option<(usize, f64, usize, Vec2)> { + let bounds = |pts: &[Vec2]| { + pts.iter().fold((Vec2::new(f64::INFINITY, f64::INFINITY), Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY)), |(lo, hi), q| { + (Vec2::new(lo.x.min(q.x), lo.y.min(q.y)), Vec2::new(hi.x.max(q.x), hi.y.max(q.y))) + }) + }; + let trimmable: Vec<(usize, Vec, (Vec2, Vec2))> = (0..sk.curves.len()) + .filter(|ci| curve_ok(sk, *ci)) + .map(|ci| { + let poly = sk.polyline(ci); + let b = bounds(&poly); + (ci, poly, b) + }) + .collect(); + for (si, w) in path.windows(2).enumerate().skip(after.0) { + let (a, b) = (w[0], w[1]); + let from = if si == after.0 { after.1 } else { f64::NEG_INFINITY }; + let (lo, hi) = bounds(&[a, b]); + let mut best: Option<(f64, usize, Vec2)> = None; + for (ci, poly, (plo, phi)) in &trimmable { + if plo.x > hi.x || plo.y > hi.y || phi.x < lo.x || phi.y < lo.y { + continue; + } + for e in poly.windows(2) { + let Some((t, q)) = seg_cross(a, b, e[0], e[1]) else { continue }; + if t > from + 1e-9 && best.is_none_or(|x| t < x.0) { + best = Some((t, *ci, q)); + } + } + } + if let Some((t, ci, q)) = best { + return Some((si, t, ci, q)); + } + } + None +} + +/// Whether trim may change curve `ci` (what [`curve_arg`] accepts, and not an infinite line). +fn curve_ok(sk: &Sketch, ci: usize) -> bool { + let Some(c) = sk.curves.get(ci) else { return false }; + !c.infinite + && !sk.is_linked_curve(ci) + && !sk.freeform_offsets.iter().any(|offset| offset.output == c.id) + && !sk.offsets.iter().filter_map(|offset| offset.topology.as_ref()).any(|topology| topology.roles.iter().any(|role| role.output == c.id)) +} + +/// Where segment `a`–`b` crosses segment `c`–`d`: the parameter along `a`–`b` and the point. +fn seg_cross(a: Vec2, b: Vec2, c: Vec2, d: Vec2) -> Option<(f64, Vec2)> { + let (r, s) = (b - a, d - c); + let den = r.cross(s); + if den.abs() <= 1e-15 * r.len2().max(s.len2()).max(1e-30) { + return None; + } + let t = (c - a).cross(s) / den; + let u = (c - a).cross(r) / den; + ((0.0..=1.0).contains(&t) && (0.0..=1.0).contains(&u)).then(|| (t, a + r * t)) +} + +fn trim_path(s: &mut Session, p: &Value) -> Result { + let cmd = "sketch.trim.path"; + let path = vec2_list(cmd, p, "points", MAX_PATH_POINTS)?; + if path.len() < 2 { + return Err(bad(cmd, "`points` needs at least two positions")); + } + if bool_(p, "dry_run").unwrap_or(false) { + let mut t = s.scratch(); + let mut q = p.clone(); + if let Some(o) = q.as_object_mut() { + o.remove("dry_run"); + } + let mut out = trim_path(&mut t, &q)?; + out["dry_run"] = json!(true); + return Ok(out); + } + let ((trimmed, removed, skipped), info) = edit(s, p, cmd, false, |sk, doc| { + let mut trimmed: Vec = Vec::new(); + let mut removed: Vec = Vec::new(); + let mut skipped: Vec = Vec::new(); + let mut after = (0, f64::NEG_INFINITY); + for _ in 0..MAX_PATH_TRIMS { + let Some((si, t, ci, q)) = next_crossing(sk, &path, after) else { break }; + after = (si, t); + // A piece trim refuses (a closed spline crossed once) stays as it was. + let before = sk.clone(); + match remove_piece(sk, ci, q, cmd) { + Ok((out, gone)) => { + trimmed.push(out); + removed.push(json!(gone.iter().map(|v| [v.x, v.y]).collect::>())); + } + Err(e) => { + *sk = before; + let why = e.to_string().replace(&format!("{cmd}: "), ""); + if !skipped.contains(&why) { + skipped.push(why); + } + } + } + } + if trimmed.is_empty() { + return Err(bad(cmd, skipped.first().cloned().unwrap_or_else(|| "the path crosses no curve that can be trimmed".into()))); + } + doc.prune_model_params(); + Ok((trimmed, removed, skipped)) + })?; + Ok(json!({"trimmed": trimmed, "removed": removed, "skipped": skipped, "sketch": info})) +} + fn break_cmd(s: &mut Session, p: &Value) -> Result { let cmd = "sketch.break"; let points = if p.get("points").is_some() { Some(vec2_list(cmd, p, "points", 1000)?) } else { None }; @@ -1884,3 +2020,7 @@ mod robust_tests; #[cfg(test)] #[path = "sketch_corner_tests.rs"] mod corner_tests; + +#[cfg(test)] +#[path = "sketch_trim_path_tests.rs"] +mod trim_path_tests; diff --git a/crates/engine/src/cmd/sketch_trim_path_tests.rs b/crates/engine/src/cmd/sketch_trim_path_tests.rs new file mode 100644 index 000000000..91e8b94bd --- /dev/null +++ b/crates/engine/src/cmd/sketch_trim_path_tests.rs @@ -0,0 +1,192 @@ +//! `sketch.trim.path`: dragging across curves trims each piece the path crosses, as clicking it +//! with `sketch.trim` would, in one undo step. + +use serde_json::{Value, json}; +use solidcraft_geom::Vec2; +use solidcraft_sketch::Shape; + +use crate::Session; + +fn run(s: &mut Session, id: &str, p: Value) -> Value { + match s.execute(id, &p) { + Ok(v) => v, + Err(e) => panic!("{id} {p}: {e}"), + } +} + +fn ids(v: &Value) -> Vec { + v.as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default() +} + +fn sketch(s: &Session) -> solidcraft_sketch::Sketch { + let id = s.active_sketch.unwrap(); + s.model.state().sketch(id).unwrap().sketch.clone() +} + +fn new_sketch() -> Session { + let mut s = Session::default(); + run(&mut s, "sketch.create", json!({"plane": "XY"})); + s +} + +fn line(s: &mut Session, points: Value) -> Vec { + ids(&run(s, "sketch.line", json!({"points": points}))["curves"]) +} + +/// A 40 x 40 square with a step cut across its top right corner (as in the single trim's +/// dimension test), the right side dimensioned. +fn square_with_step() -> (Session, String, String) { + let mut s = new_sketch(); + let sq = ids(&run(&mut s, "sketch.line", json!({"points": [[0, 0], [40, 0], [40, 40], [0, 40]], "closed": true, "infer": true}))["curves"]); + let (right, top) = (sq[1].clone(), sq[2].clone()); + run(&mut s, "sketch.dimension", json!({"entities": [right]})); + let step = ids(&run(&mut s, "sketch.line", json!({"points": [[23, 40], [23, 23], [40, 23]], "infer": true}))["curves"]); + run(&mut s, "sketch.constraint.coincident", json!({"a": format!("{}.start", step[0]), "b": top})); + run(&mut s, "sketch.constraint.coincident", json!({"a": format!("{}.end", step[1]), "b": right})); + (s, right, top) +} + +#[test] +fn a_path_trims_what_clicking_each_crossed_piece_would() { + // Clicks: the right side above the step, then the top side right of it. + let (mut clicked, right, top) = square_with_step(); + run(&mut clicked, "sketch.trim", json!({"curve": right, "at": [40, 30]})); + run(&mut clicked, "sketch.trim", json!({"curve": top, "at": [30, 40]})); + + // One drag from outside the right side, across the corner, out through the top. + let (mut dragged, ..) = square_with_step(); + let before = sketch(&dragged); + let undo_before = dragged.undo.len(); + let out = run(&mut dragged, "sketch.trim.path", json!({"points": [[45, 30], [30, 30], [30, 45]]})); + assert_eq!(out["trimmed"].as_array().map(Vec::len), Some(2), "{out}"); + assert_eq!(out["removed"].as_array().map(Vec::len), Some(2), "{out}"); + assert_eq!(sketch(&dragged), sketch(&clicked), "the drag and the two clicks leave the same sketch"); + + // One undo step brings everything back. + assert_eq!(dragged.undo.len(), undo_before + 1); + run(&mut dragged, "edit.undo", json!({})); + assert_eq!(sketch(&dragged), before); +} + +#[test] +fn a_piece_crossed_twice_is_trimmed_once() { + let mut s = new_sketch(); + line(&mut s, json!([[0, 0], [20, 0]])); + line(&mut s, json!([[0, 10], [20, 10]])); + let v = line(&mut s, json!([[10, -5], [10, 15]]))[0].clone(); + // A zigzag across the middle piece of the vertical line, three times. + let out = run(&mut s, "sketch.trim.path", json!({"points": [[5, 3], [15, 4], [5, 5], [15, 6]]})); + assert_eq!(out["trimmed"].as_array().map(Vec::len), Some(1), "{out}"); + let removed = out["removed"][0].as_array().unwrap(); + let ends: Vec = + [removed.first().unwrap(), removed.last().unwrap()].iter().map(|q| Vec2::new(q[0].as_f64().unwrap(), q[1].as_f64().unwrap())).collect(); + assert!(ends.iter().any(|q| q.dist(Vec2::new(10.0, 0.0)) < 1e-6) && ends.iter().any(|q| q.dist(Vec2::new(10.0, 10.0)) < 1e-6), "{ends:?}"); + // The two outer pieces of the vertical line stay, the original id on the lower one. + let sk = sketch(&s); + assert_eq!(sk.curves.len(), 4); + let lower = sk.shape(sk.curve_index(&v).unwrap()).unwrap(); + assert!(matches!(lower, Shape::Line { a, b } if a.dist(Vec2::new(10.0, -5.0)) < 1e-6 && b.dist(Vec2::new(10.0, 0.0)) < 1e-6), "{lower:?}"); +} + +/// A scene built twice: trimmed once along `path` and once by clicking `clicks` (curve index +/// in the scene's curves, where) in turn; both must leave the same sketch. +fn same_as_clicks(build: fn(&mut Session) -> Vec, path: Value, clicks: &[(usize, [f64; 2])]) { + let mut clicked = new_sketch(); + let curves = build(&mut clicked); + for (k, at) in clicks { + run(&mut clicked, "sketch.trim", json!({"curve": curves[*k], "at": at})); + } + let mut dragged = new_sketch(); + build(&mut dragged); + let out = run(&mut dragged, "sketch.trim.path", json!({"points": path})); + assert_eq!(out["trimmed"].as_array().map(Vec::len), Some(clicks.len()), "{out}"); + assert!(out["removed"].as_array().unwrap().iter().all(|r| r.as_array().is_some_and(|r| r.len() >= 2)), "{out}"); + assert_eq!(sketch(&dragged), sketch(&clicked), "{path}"); +} + +#[test] +fn circles_arcs_and_splines_trim_along_a_path() { + // A circle across a line: the lower half goes, the rest is an arc. + same_as_clicks( + |s| { + let c = ids(&run(s, "sketch.circle.center", json!({"center": [0, 0], "radius": 10}))["curves"]); + [c, line(s, json!([[-20, 0], [20, 0]]))].concat() + }, + json!([[0, -15], [0, -5]]), + &[(0, [0.0, -10.0])], + ); + // An arc cut by a line through its middle: the left part goes. + same_as_clicks( + |s| { + let a = ids(&run(s, "sketch.arc.three_point", json!({"start": [-10, 0], "through": [0, 10], "end": [10, 0]}))["curves"]); + [a, line(s, json!([[0, -5], [0, 15]]))].concat() + }, + json!([[-10, 8], [-3, 8]]), + &[(0, [-6.0, 8.0])], + ); + // A spline over a line: its hump goes, then the line's piece under it. + same_as_clicks( + |s| { + let sp = + ids(&run(s, "sketch.spline.fit_point", json!({"points": [[-20, -20], [-10, 5], [10, 5], [20, -20]], "connect": false}))["curves"]); + [sp, line(s, json!([[-30, 0], [30, 0]]))].concat() + }, + json!([[0, 10], [0, -1]]), + &[(0, [0.0, 10.0]), (1, [0.0, 0.0])], + ); +} + +#[test] +fn a_dry_run_reports_the_pieces_without_changing_the_design() { + let (mut s, ..) = square_with_step(); + let before = sketch(&s); + let (undo, revision) = (s.undo.len(), s.revision); + let path = json!([[45, 30], [30, 30], [30, 45]]); + let dry = run(&mut s, "sketch.trim.path", json!({"points": path, "dry_run": true})); + assert_eq!(dry["dry_run"], true); + assert_eq!(sketch(&s), before); + assert_eq!((s.undo.len(), s.revision), (undo, revision), "a dry run is no step"); + let real = run(&mut s, "sketch.trim.path", json!({"points": path})); + assert_eq!(dry["removed"], real["removed"]); + assert_eq!(dry["trimmed"], real["trimmed"]); +} + +#[test] +fn curves_trim_cannot_change_are_passed_over() { + let mut s = new_sketch(); + let inf = line(&mut s, json!([[0, -10], [0, 10]]))[0].clone(); + run(&mut s, "sketch.infinite", json!({"curves": [inf]})); + let h = line(&mut s, json!([[-20, 0], [20, 0]]))[0].clone(); + // Crossing the infinite line leaves it alone; the horizontal line's right part goes. + let out = run(&mut s, "sketch.trim.path", json!({"points": [[-5, 5], [10, 5], [10, -5]]})); + assert_eq!(out["trimmed"].as_array().map(Vec::len), Some(1), "{out}"); + let sk = sketch(&s); + assert!(sk.curves[sk.curve_index(&inf).unwrap()].infinite); + let rest = sk.shape(sk.curve_index(&h).unwrap()).unwrap(); + assert!(matches!(rest, Shape::Line { a, b } if a.dist(Vec2::new(-20.0, 0.0)) < 1e-6 && b.dist(Vec2::new(0.0, 0.0)) < 1e-6), "{rest:?}"); +} + +#[test] +fn hostile_paths_fail_cleanly() { + let mut s = new_sketch(); + line(&mut s, json!([[0, 0], [10, 0]])); + let before = sketch(&s); + let long: Vec<[f64; 2]> = (0..2_001).map(|i| [i as f64, 1.0]).collect(); + for p in [ + json!({}), + json!({"points": []}), + json!({"points": [[0, 1]]}), + json!({"points": "x"}), + json!({"points": [[0, 1], ["a", 2]]}), + json!({"points": long}), + json!({"points": [[50, 50], [60, 60]]}), + json!({"points": [[1e308, -1e308], [-1e308, 1e308]]}), + json!({"points": [[5, 1], [5, 1]]}), + ] { + assert!(s.execute("sketch.trim.path", &p).is_err(), "{p}"); + assert_eq!(sketch(&s), before, "{p}"); + } + // Outside a sketch. + let mut none = Session::default(); + assert!(none.execute("sketch.trim.path", &json!({"points": [[0, -1], [0, 1]]})).is_err()); +} diff --git a/crates/ui-egui/src/sketch_tools.rs b/crates/ui-egui/src/sketch_tools.rs index bedd33883..2e702599b 100644 --- a/crates/ui-egui/src/sketch_tools.rs +++ b/crates/ui-egui/src/sketch_tools.rs @@ -86,6 +86,78 @@ thread_local! { static ISO: RefCell>> = const { RefCell::new(Vec::new()) }; /// Center of Mass has just started: measure everything on the next frame. static DEFERRED: Cell = const { Cell::new(false) }; + /// A Trim drag: the pieces its path would remove (sketch polylines), and where the path's + /// last point is on screen. + static TRIM_REMOVED: RefCell>> = const { RefCell::new(Vec::new()) }; + static TRIM_LAST: Cell> = const { Cell::new(None) }; +} + +/// Screen distance the pointer moves before a Trim drag's path takes another point. +const TRIM_STEP_PX: f32 = 4.0; + +/// The sketch-plane position under screen position `pos`. +fn on_sketch_plane(app: &SolveApp, proj: &Proj, pos: Pos2) -> Option { + let st = app.session.world_state(); + let ss = st.sketch(active_sketch(app)?)?; + let (o, d) = proj.ray(pos); + ss.plane.intersect_ray(o, d).map(|w| ss.plane.to_local(w)) +} + +/// A press and drag with Trim draws a path from `press`; true when it started one. Each piece +/// the path crosses is trimmed when it is let go (`sketch.trim.path`). +pub fn trim_drag_start(app: &mut SolveApp, proj: &Proj, press: Pos2) -> bool { + let Some(q) = on_sketch_plane(app, proj, press) else { return false }; + let Some(tool) = app.tool.as_mut().filter(|t| t.cmd == "sketch.trim") else { return false }; + tool.pts = vec![(q, None)]; + TRIM_LAST.with(|c| c.set(Some(press))); + TRIM_REMOVED.with(|r| r.borrow_mut().clear()); + true +} + +/// The Trim drag's path reaches `pos`: the pieces it would remove light up (a dry run of the +/// command the release runs). +pub fn trim_drag_to(app: &mut SolveApp, proj: &Proj, pos: Pos2) { + if TRIM_LAST.with(Cell::get).is_some_and(|last| last.distance(pos) < TRIM_STEP_PX) { + return; + } + let Some(q) = on_sketch_plane(app, proj, pos) else { return }; + let Some(tool) = app.tool.as_mut().filter(|t| t.cmd == "sketch.trim" && !t.pts.is_empty()) else { return }; + if tool.pts.len() >= TRIM_PATH_MAX { + return; + } + tool.pts.push((q, None)); + TRIM_LAST.with(|c| c.set(Some(pos))); + let points: Vec<[f64; 2]> = tool.pts.iter().map(|p| [p.0.x, p.0.y]).collect(); + let removed = app + .session + .execute("sketch.trim.path", &json!({"points": points, "dry_run": true})) + .map(|v| { + v["removed"] + .as_array() + .into_iter() + .flatten() + .map(|piece| piece.as_array().into_iter().flatten().filter_map(solidcraft_engine::params::vec2).collect()) + .collect() + }) + .unwrap_or_default(); + TRIM_REMOVED.with(|r| *r.borrow_mut() = removed); +} + +/// Most points a Trim drag's path keeps (the command's limit). +const TRIM_PATH_MAX: usize = 2_000; + +/// The Trim drag is let go: trim every piece its path crossed, in one undo step. False when the +/// path crossed nothing (the caller takes the release as a click). +pub fn trim_drag_end(app: &mut SolveApp) -> bool { + TRIM_LAST.with(|c| c.set(None)); + let crossed = TRIM_REMOVED.with(|r| !std::mem::take(&mut *r.borrow_mut()).is_empty()); + let Some(tool) = app.tool.as_mut().filter(|t| t.cmd == "sketch.trim") else { return false }; + let points: Vec<[f64; 2]> = std::mem::take(&mut tool.pts).iter().map(|p| [p.0.x, p.0.y]).collect(); + if !crossed || points.len() < 2 { + return false; + } + let _ = app.run("sketch.trim.path", json!({"points": points})); + true } /// Commands registered on one panel that another panel also lists: the analyses (sketch @@ -528,7 +600,7 @@ pub fn hint(id: &str) -> Option { "inspect.continuity" => "Continuity: click an edge for its numbers (the button again turns the colours off)", "canvas.insert" => "Canvas: click a plane or a planar face where the image's centre goes", "canvas.decal" => "Decal: click a planar face where the image's centre goes", - "sketch.trim" => "Trim: click the piece of a curve to remove", + "sketch.trim" => "Trim: click the piece of a curve to remove, or drag across the pieces to remove", "sketch.extend" => "Extend: click a curve near the end to extend", "sketch.break" => "Break: click a curve where it should split", "sketch.line.midpoint" => "Midpoint line: click the middle, then an end", @@ -1042,6 +1114,18 @@ pub fn preview(app: &SolveApp, t: &Tool, painter: &egui::Painter, proj: &Proj) { crate::tools::paint_sketch_path(&world, 0, painter, proj, Stroke::new(4.5, tk.error)); } let stroke = Stroke::new(1.5, tk.rubber_band); + // A Trim drag: the pieces it will remove, then the path drawn so far. + if t.cmd == "sketch.trim" && !t.pts.is_empty() { + TRIM_REMOVED.with(|r| { + for piece in r.borrow().iter() { + let line: Vec = piece.iter().filter_map(|p| to(*p)).collect(); + painter.add(egui::Shape::line(line, Stroke::new(4.0, tk.error.gamma_multiply(0.8)))); + } + }); + let path: Vec = t.pts.iter().filter_map(|p| to(p.0)).collect(); + painter.add(egui::Shape::line(path, stroke)); + return; + } if let Some((hp, snap)) = &t.hover && let Some(sp) = to(*hp) { @@ -1320,3 +1404,7 @@ mod corner_ui_tests; #[cfg(test)] #[path = "sketch_continuity_tests.rs"] mod continuity_tests; + +#[cfg(test)] +#[path = "sketch_trim_drag_ui_tests.rs"] +mod trim_drag_ui_tests; diff --git a/crates/ui-egui/src/sketch_trim_drag_ui_tests.rs b/crates/ui-egui/src/sketch_trim_drag_ui_tests.rs new file mode 100644 index 000000000..a0a56c02a --- /dev/null +++ b/crates/ui-egui/src/sketch_trim_drag_ui_tests.rs @@ -0,0 +1,151 @@ +//! Trim by dragging: with Trim on, a press and drag draws a path, the pieces it crosses light +//! up, and letting go trims them all (`sketch.trim.path`) in one undo step. A click still trims +//! the one piece under it. + +use serde_json::{Value, json}; +use solidcraft_engine::geom::Vec2; +use solidcraft_engine::sketch::Shape; + +use crate::scenario::Harness; + +/// Two horizontal lines crossed by a vertical one, seen from the top, with Trim on. Returns the +/// vertical line's id. +fn ladder() -> (Harness, String) { + let mut h = Harness::new(); + h.app.home.open = false; + run(&mut h, "sketch.create", json!({"plane": "XY"})); + run(&mut h, "sketch.line", json!({"points": [[0, 0], [20, 0]], "connect": false})); + run(&mut h, "sketch.line", json!({"points": [[0, 10], [20, 10]], "connect": false})); + let v = run(&mut h, "sketch.line", json!({"points": [[10, -5], [10, 15]], "connect": false}))["curves"][0].as_str().unwrap().to_string(); + h.call("ui.view", json!({"view": "top"})); + h.app.cam.distance = 60.0; + h.frames(3); + h.call("ui.start", json!({"command": "sketch.trim"})); + h.frames(2); + (h, v) +} + +#[test] +fn dragging_across_pieces_trims_them_all_in_one_undo_step() { + let (mut h, v) = ladder(); + let before = h.app.session.doc.to_json(); + let undo = h.app.session.undo.len(); + // A zigzag across the vertical line's middle piece, three times, then down across the + // lower line's right half. + let a = screen(&mut h, 5.0, 8.0); + let b = screen(&mut h, 15.0, 7.0); + let c = screen(&mut h, 5.0, 5.0); + let d = screen(&mut h, 15.0, -3.0); + let mut path = vec![a]; + path.extend(steps(a, b, 8)); + path.extend(steps(b, c, 8)); + path.extend(steps(c, d, 8)); + press_and_move(&mut h, &path); + + // While dragging: nothing has changed yet, and the two pieces to go light up (the middle + // piece once). + assert!(h.app.viewport.trim_drag); + assert_eq!(h.app.session.doc.to_json(), before, "a drag changes nothing before it is let go"); + assert_eq!(h.app.session.undo.len(), undo); + let lit = super::TRIM_REMOVED.with(|r| r.borrow().clone()); + assert_eq!(lit.len(), 2, "{lit:?}"); + + release(&mut h, d); + assert!(!h.app.viewport.trim_drag); + assert!(super::TRIM_REMOVED.with(|r| r.borrow().is_empty())); + assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step"); + // The vertical line keeps its ends; the lower line its left half. + let sk = sketch(&h); + let rest: Vec = (0..sk.curves.len()).filter_map(|ci| sk.shape(ci)).collect(); + assert_eq!(rest.len(), 4, "{rest:?}"); + assert!(rest.iter().all(|s| s.dist(Vec2::new(10.0, 5.0)) > 1e-3 && s.dist(Vec2::new(15.0, 0.0)) > 1e-3), "{rest:?}"); + let lower = sk.shape(sk.curve_index(&v).unwrap()).unwrap(); + assert!(matches!(lower, Shape::Line { a, b } if a.dist(Vec2::new(10.0, -5.0)) < 1e-6 && b.dist(Vec2::new(10.0, 0.0)) < 1e-6), "{lower:?}"); + // Trim stays on for the next piece. + assert_eq!(h.app.tool.as_ref().map(|t| t.cmd), Some("sketch.trim")); + + run(&mut h, "edit.undo", json!({})); + assert_eq!(h.app.session.doc.to_json(), before); +} + +#[test] +fn a_click_still_trims_one_piece_and_an_empty_drag_nothing() { + let (mut h, v) = ladder(); + let undo = h.app.session.undo.len(); + // A drag that crosses nothing leaves the design alone. + let a = screen(&mut h, 1.0, 3.0); + let b = screen(&mut h, 8.0, 7.0); + let mut path = vec![a]; + path.extend(steps(a, b, 6)); + press_and_move(&mut h, &path); + release(&mut h, b); + assert_eq!(h.app.session.undo.len(), undo); + + // A click on the vertical line's middle piece trims just that piece. + h.step(&json!({"click": {"sketch": [10, 5]}})).unwrap(); + assert_eq!(h.app.session.undo.len(), undo + 1); + let sk = sketch(&h); + assert_eq!(sk.curves.len(), 4); + assert!((0..sk.curves.len()).all(|ci| sk.shape(ci).is_some_and(|s| s.dist(Vec2::new(10.0, 5.0)) > 1e-3))); + assert!(sk.curve_index(&v).is_some()); +} + +#[test] +fn a_click_that_moves_along_a_piece_still_trims_it() { + // A press that moves on the way (#2448) beside the vertical line's middle piece, crossing + // nothing: the release is the click, and trims the piece under it. + let (mut h, _) = ladder(); + let undo = h.app.session.undo.len(); + let a = screen(&mut h, 10.0, 3.0) + egui::vec2(3.0, 0.0); + let b = screen(&mut h, 10.0, 7.0) + egui::vec2(3.0, 0.0); + let mut path = vec![a]; + path.extend(steps(a, b, 6)); + press_and_move(&mut h, &path); + release(&mut h, b); + assert_eq!(h.app.session.undo.len(), undo + 1, "one trim"); + let sk = sketch(&h); + assert_eq!(sk.curves.len(), 4); + assert!((0..sk.curves.len()).all(|ci| sk.shape(ci).is_some_and(|s| s.dist(Vec2::new(10.0, 5.0)) > 1e-3))); +} + +fn run(h: &mut Harness, id: &str, p: Value) -> Value { + match h.app.run(id, p.clone()) { + Ok(v) => v, + Err(e) => panic!("{id} {p}: {e}"), + } +} + +fn sketch(h: &Harness) -> solidcraft_engine::sketch::Sketch { + let sid = h.app.session.active_sketch.expect("sketch mode"); + h.app.session.world_state().sketch(sid).expect("the sketch").sketch.clone() +} + +fn screen(h: &mut Harness, x: f64, y: f64) -> egui::Pos2 { + let [sx, sy] = h.at(&json!({"sketch": [x, y]})).expect("on screen"); + egui::pos2(sx as f32, sy as f32) +} + +fn steps(a: egui::Pos2, b: egui::Pos2, n: usize) -> Vec { + (1..=n).map(|i| a + (b - a) * (i as f32 / n as f32)).collect() +} + +/// Press at `path[0]` and move through the rest, one frame per event. +fn press_and_move(h: &mut Harness, path: &[egui::Pos2]) { + let Some(&a) = path.first() else { return }; + h.app.synthetic.push(egui::Event::PointerMoved(a)); + h.app.synthetic.push(egui::Event::PointerButton { pos: a, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() }); + h.app.synthetic.extend(path.iter().skip(1).map(|&p| egui::Event::PointerMoved(p))); + play(h); +} + +fn release(h: &mut Harness, at: egui::Pos2) { + h.app.synthetic.push(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() }); + play(h); +} + +fn play(h: &mut Harness) { + while !h.app.synthetic.is_empty() { + h.frame(); + } + h.frames(2); +} diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index dc0a5aa12..61d18726f 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -48,6 +48,8 @@ pub struct ViewportState { /// A tool's click moved on the way (#2448): egui takes a press that moves past its /// click distance, or is held past its click time, as a drag, so its release is the click. pub(crate) tool_click: bool, + /// A Trim drag is drawing its path (`sketch_tools::trim_drag_*`). + pub(crate) trim_drag: bool, /// Per-body boxes of one world state, held (not just its address, which a later state can /// reuse once the old one is freed, so stale boxes would come back). pick_bounds: std::sync::Mutex>, @@ -2533,6 +2535,23 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { crate::tools::on_hover(app, &proj, p); } } + // A Trim drag's path follows the pointer; letting go trims what it crossed. A path that + // crossed nothing was a click that moved on the way (#2448): the release clicks. + if app.viewport.trim_drag { + let at = ui.input(|i| i.pointer.latest_pos()).filter(|p| rect.contains(*p)); + if resp.drag_stopped() || !ui.input(|i| i.pointer.primary_down()) { + app.viewport.trim_drag = false; + if !crate::sketch_tools::trim_drag_end(app) + && let Some(p) = at + && app.tool.is_some() + { + crate::tools::on_hover(app, &proj, p); + crate::tools::on_click(app, &proj, p); + } + } else if let Some(p) = at { + crate::sketch_tools::trim_drag_to(app, &proj, p); + } + } // Selection chords via resolve (add-only Shift is a preference; default both toggle). let held_mods = crate::tool_modifiers::Held::from_modifiers(mods); let (add, allow_toggle) = crate::tool_modifiers::selection_click(held_mods, app.preferences.selection_shift_add_only); @@ -2541,6 +2560,20 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { if app.tool.is_some() { crate::tools::on_hover(app, &proj, p); } + // Trim also trims by press and drag across the pieces to remove (its own release handling, + // so not a click that moved on the way below). + if app.tool.as_ref().is_some_and(|t| t.cmd == "sketch.trim") + && !held + && primary_nav.is_none() + && mode.is_none() + && resp.drag_started_by(egui::PointerButton::Primary) + && let Some(a) = ui.input(|i| i.pointer.press_origin()) + { + app.viewport.trim_drag = crate::sketch_tools::trim_drag_start(app, &proj, a); + if app.viewport.trim_drag { + crate::sketch_tools::trim_drag_to(app, &proj, p); + } + } // Rectangles, circles and polygons also draw by press, drag and release (#1630): the press // places the first point as a click there would, the release the second. let two_point_start = app.tool.as_ref().is_some_and(|t| matches!(t.kind, crate::tools::Kind::Draw(2)) && t.pts.is_empty()); @@ -2553,7 +2586,13 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { { crate::tools::on_click(app, &proj, a); app.viewport.draw_drag = app.tool.as_ref().is_some_and(|t| t.pts.len() == 1).then_some(a); - } else if app.tool.is_some() && !held && primary_nav.is_none() && mode.is_none() && resp.drag_started_by(egui::PointerButton::Primary) { + } else if app.tool.is_some() + && !app.viewport.trim_drag + && !held + && primary_nav.is_none() + && mode.is_none() + && resp.drag_started_by(egui::PointerButton::Primary) + { // Any other press of a tool that turns into a drag is a click that moved on the way // (#2448): its release clicks. app.viewport.tool_click = true; diff --git a/docs/book/src/guide/sketching.md b/docs/book/src/guide/sketching.md index c9595d0ce..c74d2c301 100644 --- a/docs/book/src/guide/sketching.md +++ b/docs/book/src/guide/sketching.md @@ -30,7 +30,9 @@ Lines and polylines (L), rectangles (two-point R, three-point, centre), circles two-point, three-point, tangent), arcs (three-point, centre, tangent), polygons, slots, ellipses, fit-point and control-point splines, conics, points and text. **Construction** (X) turns curves into reference geometry that doesn't form profiles. Modify tools include trim (T), extend, break, -fillet, chamfer, offset (O), mirror, patterns, move/copy and scale. +fillet, chamfer, offset (O), mirror, patterns, move/copy and scale. With trim on, click a +piece to remove it, or press and drag a path across several pieces: the ones it crosses light up +and all go when you let go, in one undo step (`sketch.trim.path`). The Sketch Palette's **Construction Geometries** option hides construction curves while you work. A hidden construction curve cannot be picked by a click or by a box. Nothing invisible