Files
vectorcraft/crates/pathops/src/addons/keep_shape.rs
T
dotCooCoo a5493a1cd0 Paths: editing one anchor of a long path keeps one chunk of anchors for undo
A subpath's anchors are now an `Anchors` list held in chunks of up to
256 anchors behind `Arc`s. Copying a path copies the chunk table and
shares the chunks, and editing one anchor copies only the chunk that
holds it, so the undo step of a one-anchor edit no longer keeps a copy
of every anchor of the path. Inserting or removing an anchor copies the
chunk it is in and rebuilds the table. Reads and edits follow the Vec
and slice methods the code used; files write and read each subpath's
anchors as one list, as before, within the same anchor read budget.

The undo memory estimate counts only the chunks the other version of
the path does not hold, and the renderer's kept paths compare only the
chunks an edit copied when they look for moved anchors.

Moving one anchor of an open path of 10,000 or 200,000 anchors
(path.moveAnchor, path.setHandle, path.moveAnchors, a nudge) keeps at
most 48 KiB in its undo and redo steps, where it kept 56 bytes per
anchor.
2026-11-14 21:25:15 -08:00

321 lines
14 KiB
Rust

//! Shape-keeping anchor removal: an anchor goes, and the handles of its two neighbours that face it
//! are refitted (their directions kept, their lengths fitted) so one segment follows the two that
//! met there. [`remove_anchor_keep_shape`] removes one anchor and says how far the outline moved;
//! [`simplify_keep_shape`] removes as many as it can while every new segment stays within a
//! tolerance of the original outline.
use kurbo::{CubicBez, ParamCurve, ParamCurveNearest};
use vectorcraft_geom::{Anchor, PathData, SubPath};
use crate::edit::remove_anchor;
use crate::fit::{end_tangent, start_tangent};
/// The turn (degrees) at an anchor above which `protect_corners` keeps it.
pub const SHARP_CORNER_DEG: f64 = 30.0;
/// The drift (pt) each step of the tolerance the add-ons offer allows.
pub const PT_PER_TOLERANCE: f64 = 0.02;
/// Points sampled along each curve to measure how far two outlines are apart.
const SAMPLES: usize = 8;
/// Nearest-point accuracy (pt) of those measurements.
const ACCURACY: f64 = 1e-6;
/// The segment that takes the place of the two meeting at `cur` once it is removed: from `prev`
/// to `next`, their facing handles refitted ([`remove_anchor`]).
fn merged(prev: &Anchor, cur: &Anchor, next: &Anchor) -> CubicBez {
let mut run = SubPath::new(vec![*prev, *cur, *next], false);
remove_anchor(&mut run, 1);
match &*run.anchors.contiguous() {
[a, b] => CubicBez::new(prev.p, a.h_out, b.h_in, next.p),
_ => CubicBez::new(prev.p, prev.h_out, next.h_in, next.p),
}
}
/// How far `fitted` strays from the run of segments `original` it replaces, measured both ways
/// (pt): the farthest a sampled point of either lies from the other.
fn deviation(original: &[&CubicBez], fitted: &CubicBez) -> f64 {
let t = |k: usize| k as f64 / SAMPLES as f64;
let mut worst: f64 = 0.0;
for c in original {
for k in 0..=SAMPLES {
worst = worst.max(fitted.nearest(c.eval(t(k)), ACCURACY).distance_sq);
}
}
for k in 1..SAMPLES {
let p = fitted.eval(t(k));
worst = worst.max(original.iter().map(|c| c.nearest(p, ACCURACY).distance_sq).fold(f64::INFINITY, f64::min));
}
worst.sqrt()
}
/// The fewest anchors a subpath keeps: two when open, three when closed.
fn min_anchors(sp: &SubPath) -> usize {
if sp.closed { 3 } else { 2 }
}
/// Indices of anchor `i`'s neighbours in a subpath of `n` anchors (`None` for an open end).
fn neighbours(n: usize, closed: bool, i: usize) -> Option<(usize, usize)> {
match closed {
true => (n > 0).then(|| ((i + n - 1) % n, (i + 1) % n)),
false => (i > 0 && i + 1 < n).then(|| (i - 1, i + 1)),
}
}
fn finite(sp: &SubPath) -> bool {
sp.anchors.iter().all(|a| a.p.is_finite() && a.h_in.is_finite() && a.h_out.is_finite())
}
/// Does the path turn by more than [`SHARP_CORNER_DEG`] at anchor `i` (an inner anchor)?
fn is_sharp(sp: &SubPath, i: usize) -> bool {
let Some((prev, _)) = neighbours(sp.anchors.len(), sp.closed, i) else { return false };
let (into, out) = (end_tangent(&sp.segment(prev)), start_tangent(&sp.segment(i)));
into.dot(out).clamp(-1.0, 1.0).acos().to_degrees() > SHARP_CORNER_DEG
}
/// Give anchors `prev` and `next` the facing handles of segment `c`.
fn apply(sp: &mut SubPath, prev: usize, next: usize, c: &CubicBez) {
if let Some(a) = sp.anchors.get_mut(prev) {
a.h_out = c.p1;
}
if let Some(a) = sp.anchors.get_mut(next) {
a.h_in = c.p2;
}
}
/// Remove anchor `index` of `sp`, refitting the handles of its neighbours that face it so one
/// segment follows the two that met there → (the new subpath, how far its outline strays from the
/// old one, in points). `None` when the anchor can't go: out of range, an end of an open subpath,
/// a non-finite coordinate, or the subpath would keep fewer than two (open) or three (closed)
/// anchors.
pub fn remove_anchor_keep_shape(sp: &SubPath, index: usize) -> Option<(SubPath, f64)> {
let n = sp.anchors.len();
if n <= min_anchors(sp) || index >= n || !finite(sp) {
return None;
}
let (prev, next) = neighbours(n, sp.closed, index)?;
let c = merged(sp.anchors.get(prev)?, sp.anchors.get(index)?, sp.anchors.get(next)?);
let error = deviation(&[&sp.segment(prev), &sp.segment(index)], &c);
let mut out = sp.clone();
apply(&mut out, prev, next, &c);
out.anchors.remove(index);
Some((out, error))
}
/// Remove as many anchors of `path` as can go while its outline stays within `tolerance` points of
/// where it was, refitting the handles beside each ([`remove_anchor_keep_shape`]). Every new segment
/// is measured against the original outline it replaces, so removals don't add up past the
/// tolerance. With `protect_corners`, anchors where the path turns by more than
/// [`SHARP_CORNER_DEG`] stay. Open ends always stay. A subpath with a non-finite coordinate, and a
/// tolerance that isn't a positive number, are left as they are.
pub fn simplify_keep_shape(path: &PathData, tolerance: f64, protect_corners: bool) -> PathData {
if !(tolerance > 0.0 && tolerance.is_finite()) {
return path.clone();
}
PathData::new(path.subpaths.iter().map(|sp| Reducer::new(sp, protect_corners).run(tolerance)).collect())
}
/// [`simplify_keep_shape`] on subpath `sp` where only the anchors `may_go` marks (one flag per
/// anchor, by index) may go: what the Anchor Eraser Brush passes over. Open ends always stay. An
/// infinite tolerance removes every marked anchor that can go.
pub fn simplify_anchors_keep_shape(sp: &SubPath, tolerance: f64, may_go: &[bool]) -> SubPath {
if tolerance.is_nan() || tolerance <= 0.0 {
return sp.clone();
}
let mut r = Reducer::new(sp, false);
r.kept = (0..sp.anchors.len()).map(|i| !may_go.get(i).copied().unwrap_or(false)).collect();
r.run(tolerance)
}
/// One subpath being reduced: what is left of it, and where its anchors were in the original.
struct Reducer<'a> {
original: &'a SubPath,
segments: Vec<CubicBez>,
/// Anchors of the original that stay whatever the tolerance (sharp corners).
kept: Vec<bool>,
cur: SubPath,
/// The original index of each anchor left.
origin: Vec<usize>,
}
impl<'a> Reducer<'a> {
fn new(sp: &'a SubPath, protect_corners: bool) -> Self {
let n = sp.anchors.len();
Reducer {
original: sp,
segments: (0..sp.segment_count()).map(|i| sp.segment(i)).collect(),
kept: (0..n).map(|i| protect_corners && is_sharp(sp, i)).collect(),
cur: sp.clone(),
origin: (0..n).collect(),
}
}
/// Each pass removes the anchors whose removal strays least, no two side by side (so each
/// segment measured is the one that results), until none can go.
fn run(mut self, tolerance: f64) -> SubPath {
if self.cur.anchors.len() <= min_anchors(self.original) || !finite(self.original) {
return self.cur;
}
while self.pass(tolerance) {}
self.cur
}
/// The original segments between original anchors `from` and `to`, round the end of a closed
/// path.
fn span(&self, from: usize, to: usize) -> Option<Vec<&CubicBez>> {
Some(match from < to {
true => self.segments.get(from..to)?.iter().collect(),
false => self.segments.get(from..)?.iter().chain(self.segments.get(..to)?).collect(),
})
}
/// Anchor `i` of what is left, if it may go: (how far its removal strays, the segment that
/// replaces its two).
fn candidate(&self, i: usize, tolerance: f64) -> Option<(f64, CubicBez)> {
if self.origin.get(i).and_then(|&o| self.kept.get(o)) != Some(&false) {
return None;
}
let (prev, next) = neighbours(self.cur.anchors.len(), self.cur.closed, i)?;
let a = &self.cur.anchors;
let c = merged(a.get(prev)?, a.get(i)?, a.get(next)?);
let e = deviation(&self.span(*self.origin.get(prev)?, *self.origin.get(next)?)?, &c);
(e <= tolerance).then_some((e, c))
}
/// One pass: whether any anchor went.
fn pass(&mut self, tolerance: f64) -> bool {
let m = self.cur.anchors.len();
let min = min_anchors(self.original);
if m <= min {
return false;
}
let mut found: Vec<(f64, usize, CubicBez)> = (0..m).filter_map(|i| self.candidate(i, tolerance).map(|(e, c)| (e, i, c))).collect();
found.sort_by(|a, b| a.0.total_cmp(&b.0));
let mut gone = vec![false; m];
let mut left = m - min;
for (_, i, c) in found {
let Some((prev, next)) = neighbours(m, self.cur.closed, i) else { continue };
if left == 0 || gone.get(prev) != Some(&false) || gone.get(next) != Some(&false) {
continue;
}
apply(&mut self.cur, prev, next, &c);
if let Some(g) = gone.get_mut(i) {
*g = true;
}
left -= 1;
}
let mut keep = gone.iter().map(|g| !g);
self.cur.anchors.retain(|_| keep.next().unwrap_or(true));
let mut keep = gone.iter().map(|g| !g);
self.origin.retain(|_| keep.next().unwrap_or(true));
left < m - min
}
}
#[cfg(test)]
mod tests {
use kurbo::{ParamCurveNearest, Point, Vec2};
use vectorcraft_geom::{Anchor, PathData, SubPath};
use super::{remove_anchor_keep_shape, simplify_keep_shape};
/// A circle of radius `r` about the origin drawn with `n` smooth anchors.
fn circle(r: f64, n: usize) -> SubPath {
let step = std::f64::consts::TAU / n as f64;
let k = 4.0 / 3.0 * (step / 4.0).tan() * r;
let anchors = (0..n)
.map(|i| {
let a = step * i as f64;
let p = Point::new(r * a.cos(), r * a.sin());
Anchor::smooth(p, p + Vec2::new(-a.sin(), a.cos()) * k)
})
.collect();
SubPath::new(anchors, true)
}
/// The farthest a point of `sp`'s outline lies from the circle of radius `r`.
fn off_circle(sp: &SubPath, r: f64) -> f64 {
(0..sp.segment_count())
.flat_map(|i| (0..=20).map(move |k| (i, k as f64 / 20.0)))
.map(|(i, t)| (kurbo::ParamCurve::eval(&sp.segment(i), t).to_vec2().hypot() - r).abs())
.fold(0.0, f64::max)
}
#[test]
fn a_circle_keeps_its_shape_with_fewer_anchors() {
let sp = circle(50.0, 16);
let out = simplify_keep_shape(&PathData::single(sp), 0.2, false);
let s = &out.subpaths[0];
assert!(s.anchors.len() <= 8 && s.anchors.len() >= 3, "{} anchors left", s.anchors.len());
assert!(s.closed);
assert!(off_circle(s, 50.0) <= 0.2 + 1e-6, "strays {}", off_circle(s, 50.0));
}
#[test]
fn one_removal_reports_how_far_the_outline_moved() {
let sp = circle(50.0, 16);
let (out, err) = remove_anchor_keep_shape(&sp, 3).unwrap();
assert_eq!(out.anchors.len(), 15);
assert!(err < 0.05, "{err}");
assert!((off_circle(&out, 50.0) - err).abs() < 0.05);
// A corner of a square moves its outline a long way.
let sq = SubPath::polyline(&[(0.0, 0.0).into(), (10.0, 0.0).into(), (10.0, 10.0).into(), (0.0, 10.0).into()], true);
let (_, err) = remove_anchor_keep_shape(&sq, 1).unwrap();
assert!((err - 50f64.sqrt()).abs() < 1e-3, "{err}");
}
#[test]
fn sharp_corners_stay_when_protected() {
// A 90° corner at (1, 0) that a 1 pt tolerance would otherwise take away.
let sp = SubPath::polyline(&[(0.0, 0.0).into(), (1.0, 0.0).into(), (1.0, 1.0).into()], false);
let path = PathData::single(sp);
assert_eq!(simplify_keep_shape(&path, 1.0, false).anchor_count(), 2);
assert_eq!(simplify_keep_shape(&path, 1.0, true).anchor_count(), 3);
// Collinear anchors on a straight edge go either way; the square's corners stay.
let sq = SubPath::polyline(
&[(0.0, 0.0).into(), (5.0, 0.0).into(), (10.0, 0.0).into(), (10.0, 10.0).into(), (0.0, 10.0).into(), (0.0, 5.0).into()],
true,
);
let out = simplify_keep_shape(&PathData::single(sq), 0.01, true);
let pts: Vec<Point> = out.subpaths[0].anchors.iter().map(|a| a.p).collect();
assert_eq!(pts, [(0.0, 0.0).into(), (10.0, 0.0).into(), (10.0, 10.0).into(), (0.0, 10.0).into()] as [Point; 4]);
}
#[test]
fn removals_do_not_add_up_past_the_tolerance() {
// A gentle arc of many anchors: each removal alone is small, together they would flatten it.
let pts: Vec<Point> = (0..=40).map(|i| Point::new(i as f64, (i as f64 / 40.0 * std::f64::consts::PI).sin() * 3.0)).collect();
let sp = SubPath::polyline(&pts, false);
let out = simplify_keep_shape(&PathData::single(sp.clone()), 0.1, false);
let s = &out.subpaths[0];
assert!(s.anchors.len() < 41);
for p in &pts {
let d = (0..s.segment_count()).map(|i| s.segment(i).nearest(*p, 1e-6).distance_sq.sqrt()).fold(f64::INFINITY, f64::min);
assert!(d <= 0.1 + 1e-6, "{p:?} is {d} away");
}
}
#[test]
fn degenerate_input_is_left_alone() {
let line = SubPath::polyline(&[(0.0, 0.0).into(), (1.0, 0.0).into()], false);
assert!(remove_anchor_keep_shape(&line, 0).is_none(), "two anchors stay");
let three = SubPath::polyline(&[(0.0, 0.0).into(), (1.0, 0.0).into(), (2.0, 0.0).into()], false);
assert!(remove_anchor_keep_shape(&three, 0).is_none(), "an open end stays");
assert!(remove_anchor_keep_shape(&three, 9).is_none(), "out of range");
assert_eq!(remove_anchor_keep_shape(&three, 1).unwrap().0.anchors.len(), 2);
let tri = SubPath::polyline(&[(0.0, 0.0).into(), (1.0, 0.0).into(), (0.0, 1.0).into()], true);
assert!(remove_anchor_keep_shape(&tri, 1).is_none(), "a closed path keeps three");
let nan = SubPath::polyline(&[(0.0, 0.0).into(), (f64::NAN, 0.0).into(), (2.0, 0.0).into()], false);
assert!(remove_anchor_keep_shape(&nan, 1).is_none());
for path in [PathData::default(), PathData::single(SubPath::default()), PathData::single(nan.clone()), PathData::single(three.clone())] {
// Compared as text: NaN never equals itself.
for tol in [f64::NAN, -1.0, 0.0, f64::INFINITY] {
assert_eq!(format!("{:?}", simplify_keep_shape(&path, tol, false)), format!("{path:?}"));
}
let _ = simplify_keep_shape(&path, 1.0, true);
}
assert_eq!(format!("{:?}", simplify_keep_shape(&PathData::single(nan.clone()), 1.0, false)), format!("{:?}", PathData::single(nan)));
}
}