Files
vectorcraft/crates/pathops/src/addons/keep_shape.rs
T
bflatastic ac85b529fe Add-ons: Artwork Cleanup — simplify keeping shape, health check, deep ungroup, rejoin
A built-in add-on under Object › Plug-ins › Artwork Cleanup:
- Simplify Anchors (Keep Shape) removes anchors while the outline stays
  within a tolerance, optionally keeping sharp corners.
- Document Health Check finds and fixes 16 kinds of problems in the
  selection or the document (stray points, duplicate and collinear
  anchors, tiny handles, nearly closed paths, needless groups, compound
  paths and clipping groups, unpainted and invisible objects, duplicate
  objects, art off every artboard, empty artboards…), with Show, Fix
  Selected and Fix All, each fix one undo step.
- Deep Ungroup and Rejoin Path Pieces.

The add-on lives in its own modules (pathops, engine and ui-egui
addons folders) and leaves the existing commands, tools and menus as
they were.
2026-10-30 13:11:20 +07:00

306 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;
/// 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.as_slice() {
[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())
}
/// 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)));
}
}