Skip to content

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

Sketch: a changed length dimension keeps its start point, so a side grows from its first corner (#6070) (#6139)

DuBeartef077f48318ef
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index c03865c5e6..4fa3f3248c 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -1490,6 +1490,13 @@ fn adopt_solution(stored: &mut solidcraft_sketch::Sketch, solved: &solidcraft_sk
true
}
+impl Document {
+ /// The values features are evaluated with: the parameters, and the design's length unit.
+ pub fn evaluation_values(&self) -> BTreeMap<String, Value> {
+ evaluation_values(self).0
+ }
+}
+
/// The values features are evaluated with: the parameters, and the design's length unit.
fn evaluation_values(doc: &Document) -> (BTreeMap<String, Value>, BTreeMap<String, String>) {
let (mut vals, perr) = doc.param_values();
diff --git a/crates/engine/src/cmd/parameters.rs b/crates/engine/src/cmd/parameters.rs
index c2ebe6c534..e8b86a4e9c 100644
--- a/crates/engine/src/cmd/parameters.rs
+++ b/crates/engine/src/cmd/parameters.rs
@@ -3,7 +3,9 @@
//! graph, CSV/JSON import and export, expression evaluation and autocomplete.
use serde_json::{Value, json};
+use solidcraft_doc::FeatureKind;
use solidcraft_doc::expr::{self, Kind};
+use solidcraft_sketch::{Analysis, ConstraintKind, CurveKind, Hold, Sketch, solve_with};
use super::CommandSpec;
use crate::params::{bad, bool_, str_};
@@ -128,6 +130,9 @@ fn change_param(s: &mut Session, p: &Value) -> Result<Value> {
s.doc_mut().set_favorite(&name, f)?;
}
let switched = switch_by_rules(s, &before);
+ if e.is_some() {
+ keep_dimension_start(s, &name);
+ }
s.settle_value_edit(&solved)?;
let (vals, _) = s.doc.param_values();
if !switched.is_empty() {
@@ -146,6 +151,64 @@ fn change_param(s: &mut Session, p: &Value) -> Result<Value> {
Ok(out)
}
+/// The point a length dimension keeps when its value changes: the first it measures from (a
+/// line's start). None for other dimensions.
+fn dimension_start(sk: &Sketch, kind: &ConstraintKind) -> Option<usize> {
+ match kind {
+ ConstraintKind::Distance { p, .. } | ConstraintKind::DistanceX { p, .. } | ConstraintKind::DistanceY { p, .. } => Some(*p),
+ ConstraintKind::Length { l, .. } => match sk.curves.get(*l)?.kind {
+ CurveKind::Line { a, .. } => Some(a),
+ _ => None,
+ },
+ _ => None,
+ }
+}
+
+/// A length dimension driven by `name` keeps its first point where it is when the value
+/// changes, so a rectangle's side grows from its first corner, not from both ends (#6070). The
+/// sketch is solved here with that point held, before the design evaluates from its stored
+/// positions. Where holding it can't solve (a symmetry moves both ends), evaluation solves as
+/// before.
+fn keep_dimension_start(s: &mut Session, name: &str) {
+ let targets: Vec<(u64, usize)> = s
+ .doc
+ .features
+ .iter()
+ .filter_map(|f| match &f.kind {
+ FeatureKind::Sketch { sketch, .. } => sketch
+ .constraints
+ .iter()
+ .find(|c| !c.driven && c.param.as_deref() == Some(name))
+ .and_then(|c| dimension_start(sketch, &c.kind))
+ .map(|p| (f.id, p)),
+ _ => None,
+ })
+ .collect();
+ if targets.is_empty() {
+ return;
+ }
+ let vals = s.doc.evaluation_values();
+ for (id, start) in targets {
+ let Ok(stored) = s.doc.sketch(id) else { continue };
+ let mut trial = stored.clone();
+ if s.doc.apply_dimension_values(&vals, &mut trial).is_err() {
+ continue;
+ }
+ let reference: Vec<_> = stored.points.iter().map(|p| p.pos).collect();
+ let hold = Hold { points: vec![start], radii: Vec::new() };
+ if !solve_with(&mut trial, &hold, Some(&reference), Analysis::StatusOnly, None).keeps_orientation() {
+ continue;
+ }
+ if let Ok(stored) = s.doc_mut().sketch_mut(id)
+ && stored.points.len() == trial.points.len()
+ {
+ for (p, q) in stored.points.iter_mut().zip(&trial.points) {
+ p.pos = q.pos;
+ }
+ }
+ }
+}
+
/// `parameters.change {changes}`: several existing parameters set at once, so a design is
/// rebuilt once for all of them instead of once per parameter.
fn change_many(s: &mut Session, changes: &Value, solved: &crate::SketchValues) -> Result<Value> {
@@ -162,6 +225,9 @@ fn change_many(s: &mut Session, changes: &Value, solved: &crate::SketchValues) -
let before = s.doc.param_values().0;
s.doc_mut().change_params_atomic(&list)?;
let switched = switch_by_rules(s, &before);
+ for (name, _) in &list {
+ keep_dimension_start(s, name);
+ }
s.settle_value_edit(solved)?;
let (vals, _) = s.doc.param_values();
let values: serde_json::Map<String, Value> = list.iter().map(|(n, _)| (n.clone(), json!(vals.get(n).map(|v| v.v)))).collect();
diff --git a/crates/engine/src/cmd/sketch_ux_tests.rs b/crates/engine/src/cmd/sketch_ux_tests.rs
index 8e073759d9..d1a34fef56 100644
--- a/crates/engine/src/cmd/sketch_ux_tests.rs
+++ b/crates/engine/src/cmd/sketch_ux_tests.rs
@@ -1850,3 +1850,36 @@ fn a_driven_dimension_made_driving_and_autoconstrain_dimensions_use_the_design_u
assert!(!lengths.is_empty(), "AutoConstrain dimensioned the line");
assert!(lengths.iter().all(|p| p.unit == "in" && p.expr.ends_with(" in")), "{lengths:?}");
}
+
+/// #6070: changing a rectangle side's dimension keeps the side's first corner where it is, so
+/// the side grows from where it was drawn, not from both ends. A centred rectangle (Symmetric
+/// about the axis) still grows both ways, as it must.
+#[test]
+fn a_changed_length_dimension_keeps_its_first_point() {
+ let at = |s: &Session, p: &str| {
+ let sk = sketch(s);
+ sk.point(sk.resolve_point(p).unwrap()).unwrap()
+ };
+ let mut s = new_sketch();
+ let r = run(&mut s, "sketch.rectangle.two_point", json!({"p0": [10, 10], "p1": [50, 30]}));
+ let bottom = r["sides"]["bottom"].as_str().unwrap().to_string();
+ let right = r["sides"]["right"].as_str().unwrap().to_string();
+ let width = run(&mut s, "sketch.dimension", json!({"entities": [bottom]}))["param"].as_str().unwrap().to_string();
+ let height = run(&mut s, "sketch.dimension", json!({"entities": [right]}))["param"].as_str().unwrap().to_string();
+ run(&mut s, "parameters.change", json!({"name": width, "expression": "60 mm"}));
+ assert!(at(&s, "p1").dist(solidcraft_geom::Vec2::new(10.0, 10.0)) < 1e-6, "the first corner stays: {:?}", at(&s, "p1"));
+ assert!(at(&s, "p2").dist(solidcraft_geom::Vec2::new(70.0, 10.0)) < 1e-6, "the far corner moves: {:?}", at(&s, "p2"));
+ // Several at once: the right side grows up from its start, the bottom-right corner.
+ run(&mut s, "parameters.change", json!({"changes": {height: "25 mm"}}));
+ assert!(at(&s, "p2").dist(solidcraft_geom::Vec2::new(70.0, 10.0)) < 1e-6, "{:?}", at(&s, "p2"));
+ assert!(at(&s, "p3").dist(solidcraft_geom::Vec2::new(70.0, 35.0)) < 1e-6, "{:?}", at(&s, "p3"));
+
+ // Centred on the Y axis: holding a corner can't keep it symmetric, so both ends move.
+ let mut s = new_sketch();
+ let r = run(&mut s, "sketch.rectangle.two_point", json!({"p0": [-20, 0], "p1": [20, 10]}));
+ let bottom = r["sides"]["bottom"].as_str().unwrap().to_string();
+ run(&mut s, "sketch.constraint.symmetry", json!({"a": "p1", "b": "p2", "line": "y"}));
+ let width = run(&mut s, "sketch.dimension", json!({"entities": [bottom]}))["param"].as_str().unwrap().to_string();
+ run(&mut s, "parameters.change", json!({"name": width, "expression": "60 mm"}));
+ assert!((at(&s, "p1").x + 30.0).abs() < 1e-6 && (at(&s, "p2").x - 30.0).abs() < 1e-6, "{:?} {:?}", at(&s, "p1"), at(&s, "p2"));
+}