Sketch: a distance along a line keeps its side (#7506) (#7510)

A point a distance from another point on the same line has two places on it, the same distance
either way. A solve after a value edit or a link move could land on the other one and report the
sketch solved, with no warning: the point jumped to the other side of its anchor, twice the
distance away. Such a distance is now an orientation the solves keep, like an unsigned offset's
side: which way along the line the one point lies from the other. One point must be on the line
by a constraint (an end, a point held on it, or coincident with either); the other may lie on it
by what else holds it (the mirror image of a point on it across a line square to it), read where
it is in the reference state.

Test: a point 3 mm along a linked rail from a point held on it, or mirrored onto it: the image
back past that point counts as a flip, and the rail walked far keeps the side.

Fixes #7506.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
NOWN-DEV
2026-10-27 12:43:05 +00:00
committed by GitHub
parent f5bfd6d1f2
commit 285fa9433b
2 changed files with 120 additions and 1 deletions
+55
View File
@@ -172,3 +172,58 @@ fn a_line_tangent_to_a_linked_circle_keeps_its_side_when_the_circle_moves_far()
let mut sk = stored.clone();
assert!(solve_after_link_move(&mut sk, &stored, &stored.driving_values(), Analysis::Full).is_none());
}
/// A point held on a linked rail 3 mm from another point on it (a distance between the two):
/// the same distance back past the other point solves every constraint too, and only the side
/// it was drawn on tells them apart. The other point is held on the rail itself, or lies on it
/// as the mirror image of a point on it across a line square to it. The mirror image counts as
/// a flip, and the rail walked far (steeper, higher, the other way up) keeps the point on its side.
#[test]
fn a_point_a_distance_along_a_linked_line_keeps_its_side() {
let slant = |y0: f64, y1: f64| vec![LinkGeom::Line(Vec2::new(0.0, y0), Vec2::new(80.0, y1))];
for mirrored_on in [false, true] {
let mut sk = Sketch::new();
let link = sk.add_link(LinkKind::Project, source(), &slant(10.0, 50.0)).unwrap();
let rail = sk.link_curves(&link)[0];
let a = sk.add_point(Vec2::new(20.0, 20.0), None).unwrap();
let h = sk.add_point(Vec2::new(23.0, 21.5), None).unwrap();
if mirrored_on {
// `a` mirrors `b` (on the rail, x 0..) across a line square to the rail at x 10.
let b = sk.add_point(Vec2::new(0.5, 10.0), None).unwrap();
let mh = sk.add_line(Vec2::new(10.0, 15.0), Vec2::new(5.5, 24.0), None, None, None).unwrap();
let (m, _) = sk.curves[mh].kind.ends().unwrap();
sk.add_constraint(ConstraintKind::PointOnCurve { p: b, c: rail }, None).unwrap();
sk.add_constraint(ConstraintKind::PointOnCurve { p: m, c: rail }, None).unwrap();
sk.add_constraint(ConstraintKind::Perpendicular { a: mh, b: rail }, None).unwrap();
sk.add_constraint(ConstraintKind::Length { l: mh, value: 10.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::DistanceX { p: 0, q: m, value: 10.0 }, None).unwrap();
sk.add_constraint(ConstraintKind::DistanceX { p: 0, q: b, value: 0.5 }, None).unwrap();
sk.add_constraint(ConstraintKind::Symmetric { p: b, q: a, l: mh }, None).unwrap();
} else {
sk.add_constraint(ConstraintKind::PointOnCurve { p: a, c: rail }, None).unwrap();
sk.add_constraint(ConstraintKind::DistanceX { p: 0, q: a, value: 20.0 }, None).unwrap();
}
sk.add_constraint(ConstraintKind::PointOnCurve { p: h, c: rail }, None).unwrap();
let span = sk.add_constraint(ConstraintKind::Distance { p: a, q: h, value: 3.0 }, None).unwrap();
assert!(solve(&mut sk).ok(), "{mirrored_on}");
let ahead = |sk: &Sketch| match sk.curves[rail].kind {
CurveKind::Line { a: s, b: e } => (sk.points[e].pos - sk.points[s].pos).dot(sk.points[h].pos - sk.points[a].pos),
_ => f64::NAN,
};
assert!(ahead(&sk) > 0.0 && (sk.points[h].pos.dist(sk.points[a].pos) - 3.0).abs() < 1e-9, "{mirrored_on}");
let stored = sk.clone();
// The same 3 mm back past `a`: solved as it is, and told apart only by the side.
let mut back = stored.clone();
back.points[h].pos = back.points[a].pos * 2.0 - back.points[h].pos;
assert!(solve(&mut back).ok() && ahead(&back) < 0.0, "{mirrored_on}");
assert!(flips_from_stored(&back, &stored).contains(&span), "{mirrored_on}: {:?}", flips_from_stored(&back, &stored));
// Walked there, `h` stays ahead of `a` along the rail.
for (y0, y1) in [(300.0, 260.0), (-40.0, 400.0), (2000.0, 1990.0)] {
let mut sk = stored.clone();
sk.update_link(&link, &slant(y0, y1)).unwrap();
let report = solve_after_link_move(&mut sk, &stored, &stored.driving_values(), Analysis::Full);
assert!(report.is_some_and(|r| r.keeps_orientation()), "{mirrored_on} {y0} {y1}");
assert!(ahead(&sk) > 0.0 && flips_from_stored(&sk, &stored).is_empty(), "{mirrored_on} {y0} {y1}: {}", ahead(&sk));
}
}
}
+65 -1
View File
@@ -1990,6 +1990,10 @@ enum Orient {
OfLine(usize, usize, f64),
/// Which of two nested circles or arcs encloses the other.
RadiusOrder(usize, usize),
/// Which way along line `l` the point `q` is from `p`: a `Distance` between two points that
/// both lie on `l` (its ends, points on it, or points coincident with either; one of them may
/// lie on it by what else holds it).
Along(usize, usize, usize, f64),
}
/// An orientation's signed offset in a state (a corner's distance from the opposite side, an
@@ -2023,6 +2027,11 @@ fn offset(s: &State, o: Orient) -> Option<(f64, f64, f64)> {
// its size; rounding still accounts for the radii and the arc coordinates.
(ra - rb, (ra - rb).abs(), ra.max(rb).max(coords(&[ca, cb])))
}
Orient::Along(p, q, l, size) => {
let (a, b) = s.line(l);
let (pp, pq) = (s.p(p), s.p(q));
((b - a).normalized()?.dot(pq - pp), size, coords(&[pp, pq, a, b]))
}
})
}
@@ -2154,13 +2163,17 @@ fn orients(s: &State, sub: &[(Block, Vec<usize>)]) -> Vec<(Orient, Vec<usize>)>
let mut out = Vec::new();
let mut joins = Vec::new();
let mut edges = Vec::new();
let mut spans: Vec<(usize, usize, f64, usize)> = Vec::new();
for (b, _) in sub {
// A tangency at a point the two curves share (or a line's end held on the round) is a
// block of its own; its round keeps its side of the line all the same.
let (Block::User(ci, kind) | Block::TangentAt(ci, kind, _)) = b else { continue };
match **kind {
ConstraintKind::Coincident { p, q } => joins.push((p, q)),
ConstraintKind::Distance { p, q, .. } => edges.push((p, q, *ci)),
ConstraintKind::Distance { p, q, value } => {
edges.push((p, q, *ci));
spans.push((p, q, value, *ci));
}
ConstraintKind::Length { l, .. } => edges.extend(line(l).map(|(p, q)| (p, q, *ci))),
ConstraintKind::DistanceX { p, q, value } if free(p) || free(q) => out.push((Orient::SideX(p, q, value), vec![*ci])),
ConstraintKind::DistanceY { p, q, value } if free(p) || free(q) => out.push((Orient::SideY(p, q, value), vec![*ci])),
@@ -2191,6 +2204,57 @@ fn orients(s: &State, sub: &[(Block, Vec<usize>)]) -> Vec<(Orient, Vec<usize>)>
_ => {}
}
}
// A distance between two points on one line leaves which way along it open: the other
// solution is the same distance back past `p`. A point is on a line as one of its ends, as a
// point held on it, or coincident with either, read from the whole sketch (the line may be
// fixed, solved apart from these points).
let ends = |l: usize| line(l).map(|(a, b)| [a, b]).unwrap_or([usize::MAX; 2]);
let mut lines_at: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
let mut together: Vec<(usize, usize)> = Vec::new();
if !spans.is_empty() {
for (l, c) in s.sk.curves.iter().enumerate() {
if let CurveKind::Line { a, b } = c.kind {
lines_at.entry(a).or_default().push(l);
lines_at.entry(b).or_default().push(l);
}
}
for c in &s.sk.constraints {
match c.kind {
ConstraintKind::PointOnCurve { p, c } if line(c).is_some() => lines_at.entry(p).or_default().push(c),
ConstraintKind::Coincident { p, q } => together.push((p, q)),
_ => {}
}
}
}
let lines_of = |p: usize| -> Vec<usize> {
let joined = together.iter().filter_map(|&(x, y)| {
if x == p {
Some(y)
} else if y == p {
Some(x)
} else {
None
}
});
std::iter::once(p).chain(joined).flat_map(|x| lines_at.get(&x).into_iter().flatten().copied()).collect()
};
// One of the two may lie on the line by what else holds it (the mirror image of a point on
// it, across a line square to it): where it is now, as exactly as a solve puts it.
let lies_on = |x: usize, l: usize| {
let ((a, b), px) = (s.line(l), s.p(x));
let reach = 1e-7 * crate::loci::mag(a).max(crate::loci::mag(b)).max(crate::loci::mag(px)).max(1.0);
(b - a).normalized().is_some_and(|d| d.cross(px - a).abs() <= reach)
};
for &(p, q, value, ci) in &spans {
if !(free(p) || free(q)) {
continue;
}
let (lp, lq) = (lines_of(p), lines_of(q));
let both = |l: &usize| (lp.contains(l) || lies_on(p, *l)) && (lq.contains(l) || lies_on(q, *l));
if let Some(l) = lp.iter().chain(&lq).copied().find(|l| both(l) && !(ends(*l).contains(&p) && ends(*l).contains(&q))) {
out.push((Orient::Along(p, q, l, value), vec![ci]));
}
}
// Union-find over the points these constraints name (not the whole sketch).
let mut local: BTreeMap<usize, usize> = BTreeMap::new();
for (p, q) in joins.iter().copied().chain(edges.iter().map(|&(p, q, _)| (p, q))) {