Sketch: the first dimension scales only a connected drawing (#3786) (#3815)

* claim: #3786

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Sketch: the first dimension scales only a connected drawing (#3786)

The first length dimension scaled the whole sketch about its origin, so a
second rectangle that nothing links to the first was resized and moved too.
Now the sketch scales only when its curves form one chain, joined by shared
points or constraints (the origin counts as a point); separate shapes keep
the previous behaviour: the dimension sizes the shape it measures.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
rlartot
2026-10-24 21:21:08 +00:00
committed by GitHub
parent b201c283c7
commit e726f780d1
2 changed files with 55 additions and 1 deletions
+28
View File
@@ -1525,6 +1525,34 @@ fn the_first_dimension_does_not_scale_a_sketch_that_has_a_size() {
assert!(out.get("scaled").is_none(), "{out}");
}
/// #3786: shapes that nothing links together are not one drawing: the first dimension sizes
/// the shape it measures and leaves the other alone.
#[test]
fn the_first_dimension_leaves_a_separate_shape_alone() {
let mut s = new_sketch();
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [20, 10]}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [30, 10], "p1": [45, 20]}));
let other = sketch(&s);
let out = run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": "30 mm", "scale_sketch": true}));
assert!(out.get("scaled").is_none(), "{out}");
let after = sketch(&s);
// The second rectangle (points 4..8, after the origin and the first rectangle's four) is untouched.
for (p, q) in other.points.iter().zip(&after.points).skip(5) {
assert!(q.pos.dist(p.pos) < 1e-6, "{} {:?} -> {:?}", p.id, p.pos, q.pos);
}
}
/// #1365 still holds for one drawing: shapes joined by a constraint scale together.
#[test]
fn the_first_dimension_scales_shapes_joined_by_a_constraint() {
let mut s = new_sketch();
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [20, 10]}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [30, 10], "p1": [45, 20]}));
run(&mut s, "sketch.constraint.coincident", json!({"a": "l1.start", "b": "l5.start"}));
let out = run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": "40 mm", "scale_sketch": true}));
assert!(out.get("scaled").is_some(), "{out}");
}
/// The cursor fallback shares the held solves' frame budget; a scripted drag can finish later.
#[test]
fn cursor_fallback_respects_an_exhausted_live_frame_budget() {
+27 -1
View File
@@ -1029,7 +1029,8 @@ impl Sketch {
/// with nothing that fixes a size: no other driving length dimension, nothing fixed,
/// projected or patterned, no offsets and no 3D curves. Every geometric constraint
/// (coincident, horizontal, parallel, tangent, equal, symmetric, …) and every angle holds
/// on the scaled sketch as it held before. `None` when the sketch does not qualify.
/// on the scaled sketch as it held before. `None` when the sketch does not qualify, also
/// when its curves form several separate chains (#3786): the dimension sizes only its own.
pub fn scaled_for_first_dimension(&self, factor: f64) -> Option<Sketch> {
if !(factor.is_finite() && (1e-6..=1e6).contains(&factor)) {
return None;
@@ -1049,6 +1050,31 @@ impl Sketch {
{
return None;
}
// Shapes nothing joins (#3786) are not one drawing: only one connected chain of curves
// scales. Curves and driving constraints join their points; the origin is a point too.
let mut parent: Vec<usize> = (0..self.points.len()).collect();
for c in &self.curves {
let ids = c.kind.point_ids();
for w in ids.windows(2) {
if let [a, b] = *w {
union(&mut parent, a, b);
}
}
}
for c in self.constraints.iter().filter(|c| !c.driven) {
let ids = self.constraint_points(&c.kind);
for w in ids.windows(2) {
if let [a, b] = *w {
union(&mut parent, a, b);
}
}
}
let mut roots = self.curves.iter().filter_map(|c| c.kind.point_ids().first().map(|&p| find(&mut parent, p)));
if let Some(first) = roots.next()
&& roots.any(|r| r != first)
{
return None;
}
let mut out = self.clone();
for p in out.points.iter_mut().filter(|p| !p.fixed) {
p.pos = p.pos * factor;