SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch Trim: a cut on a shape's centre ends the piece there, with no second point (#12101) (#12103)
Daniel155387bac117
diff --git a/crates/engine/src/cmd/sketch_modify.rs b/crates/engine/src/cmd/sketch_modify.rsindex 00c3189e4a..b0c459b093 100644--- a/crates/engine/src/cmd/sketch_modify.rs+++ b/crates/engine/src/cmd/sketch_modify.rs@@ -9,7 +9,7 @@ use solidcore_record::{Plane, Vec2};use solidcraft_doc::ProfileSel;use solidcraft_sketch::{ConstraintKind, Curve, CurveKind, Shape, Sketch, Wire, WireSpace, intersections, intersections_within};-use super::sketch::{add_c, coincident_points, edit, ids_of, line_or_axis_ref, solve_current};+use super::sketch::{add_c, coincident_points, dof_now, edit, ids_of, line_or_axis_ref, solve_current};use super::sketch_store;use super::{CommandSpec, in_sketch};use crate::params::{bad, bool_, expr, num, req_expr, req_vec2, str_, string_list, vec2, vec2_list};@@ -555,6 +555,14 @@ fn release_source_line_offsets(sk: &mut Sketch, doc: &solidcraft_doc::Document,Ok(released)}+/// Whether the sketch already holds point `m` at the middle of line `l`, though no constraint says+/// so: adding that Midpoint takes away no degree of freedom (a center rectangle's centre, held on+/// one diagonal, is the other's middle too because the diagonals bisect each other).+fn middle_implied(sk: &Sketch, m: usize, l: usize) -> bool {+ let mut with = sk.clone();+ add_c(&mut with, ConstraintKind::Midpoint { p: m, l }).is_ok() && dof_now(&with) == dof_now(sk)+}+/// 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.@@ -597,6 +605,18 @@ fn remove_piece(sk: &mut Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<(Valu.then(|| dimension.id.clone())}).collect();+ // Points held at the middle of the trimmed line (a center rectangle's centre on its first+ // diagonal): `release_extent` drops that hold, so remember them for the cuts below.+ let midpoints: Vec<usize> = sk+ .constraints+ .iter()+ .filter_map(|k| match k.kind {+ ConstraintKind::Midpoint { p, l } if l == ci => Some(p),+ _ => None,+ })+ .collect();+ // The sketch as it was, for `middle_implied`: only needed when a midpoint can be cut.+ let before = (!midpoints.is_empty()).then(|| sk.clone());release_extent(sk, ci);let tangencies = endpoint_tangencies(sk, ci);let ts: Vec<f64> = cuts.iter().map(|c| c.0).collect();@@ -608,8 +628,40 @@ fn remove_piece(sk: &mut Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<(Valu} else {ts.iter().filter(|t| **t < tq).count()};+ // A cut on a point already held there ends the piece on that point: no second point.+ let mut welds: Vec<(usize, usize)> = Vec::new();for (pi, c) in pts.iter().zip(&cuts) {- pin(sk, *pi, c.2)?;+ let cutter = c.2;+ let Some(at) = sk.point(*pi) else { continue };+ let near = |sk: &Sketch, p: usize| sk.point(p).is_some_and(|q| q.dist(at) < TOL * 10.0);+ // The cutter's middle, held there, is taken as its ends are (`pin`).+ let held = sk.constraints.iter().find_map(|k| match k.kind {+ ConstraintKind::Midpoint { p, l } if l == cutter && near(sk, p) => Some(p),+ _ => None,+ });+ if let Some(m) = held {+ welds.push((*pi, m));+ } else if let Some(m) = midpoints.iter().copied().find(|m| near(sk, *m)) {+ // The trimmed line's middle: it moves to the cutter's middle when the sketch makes it+ // that too (a center rectangle's diagonals bisect each other), else it stays on the+ // cutter. A cutter whose middle is there only by chance gets no hold it never had.+ welds.push((*pi, m));+ let middle = match sk.curves.get(cutter).map(|c| &c.kind) {+ Some(CurveKind::Line { a, b }) => sk.point(*a).zip(sk.point(*b)).map(|(a, b)| (a + b) * 0.5),+ _ => None,+ };+ let implied = match &before {+ Some(was) if middle.is_some_and(|q| q.dist(at) < TOL * 10.0) => middle_implied(was, m, cutter),+ _ => false,+ };+ if implied {+ add_c(sk, ConstraintKind::Midpoint { p: m, l: cutter })?;+ } else {+ pin(sk, m, cutter)?;+ }+ } else {+ pin(sk, *pi, cutter)?;+ }}let gone = pieces.get(k).copied().ok_or_else(|| bad(cmd, "piece"))?;let keep: Vec<usize> = pieces.iter().copied().filter(|x| *x != gone).collect();@@ -632,6 +684,13 @@ fn remove_piece(sk: &mut Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<(Valu};rebind_endpoint_tangencies(sk, ci, &pieces, &tangencies);let keep: Vec<usize> = pieces.iter().copied().filter(|x| *x != gone).collect();+ for &(from, to) in &welds {+ for piece in &keep {+ if let Some(c) = sk.curves.get_mut(*piece) {+ c.kind.map_points(&|p| if p == from { to } else { p });+ }+ }+ }tie(sk, &keep)?;if let Some((a, _)) = sk.curves.get(ci).and_then(|c| c.kind.ends()) {for dimension in &mut sk.constraints {diff --git a/crates/engine/src/cmd/sketch_modify_tests.rs b/crates/engine/src/cmd/sketch_modify_tests.rsindex ecbc0de592..6cd1030e42 100644--- a/crates/engine/src/cmd/sketch_modify_tests.rs+++ b/crates/engine/src/cmd/sketch_modify_tests.rs@@ -577,6 +577,116 @@ fn trim_circle_makes_an_arc_and_a_profile() {assert!(close(a[0], std::f64::consts::PI * 50.0), "{a:?}");}+/// Trimming half of a center rectangle's diagonal left two points at the centre, one held by+/// nothing: dragging a corner pulled them apart. Either diagonal, the half that stays ends on the+/// one centre point, which stays where the diagonals cross.+#[test]+fn trimming_half_a_center_rectangle_diagonal_keeps_one_centre() {+ for (diagonal, at) in [(0, [7.5, 4.25]), (1, [7.5, -0.25])] {+ let mut s = new_sketch();+ run(&mut s, "sketch.rectangle.center", json!({"center": [3, 2], "corner": [12, 6.5]}));+ let sk = sketch(&s);+ let diagonals: Vec<String> = sk.curves.iter().filter(|c| c.construction).map(|c| c.id.clone()).collect();+ assert_eq!(diagonals.len(), 2, "{diagonals:?}");+ let (cut, other) = (diagonals[diagonal].clone(), diagonals[1 - diagonal].clone());+ run(&mut s, "sketch.trim", json!({"curve": cut, "at": at}));+ let sk = sketch(&s);+ let at_centre = sk.points.iter().filter(|p| p.pos.dist(Vec2::new(3.0, 2.0)) < 1e-7).count();+ assert_eq!(at_centre, 1, "diagonal {cut}: {} points at the centre", at_centre);+ let si = run(&mut s, "sketch.inspect", json!({}));+ assert_eq!(si["dof"], 4, "diagonal {cut}: {si}");+ assert_ne!(si["status"], "conflict", "diagonal {cut}: {si}");+ assert!(si["status"].as_str().is_none_or(|t| !t.contains("over")), "diagonal {cut}: {si}");+ // Drag a corner: the trimmed half still ends where the diagonals cross.+ run(&mut s, "sketch.drag", json!({"entity": "l2.end", "from": [12, 6.5], "to": [16, 9]}));+ let sk = sketch(&s);+ let ends = |id: &str| {+ let (a, b) = sk.curves[sk.curve_index(id).unwrap()].kind.ends().unwrap();+ (sk.point(a).unwrap(), sk.point(b).unwrap())+ };+ let (o0, o1) = ends(&other);+ let centre = (o0 + o1) * 0.5;+ let (c0, c1) = ends(&cut);+ assert!(c0.dist(centre).min(c1.dist(centre)) < 1e-6, "diagonal {cut}: {c0:?} {c1:?}, centre {centre:?}");+ }+}++#[test]+fn trimming_the_start_half_of_a_center_rectangle_diagonal_keeps_its_parallel_distance_on_the_centre() {+ let mut s = new_sketch();+ run(&mut s, "sketch.rectangle.center", json!({"center": [3, 2], "corner": [12, 6.5]}));+ let diagonal = sketch(&s).curves.iter().find(|c| c.construction).map(|c| c.id.clone()).unwrap();+ // A line parallel to the diagonal (-6,-2.5)-(12,6.5), 10 mm lower, dimensioned from the+ // diagonal's start.+ let line = ids(&run(&mut s, "sketch.line", json!({"points": [[-6, -12.5], [12, -3.5]], "connect": false, "infer": false}))["curves"])[0].clone();+ run(&mut s, "sketch.constraint.parallel", json!({"a": diagonal, "b": line}));+ run(&mut s, "sketch.dimension", json!({"entities": [diagonal, line]}));+ let value = |sk: &solidcraft_sketch::Sketch| {+ sk.constraints.iter().find_map(|c| match c.kind {+ ConstraintKind::PointLineDistance { p, value, .. } => Some((sk.point(p).unwrap(), value)),+ _ => None,+ })+ };+ let (from, d) = value(&sketch(&s)).expect("the distance between the parallel lines");+ assert!(from.dist(Vec2::new(-6.0, -2.5)) < 1e-7, "{from:?}");+ // Trim the half from the diagonal's start: the kept half starts at the centre, so the+ // distance moves there, onto the one point the cut is welded to.+ run(&mut s, "sketch.trim", json!({"curve": diagonal, "at": [-1.5, -0.25]}));+ let sk = sketch(&s);+ let (from, after) = value(&sk).expect("the distance survives the trim");+ assert!(from.dist(Vec2::new(3.0, 2.0)) < 1e-7, "{from:?}");+ assert!((after - d).abs() < 1e-9, "{after} != {d}");+}++/// A center rectangle whose bottom is held square to a side instead of horizontal keeps one+/// centre after a trim: what makes its diagonals bisect each other is the solver's to say, not+/// which constraints hold the sides.+#[test]+fn trimming_a_diagonal_of_a_center_rectangle_held_by_other_constraints_keeps_one_centre() {+ let mut s = new_sketch();+ run(&mut s, "sketch.rectangle.center", json!({"center": [3, 2], "corner": [12, 6.5]}));+ let sk = sketch(&s);+ let bottom = sk.constraints.iter().find(|c| matches!(c.kind, ConstraintKind::Horizontal { l: 0 })).map(|c| c.id.clone()).unwrap();+ run(&mut s, "sketch.delete", json!({"entities": [bottom]}));+ run(&mut s, "sketch.constraint.perpendicular", json!({"a": "l1", "b": "l2"}));+ let dof = run(&mut s, "sketch.inspect", json!({}))["dof"].clone();+ let diagonal = sketch(&s).curves.iter().find(|c| c.construction).map(|c| c.id.clone()).unwrap();+ run(&mut s, "sketch.trim", json!({"curve": diagonal, "at": [7.5, 4.25]}));+ let sk = sketch(&s);+ let at_centre = sk.points.iter().filter(|p| p.pos.dist(Vec2::new(3.0, 2.0)) < 1e-7).count();+ assert_eq!(at_centre, 1, "{at_centre} points at the centre");+ let si = run(&mut s, "sketch.inspect", json!({}));+ assert_eq!(si["dof"], dof, "the trim frees the centre: {si}");+}++/// A line's held midpoint trimmed at a crossing line that only happens to have its middle there+/// ends the kept half on that point and keeps it on the crossing line, without tying the crossing+/// line's middle to it: nothing held that middle before.+#[test]+fn trimming_at_a_held_midpoint_on_an_unrelated_line_adds_no_hold_to_that_line() {+ let mut s = new_sketch();+ let trimmed = ids(&run(&mut s, "sketch.line", json!({"points": [[0,0], [10,0]], "connect": false, "infer": false}))["curves"])[0].clone();+ let crossing = ids(&run(&mut s, "sketch.line", json!({"points": [[5,-3], [5,3]], "connect": false, "infer": false}))["curves"])[0].clone();+ run(&mut s, "sketch.point", json!({"point": format!("mid:{trimmed}")}));+ let sk = sketch(&s);+ let mid = sk.points.iter().find(|p| p.pos.dist(Vec2::new(5.0, 0.0)) < 1e-7).map(|p| p.id.clone()).unwrap();+ run(&mut s, "sketch.trim", json!({"curve": trimmed, "at": [8, 0]}));+ let sk = sketch(&s);+ let l = sk.curve_index(&crossing).unwrap();+ let m = sk.resolve_point(&mid).unwrap();+ assert!(+ !sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::Midpoint { l: cl, .. } if cl == l)),+ "the crossing line gets no midpoint hold: {:?}",+ sk.constraints+ );+ assert!(+ sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::PointOnCurve { p, c: cc } if p == m && cc == l)),+ "the old midpoint stays on the crossing line: {:?}",+ sk.constraints+ );+ assert_eq!(sk.points.iter().filter(|p| p.pos.dist(Vec2::new(5.0, 0.0)) < 1e-7).count(), 1, "one point at the cut");+}+#[test]fn exact_extend_ellipse_preserves_support_target_and_history() {for (y, expected_x) in [(3.0, 12.0), (5.0, 20.0)] {