Sketch Trim: keep endpoint tangency on the surviving arc (#10851) (#10853)

* claim: #10851

* Sketch Trim: keep endpoint tangency on the surviving arc (#10851)
This commit is contained in:
Colin Faulkingham
2026-11-02 13:47:26 +00:00
committed by GitHub
parent a9fa61ce77
commit 2339510e41
2 changed files with 131 additions and 0 deletions
+50
View File
@@ -326,6 +326,54 @@ fn release_extent(sk: &mut Sketch, ci: usize) {
});
}
/// Tangencies tied to one of the curve's ends, through a shared point or Coincident
/// constraints. Record them before splitting: keeping the curve ID alone would leave an
/// end tangent on the wrong piece and lose the solver's endpoint tangency equation.
fn endpoint_tangencies(sk: &Sketch, ci: usize) -> Vec<(usize, usize)> {
let Some((start, end)) = sk.curves.get(ci).and_then(|c| c.kind.ends()) else { return Vec::new() };
let groups = coincident_points(sk);
let root = |p: usize| groups.get(p).copied().unwrap_or(p);
sk.constraints
.iter()
.enumerate()
.filter_map(|(i, k)| {
let ConstraintKind::Tangent { a, b } = k.kind else { return None };
let other = if a == ci {
b
} else if b == ci {
a
} else {
return None;
};
let (a, b) = sk.curves.get(other)?.kind.ends()?;
let joined = |p| root(p) == root(a) || root(p) == root(b);
match (joined(start), joined(end)) {
(true, false) => Some((i, start)),
(false, true) => Some((i, end)),
_ => None,
}
})
.collect()
}
/// Follow the original endpoints after the pieces have exchanged geometry to preserve the
/// original curve ID. A tangent on the removed piece goes with it in `remove_curves`.
fn rebind_endpoint_tangencies(sk: &mut Sketch, ci: usize, pieces: &[usize], tangencies: &[(usize, usize)]) {
for &(constraint, point) in tangencies {
let owner = pieces.iter().copied().find(|i| sk.curves.get(*i).and_then(|c| c.kind.ends()).is_some_and(|(a, b)| a == point || b == point));
if let Some(owner) = owner
&& let Some(k) = sk.constraints.get_mut(constraint)
&& let ConstraintKind::Tangent { a, b } = &mut k.kind
{
if *a == ci {
*a = owner;
} else if *b == ci {
*b = owner;
}
}
}
}
/// The cut parameters bracketing `tq` on curve `ci`: (before, after) with their cutter curves.
fn bracket(sk: &Sketch, ci: usize, tq: f64) -> (Vec<(f64, Vec2, usize)>, bool) {
let Some(sh) = sk.shape(ci) else { return (Vec::new(), false) };
@@ -549,6 +597,7 @@ fn remove_piece(sk: &mut Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<(Valu
})
.collect();
release_extent(sk, ci);
let tangencies = endpoint_tangencies(sk, ci);
let ts: Vec<f64> = cuts.iter().map(|c| c.0).collect();
let (pieces, pts) = split_at(sk, ci, &ts)?;
// The piece containing tq.
@@ -580,6 +629,7 @@ fn remove_piece(sk: &mut Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<(Valu
}
_ => gone,
};
rebind_endpoint_tangencies(sk, ci, &pieces, &tangencies);
let keep: Vec<usize> = pieces.iter().copied().filter(|x| *x != gone).collect();
tie(sk, &keep)?;
if let Some((a, _)) = sk.curves.get(ci).and_then(|c| c.kind.ends()) {
@@ -196,6 +196,87 @@ fn analytic_trim_and_break_use_freeform_cutters() {
assert!(sk.shape(ci).unwrap().dist(Vec2::new(-5.0, 0.0)) < 1e-6);
}
/// #10851: an endpoint's tangent must stay with the arc piece that owns that endpoint,
/// including when the endpoints are separate points joined by a Coincident constraint.
#[test]
fn trim_keeps_endpoint_tangency_on_its_arc_piece() {
for path in [false, true] {
for separate in [false, true] {
for at_start in [false, true] {
for reverse in [false, true] {
let mut s = new_sketch();
run(&mut s, "sketch.arc.center_point", json!({"center": [0,0], "start": [50,0], "end": [-50,0]}));
let endpoint = if at_start { "a1.start" } else { "a1.end" };
let x = if at_start { 50 } else { -50 };
let start = if separate { json!([x, 0]) } else { json!(endpoint) };
run(&mut s, "sketch.line", json!({"points": [start, [x,-30]], "connect": false, "infer": false}));
if separate {
run(&mut s, "sketch.constraint.coincident", json!({"a": "l1.start", "b": endpoint}));
}
let (a, b) = if reverse { ("a1", "l1") } else { ("l1", "a1") };
let tangent = run(&mut s, "sketch.constraint.tangent", json!({"a": a, "b": b}))["constraint"].as_str().unwrap().to_string();
run(&mut s, "sketch.dimension", json!({"entities": ["a1"], "type": "radius", "value": "50"}));
run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": "30"}));
run(&mut s, "sketch.constraint.horizontal_vertical", json!({"points": ["origin", "a1.start"], "mode": "horizontal"}));
for x in [-10, 10] {
run(&mut s, "sketch.line", json!({"points": [[x,40],[x,60]]}));
}
run(&mut s, "sketch.constraint.fix", json!({"entities": ["l2", "l3"]}));
assert_eq!(run(&mut s, "sketch.solve", json!({}))["dof"], 1);
let before = sketch(&s);
let undo = s.undo.len();
let result = if path {
run(&mut s, "sketch.trim.path", json!({"points": [[0,45],[0,55]]}))
} else {
run(&mut s, "sketch.trim", json!({"curve": "a1", "at": [0,50]}))
};
assert_eq!(result["sketch"]["dof"], 1, "path={path}, separate={separate}, at_start={at_start}, reverse={reverse}: {result}");
assert_eq!(s.undo.len(), undo + 1);
let after = sketch(&s);
let ci = after.curve_index(if at_start { "a1" } else { "a3" }).unwrap();
let li = after.curve_index("l1").unwrap();
assert!(after.constraints.iter().any(
|k| k.id == tangent && matches!(k.kind, ConstraintKind::Tangent { a, b } if (a == ci && b == li) || (a == li && b == ci))
));
let at = |id: &str| after.point(after.resolve_point(id).unwrap()).unwrap();
assert!(at(endpoint).dist(at("l1.start")) < 1e-8);
let radius = at("l1.start") - at("a1.center");
let line = at("l1.end") - at("l1.start");
assert!(radius.dot(line).abs() < 1e-6, "the line stays tangent to the circle");
run(&mut s, "edit.undo", json!({}));
assert_eq!(sketch(&s), before);
run(&mut s, "edit.redo", json!({}));
assert_eq!(sketch(&s), after);
}
}
}
}
}
#[test]
fn trim_keeps_or_removes_tangency_with_the_original_end() {
for remove_tangent_end in [false, true] {
let mut s = new_sketch();
run(&mut s, "sketch.arc.center_point", json!({"center": [0,0], "start": [50,0], "end": [-50,0]}));
run(&mut s, "sketch.line", json!({"points": ["a1.end", [-50,-30]]}));
let tangent = run(&mut s, "sketch.constraint.tangent", json!({"a": "l1", "b": "a1"}))["constraint"].as_str().unwrap().to_string();
run(&mut s, "sketch.line", json!({"points": [[0,40],[0,60]]}));
let before = sketch(&s);
let x = if remove_tangent_end { -40 } else { 40 };
run(&mut s, "sketch.trim", json!({"curve": "a1", "at": [x,30]}));
let after = sketch(&s);
assert!(after.curve_index("a1").is_some(), "the original curve ID survives either end trim");
assert_eq!(after.constraints.iter().any(|k| k.id == tangent), !remove_tangent_end);
if !remove_tangent_end {
let arc = after.curve_index("a1").unwrap();
let line = after.curve_index("l1").unwrap();
assert!(after.constraints.iter().any(|k| k.id == tangent && matches!(k.kind, ConstraintKind::Tangent { a, b } if a == line && b == arc)));
}
run(&mut s, "edit.undo", json!({}));
assert_eq!(sketch(&s), before);
}
}
#[test]
fn trim_extend_break() {
let mut s = new_sketch();