Sketch: a text rebuilt with other words keeps the far-move walk (#10357)

A sketch holding a text whose words come from a text parameter is left
unsolved after the words change and its links then move far, with the
warning "the sketch constraints conflict (k1, ..., k10)". The same two
changes the other way round solve.

Repro: a sketch with three projected points, a construction rectangle on
them and a centred text along its far side, the text's words given by a
text parameter. Change the parameter's words, then move the source
geometry about 280 mm. Without the word change it solves; with it, the
sketch warns of conflicting constraints.

Other words are other outlines: the text is built anew with new points
and curves. The solve that walks a sketch from its stored state to a far
link move (and the check for sides the jump turned over) refused the two
sketches as not the same entities, and the single jump left alone failed.

`Sketch::stored_with_rebuilt_texts` gives the stored sketch as this one
has its entities when they differ only by rebuilt texts: the texts'
entities as they are now, every other point, radius, arc turn and
constraint value as stored. `Document::solve_sketch` walks from that, so
the points pair up again. Sketches that differ in anything else are
refused as before.

Test: sketch_project::side_tests::a_label_follows_its_source_far_after_a_text_parameter_gave_it_other_words
(fails without the fix with the conflict warning above).

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
NOWN-DEV
2026-11-01 00:15:32 +00:00
committed by GitHub
parent 11e283ba77
commit 68105938e2
3 changed files with 129 additions and 0 deletions
+5
View File
@@ -4173,6 +4173,11 @@ impl Document {
analysis: solidcraft_sketch::Analysis,
) -> Result<solidcraft_sketch::SolveReport> {
self.apply_dimension_values(vals, sk)?;
// A text built anew since it was stored (an expression gave it other words) has other
// outline entities: the stored sketch is taken with this sketch's, so the points still
// pair up for the side checks and the walk below.
let paired = moved_from.and_then(|from| sk.stored_with_rebuilt_texts(from));
let moved_from = paired.as_ref().or(moved_from);
let was = |sk: &Sketch| moved_from.and_then(|from| sk.positions_in(from));
let offsets = !sk.offsets.is_empty() || !sk.freeform_offsets.is_empty();
// Offsets always require another solve after refresh. Only that last report is
@@ -86,6 +86,77 @@ fn a_distance_from_a_projected_line_keeps_its_side_when_the_source_moves_past()
assert_p(&s, 15.0, "after an edit");
}
/// A label's sketch: three points brought in from sketch `A` (a 20 long vertical line whose start
/// the parameters `x` and `y` place, and its middle), a construction rectangle 5 wide on them
/// (its near side on the line's ends, its far side 5 from the middle) and a centred text on the
/// far side whose words the text parameter `Label` gives. Other words are other outlines: the text
/// is built anew in the evaluated sketch, so its entities are not the stored sketch's. Moved 280
/// away afterwards (more than one jump can take: the solve walks there from the stored sketch), the
/// rectangle follows and keeps its side.
#[test]
fn a_label_follows_its_source_far_after_a_text_parameter_gave_it_other_words() {
let mut s = Session::default();
run(&mut s, "parameters.add", json!({"name": "x", "expression": "100 mm"}));
run(&mut s, "parameters.add", json!({"name": "y", "expression": "200 mm"}));
run(&mut s, "parameters.add", json!({"name": "Label", "expression": "A1", "unit": "text"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "A"}));
run(&mut s, "sketch.line", json!({"points": [[100, 200], [100, 180]], "ids": ["rail"]}));
run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "rail", "mode": "vertical"}));
run(&mut s, "sketch.dimension", json!({"entities": ["origin", "rail.start"], "type": "horizontal", "value": "x"}));
run(&mut s, "sketch.dimension", json!({"entities": ["origin", "rail.start"], "type": "vertical", "value": "y"}));
run(&mut s, "sketch.dimension", json!({"entities": ["rail"], "value": "20 mm"}));
run(&mut s, "sketch.point", json!({"point": [100, 190], "id": "mid"}));
run(&mut s, "sketch.constraint.midpoint", json!({"point": "mid", "line": "rail"}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"}));
let refs = ["rail.start", "rail.end", "mid"].map(|p| json!({"sketch": "A", "point": p}));
let r = run(&mut s, "sketch.project", json!({"refs": refs}));
let brought: Vec<String> = (0..3).map(|i| r["links"][i]["points"][0].as_str().unwrap().to_string()).collect();
let near = 100.0 - 5.0;
for (id, a, b) in [
("l1", [100.0, 200.0], [100.0, 180.0]),
("l2", [near, 200.0], [near, 180.0]),
("l3", [100.0, 200.0], [near, 200.0]),
("l4", [100.0, 180.0], [near, 180.0]),
] {
run(&mut s, "sketch.line", json!({"points": [a, b], "ids": [id], "construction": true, "connect": false}));
}
for (a, b) in [
("l1.start", brought[0].as_str()),
("l1.end", &brought[1]),
("l3.start", "l1.start"),
("l3.end", "l2.start"),
("l4.start", "l1.end"),
("l4.end", "l2.end"),
] {
run(&mut s, "sketch.constraint.coincident", json!({"a": a, "b": b}));
}
run(&mut s, "sketch.constraint.parallel", json!({"a": "l2", "b": "l1"}));
run(&mut s, "sketch.dimension", json!({"entities": [brought[2], "l2"], "type": "distance", "value": "5 mm"}));
run(&mut s, "sketch.constraint.perpendicular", json!({"a": "l3", "b": "l1"}));
run(&mut s, "sketch.constraint.perpendicular", json!({"a": "l4", "b": "l1"}));
run(&mut s, "sketch.text", json!({"text_expression": "Label + '-1'", "at": [0, 0], "height": 3, "align": "center", "path": "l2"}));
run(&mut s, "sketch.finish", json!({}));
let far_side = |s: &Session| {
let st = s.model.state();
let sk = &st.sketch(s.doc.find_feature("S").unwrap().id).unwrap().sketch;
sk.point(sk.resolve_point("l2.start").unwrap()).unwrap()
};
#[track_caller]
fn quiet(s: &Session, when: &str) {
let feature = s.model.result(s.doc.find_feature("S").unwrap().id).unwrap();
assert_eq!((&feature.error, &feature.warning), (&None, &None), "{when}");
}
quiet(&s, "drawn");
run(&mut s, "parameters.change", json!({"name": "Label", "expression": "B2"}));
quiet(&s, "relabelled");
for (x, y) in [(300.0, 400.0), (100.0, 200.0)] {
run(&mut s, "parameters.change", json!({"changes": {"x": format!("{x} mm"), "y": format!("{y} mm")}}));
quiet(&s, &format!("moved to ({x}, {y})"));
assert!(far_side(&s).dist(Vec2::new(x - 5.0, y)) < 1e-6, "({x}, {y}): {:?}", far_side(&s));
}
}
/// The same from the other side: the point above the line, the source rising past it and
/// coming back; and with the line brought in by Include 3D Geometry.
#[test]
+53
View File
@@ -1128,6 +1128,59 @@ impl Sketch {
self.points.iter().zip(&was).any(|(p, w)| p.pos != *w).then_some(was)
}
/// `stored` as this sketch has its entities, when they differ only by texts built anew
/// since (other words, from an expression, are other outlines with new points and curves):
/// those texts' entities as this sketch has them, every other point where `stored` has it,
/// every other circle and ellipse with its stored radius, arcs with their stored turn and
/// constraints with their stored values. Paired so entity by entity, a solve after the links
/// moved can walk from the stored state as it does when no text changed. `None` when the
/// two are the same entities or differ in anything else.
pub fn stored_with_rebuilt_texts(&self, stored: &Sketch) -> Option<Sketch> {
let texts: Vec<&str> = self.links.iter().filter(|l| matches!(l.source, LinkSource::Text { .. })).map(|l| l.id.as_str()).collect();
let in_text = |link: &Option<String>| link.as_deref().is_some_and(|l| texts.contains(&l));
let same = self.points.len() == stored.points.len()
&& self.curves.len() == stored.curves.len()
&& self.points.iter().zip(&stored.points).all(|(p, q)| p.id == q.id)
&& self.curves.iter().zip(&stored.curves).all(|(c, d)| c.id == d.id);
let ids = |sk: &Sketch| sk.links.iter().map(|l| l.id.clone()).collect::<Vec<_>>();
if same
|| texts.is_empty()
|| ids(self) != ids(stored)
|| !self.points.iter().filter(|p| !in_text(&p.link)).map(|p| &p.id).eq(stored.points.iter().filter(|p| !in_text(&p.link)).map(|p| &p.id))
|| !self.curves.iter().filter(|c| !in_text(&c.link)).map(|c| &c.id).eq(stored.curves.iter().filter(|c| !in_text(&c.link)).map(|c| &c.id))
|| !self.constraints.iter().map(|c| &c.id).eq(stored.constraints.iter().map(|c| &c.id))
{
return None;
}
let mut out = self.clone();
let points: std::collections::BTreeMap<&str, Vec2> =
stored.points.iter().filter(|p| !in_text(&p.link)).map(|p| (p.id.as_str(), p.pos)).collect();
for p in out.points.iter_mut().filter(|p| !in_text(&p.link)) {
if let Some(pos) = points.get(p.id.as_str()) {
p.pos = *pos;
}
}
let curves: std::collections::BTreeMap<&str, &Curve> =
stored.curves.iter().filter(|c| !in_text(&c.link)).map(|c| (c.id.as_str(), c)).collect();
for c in out.curves.iter_mut().filter(|c| !in_text(&c.link)) {
let Some(d) = curves.get(c.id.as_str()) else { continue };
match (&mut c.kind, &d.kind) {
(CurveKind::Circle { r, .. }, CurveKind::Circle { r: s, .. }) | (CurveKind::Ellipse { r, .. }, CurveKind::Ellipse { r: s, .. }) => {
*r = *s
}
(CurveKind::Conic { rho, .. }, CurveKind::Conic { rho: s, .. }) => *rho = *s,
_ => {}
}
c.reversed = d.reversed;
}
for (c, d) in out.constraints.iter_mut().zip(&stored.constraints) {
if let Some(v) = d.kind.value() {
c.kind.set_value(v);
}
}
Some(out)
}
fn drop_link_entities(&mut self, id: &str) {
let curves = self.link_curves(id);
let keep = self.links.clone();