mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-16 15:26:50 +00:00
Merge pull request #7920 from dotCooCoo/fix/smooth-corners-dense-paths
Smooth tool: keep corners on a path cut into very many short segments
This commit is contained in:
@@ -117,11 +117,10 @@ fn smooth_corners(anchors: &[Anchor], closed: bool, reach: f64) -> Vec<bool> {
|
||||
// eighth of the way round a closed path. Over that much of a circle the path turns by 45°, so a
|
||||
// loop shorter than the reach is not all corners, while a square's or a triangle's corners still are.
|
||||
let mut spans = [reach, 2.0 * reach];
|
||||
// The lengths along the path ahead and back, measured once when an anchor needs them.
|
||||
let (mut ahead, mut back) = (None, None);
|
||||
if closed {
|
||||
let mut total = 0.0;
|
||||
for i in 0..n {
|
||||
total += walk(anchors, closed, (i, true), [f64::INFINITY; 2], reach, 1).1;
|
||||
}
|
||||
let total = ahead.get_or_insert_with(|| walk_blocks(anchors, closed, true, reach)).first().map_or(0.0, |lens| lens.iter().take(n).sum());
|
||||
if !(total.is_finite() && total > 0.0) {
|
||||
return corners;
|
||||
}
|
||||
@@ -137,8 +136,10 @@ fn smooth_corners(anchors: &[Anchor], closed: bool, reach: f64) -> Vec<bool> {
|
||||
if !turn_between(arrive, leave).is_some_and(|t| t > SMOOTH_CORNER_DEG) {
|
||||
continue;
|
||||
}
|
||||
let [Some(back_near), Some(back_far)] = walk(anchors, closed, (i, false), spans, reach, MAX_CORNER_WALK).0 else { continue };
|
||||
let [Some(ahead_near), Some(ahead_far)] = walk(anchors, closed, (i, true), spans, reach, MAX_CORNER_WALK).0 else { continue };
|
||||
let back = back.get_or_insert_with(|| walk_blocks(anchors, closed, false, reach));
|
||||
let [Some(back_near), Some(back_far)] = spans.map(|r| point_along(anchors, closed, (i, false), r, back, reach)) else { continue };
|
||||
let ahead = ahead.get_or_insert_with(|| walk_blocks(anchors, closed, true, reach));
|
||||
let [Some(ahead_near), Some(ahead_far)] = spans.map(|r| point_along(anchors, closed, (i, true), r, ahead, reach)) else { continue };
|
||||
*flag = [(back_near, ahead_near, spans[0]), (back_far, ahead_far, spans[1])]
|
||||
.into_iter()
|
||||
.all(|(back, ahead, r)| r <= 0.0 || turn_between(a.p - back, ahead - a.p).is_some_and(|t| t > SMOOTH_CORNER_DEG));
|
||||
@@ -146,9 +147,54 @@ fn smooth_corners(anchors: &[Anchor], closed: bool, reach: f64) -> Vec<bool> {
|
||||
corners
|
||||
}
|
||||
|
||||
/// Most segments [`walk`] passes from an anchor before it stops, which bounds the work for each
|
||||
/// anchor on a path of very many very short segments.
|
||||
const MAX_CORNER_WALK: usize = 256;
|
||||
/// The lengths [`walk`] measures along the segments of `anchors`, in the order a walk ahead
|
||||
/// (`forward`) or back passes them, twice round, starting at the first anchor ahead or the last
|
||||
/// anchor back, and added up in blocks: element `l` holds the lengths of each run of 2^`l`
|
||||
/// segments that starts at a multiple of 2^`l`. Each block adds up only its own segments, so a short
|
||||
/// stretch keeps its length next to very long ones. The segment past an open path's end has no
|
||||
/// length.
|
||||
fn walk_blocks(anchors: &[Anchor], closed: bool, forward: bool, reach: f64) -> Vec<Vec<f64>> {
|
||||
let n = anchors.len();
|
||||
let lens: Vec<f64> =
|
||||
(0..n).map(|k| walk(anchors, closed, (if forward { k } else { n - 1 - k }, forward), [f64::INFINITY; 2], reach, 1).1).collect();
|
||||
let mut blocks = vec![(0..2 * n).map(|k| lens[k % n]).collect::<Vec<f64>>()];
|
||||
while let Some(last) = blocks.last().filter(|b| b.len() > 1) {
|
||||
let next = last.as_chunks::<2>().0.iter().map(|[a, b]| a + b).collect();
|
||||
blocks.push(next);
|
||||
}
|
||||
blocks
|
||||
}
|
||||
|
||||
/// The point `dist` along the path `anchors` from anchor `from.0`, ahead when `from.1` and back
|
||||
/// otherwise, as [`walk`] finds it: an open path's end for a distance beyond the end, and `None`
|
||||
/// when a length is not a number or is too large to add. The walk skips whole blocks of `blocks`
|
||||
/// ([`walk_blocks`] in the same direction) that end no more than `dist` along the path, so a path of
|
||||
/// very many short segments is not walked one segment at a time from each anchor.
|
||||
fn point_along(anchors: &[Anchor], closed: bool, from: (usize, bool), dist: f64, blocks: &[Vec<f64>], reach: f64) -> Option<Point> {
|
||||
let (n, (i, forward)) = (anchors.len(), from);
|
||||
let start = if forward { i } else { n - 1 - i };
|
||||
let end = start
|
||||
+ if closed {
|
||||
n
|
||||
} else if forward {
|
||||
n - 1 - i
|
||||
} else {
|
||||
i
|
||||
};
|
||||
let (mut pos, mut gone) = (start, 0.0);
|
||||
// The largest block that starts at `pos`, stays within the walk and ends within `dist`, until
|
||||
// none does; a block whose length is not a number is never skipped.
|
||||
while let Some((size, len)) = blocks.iter().enumerate().rev().find_map(|(l, lens)| {
|
||||
let size = 1usize << l;
|
||||
let len = lens.get(pos >> l).copied()?;
|
||||
(pos % size == 0 && pos + size <= end && gone + len <= dist).then_some((size, len))
|
||||
}) {
|
||||
pos += size;
|
||||
gone += len;
|
||||
}
|
||||
let at = if forward { pos % n } else { n - 1 - pos % n };
|
||||
walk(anchors, closed, (at, forward), [(dist - gone).max(0.0); 2], reach, n).0[0]
|
||||
}
|
||||
|
||||
/// A walk along the path `anchors` from anchor `from.0`, ahead when `from.1` and back otherwise,
|
||||
/// past no more than `segments` segments, measured along the lines between each curved segment's
|
||||
@@ -1099,11 +1145,12 @@ mod tests {
|
||||
}
|
||||
|
||||
/// A 90° bump 400 pt high cut into 1 pt segments, between two long straight segments: with a reach
|
||||
/// of 10 pt its top is a corner, and with a reach of 1,000 pt, where the walk passes more segments
|
||||
/// than it measures before it gets that far, its top is not one, as the path turns by about 51°
|
||||
/// over that reach.
|
||||
/// of 10 pt, and of 300 pt, where twice the reach passes the bump's 566 segments on each side, its
|
||||
/// top is a corner, and with a reach of 1,000 pt its top is not one, as the path turns by about 51°
|
||||
/// over that reach. The turns into and between 1 pt segments that follow two segments 1e16 pt long
|
||||
/// are corners too.
|
||||
#[test]
|
||||
fn a_corner_is_not_kept_where_the_reach_is_not_measured() {
|
||||
fn a_bump_of_many_short_segments_is_a_corner_where_it_turns_over_the_reach() {
|
||||
let side = 400.0 * std::f64::consts::SQRT_2;
|
||||
let steps = side.ceil() as usize;
|
||||
let mut pts = vec![(-3000.0, 0.0)];
|
||||
@@ -1120,6 +1167,10 @@ mod tests {
|
||||
let top = steps + 1;
|
||||
assert_eq!(anchors[top].p, Point::new(0.0, 400.0));
|
||||
assert!(smooth_corners(&anchors, false, 10.0)[top]);
|
||||
assert!(smooth_corners(&anchors, false, 300.0)[top]);
|
||||
let long = polyline(&[(0.0, 0.0), (1e16, 0.0), (0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 2.0)]);
|
||||
let corners = smooth_corners(&long, false, 0.5);
|
||||
assert!(corners[2] && corners[3] && corners[4], "{corners:?}");
|
||||
assert!(!smooth_corners(&anchors, false, 1000.0)[top]);
|
||||
}
|
||||
|
||||
|
||||
@@ -2326,6 +2326,39 @@ fn smoothing_keeps_a_corner_between_curves() {
|
||||
}
|
||||
}
|
||||
|
||||
/// A Smooth drag over a corner of a path cut into very many short segments keeps it, however many
|
||||
/// segments twice the reach spans: an open path's 90° corner with legs of 2,000 segments 0.05 pt
|
||||
/// long at the default reach, and a corner of a 200 pt square cut into 0.25 pt segments with a 40 pt
|
||||
/// reach.
|
||||
#[test]
|
||||
fn smoothing_keeps_corners_on_a_path_of_many_short_segments() {
|
||||
let mut s = session();
|
||||
let (id, v, drag) = smooth_corner_path(&mut s, 90.0, 2000);
|
||||
smooth_pass(&mut s, &drag);
|
||||
let at = smooth_turn_at(&path(&s, id).subpaths[0], v);
|
||||
assert!(at.is_some_and(|t| (t - 90.0).abs() < 0.01), "the open path's corner is kept: {at:?}");
|
||||
|
||||
let mut s = session();
|
||||
let ends = [Point::new(200.0, 200.0), Point::new(400.0, 200.0), Point::new(400.0, 400.0), Point::new(200.0, 400.0)];
|
||||
let mut anchors = vec![];
|
||||
for k in 0..4 {
|
||||
let (a, b) = (ends[k], ends[(k + 1) % 4]);
|
||||
anchors.extend((0..800).map(|j| {
|
||||
let p = a.lerp(b, f64::from(j) / 800.0);
|
||||
json!({"x": p.x, "y": p.y})
|
||||
}));
|
||||
}
|
||||
let id = smooth_test_path(&mut s, &anchors, true);
|
||||
let v = ends[1];
|
||||
let mut drag: Vec<Point> = (0..8).map(|k| v - kurbo::Vec2::new(40.0 - 5.0 * f64::from(k), 0.0)).collect();
|
||||
drag.extend((0..=8).map(|k| v + kurbo::Vec2::new(0.0, 5.0 * f64::from(k))));
|
||||
let pts: Vec<_> = drag.iter().map(|p| json!([p.x, p.y])).collect();
|
||||
s.execute("path.smoothRegion", &json!({"points": pts, "radius": 40, "fidelity": 2.5})).unwrap();
|
||||
let sp = &path(&s, id).subpaths[0];
|
||||
let at = smooth_turn_at(sp, v);
|
||||
assert!(sp.closed && at.is_some_and(|t| (t - 90.0).abs() < 0.01), "the square's corner is kept: {at:?}");
|
||||
}
|
||||
|
||||
/// A corner at the first anchor of the stretch a drag smooths, just out of its reach, keeps its
|
||||
/// place and its turn.
|
||||
#[test]
|
||||
|
||||
+1
-1
@@ -5874,7 +5874,7 @@ direction.
|
||||
|
||||
`path.smoothRegion` keeps an anchor as a corner where the path turns by more than 57.5° (an angle inside the corner
|
||||
under 122.5°) at the anchor and also over `radius` and over twice `radius` on either side of it (on a closed path that the drag reaches all the
|
||||
way round, no more than an eighth of its length), so a jag or a bump smaller than `radius` is still smoothed. The stretches on either side of a kept corner are smoothed and refitted on their
|
||||
way round, no more than an eighth of its length), measured along the path however many segments it is cut into, so a jag or a bump smaller than `radius` is still smoothed. The stretches on either side of a kept corner are smoothed and refitted on their
|
||||
own, and the corner keeps its place and the directions the path arrives and leaves along, on every call and at any
|
||||
`fidelity`. A call that changes no anchor returns `{ids: [], before: 0, after: 0}` and adds no undo step. The 57.5°
|
||||
threshold is VectorCraft's own value.
|
||||
|
||||
Reference in New Issue
Block a user