Path Precision Tools: a path that ends on a curve still divides it after the curve is cut

The crossing search took a crossing only where the straight pieces it
splits two curves into actually cross. A line trimmed at a curve ends
where that search found the crossing, up to about 0.0001 pt off the
curve. Once the curve was cut as well, its segments were split
differently, the line's end could fall just short of them, and the end
no longer counted as a place on the curve. Trim at Crossings then
removed the curve past that line, to the next crossing or the whole
path.

An open end of a path that lies within 0.001 pt of another path now
meets it at the nearest point there, at any angle. Corners of a path
and closed paths keep the exact test, and paths that lie along each
other still don't cross. Trim at Crossings and its hover, Add Points
at Crossings (with and without cut) and the Join tool's trim and join
of crossing paths use this search. The params text of Trim at
Crossings and Add Points at Crossings and docs/mcp.md say so.
This commit is contained in:
dotCooCoo
2026-11-16 11:22:22 -08:00
parent 94eacd67cd
commit 2af27232e0
6 changed files with 165 additions and 37 deletions
+1 -1
View File
@@ -147,7 +147,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Add Points at Crossings",
["Object", "Plug-ins", "Path Precision Tools"],
None,
"{cut?: bool (false: add anchors where the paths cross; true: also cut them there), selfCrossings?: bool (false: where a path crosses itself too, a curved segment that loops over itself included), ids?: [id…] (default: the selection)} where the paths under the objects cross one another, as one undo step; at most 10000 segments → {ids, crossings (anchors placed)}",
"{cut?: bool (false: add anchors where the paths cross; true: also cut them there), selfCrossings?: bool (false: where a path crosses itself too, a curved segment that loops over itself included), ids?: [id…] (default: the selection)} where the paths under the objects cross one another, an open end that lies within 0.001 pt of another path counting as crossing it there, as one undo step; at most 10000 segments → {ids, crossings (anchors placed)}",
has_selection,
crossings
),
@@ -33,7 +33,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
"Trim at Crossings",
[],
None,
"{at: [x, y], tolerance?: pt 0..100 (3; how near `at` a path counts as under it)} or {rect: [x, y, width, height]} or {points: [[x, y]…] (2 to 100000 points)} remove stretches of paths, a stretch running between two neighboring places where the path is crossed by another path or by itself, or from such a place to an open end: `at` removes the stretch of the nearest path at that point, `rect` every stretch the rectangle touches, `points` every stretch the line through the points crosses. Give exactly one of the three. Every path that can be edited takes part, selected or not, compound path members included; hidden and locked paths, guides and clipping paths (compound ones' members included) are neither trimmed nor counted as crossing; in isolation mode only paths inside the isolated object are trimmed. A path that ends on another marks a place on the other; paths that lie along each other don't cross. A closed path that loses a stretch becomes open, an open path that loses a middle stretch becomes two paths with its appearance in its place in the stacking order, and a path nothing crosses is removed whole; a live shape becomes a plain path. One undo step, none when nothing is removed → {ids (the paths left of those trimmed), removed (stretches)}",
"{at: [x, y], tolerance?: pt 0..100 (3; how near `at` a path counts as under it)} or {rect: [x, y, width, height]} or {points: [[x, y]…] (2 to 100000 points)} remove stretches of paths, a stretch running between two neighboring places where the path is crossed by another path or by itself, or from such a place to an open end: `at` removes the stretch of the nearest path at that point, `rect` every stretch the rectangle touches, `points` every stretch the line through the points crosses. Give exactly one of the three. Every path that can be edited takes part, selected or not, compound path members included; hidden and locked paths, guides and clipping paths (compound ones' members included) are neither trimmed nor counted as crossing; in isolation mode only paths inside the isolated object are trimmed. A path that ends on another, or within 0.001 pt of it, marks a place on the other; paths that lie along each other don't cross. A closed path that loses a stretch becomes open, an open path that loses a middle stretch becomes two paths with its appearance in its place in the stacking order, and a path nothing crosses is removed whole; a live shape becomes a plain path. One undo step, none when nothing is removed → {ids (the paths left of those trimmed), removed (stretches)}",
has_doc,
trim
)]
@@ -648,3 +648,45 @@ fn bad_params_are_refused_and_change_nothing() {
assert_eq!(steps(&s), n);
assert!(*s.doc().unwrap().doc == *before);
}
#[test]
fn a_line_ending_on_a_curve_that_was_cut_still_divides_it_there() {
// An open egg-shaped curve, lines across it whose stubs on the left are trimmed away, so each
// line ends on the curve, and the curve's bottom trimmed off below the last line, which cuts
// its segments there. A click on the curve between the last two lines removes only that
// stretch: the lines' ends on it still divide it, however the curve was cut. Twenty placements,
// as how near a cut end lies to the curve depends on the coordinates.
for shift in 0..20 {
let dx = shift as f64 * 7.31;
let mut s = session();
let egg = json!({"anchors": [
{"x": 160.0 + dx, "y": 40.0, "out": [110.0 + dx, 80.0]},
{"x": 92.3 + dx, "y": 190.7, "in": [88.0 + dx, 140.0], "out": [97.0 + dx, 240.0]},
{"x": 170.0 + dx, "y": 268.0, "in": [130.0 + dx, 265.0], "out": [210.0 + dx, 271.0]},
{"x": 236.4 + dx, "y": 170.2, "in": [238.0 + dx, 230.0], "out": [233.0 + dx, 110.0]},
{"x": 150.0 + dx, "y": 20.0, "in": [200.0 + dx, 40.0]}
], "closed": false});
let egg = NodeId(s.execute("path.create", &egg).unwrap()["id"].as_u64().unwrap());
s.execute("select.none", &json!({})).unwrap();
let ys: Vec<f64> = (0..8).map(|k| 70.0 + k as f64 * 23.17 + shift as f64 * 0.37).collect();
let lines: Vec<NodeId> = ys.iter().map(|y| line(&mut s, &[(40.0 + dx, *y), (300.0 + dx, *y)], false)).collect();
for y in &ys {
assert_eq!(s.execute(TRIM, &json!({"at": [50.0 + dx, y], "tolerance": 0.5})).unwrap()["removed"], json!(1));
}
assert_eq!(s.execute(TRIM, &json!({"at": [170.0 + dx, 268.0], "tolerance": 0.5})).unwrap()["removed"], json!(1));
let start = |id: NodeId| path(&s, id).subpaths[0].anchors[0].p;
let ends: Vec<Point> = lines.iter().map(|id| start(*id)).collect();
// Off every path but the lines: the curve's pieces.
let off_curve = |s: &Session, p: Point| {
stack(s).into_iter().filter(|id| !lines.contains(id)).filter_map(|id| path(s, id).nearest(p)).map(|n| n.4).fold(f64::INFINITY, f64::min)
};
let (a, b) = (ends[6], ends[7]);
let click = path(&s, egg).nearest(a.midpoint(b)).unwrap().3;
assert!(off_curve(&s, a) < 1e-3 && off_curve(&s, click) < 1e-3);
assert_eq!(s.execute(TRIM, &json!({"at": [click.x, click.y], "tolerance": 0.5})).unwrap()["removed"], json!(1));
assert!(off_curve(&s, click) > 0.5, "{shift}: the stretch clicked is left");
for (k, e) in ends.iter().enumerate().take(7) {
assert!(off_curve(&s, *e) < 1e-3, "{shift}: the curve no longer reaches line {k}'s end");
}
}
}