Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Sketch Symmetry: centre a line between two fixed lines (#1796) (#3895)

leValdemar1952e496d01775
diff --git a/crates/engine/src/cmd/sketch_constraints_tests.rs b/crates/engine/src/cmd/sketch_constraints_tests.rs
index 87f1eb451a..0746182af8 100644
--- a/crates/engine/src/cmd/sketch_constraints_tests.rs
+++ b/crates/engine/src/cmd/sketch_constraints_tests.rs
@@ -477,6 +477,49 @@ fn symmetry_slides_a_rectangle_whose_width_is_dimensioned() {
assert!((r.x - l.x - 42.0).abs() < 1e-6 && (l.x + 21.0).abs() < 1e-6, "sides at ±21: {l:?} {r:?}");
}
+#[test]
+fn symmetry_pairs_the_ends_of_fixed_lines_drawn_the_opposite_way() {
+ // #1796: the sides of a face outline run in opposite directions (up one side, down the
+ // other). Pairing start with start asked for a reflection no line gives, and centring a
+ // construction line between them was refused as "neither entity can move".
+ let mut s = new_sketch();
+ run(&mut s, "sketch.line", json!({"points": [[0, 0], [0, 20]], "ids": ["left"]}));
+ run(&mut s, "sketch.line", json!({"points": [[10, 20], [10, 0]], "ids": ["right"]}));
+ run(&mut s, "sketch.line", json!({"points": [[3, 2], [3, 18]], "construction": true, "ids": ["mid"]}));
+ run(&mut s, "sketch.constraint.fix", json!({"entities": ["left", "right"]}));
+ run(&mut s, "sketch.constraint.symmetry", json!({"a": "left", "b": "right", "line": "mid"}));
+ let sk = sketch(&s);
+ let at = |r: &str| sk.point(sk.resolve_point(r).unwrap()).unwrap();
+ for end in ["mid.start", "mid.end"] {
+ assert!((at(end).x - 5.0).abs() < 1e-7, "{end} at {:?}", at(end));
+ }
+ assert!((at("mid.end").y - at("mid.start").y - 16.0).abs() < 1e-7, "the line keeps its length");
+}
+
+#[test]
+fn symmetry_pairs_ends_by_their_mirror_images() {
+ // Free lines: each `b` end goes to the mirror image of the `a` end nearest it, so a line
+ // drawn either way round mirrors without flipping, and lines meeting at the axis (a V) or
+ // end to end along it keep their pairs.
+ for (a, b, axis, want) in [
+ ([[0.0, 0.0], [0.0, 20.0]], [[10.0, 21.0], [10.0, 1.0]], [[5.0, -5.0], [5.0, 30.0]], [[10.0, 20.0], [10.0, 0.0]]),
+ ([[0.0, 0.0], [4.0, 10.0]], [[10.0, 1.0], [6.0, 9.0]], [[5.0, -5.0], [5.0, 30.0]], [[10.0, 0.0], [6.0, 10.0]]),
+ ([[0.0, 0.0], [10.0, 0.0]], [[29.0, 1.0], [21.0, -1.0]], [[15.0, -5.0], [15.0, 5.0]], [[30.0, 0.0], [20.0, 0.0]]),
+ ] {
+ let mut s = new_sketch();
+ run(&mut s, "sketch.line", json!({"points": a, "ids": ["a"]}));
+ run(&mut s, "sketch.line", json!({"points": b, "ids": ["b"]}));
+ run(&mut s, "sketch.line", json!({"points": axis, "construction": true, "ids": ["m"]}));
+ run(&mut s, "sketch.constraint.fix", json!({"entities": ["a", "m"]}));
+ run(&mut s, "sketch.constraint.symmetry", json!({"a": "a", "b": "b", "line": "m"}));
+ let sk = sketch(&s);
+ let at = |r: &str| sk.point(sk.resolve_point(r).unwrap()).unwrap();
+ for (end, [x, y]) in ["b.start", "b.end"].into_iter().zip(want) {
+ assert!(at(end).dist(Vec2::new(x, y)) < 1e-6, "{a:?} {b:?}: {end} at {:?}, want [{x}, {y}]", at(end));
+ }
+ }
+}
+
#[test]
fn midpoint_alignment_persists_undoes_and_survives_endpoint_edits() {
use solidcraft_sketch::ConstraintKind;
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index e53a3626cd..3e245c2e45 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -1132,7 +1132,9 @@ impl SolveApp {
self.last_command = Some((spec.id.to_string(), spec.label.to_string()));
}
if let Some(mut t) = tools::Tool::for_command(id) {
- if let Some(params) = tools::constraint_preselection(id, &self.session.selection) {
+ let state = self.session.world_state();
+ let sketch = self.session.active_sketch.and_then(|s| state.sketch(s)).map(|ss| &ss.sketch);
+ if let Some(params) = tools::constraint_preselection(id, &self.session.selection, sketch) {
if self.run(id, params).is_ok() {
let _ = self.session.execute("select.clear", &json!({}));
self.set_status("Constraint applied", false);
diff --git a/crates/ui-egui/src/symmetry_pick_tests.rs b/crates/ui-egui/src/symmetry_pick_tests.rs
index 1dcb705bcc..d24f7b1c0e 100644
--- a/crates/ui-egui/src/symmetry_pick_tests.rs
+++ b/crates/ui-egui/src/symmetry_pick_tests.rs
@@ -1,4 +1,5 @@
-//! The Symmetry tool's third pick may be the origin point or an origin axis (#1075).
+//! The Symmetry tool's third pick may be the origin point or an origin axis (#1075); with three
+//! lines, the construction line between the other two is the symmetry line in any pick order (#1796).
use serde_json::json;
use solidcraft_engine::geom::Vec2;
@@ -44,3 +45,54 @@ fn symmetry_about_an_origin_axis() {
let (p, q) = (point(&h, "p"), point(&h, "q"));
assert!((p.x + q.x).abs() < 1e-6 && (p.y - q.y).abs() < 1e-6, "mirrored in the Y axis: {p:?} {q:?}");
}
+
+/// Two fixed lines and a construction line between them, off centre (#1796).
+fn between_two_lines() -> Harness {
+ let mut h = Harness::new();
+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
+ h.app.run("sketch.line", json!({"points":[[0,0],[0,20]],"ids":["left"]})).unwrap();
+ h.app.run("sketch.line", json!({"points":[[10,20],[10,0]],"ids":["right"]})).unwrap();
+ h.app.run("sketch.line", json!({"points":[[3,2],[3,18]],"ids":["mid"],"construction":true})).unwrap();
+ h.app.run("sketch.constraint.fix", json!({"entities":["left","right"]})).unwrap();
+ h.app.cam.distance = 80.0;
+ h.settle();
+ h
+}
+
+fn centred(h: &Harness) -> bool {
+ [point(h, "mid.start"), point(h, "mid.end")].iter().all(|p| (p.x - 5.0).abs() < 1e-6)
+}
+
+#[test]
+fn the_construction_line_is_the_symmetry_line_whatever_the_pick_order() {
+ for order in [["mid", "left", "right"], ["left", "mid", "right"], ["left", "right", "mid"]] {
+ let mut h = between_two_lines();
+ h.app.start("sketch.constraint.symmetry");
+ for id in order {
+ let xy = match id {
+ "left" => [0, 10],
+ "right" => [10, 10],
+ _ => [3, 10],
+ };
+ let at = h.call("ui.at", json!({ "sketch": xy }))["result"].clone();
+ h.step(&json!({ "click": at })).unwrap();
+ }
+ assert!(centred(&h), "{order:?}: mid at {:?}", point(&h, "mid.start"));
+ }
+}
+
+#[test]
+fn three_selected_lines_take_the_construction_line_as_the_symmetry_line() {
+ use solidcraft_engine::Sel::SketchCurve;
+ let h = between_two_lines();
+ let state = h.app.session.world_state();
+ let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;
+ let sel = |ids: [&str; 3]| ids.map(|id| SketchCurve { id: id.into() });
+ for ids in [["mid", "left", "right"], ["right", "mid", "left"]] {
+ let params = crate::tools::constraint_preselection("sketch.constraint.symmetry", &sel(ids), Some(sk)).unwrap();
+ assert_eq!(params["line"], "mid", "{ids:?}");
+ }
+ // Without a construction line among them, the last one stays the symmetry line.
+ let params = crate::tools::constraint_preselection("sketch.constraint.symmetry", &sel(["left", "right", "mid"]), None).unwrap();
+ assert_eq!(params["line"], "mid");
+}
diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rs
index d31f9f3c0e..b814e32267 100644
--- a/crates/ui-egui/src/tools.rs
+++ b/crates/ui-egui/src/tools.rs
@@ -533,7 +533,11 @@ fn run_shape(app: &mut SolveApp, t: &Tool) -> Result<Vec<String>, String> {
}
/// Only consume a complete, unambiguous selection; command validation owns geometry.
-pub(crate) fn constraint_preselection(command: &str, selection: &[solidcraft_engine::Sel]) -> Option<Value> {
+pub(crate) fn constraint_preselection(
+ command: &str,
+ selection: &[solidcraft_engine::Sel],
+ sketch: Option<&solidcraft_engine::sketch::Sketch>,
+) -> Option<Value> {
use solidcraft_engine::Sel::{SketchCurve, SketchPoint};
let selected_ids = |curves_only: bool, minimum: usize| -> Option<Vec<&str>> {
if !(minimum..=200).contains(&selection.len()) {
@@ -572,19 +576,14 @@ pub(crate) fn constraint_preselection(command: &str, selection: &[solidcraft_eng
) => Some(json!({"point":point,"line":line})),
("sketch.constraint.midpoint", [SketchCurve { id: a }, SketchCurve { id: b }]) if a != b => Some(json!({"a":a,"b":b})),
("sketch.constraint.symmetry", [a, b, c]) => {
- let mut points = Vec::new();
- let mut lines = Vec::new();
- for entity in [a, b, c] {
- match entity {
- SketchPoint { id } => points.push(id),
- SketchCurve { id } => lines.push(id),
- _ => return None,
- }
- }
- match (points.as_slice(), lines.as_slice()) {
- ([a, b], [line]) if a != b => Some(json!({"a":a,"b":b,"line":line})),
- _ => None,
- }
+ let picks = [a, b, c]
+ .into_iter()
+ .map(|entity| match entity {
+ SketchPoint { id } | SketchCurve { id } => Some(json!(id)),
+ _ => None,
+ })
+ .collect::<Option<Vec<_>>>()?;
+ symmetry_args(&picks, sketch)
}
_ => None,
}
@@ -639,6 +638,29 @@ fn sketch_axis_of(app: &SolveApp, name: &str) -> Option<&'static str> {
}
}
+/// Symmetry's arguments from three picked sketch ids in any order (#1796): with two points and
+/// a line, the line; with three lines, the only construction line or centerline among them (the
+/// line drawn between the two it mirrors); otherwise the last pick, as before.
+fn symmetry_args(picks: &[Value], sketch: Option<&solidcraft_engine::sketch::Sketch>) -> Option<Value> {
+ let curve = |v: &Value| match v.as_str() {
+ Some(id) => sketch.and_then(|sk| sk.curve_index(id).and_then(|i| sk.curves.get(i))),
+ None => None,
+ };
+ let is_line = |v: &Value| matches!(v.as_str(), Some("x" | "y")) || curve(v).is_some();
+ let is_axis = |v: &Value| matches!(v.as_str(), Some("x" | "y")) || curve(v).is_some_and(|c| c.construction || c.centerline);
+ let only = |f: &dyn Fn(&Value) -> bool| {
+ let hits: Vec<usize> = (0..picks.len()).filter(|i| picks.get(*i).is_some_and(f)).collect();
+ hits.first().copied().filter(|_| hits.len() == 1)
+ };
+ if picks.len() != 3 {
+ return None;
+ }
+ let line = only(&is_line).or_else(|| only(&is_axis)).unwrap_or(2);
+ let mut rest = (0..3).filter(|i| *i != line).filter_map(|i| picks.get(i));
+ let (a, b, line) = (rest.next()?, rest.next()?, picks.get(line)?);
+ (a != b).then(|| json!({"a": a, "b": b, "line": line}))
+}
+
fn run_pick(app: &mut SolveApp, t: &Tool) {
let k = &t.picks;
let params = match t.cmd {
@@ -646,7 +668,18 @@ fn run_pick(app: &mut SolveApp, t: &Tool) {
"sketch.constraint.coincident" => json!({"a": k[0], "b": k[1]}),
// In pick order: a point and a line either way round, or two lines to centre.
"sketch.constraint.midpoint" => json!({"a": k[0], "b": k[1]}),
- "sketch.constraint.symmetry" => json!({"a": k[0], "b": k[1], "line": k[2]}),
+ "sketch.constraint.symmetry" => {
+ let picks: Vec<Value> = k.iter().map(|pick| json!(pick)).collect();
+ let params = {
+ let state = app.session.world_state();
+ symmetry_args(&picks, app.session.active_sketch.and_then(|id| state.sketch(id)).map(|ss| &ss.sketch))
+ };
+ let Some(params) = params else {
+ app.set_status("Symmetry: pick two points or two curves and the line between them", true);
+ return;
+ };
+ params
+ }
_ => json!({"a": k[0], "b": k[1]}),
};
let _ = app.run(t.cmd, params);
diff --git a/crates/ui-egui/tests/scenarios/sketch_symmetry_face_edges.json b/crates/ui-egui/tests/scenarios/sketch_symmetry_face_edges.json
new file mode 100644
index 0000000000..049c27988f
--- /dev/null
+++ b/crates/ui-egui/tests/scenarios/sketch_symmetry_face_edges.json
@@ -0,0 +1,29 @@
+[
+ {"note": "#1796: on a sketch on a face, Symmetry centres a construction line between two of the face's edges (its projected outline, whose sides run in opposite directions). Before, that was refused: 'neither entity can move'. The picks may come in any order: the construction line is the symmetry line."},
+ {"call": "engine.execute", "params": {"command": "sketch.create", "params": {"plane": "XY"}}},
+ {"call": "engine.execute", "params": {"command": "sketch.rectangle.two_point", "params": {"p0": [0, 0], "p1": [20, 30]}}},
+ {"call": "engine.execute", "params": {"command": "sketch.finish", "params": {}}},
+ {"call": "engine.execute", "params": {"command": "solid.extrude", "params": {"distance": 5}}},
+ {"call": "engine.execute", "params": {"command": "sketch.create", "params": {"plane": {"face": [10, 15, 5]}}}},
+ {"call": "engine.execute", "params": {"command": "sketch.line", "params": {"points": [[7, 4], [7, 26]], "ids": ["lc"], "construction": true}}},
+ {"call": "ui.view", "params": {"view": "top"}},
+ {"call": "ui.view", "params": {"view": "fit"}},
+ {"start": "sketch.constraint.symmetry"},
+ {"click": {"world": [0, 15, 5]}},
+ {"click": {"world": [20, 15, 5]}},
+ {"click": {"sketch": [7, 15]}},
+ {"key": "Escape"},
+ {"shot": "centred"},
+ {"expect": {"errors": 0}},
+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "start_at", 0], "value": 10}}},
+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "end_at", 0], "value": 10}}},
+ {"call": "engine.execute", "params": {"command": "edit.undo", "params": {}}},
+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "start_at", 0], "value": 7}}},
+ {"start": "sketch.constraint.symmetry"},
+ {"click": {"sketch": [7, 15]}},
+ {"click": {"world": [0, 15, 5]}},
+ {"click": {"world": [20, 15, 5]}},
+ {"key": "Escape"},
+ {"expect": {"errors": 0}},
+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 4, "start_at", 0], "value": 10}}}
+]