SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch constraints accept x / y for the sketch's own axes (#394) (#448)
Irakli Kourtis0dee9deec15e
diff --git a/crates/doc/src/project.rs b/crates/doc/src/project.rsindex b3a17dea2d..51da7fda6e 100644--- a/crates/doc/src/project.rs+++ b/crates/doc/src/project.rs@@ -259,6 +259,9 @@ fn resolve_uncached(_ => vec![LinkGeom::Point(o)],}}+ LinkSource::SketchAxis { name } => {+ vec![solidcraft_sketch::sketch_axis_geom(name).ok_or_else(|| DocError::Unknown(format!("sketch axis `{name}`")))?]+ }LinkSource::Text { text, at, height, angle } => solidcraft_sketch::text_geometry(text, *at, *height, *angle)?,LinkSource::Plane { name } => {let pr =diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rsindex 6888bd1660..b2d4c73294 100644--- a/crates/engine/src/cmd/sketch.rs+++ b/crates/engine/src/cmd/sketch.rs@@ -117,12 +117,12 @@ pub static COMMANDS: &[CommandSpec] = &[.at("SKETCH", "CONSTRAINTS").icon("c_coincident").enabled(in_sketch)- .params("a, b: points, a point and a curve, or two distinct lines (joins their closest endpoints)"),+ .params("a, b: points, a point and a curve or sketch axis (x / y: the sketch's own axes, unless a curve has that id; an axis becomes a linked construction line on it, reported in created), or two distinct lines (joins their closest endpoints)"),CommandSpec::new("sketch.constraint.tangent", "Tangent", c_tangent).at("SKETCH", "CONSTRAINTS").icon("c_tangent").enabled(in_sketch)- .params("a, b: curves"),+ .params("a, b: curves or sketch axes (x / y: the sketch's own axes, unless a curve has that id; an axis becomes a linked construction line on it, reported in created)"),CommandSpec::new("sketch.constraint.equal", "Equal", c_equal).at("SKETCH", "CONSTRAINTS").icon("c_equal")@@ -132,12 +132,12 @@ pub static COMMANDS: &[CommandSpec] = &[.at("SKETCH", "CONSTRAINTS").icon("c_parallel").enabled(in_sketch)- .params("a, b: lines"),+ .params("a, b: lines or sketch axes (x / y: the sketch's own axes, unless a curve has that id; an axis becomes a linked construction line on it, reported in created)"),CommandSpec::new("sketch.constraint.perpendicular", "Perpendicular", c_perpendicular).at("SKETCH", "CONSTRAINTS").icon("c_perpendicular").enabled(in_sketch)- .params("a, b: lines"),+ .params("a, b: lines or sketch axes (x / y: the sketch's own axes, unless a curve has that id; an axis becomes a linked construction line on it, reported in created)"),CommandSpec::new("sketch.constraint.fix", "Fix/UnFix", c_fix).at("SKETCH", "CONSTRAINTS").icon("c_fix")@@ -157,12 +157,12 @@ pub static COMMANDS: &[CommandSpec] = &[.at("SKETCH", "CONSTRAINTS").icon("c_collinear").enabled(in_sketch)- .params("a, b: lines"),+ .params("a, b: lines or sketch axes (x / y: the sketch's own axes, unless a curve has that id; an axis becomes a linked construction line on it, reported in created)"),CommandSpec::new("sketch.constraint.symmetry", "Symmetry", c_symmetry).at("SKETCH", "CONSTRAINTS").icon("c_symmetry").enabled(in_sketch)- .params("a, b: points, line: symmetry line"),+ .params("a, b: two points or two curves (lines mirror their ends, circles/arcs their centres); line: symmetry line id, or x / y for the sketch's own axes (a curve with that id wins; an axis becomes a linked construction line on it, reported in created)"),CommandSpec::new("sketch.construction", "Normal/Construction", construction).at("SKETCH", "CREATE").icon("construction")@@ -454,6 +454,22 @@ pub(super) fn curve_ref(sk: &Sketch, v: Option<&Value>, cmd: &str, what: &str) -sk.curve_index(id).ok_or_else(|| bad(cmd, format!("unknown sketch curve `{id}`")))}+/// A line a constraint refers to: a curve id, or `x` / `y` for the sketch's own axes (a curve+/// with that id wins). An axis becomes the sketch's linked construction line on it+/// ([`Sketch::sketch_axis_line`]), added on first use and reported in `created`.+pub(super) fn line_or_axis_ref(sk: &mut Sketch, v: Option<&Value>, cmd: &str, what: &str) -> Result<usize> {+ let id = v.and_then(Value::as_str).ok_or_else(|| bad(cmd, format!("`{what}` must be a curve id, or x / y for a sketch axis")))?;+ curve_or_axis(sk, id)?.ok_or_else(|| bad(cmd, format!("unknown sketch curve `{id}` (x and y name the sketch's own axes)")))+}++/// Curve `id`, or the line of sketch axis `id` (see [`line_or_axis_ref`]); `None` when neither.+fn curve_or_axis(sk: &mut Sketch, id: &str) -> Result<Option<usize>> {+ match sk.curve_index(id) {+ Some(c) => Ok(Some(c)),+ None => Ok(sk.sketch_axis_line(id)?),+ }+}+pub(super) fn point_ref(sk: &Sketch, v: Option<&Value>, cmd: &str, what: &str) -> Result<usize> {let id = v.and_then(Value::as_str).ok_or_else(|| bad(cmd, format!("`{what}` must be a point reference")))?;sk.resolve_point(id).ok_or_else(|| bad(cmd, format!("unknown sketch point `{id}`")))@@ -1154,7 +1170,7 @@ fn draw_point(s: &mut Session, p: &Value) -> Result<Value> {// ---------------------------------------------------------------------------------------------// Constraints-fn constrain(s: &mut Session, p: &Value, cmd: &str, f: impl FnOnce(&Sketch) -> Result<ConstraintKind>) -> Result<Value> {+fn constrain(s: &mut Session, p: &Value, cmd: &str, f: impl FnOnce(&mut Sketch) -> Result<ConstraintKind>) -> Result<Value> {let mut before = None;let (id, info) = edit(s, p, cmd, true, |sk, _| {let k = f(sk)?;@@ -1179,7 +1195,7 @@ pub(super) enum Ent {}fn ent(sk: &Sketch, r: &str) -> Option<Ent> {- sk.resolve_point(r).map(Ent::Point).or_else(|| sk.curve_index(r).map(Ent::Curve))+ sk.resolve_point(r).map(Ent::Point).or_else(|| sk.curve_index(r).or_else(|| sk.sketch_axis_curve(r)).map(Ent::Curve))}/// The entities of a two-entity constraint in the order they were picked (`a` then `b`, or@@ -1372,15 +1388,18 @@ fn c_coincident(s: &mut Session, p: &Value) -> Result<Value> {}let aref = p.get("a").and_then(Value::as_str).unwrap_or_default();let bref = p.get("b").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`b` must be a point or curve"))?;- // A curve picked first and a point second: the point goes onto the curve.- if let (None, Some(c), Some(q)) = (sk.resolve_point(aref), sk.curve_index(aref), sk.resolve_point(bref)) {+ // A curve (or sketch axis) picked first and a point second: the point goes onto it.+ if sk.resolve_point(aref).is_none()+ && let Some(q) = sk.resolve_point(bref)+ && let Some(c) = curve_or_axis(sk, aref)?+ {return Ok(ConstraintKind::PointOnCurve { p: q, c });}let a = point_ref(sk, p.get("a"), cmd, "a")?;if let Some(b) = sk.resolve_point(bref) {return Ok(ConstraintKind::Coincident { p: a, q: b });}- let c = sk.curve_index(bref).ok_or_else(|| bad(cmd, format!("unknown entity `{bref}`")))?;+ let c = curve_or_axis(sk, bref)?.ok_or_else(|| bad(cmd, format!("unknown entity `{bref}`")))?;Ok(ConstraintKind::PointOnCurve { p: a, c })})}@@ -1420,20 +1439,27 @@ fn two_curves(sk: &Sketch, p: &Value, cmd: &str) -> Result<(usize, usize)> {Ok((curve_ref(sk, p.get("a"), cmd, "a")?, curve_ref(sk, p.get("b"), cmd, "b")?))}+/// Two curves where either may be a sketch axis (`x` / `y`, see [`line_or_axis_ref`]).+fn two_curves_or_axes(sk: &mut Sketch, p: &Value, cmd: &str) -> Result<(usize, usize)> {+ Ok((line_or_axis_ref(sk, p.get("a"), cmd, "a")?, line_or_axis_ref(sk, p.get("b"), cmd, "b")?))+}+fn c_tangent(s: &mut Session, p: &Value) -> Result<Value> {- constrain(s, p, "sketch.constraint.tangent", |sk| two_curves(sk, p, "sketch.constraint.tangent").map(|(a, b)| ConstraintKind::Tangent { a, b }))+ constrain(s, p, "sketch.constraint.tangent", |sk| {+ two_curves_or_axes(sk, p, "sketch.constraint.tangent").map(|(a, b)| ConstraintKind::Tangent { a, b })+ })}fn c_equal(s: &mut Session, p: &Value) -> Result<Value> {constrain(s, p, "sketch.constraint.equal", |sk| two_curves(sk, p, "sketch.constraint.equal").map(|(a, b)| ConstraintKind::Equal { a, b }))}fn c_parallel(s: &mut Session, p: &Value) -> Result<Value> {constrain(s, p, "sketch.constraint.parallel", |sk| {- two_curves(sk, p, "sketch.constraint.parallel").map(|(a, b)| ConstraintKind::Parallel { a, b })+ two_curves_or_axes(sk, p, "sketch.constraint.parallel").map(|(a, b)| ConstraintKind::Parallel { a, b })})}fn c_perpendicular(s: &mut Session, p: &Value) -> Result<Value> {constrain(s, p, "sketch.constraint.perpendicular", |sk| {- two_curves(sk, p, "sketch.constraint.perpendicular").map(|(a, b)| ConstraintKind::Perpendicular { a, b })+ two_curves_or_axes(sk, p, "sketch.constraint.perpendicular").map(|(a, b)| ConstraintKind::Perpendicular { a, b })})}fn c_concentric(s: &mut Session, p: &Value) -> Result<Value> {@@ -1443,7 +1469,7 @@ fn c_concentric(s: &mut Session, p: &Value) -> Result<Value> {}fn c_collinear(s: &mut Session, p: &Value) -> Result<Value> {constrain(s, p, "sketch.constraint.collinear", |sk| {- two_curves(sk, p, "sketch.constraint.collinear").map(|(a, b)| ConstraintKind::Collinear { a, b })+ two_curves_or_axes(sk, p, "sketch.constraint.collinear").map(|(a, b)| ConstraintKind::Collinear { a, b })})}fn c_midpoint(s: &mut Session, p: &Value) -> Result<Value> {@@ -1455,7 +1481,7 @@ fn c_midpoint(s: &mut Session, p: &Value) -> Result<Value> {fn c_symmetry(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "sketch.constraint.symmetry";let (ids, info) = edit(s, p, cmd, true, |sk, _| {- let l = curve_ref(sk, p.get("line"), cmd, "line")?;+ let l = line_or_axis_ref(sk, p.get("line"), cmd, "line")?;let ra = p.get("a").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`a` must be a point or curve"))?;let rb = p.get("b").and_then(Value::as_str).ok_or_else(|| bad(cmd, "`b` must be a point or curve"))?;let rep = solve(&mut sk.clone());@@ -2119,6 +2145,9 @@ mod rect_tests;#[path = "sketch_ux_tests.rs"]mod ux_tests;+#[cfg(test)]+#[path = "sketch_axis_ref_tests.rs"]+mod axis_ref_tests;#[cfg(test)]#[path = "sketch_drag_live_tests.rs"]mod drag_live_tests;diff --git a/crates/engine/src/cmd/sketch_axis_ref_tests.rs b/crates/engine/src/cmd/sketch_axis_ref_tests.rsnew file mode 100644index 0000000000..2f23979227--- /dev/null+++ b/crates/engine/src/cmd/sketch_axis_ref_tests.rs@@ -0,0 +1,238 @@+//! Constraints that take a line accept `x` / `y` for the sketch's own axes (issue #394): the+//! axis becomes one linked construction line on it, shared by every constraint on that axis,+//! reported in `created`, and left out of profiles. A real curve with that id wins.++use serde_json::{Value, json};+use solidcraft_geom::{Vec2, Vec3};+use solidcraft_sketch::{CurveKind, LinkSource, Sketch};++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 sketch(s: &Session) -> Sketch {+ s.doc.sketch(s.active_sketch.unwrap()).unwrap().clone()+}++fn on(plane: Value) -> Session {+ let mut s = Session::default();+ run(&mut s, "sketch.create", json!({ "plane": plane }));+ s+}++fn pt(sk: &Sketch, r: &str) -> Vec2 {+ sk.point(sk.resolve_point(r).unwrap()).unwrap()+}++fn strs(v: &Value) -> Vec<String> {+ v.as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default()+}++/// The sketch's axis lines: (axis name, curve id).+fn axis_lines(sk: &Sketch) -> Vec<(String, String)> {+ sk.links+ .iter()+ .filter_map(|l| match &l.source {+ LinkSource::SketchAxis { name } => Some((name.clone(), l.id.clone())),+ _ => None,+ })+ .flat_map(|(name, link)| sk.link_curves(&link).into_iter().map(move |c| (name.clone(), sk.curves[c].id.clone())))+ .collect()+}++fn assert_axis_line(sk: &Sketch, id: &str, dir: Vec2) {+ let c = sk.curve_index(id).unwrap();+ let curve = &sk.curves[c];+ assert!(curve.construction, "axis line {id} is construction");+ assert!(sk.is_linked_curve(c), "axis line {id} is linked");+ let CurveKind::Line { a, b } = curve.kind else { panic!("axis line {id} is a line") };+ for p in [sk.point(a).unwrap(), sk.point(b).unwrap()] {+ assert!(p.cross(dir).abs() < 1e-9, "{id} end {p:?} lies on the axis {dir:?}");+ }+}++#[test]+fn issue_394_symmetry_about_the_sketch_y_axis() {+ let mut s = on(json!("XY"));+ run(&mut s, "sketch.line", json!({"points": [[-4, 0], [10, 0]], "ids": ["a"]}));+ let r = run(&mut s, "sketch.constraint.symmetry", json!({"a": "a.start", "b": "a.end", "line": "y"}));+ assert!(r["sketch"]["solved"].as_bool().unwrap(), "{r}");+ let sk = sketch(&s);+ let (start, end) = (pt(&sk, "a.start"), pt(&sk, "a.end"));+ assert!((start.x + end.x).abs() < 1e-7 && (start.y - end.y).abs() < 1e-7, "mirrored about y: {start:?} {end:?}");+ assert!((start.x - -4.0).abs() < 1e-7, "the first entity stays: {start:?}");+ let axes = axis_lines(&sk);+ assert_eq!(axes.len(), 1, "{axes:?}");+ let (name, line) = &axes[0];+ assert_eq!(name, "y");+ assert_axis_line(&sk, line, Vec2::Y);+ assert_eq!(strs(&r["created"]["curves"]), vec![line.clone()], "the axis line is reported in created: {r}");+ assert_eq!(strs(&r["created"]["constraints"]).len(), 1, "{r}");++ // A second constraint on the same axis reuses its line.+ run(&mut s, "sketch.line", json!({"points": [[-3, 5], [8, 5]], "ids": ["b"]}));+ let r = run(&mut s, "sketch.constraint.symmetry", json!({"a": "b.start", "b": "b.end", "line": "y"}));+ assert!(strs(&r["created"]["curves"]).is_empty(), "{r}");+ assert_eq!(axis_lines(&sketch(&s)).len(), 1);+}++#[test]+fn a_real_curve_named_like_an_axis_wins() {+ let mut s = on(json!("XY"));+ run(&mut s, "sketch.line", json!({"points": [[5, -20], [5, 20]], "ids": ["y"]}));+ run(&mut s, "sketch.constraint.fix", json!({"entity": "y"}));+ run(&mut s, "sketch.line", json!({"points": [[0, 0], [12, 0]], "ids": ["a"]}));+ run(&mut s, "sketch.constraint.symmetry", json!({"a": "a.start", "b": "a.end", "line": "y"}));+ let sk = sketch(&s);+ assert!(axis_lines(&sk).is_empty(), "no axis line when a curve is called y");+ let (start, end) = (pt(&sk, "a.start"), pt(&sk, "a.end"));+ assert!((start.x + end.x - 10.0).abs() < 1e-7, "mirrored about x = 5: {start:?} {end:?}");+}++#[test]+fn a_rectangle_centred_on_the_origin_keeps_one_profile() {+ let mut s = on(json!("XY"));+ let r = run(&mut s, "sketch.rectangle.two_point", json!({"p0": [2, 1], "p1": [12, 7]}));+ let sk = sketch(&s);+ let lines = strs(&r["curves"]);+ let dir = |id: &String| {+ let CurveKind::Line { a, b } = sk.curves[sk.curve_index(id).unwrap()].kind else { panic!() };+ sk.point(b).unwrap() - sk.point(a).unwrap()+ };+ let horizontal = lines.iter().find(|l| dir(l).y.abs() < 1e-9).unwrap().clone();+ let vertical = lines.iter().find(|l| dir(l).x.abs() < 1e-9).unwrap().clone();+ run(&mut s, "sketch.constraint.symmetry", json!({"a": format!("{horizontal}.start"), "b": format!("{horizontal}.end"), "line": "y"}));+ run(&mut s, "sketch.constraint.symmetry", json!({"a": format!("{vertical}.start"), "b": format!("{vertical}.end"), "line": "x"}));+ let sk = sketch(&s);+ let mut lo = Vec2::new(f64::INFINITY, f64::INFINITY);+ let mut hi = Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY);+ for l in &lines {+ for end in ["start", "end"] {+ let p = pt(&sk, &format!("{l}.{end}"));+ lo = Vec2::new(lo.x.min(p.x), lo.y.min(p.y));+ hi = Vec2::new(hi.x.max(p.x), hi.y.max(p.y));+ }+ }+ assert!((lo.x + hi.x).abs() < 1e-7 && (lo.y + hi.y).abs() < 1e-7, "centred on the origin: {lo:?} {hi:?}");+ assert_eq!(axis_lines(&sk).len(), 2);+ // The axis lines cross the rectangle but are construction: still one profile.+ assert_eq!(run(&mut s, "sketch.solve", json!({}))["profiles"], json!(1));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"distance": 5}));+}++#[test]+fn sketch_axes_on_a_plane_off_the_world_axes() {+ // A plane whose own axes are none of the world axes: x along world Y, y along world Z,+ // origin away from the world origin.+ let origin = Vec3::new(5.0, 7.0, 9.0);+ let mut s = on(json!({"origin": [5, 7, 9], "x_dir": [0, 1, 0], "y_dir": [0, 0, 1]}));+ run(&mut s, "sketch.line", json!({"points": [[3, -6], [3, 2]], "ids": ["a"]}));+ let r = run(&mut s, "sketch.constraint.symmetry", json!({"a": "a.start", "b": "a.end", "line": "x"}));+ assert!(r["sketch"]["solved"].as_bool().unwrap(), "{r}");+ let sk = sketch(&s);+ let (start, end) = (pt(&sk, "a.start"), pt(&sk, "a.end"));+ assert!((start.y + end.y).abs() < 1e-7 && (start.x - end.x).abs() < 1e-7, "mirrored about the sketch x axis: {start:?} {end:?}");+ let axes = axis_lines(&sk);+ assert_eq!(axes.len(), 1);+ assert_axis_line(&sk, &axes[0].1, Vec2::X);++ // After a recompute the axis line is still the sketch's x axis, in world space too.+ run(&mut s, "sketch.finish", json!({}));+ let st = s.model.state();+ let id = s.doc.find_feature("Sketch1").map(|f| f.id).unwrap();+ let ss = st.sketch(id).unwrap();+ let c = ss.sketch.curve_index(&axes[0].1).unwrap();+ let CurveKind::Line { a, b } = ss.sketch.curves[c].kind else { panic!() };+ for p in [a, b] {+ let w = ss.plane.to_world(ss.sketch.point(p).unwrap()) - origin;+ assert!(w.x.abs() < 1e-9 && w.z.abs() < 1e-9, "on the plane's x axis (world Y through its origin): {w:?}");+ }+}++#[test]+fn other_line_constraints_take_sketch_axes() {+ let mut s = on(json!("XZ"));+ run(&mut s, "sketch.line", json!({"points": [[1, 1], [6, 3]], "ids": ["p"]}));+ run(&mut s, "sketch.constraint.parallel", json!({"a": "p", "b": "x"}));+ let sk = sketch(&s);+ assert!((pt(&sk, "p.start").y - pt(&sk, "p.end").y).abs() < 1e-7, "parallel to x");++ run(&mut s, "sketch.line", json!({"points": [[-2, 1], [-1, 6]], "ids": ["q"]}));+ run(&mut s, "sketch.constraint.perpendicular", json!({"a": "x", "b": "q"}));+ let sk = sketch(&s);+ assert!((pt(&sk, "q.start").x - pt(&sk, "q.end").x).abs() < 1e-7, "perpendicular to x");++ run(&mut s, "sketch.line", json!({"points": [[2, -5], [4, -8]], "ids": ["r"]}));+ run(&mut s, "sketch.constraint.collinear", json!({"a": "r", "b": "y"}));+ let sk = sketch(&s);+ assert!(pt(&sk, "r.start").x.abs() < 1e-7 && pt(&sk, "r.end").x.abs() < 1e-7, "on the y axis");++ run(&mut s, "sketch.circle.center", json!({"center": [10, 4], "radius": 2, "id": "c"}));+ run(&mut s, "sketch.constraint.tangent", json!({"a": "c", "b": "x"}));+ let sk = sketch(&s);+ let c = sk.curve_index("c").unwrap();+ let CurveKind::Circle { c: centre, r } = sk.curves[c].kind else { panic!() };+ assert!((sk.point(centre).unwrap().y.abs() - r).abs() < 1e-7, "tangent to x");++ // A point onto an axis, either pick order.+ run(&mut s, "sketch.point", json!({"point": [7, 9], "id": "u"}));+ run(&mut s, "sketch.constraint.coincident", json!({"a": "u", "b": "x"}));+ assert!(pt(&sketch(&s), "u").y.abs() < 1e-7);+ run(&mut s, "sketch.point", json!({"point": [7, 9], "id": "v"}));+ run(&mut s, "sketch.constraint.coincident", json!({"a": "y", "b": "v"}));+ assert!(pt(&sketch(&s), "v").x.abs() < 1e-7);++ // Still one line per axis.+ let mut names: Vec<String> = axis_lines(&sketch(&s)).into_iter().map(|(n, _)| n).collect();+ names.sort();+ assert_eq!(names, ["x", "y"]);+}++#[test]+fn the_axis_survives_save_and_load() {+ let mut s = on(json!("YZ"));+ run(&mut s, "sketch.line", json!({"points": [[-4, 0], [10, 0]], "ids": ["a"]}));+ run(&mut s, "sketch.constraint.symmetry", json!({"a": "a.start", "b": "a.end", "line": "y"}));+ run(&mut s, "sketch.finish", json!({}));+ let doc = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();+ let id = doc.find_feature("Sketch1").map(|f| f.id).unwrap();+ let sk = doc.sketch(id).unwrap();+ assert_eq!(axis_lines(sk).len(), 1);+ assert_eq!(sk.links.iter().map(|l| &l.source).collect::<Vec<_>>(), [&LinkSource::SketchAxis { name: "y".into() }]);+}++#[test]+fn bad_line_references_are_errors_and_change_nothing() {+ let mut s = on(json!("XY"));+ run(&mut s, "sketch.line", json!({"points": [[-4, 0], [10, 0]], "ids": ["a"]}));+ run(&mut s, "sketch.line", json!({"points": [[0, 3], [9, 4]], "ids": ["b"]}));+ let before = s.doc.to_json();+ let hostile =+ [json!("Y"), json!("X"), json!("z"), json!(""), json!("x.start"), json!(" y"), json!(5), json!(null), json!(["y"]), json!({"axis": "y"})];+ for line in &hostile {+ assert!(s.execute("sketch.constraint.symmetry", &json!({"a": "a.start", "b": "a.end", "line": line})).is_err(), "symmetry line {line}");+ for cmd in ["sketch.constraint.parallel", "sketch.constraint.perpendicular", "sketch.constraint.collinear", "sketch.constraint.tangent"] {+ assert!(s.execute(cmd, &json!({"a": "b", "b": line})).is_err(), "{cmd} b {line}");+ }+ assert!(s.execute("sketch.constraint.coincident", &json!({"a": "b.start", "b": line})).is_err(), "coincident b {line}");+ }+ // Constraints that do not take an axis still refuse x / y, and leave no axis line behind.+ for cmd in ["sketch.constraint.equal", "sketch.constraint.concentric"] {+ assert!(s.execute(cmd, &json!({"a": "b", "b": "x"})).is_err(), "{cmd}");+ }+ assert!(s.execute("sketch.constraint.midpoint", &json!({"point": "b.start", "line": "y"})).is_err());+ assert!(s.execute("sketch.constraint.horizontal_vertical", &json!({"line": "x"})).is_err());+ assert_eq!(s.doc.to_json(), before, "failed commands change nothing");+ // A constraint the sketch refuses rolls the axis line back with it.+ run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "b", "mode": "horizontal"}));+ let before_redundant = s.doc.to_json();+ assert!(s.execute("sketch.constraint.parallel", &json!({"a": "b", "b": "x"})).is_err(), "already horizontal");+ assert_eq!(s.doc.to_json(), before_redundant);+ assert!(axis_lines(&sketch(&s)).is_empty());+}diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rsindex 5b86ccac7e..05a9f42c20 100644--- a/crates/sketch/src/lib.rs+++ b/crates/sketch/src/lib.rs@@ -42,7 +42,7 @@ pub use curves::{pub use decompose::Budget;pub use dims::{DimFrame, DimLayout, chain_centres, default_text, dim_frame, dim_layout, encode_text};pub use freeform_offset::{FreeformOffset, OFFSET_TOLERANCE};-pub use link::{Link, LinkGeom, LinkKind, LinkSource, MAX_LINK_ENTITIES};+pub use link::{Link, LinkGeom, LinkKind, LinkSource, MAX_LINK_ENTITIES, SKETCH_AXIS_HALF, sketch_axis_geom};pub use model::{Constraint, ConstraintKind, Curve, CurveKind, MAX_CONSTRAINTS, MAX_CURVES, MAX_POINTS, SPoint, Sketch, SketchError, SketchView};pub use offset::OffsetChain;pub use offset_topology::{OffsetCreated, OffsetRole, OffsetRoleFlags, OffsetRoleKind, OffsetTopology};diff --git a/crates/sketch/src/link.rs b/crates/sketch/src/link.rsindex cb716f8d78..846e9c048f 100644--- a/crates/sketch/src/link.rs+++ b/crates/sketch/src/link.rs@@ -55,6 +55,9 @@ pub enum LinkSource {Origin,/// An origin axis (`X`, `Y`, `Z`).Axis { name: String },+ /// One of the sketch's own axes (`x` or `y`): the line through the sketch origin along it,+ /// whatever plane the sketch is on (see [`sketch_axis_geom`]).+ SketchAxis { name: String },/// An origin plane (`XY`, `XZ`, `YZ`) or a construction plane (by name): its trace on the/// sketch plane.Plane { name: String },@@ -90,6 +93,7 @@ impl LinkSource {LinkSource::SketchPoint { point, .. } => format!("sketch point {point}"),LinkSource::Origin => "origin".into(),LinkSource::Axis { name } => format!("{name} axis"),+ LinkSource::SketchAxis { name } => format!("sketch {name} axis"),LinkSource::Plane { name } => format!("{name} plane"),LinkSource::OnSurface { curve, .. } => format!("{curve} on a face"),LinkSource::Intersection { a, b } => format!("intersection of {} and {}", a.describe(), b.describe()),@@ -100,6 +104,19 @@ impl LinkSource {}}+/// Half length of the line a sketch axis link produces.+pub const SKETCH_AXIS_HALF: f64 = 100.0;++/// The geometry of sketch axis `name` (`x` or `y`, sketch coordinates); `None` for any other name.+pub fn sketch_axis_geom(name: &str) -> Option<LinkGeom> {+ let u = match name {+ "x" => Vec2::X,+ "y" => Vec2::Y,+ _ => return None,+ };+ Some(LinkGeom::Line(Vec2::ZERO - u * SKETCH_AXIS_HALF, u * SKETCH_AXIS_HALF))+}+/// One link and its state.#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct Link {@@ -417,6 +434,34 @@ impl Sketch {self.curves.get(ci).and_then(|c| c.link.as_deref()).and_then(|l| self.link(l)).is_some_and(|l| l.lost)}+ /// The line of sketch axis `name` (`x` or `y`) when the sketch already has one (see+ /// [`Sketch::sketch_axis_line`]).+ pub fn sketch_axis_curve(&self, name: &str) -> Option<usize> {+ self.links+ .iter()+ .filter(|l| matches!(&l.source, LinkSource::SketchAxis { name: n } if n == name))+ .find_map(|l| self.link_curves(&l.id).into_iter().find(|c| matches!(self.curves.get(*c).map(|c| &c.kind), Some(CurveKind::Line { .. }))))+ }++ /// The line of sketch axis `name` (`x` or `y`) that constraints can refer to: a linked+ /// construction line on the axis (it stays there and is left out of profiles), shared by+ /// every reference to that axis and added on first use. `None` when `name` is not a sketch+ /// axis.+ pub fn sketch_axis_line(&mut self, name: &str) -> Result<Option<usize>> {+ let Some(geom) = sketch_axis_geom(name) else { return Ok(None) };+ if let Some(c) = self.sketch_axis_curve(name) {+ return Ok(Some(c));+ }+ let id = self.add_link(LinkKind::Project, LinkSource::SketchAxis { name: name.into() }, &[geom])?;+ let curves = self.link_curves(&id);+ for c in &curves {+ if let Some(cu) = self.curves.get_mut(*c) {+ cu.construction = true;+ }+ }+ curves.first().copied().map(Some).ok_or_else(|| SketchError::Invalid(format!("sketch {name} axis")))+ }+/// Add linked geometry. Returns the link id; the new curve and point ids are/// [`Sketch::link_curves`] / [`Sketch::link_points`] of it.pub fn add_link(&mut self, kind: LinkKind, source: LinkSource, geom: &[LinkGeom]) -> Result<String> {