SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: the same constraint twice is one constraint (#5224) (#8850)
Colin Faulkingham4e78acc7a21d
diff --git a/crates/engine/src/cmd/sketch_constraints_tests.rs b/crates/engine/src/cmd/sketch_constraints_tests.rsindex 1b48667e8a..1759f8e6ab 100644--- a/crates/engine/src/cmd/sketch_constraints_tests.rs+++ b/crates/engine/src/cmd/sketch_constraints_tests.rs@@ -49,6 +49,37 @@ fn redundant_dimensions_are_refused_driven_ones_measure() {assert_eq!(g["fully_constrained"], true);}+/// The same constraint between the same two lines, picked again (in either order), adds nothing:+/// the one already there is reported back as redundant, and the sketch keeps one glyph (#5224).+#[test]+fn the_same_constraint_twice_adds_nothing() {+ let mut s = new_sketch();+ let a = ids(&run(&mut s, "sketch.line", json!({"points": [[1, 1], [10, 1]]}))["curves"])[0].clone();+ let b = ids(&run(&mut s, "sketch.line", json!({"points": [[0, 5], [10, 7]]}))["curves"])[0].clone();+ let first = run(&mut s, "sketch.constraint.parallel", json!({"a": a, "b": b}));+ for (x, y) in [(&a, &b), (&b, &a), (&a, &b)] {+ let r = run(&mut s, "sketch.constraint.parallel", json!({"a": x, "b": y}));+ assert_eq!(r["redundant"], true, "{r}");+ assert_eq!(r["constraint"], first["constraint"], "the one already there: {r}");+ }+ let e = s.execute("sketch.constraint.parallel", &json!({"a": a, "b": b, "if_redundant": "refuse"})).unwrap_err().to_string();+ assert!(e.contains("already determined"), "{e}");+ let parallels = sketch(&s).constraints.iter().filter(|c| matches!(c.kind, ConstraintKind::Parallel { .. })).count();+ assert_eq!(parallels, 1);+ let g = run(&mut s, "sketch.glyphs", json!({}));+ assert_eq!(g["glyphs"].as_array().map(Vec::len), Some(1), "{g}");+ // The sketch model itself hands back the one already there.+ let mut sk = sketch(&s);+ let n = sk.constraints.len();+ let k = sk.constraints.iter().find(|c| matches!(c.kind, ConstraintKind::Parallel { .. })).unwrap().clone();+ let (ia, ib) = match k.kind {+ ConstraintKind::Parallel { a, b } => (a, b),+ _ => (0, 0),+ };+ assert_eq!(sk.add_constraint(ConstraintKind::Parallel { a: ib, b: ia }, None).unwrap(), k.id);+ assert_eq!(sk.constraints.len(), n);+}+/// `measured` is the dimension on the solved sketch: a trough drawn 99.84 long and dimensioned/// 100 reports 100, not the length it had before solving.#[test]diff --git a/crates/sketch/src/model.rs b/crates/sketch/src/model.rsindex 3d1991d99c..0acfb15ec9 100644--- a/crates/sketch/src/model.rs+++ b/crates/sketch/src/model.rs@@ -963,15 +963,48 @@ impl Sketch {}pub fn add_constraint(&mut self, kind: ConstraintKind, param: Option<String>) -> Result<String> {+ self.validate(&kind)?;+ if let Some(same) = self.same_constraint(&kind) {+ return Ok(same.to_string());+ }if self.constraints.len() >= MAX_CONSTRAINTS {return Err(SketchError::TooLarge);}- self.validate(&kind)?;let id = self.fresh("k")?;self.constraints.push(Constraint { id: id.clone(), kind, param, driven: false, text: None });Ok(id)}+ /// The id of a geometric (not dimensional) constraint that already says what `kind` says: the+ /// same kind on the same entities, in either order where the order doesn't matter.+ pub fn same_constraint(&self, kind: &ConstraintKind) -> Option<&str> {+ use ConstraintKind::*;+ let pair = |x: usize, y: usize| if x <= y { (x, y) } else { (y, x) };+ let key = |k: &ConstraintKind| -> Option<(u8, usize, usize, usize)> {+ Some(match *k {+ Coincident { p, q } => (0, pair(p, q).0, pair(p, q).1, 0),+ PointOnCurve { p, c } => (1, p, c, 0),+ Horizontal { l } => (2, l, 0, 0),+ Vertical { l } => (3, l, 0, 0),+ HorizontalPoints { p, q } => (4, pair(p, q).0, pair(p, q).1, 0),+ VerticalPoints { p, q } => (5, pair(p, q).0, pair(p, q).1, 0),+ Parallel { a, b } => (6, pair(a, b).0, pair(a, b).1, 0),+ Perpendicular { a, b } => (7, pair(a, b).0, pair(a, b).1, 0),+ Collinear { a, b } => (8, pair(a, b).0, pair(a, b).1, 0),+ Tangent { a, b } => (9, pair(a, b).0, pair(a, b).1, 0),+ Equal { a, b } => (10, pair(a, b).0, pair(a, b).1, 0),+ Concentric { a, b } => (11, pair(a, b).0, pair(a, b).1, 0),+ Midpoint { p, l } => (12, p, l, 0),+ Symmetric { p, q, l } => (13, pair(p, q).0, pair(p, q).1, l),+ Fix { p } => (14, p, 0, 0),+ Smooth { a, b } => (15, pair(a, b).0, pair(a, b).1, 0),+ _ => return None,+ })+ };+ let want = key(kind)?;+ self.constraints.iter().find(|c| key(&c.kind) == Some(want)).map(|c| c.id.as_str())+ }+/// Check indices and entity kinds of a constraint.pub fn validate(&self, k: &ConstraintKind) -> Result<()> {use ConstraintKind::*;