GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
//! HP-GL export: the visible art over a region as pen moves, for pen plotters and cutters.
//!
//! Every visible path is drawn once along its own line: its fills and strokes are not painted, so
//! a filled shape is its closed outline (what a cutter cuts) and a stroke is its center line. Each
//! color is a pen: by default pen 1 is the first color the plot draws in, pen 2 the next new one,
//! and so on; with a pen table each path takes the pen whose color is nearest its own. The plots
//! of one export ([`export_regions`]) share the numbering. A path's color is its topmost visible
//! stroke's, else its topmost visible fill's (one at 0% opacity does not count); a gradient is the
//! average of its stops and a pattern its first visible solid fill (gray without one). Curves are
//! flattened to straight moves within a tolerance. Type is drawn as its glyph outlines, a gradient
//! mesh as its outline in the average of its shown points' colors, clipping masks cut what they clip,
//! and the art is cut at the region's edges. Hidden and non-printing layers, hidden objects,
//! objects at 0% opacity, template layers, guides and placed images are left out.
//!
//! Coordinates are plotter units (1016 to the inch, y up) from the region's bottom-left corner or
//! its center, rounded to whole units. Art past ±8,388,607 units (2²³ − 1, the smallest range
//! the HP-GL/2 reference asks a device to take for encoded polylines) from the origin is cut off.
//! An HP-GL plot with a coordinate outside −32,768 to 32,767 (16-bit numbers, the range older
//! devices read) gets a warning; HP-GL/2's encoded polylines take the wider range.
//! The pens are drawn in turn (pen 1's paths, then pen 2's), each in paint order or, with
//! `sort`, each next path the one that starts nearest where the pen stopped. With `inside_first`,
//! a pen draws a path only after every path of its own that lies inside it (a letter's counter
//! before the letter, a hole before the part).
//!
//! HP-GL writes `IN;`, then for each pen `PU;SP<n>;` and per path `PUx,y;PDx,y,…;`, then `PU;SP0;`.
//! HP-GL/2 also writes the palette (`NP` and a `PC` color for each pen) and draws each pen's paths
//! as one encoded polyline (`PE`, base 64).

mod clip;
mod nest;

use std::cmp::Reverse;
use std::collections::{BinaryHeap, HashSet};
use std::sync::Arc;

use kurbo::PathEl;
use vectorcraft_color::Paint;
use vectorcraft_doc::{AppearanceItem, Document, Node, NodeKind, StrokeLayer, SymbolBoxes};
use vectorcraft_geom::{Affine, BezPath, FillRule, Point, Rect};

use crate::MAX_NEST;
use clip::Region;

/// Plotter units per point.
const PLU_PER_PT: f64 = 1016.0 / 72.0;
/// The largest coordinate written, plotter units.
pub const MAX_COORD: i64 = (1 << 23) - 1;
/// The coordinates an HP-GL plot keeps to without a warning: 16-bit numbers, plotter units.
const CLASSIC_RANGE: std::ops::RangeInclusive<i64> = -32_768..=32_767;
/// The curve tolerance a path is flattened to by default, points.
pub const DEFAULT_TOLERANCE: f64 = 0.1;
/// The smallest and largest curve tolerance, points.
pub const TOLERANCE_RANGE: std::ops::RangeInclusive<f64> = 0.01..=10.0;
/// The most pens: a pen table's length, and the colors that get a pen of their own.
pub const MAX_PENS: usize = 255;
/// The most points the plots of one export hold.
const MAX_POINTS: usize = if cfg!(test) { 100_000 } else { 10_000_000 };
/// The most work sorting paths and finding which lie inside others may take, over the whole plot:
/// one for each point or box compared.
const MAX_SORT_WORK: u64 = if cfg!(test) { 100_000 } else { 500_000_000 };
/// The most edge tests clipping masks may take, over the whole plot.
const MAX_CLIP_TESTS: u64 = if cfg!(test) { 1_000_000 } else { 200_000_000 };
/// The most points the clipping masks around an object may hold, together.
const MAX_MASK_POINTS: usize = if cfg!(test) { 10_000 } else { 10_000_000 };
/// The most objects live art (blends, envelopes, repeats) may make for a plot, together, as one
/// evaluation of live art may make ([`vectorcraft_doc::live::MAX_GENERATED`]).
const MAX_GENERATED: u64 = if cfg!(test) { 1_000 } else { vectorcraft_doc::live::MAX_GENERATED as u64 };

const TEXT_OUTLINES: &str = "type is plotted as its glyph outlines";
const INLINE_GRAPHICS: &str = "inline graphics in type are left out";
const IMAGES: &str = "placed images are left out: a pen draws only lines";
const MASKS: &str = "opacity masks are left out";
const RASTER_FX: &str = "raster effects (shadows, glows, blurs, feathering) are left out";
const STROKE_LOOK: &str = "stroke widths, dashes, brushes and arrowheads are left out: each path is drawn once along its own line";
const TOO_MANY_POINTS: &str = "the export is too large: the art past its first 10 million points was left out";
const CLIP_WORK: &str = "clipping masks are too complex to apply in full: the art past that point is drawn whole";
const MASK_POINTS: &str = "clipping masks past 10 million points together are left out: the art they clip is drawn unclipped by them";
const OUT_OF_RANGE: &str = "art past 8,388,607 plotter units (about 210 m) from the origin is cut off";
const PAST_CLASSIC_RANGE: &str = "the plot has coordinates past 32,767 plotter units (about 82 cm) from the origin, which older HP-GL devices may not read: HP-GL/2 takes a wider range";
const MANY_COLORS: &str = "the art has more than 255 colors: the colors past those draw with the pen of the nearest color";
const UNSORTED: &str = "the plot has too many paths to sort in full: the rest are drawn in paint order";
const UNSORTED_INSIDE: &str = "the plot has too many paths to sort in full: the rest are drawn in paint order, each after the paths inside it";
const UNNESTED: &str = "the plot has too many paths to find in full which lie inside others: from the pen where that stopped, a path may be drawn before the paths inside it";
const TOO_DEEP: &str = "symbols, blends, envelopes and repeats nested more than 8 deep were left out";
const LIVE_LEFT_OUT: &str = "blends, envelopes and repeats make too many objects: the art past 4 million objects was left out";
const SYMBOLS_LEFT_OUT: &str = "symbols placed inside symbols hold too many objects: the instances past that were left out";

/// The language written.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Version {
    /// `IN`, `SP`, `PU` and `PD` only.
    #[default]
    Hpgl,
    /// HP-GL/2: pen colors (`NP`, `PC`) and encoded polylines (`PE`).
    Hpgl2,
}

impl Version {
    pub const ALL: [Self; 2] = [Self::Hpgl, Self::Hpgl2];

    /// The `hpglVersion` param value.
    pub fn id(self) -> &'static str {
        match self {
            Self::Hpgl => "hpgl",
            Self::Hpgl2 => "hpgl2",
        }
    }

    pub fn label(self) -> &'static str {
        match self {
            Self::Hpgl => "HP-GL",
            Self::Hpgl2 => "HP-GL/2",
        }
    }

    /// A version by id (`hpgl`, `hpgl2`; `hp-gl` and `hp-gl/2` also read), any case.
    pub fn from_id(s: &str) -> Option<Self> {
        let s = s.trim();
        Self::ALL.into_iter().find(|v| s.eq_ignore_ascii_case(v.id()) || s.eq_ignore_ascii_case(v.label()))
    }
}

/// Where the plot's origin (0, 0) lies on the region.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Origin {
    #[default]
    BottomLeft,
    Center,
}

impl Origin {
    pub const ALL: [Self; 2] = [Self::BottomLeft, Self::Center];

    /// The `origin` param value.
    pub fn id(self) -> &'static str {
        match self {
            Self::BottomLeft => "bottomLeft",
            Self::Center => "center",
        }
    }

    /// An origin by id, any case.
    pub fn from_id(s: &str) -> Option<Self> {
        Self::ALL.into_iter().find(|o| s.trim().eq_ignore_ascii_case(o.id()))
    }
}

/// The HP-GL export settings.
#[derive(Clone, Debug)]
pub struct HpglOptions {
    pub version: Version,
    /// How far a flattened curve may lie from the curve, points ([`TOLERANCE_RANGE`]; a value
    /// outside it is an error).
    pub tolerance: f64,
    /// The pen table: pen 1's color first, up to [`MAX_PENS`] (more is an error). Empty: a pen for
    /// each color the art draws in.
    pub pens: Vec<[u8; 3]>,
    pub origin: Origin,
    /// Draw each pen's paths nearest first, instead of in paint order.
    pub sort: bool,
    /// Draw a path only after the pen's paths that lie inside it.
    pub inside_first: bool,
    /// The area plotted (document space): its bottom-left corner or center is the origin, and the
    /// art is cut at its edges.
    pub region: Rect,
}

impl Default for HpglOptions {
    fn default() -> Self {
        Self {
            version: Version::default(),
            tolerance: DEFAULT_TOLERANCE,
            pens: vec![],
            origin: Origin::default(),
            sort: false,
            inside_first: false,
            region: Rect::ZERO,
        }
    }
}

/// A written plot.
#[derive(Clone, Debug, Default)]
pub struct HpglOutput {
    pub bytes: Vec<u8>,
    /// The pens' colors, pen 1's first.
    pub pens: Vec<[u8; 3]>,
    /// What was approximated or left out.
    pub warnings: Vec<String>,
    /// Notes on the options: sorting the paths or drawing the inner paths first was applied only
    /// in part.
    pub setting_notes: Vec<String>,
}

/// Write the visible art of `doc` over `opts.region` as an HP-GL plot. Live geometry effects are
/// applied first.
pub fn export(doc: &Document, opts: &HpglOptions) -> Result<HpglOutput, String> {
    Ok(export_regions(doc, opts, &[opts.region])?.pop().unwrap_or_default())
}

/// An error unless a plot can cover `region`: its corners are finite and it has a width and a
/// height (either corner may come first).
pub fn check_region(region: Rect) -> Result<(), String> {
    let r = region.abs();
    if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) || r.width() <= 0.0 || r.height() <= 0.0 {
        return Err("the export region is empty".into());
    }
    Ok(())
}

/// Write the visible art of `doc` over each of `regions` as an HP-GL plot, one per region, as
/// [`export`] does with `opts.region`. The plots share one pen numbering, so a color is the same
/// pen in each, and one point budget.
pub fn export_regions(doc: &Document, opts: &HpglOptions, regions: &[Rect]) -> Result<Vec<HpglOutput>, String> {
    for r in regions {
        check_region(*r)?;
    }
    let regions: Vec<Rect> = regions.iter().map(|r| r.abs()).collect();
    if !TOLERANCE_RANGE.contains(&opts.tolerance) {
        return Err("the curve tolerance must be from 0.01 to 10 points".into());
    }
    if opts.pens.len() > MAX_PENS {
        return Err("the pen table holds more than 255 pens".into());
    }
    let tolerance = opts.tolerance;
    // Layers the plot leaves out go first: baking can wrap one in art that would be drawn (its
    // crop marks).
    let shown = plotted(&doc.layers, false).map(|layers| {
        let mut d = doc.clone();
        d.layers = layers;
        d
    });
    let doc = shown.as_ref().unwrap_or(doc);
    let baked = vectorcraft_effects::bake_document(doc);
    let doc = baked.as_ref().unwrap_or(doc);
    // Each plot's lines in plotter units, with the points a move doesn't change dropped, and its
    // warnings.
    let mut plots: Vec<(Lines, Vec<String>)> = Vec::with_capacity(regions.len());
    let mut points = 0;
    for r in regions {
        // Document space to plotter units, y up.
        let o = match opts.origin {
            Origin::BottomLeft => Point::new(r.x0, r.y1),
            Origin::Center => r.center(),
        };
        let span = MAX_COORD as f64 / PLU_PER_PT;
        let range = Rect::new(o.x - span, o.y - span, o.x + span, o.y + span);
        let mut walk = Walk::new(doc, r.intersect(range), tolerance);
        walk.points = points;
        // Only a region past the range can have art the range cuts off.
        if r.intersect(range) != r {
            walk.range = Some((range, r));
            walk.asked = Region::new(vec![corners(r)], FillRule::NonZero);
        }
        for l in &doc.layers {
            walk.node(l, false);
        }
        points = walk.points;
        let Walk { runs, warnings, .. } = walk;
        let to_plu = |p: Point| {
            let x = ((p.x - o.x) * PLU_PER_PT).round().clamp(-(MAX_COORD as f64), MAX_COORD as f64) as i64;
            let y = ((o.y - p.y) * PLU_PER_PT).round().clamp(-(MAX_COORD as f64), MAX_COORD as f64) as i64;
            (x, y)
        };
        let lines = runs
            .into_iter()
            .filter_map(|run| {
                let mut pts: Vec<(i64, i64)> = Vec::with_capacity(run.points.len());
                for p in run.points {
                    let q = to_plu(p);
                    if pts.last() != Some(&q) {
                        pts.push(q);
                    }
                }
                // A line shorter than a plotter unit draws nothing and takes no pen.
                (pts.len() >= 2).then_some((run.rgb, pts))
            })
            .collect();
        plots.push((lines, warnings));
    }
    let mut pen_warnings = vec![];
    let colors: Vec<[u8; 3]> = plots.iter().flat_map(|(lines, _)| lines.iter().map(|(c, _)| *c)).collect();
    let (pens, of_line) = assign_pens(&colors, &opts.pens, &mut pen_warnings);
    let mut of_line = of_line.into_iter();
    let mut out = Vec::with_capacity(plots.len());
    for (lines, mut warnings) in plots {
        let mut by_pen: Vec<Vec<Vec<(i64, i64)>>> = vec![vec![]; pens.len()];
        for ((_, pts), pen) in lines.into_iter().zip(of_line.by_ref()) {
            if let Some(paths) = by_pen.get_mut(pen) {
                paths.push(pts);
            }
        }
        if !by_pen.iter().all(Vec::is_empty) {
            pen_warnings.iter().for_each(|w| warn(&mut warnings, w));
        }
        let mut setting_notes = vec![];
        if opts.sort || opts.inside_first {
            let (mut at, mut work) = ((0, 0), MAX_SORT_WORK);
            for paths in &mut by_pen {
                at = reorder(paths, at, &mut work, opts.sort, opts.inside_first, &mut setting_notes);
            }
        }
        if opts.version == Version::Hpgl && by_pen.iter().flatten().flatten().any(|(x, y)| !CLASSIC_RANGE.contains(x) || !CLASSIC_RANGE.contains(y)) {
            warn(&mut warnings, PAST_CLASSIC_RANGE);
        }
        let bytes = match opts.version {
            Version::Hpgl => plain(&by_pen),
            Version::Hpgl2 => encoded(&by_pen, &pens),
        };
        out.push(HpglOutput { bytes, pens: pens.clone(), warnings, setting_notes });
    }
    Ok(out)
}

/// A plot's lines in plotter units, each with its color.
type Lines = Vec<([u8; 3], Vec<(i64, i64)>)>;

fn warn(warnings: &mut Vec<String>, w: &str) {
    if !warnings.iter().any(|x| x == w) {
        warnings.push(w.to_string());
    }
}

/// The corners of `r`, as a clipping ring.
fn corners(r: Rect) -> Vec<Point> {
    vec![Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)]
}

/// Does `r` hold `p`, its edges included?
fn holds(r: Rect, p: Point) -> bool {
    p.x >= r.x0 && p.x <= r.x1 && p.y >= r.y0 && p.y <= r.y1
}

/// The pens and each line's pen (0-based), from the lines' `colors`: with a table, the table and
/// the nearest of its colors; else each new color a pen of its own, up to [`MAX_PENS`], and the
/// nearest after that.
fn assign_pens(colors: &[[u8; 3]], table: &[[u8; 3]], warnings: &mut Vec<String>) -> (Vec<[u8; 3]>, Vec<usize>) {
    let mut pens: Vec<[u8; 3]> = table.iter().take(MAX_PENS).copied().collect();
    let fixed = !pens.is_empty();
    let mut of_line = Vec::with_capacity(colors.len());
    for &rgb in colors {
        let pen = match pens.iter().position(|c| *c == rgb) {
            Some(i) => i,
            None if !fixed && pens.len() < MAX_PENS => {
                pens.push(rgb);
                pens.len() - 1
            }
            None => {
                if !fixed {
                    warn(warnings, MANY_COLORS);
                }
                nearest(&pens, rgb)
            }
        };
        of_line.push(pen);
    }
    (pens, of_line)
}

/// The index of the color in `pens` nearest `c` (the first of equally near ones).
fn nearest(pens: &[[u8; 3]], c: [u8; 3]) -> usize {
    let d = |p: &[u8; 3]| (0..3).map(|i| (i32::from(p[i]) - i32::from(c[i])).pow(2)).sum::<i32>();
    pens.iter().enumerate().min_by_key(|(_, p)| d(p)).map_or(0, |(i, _)| i)
}

fn dist2(a: (i64, i64), b: (i64, i64)) -> i128 {
    let (dx, dy) = (i128::from(a.0) - i128::from(b.0), i128::from(a.1) - i128::from(b.1));
    dx * dx + dy * dy
}

/// The squared distance from `p` to box `b` (`[x0, y0, x1, y1]`), 0 inside it.
fn box_dist2(p: (i64, i64), b: [i64; 4]) -> i128 {
    let d = |v: i64, lo: i64, hi: i64| i128::from(lo.saturating_sub(v).max(v.saturating_sub(hi)).max(0));
    let (dx, dy) = (d(p.0, b[0], b[2]), d(p.1, b[1], b[3]));
    dx * dx + dy * dy
}

/// `paths` (one pen's) reordered from `at`. With `nearest`, each next path is the one nearest
/// where the pen stopped, by its start or, for an open path (then drawn backwards), its end, or
/// for a closed path any of its points (where it then starts); without, the first in paint order.
/// With `inside_first`, a path is drawn only once every path lying inside it ([`nest::outer`]) is.
/// Once `work` is spent, the paths left keep paint order, each after the paths inside it with
/// `inside_first`, with a note in `notes`. Returns where the pen stops.
fn reorder(
    paths: &mut Vec<Vec<(i64, i64)>>,
    mut at: (i64, i64),
    work: &mut u64,
    nearest: bool,
    inside_first: bool,
    notes: &mut Vec<String>,
) -> (i64, i64) {
    let boxes: Vec<[i64; 4]> = paths.iter().map(|p| nest::bounds(p)).collect();
    // The paths each path lies inside, and how many paths inside each are still to draw.
    let outer = inside_first.then(|| nest::outer(paths, &boxes, work)).flatten();
    if inside_first && outer.is_none() {
        warn(notes, UNNESTED);
    }
    let mut waiting = vec![0usize; paths.len()];
    for o in outer.iter().flatten().flatten() {
        if let Some(w) = waiting.get_mut(*o) {
            *w += 1;
        }
    }
    if !nearest {
        if let Some(outer) = &outer {
            let all = std::mem::take(paths).into_iter().enumerate().collect();
            inner_first(all, outer, &mut waiting, paths);
        }
        return at;
    }
    // Each path with its index and box.
    let mut left: Vec<_> = std::mem::take(paths).into_iter().zip(boxes).enumerate().map(|(i, (p, b))| (i, p, b)).collect();
    while !left.is_empty() {
        // (index, reversed, the closed path's point to start at, distance)
        let mut best: (usize, bool, Option<usize>, i128) = (usize::MAX, false, None, i128::MAX);
        for (i, (j, p, b)) in left.iter().enumerate() {
            let (Some(&s), Some(&e)) = (p.first(), p.last()) else { continue };
            *work = work.saturating_sub(1);
            if waiting.get(*j).is_some_and(|w| *w > 0) {
                continue;
            }
            if s == e && p.len() > 2 {
                if box_dist2(at, *b) >= best.3 {
                    continue;
                }
                *work = work.saturating_sub(p.len() as u64);
                if let Some((k, d)) = p.iter().enumerate().map(|(k, q)| (k, dist2(at, *q))).min_by_key(|(_, d)| *d)
                    && d < best.3
                {
                    best = (i, false, Some(k), d);
                }
                continue;
            }
            let (ds, de) = (dist2(at, s), dist2(at, e));
            if ds < best.3 {
                best = (i, false, None, ds);
            }
            if de < best.3 {
                best = (i, true, None, de);
            }
        }
        // Spent, or no path free to draw (which only a fault could cause): the rest in paint
        // order, each after the paths inside it.
        if *work == 0 || best.0 >= left.len() {
            match &outer {
                Some(outer) => {
                    warn(notes, UNSORTED_INSIDE);
                    inner_first(left.into_iter().map(|(j, p, _)| (j, p)).collect(), outer, &mut waiting, paths);
                }
                None => {
                    warn(notes, UNSORTED);
                    paths.extend(left.into_iter().map(|(_, p, _)| p));
                }
            }
            return at;
        }
        let (j, mut p, _) = left.remove(best.0);
        for o in outer.as_ref().and_then(|outer| outer.get(j)).into_iter().flatten() {
            if let Some(w) = waiting.get_mut(*o) {
                *w = w.saturating_sub(1);
            }
        }
        if best.1 {
            p.reverse();
        } else if let Some(k) = best.2 {
            // A closed path starts at its point nearest the pen.
            p.pop();
            let k = k.min(p.len().saturating_sub(1));
            p.rotate_left(k);
            if let Some(&s) = p.first() {
                p.push(s);
            }
        }
        if let Some(&e) = p.last() {
            at = e;
        }
        paths.push(p);
    }
    at
}

/// Appends `left` (each path with its index among the pen's paths) to `paths` in paint order,
/// each after the paths lying inside it: `outer` lists the paths each lies inside, and `waiting`
/// counts, for each, the paths inside it still to draw. [`nest::outer`] puts a path only inside
/// larger ones, so every path comes free; a path left waiting by a fault is drawn last.
fn inner_first(left: Vec<(usize, Vec<(i64, i64)>)>, outer: &[Vec<usize>], waiting: &mut [usize], paths: &mut Vec<Vec<(i64, i64)>>) {
    let mut held: Vec<Option<Vec<(i64, i64)>>> = (0..outer.len()).map(|_| None).collect();
    let mut free = BinaryHeap::new();
    for (j, p) in left {
        if let Some(h) = held.get_mut(j) {
            if waiting.get(j).is_none_or(|w| *w == 0) {
                free.push(Reverse(j));
            }
            *h = Some(p);
        } else {
            paths.push(p);
        }
    }
    while let Some(Reverse(j)) = free.pop() {
        let Some(p) = held.get_mut(j).and_then(Option::take) else { continue };
        paths.push(p);
        for &o in outer.get(j).into_iter().flatten() {
            if let Some(w) = waiting.get_mut(o) {
                *w = w.saturating_sub(1);
                if *w == 0 {
                    free.push(Reverse(o));
                }
            }
        }
    }
    paths.extend(held.into_iter().flatten());
}

/// HP-GL: `IN;`, each pen's paths as `PU` and `PD`, `PU;SP0;`.
fn plain(by_pen: &[Vec<Vec<(i64, i64)>>]) -> Vec<u8> {
    let mut s = String::from("IN;");
    for (i, paths) in by_pen.iter().enumerate().filter(|(_, p)| !p.is_empty()) {
        s.push_str(&format!("PU;SP{};", i + 1));
        for path in paths {
            let Some(((x, y), rest)) = path.split_first() else { continue };
            s.push_str(&format!("PU{x},{y};PD"));
            for (k, (x, y)) in rest.iter().enumerate() {
                if k > 0 {
                    s.push(',');
                }
                s.push_str(&format!("{x},{y}"));
            }
            s.push(';');
        }
    }
    s.push_str("PU;SP0;");
    s.into_bytes()
}

/// HP-GL/2: `IN;`, the palette, each pen's paths as one `PE`, `PU;SP0;`.
fn encoded(by_pen: &[Vec<Vec<(i64, i64)>>], pens: &[[u8; 3]]) -> Vec<u8> {
    let mut out = b"IN;".to_vec();
    if !pens.is_empty() {
        // Pens 1 to n on a plotter, and on a raster device (whose pens are 0 to NP − 1) too.
        let np = (pens.len() + 1).next_power_of_two().max(2);
        out.extend(format!("NP{np};").bytes());
        for (i, [r, g, b]) in pens.iter().enumerate() {
            out.extend(format!("PC{},{r},{g},{b};", i + 1).bytes());
        }
    }
    let mut at: Option<(i64, i64)> = None;
    for (i, paths) in by_pen.iter().enumerate().filter(|(_, p)| !p.is_empty()) {
        out.extend(format!("PU;SP{};PE", i + 1).bytes());
        for path in paths {
            for (k, &p) in path.iter().enumerate() {
                if k == 0 {
                    out.push(b'<');
                }
                // The first move of the plot is absolute, and so is one longer than the range a
                // device takes for each number; every other is relative.
                match at.map(|a| (p.0 - a.0, p.1 - a.1)).filter(|d| d.0.abs() <= MAX_COORD && d.1.abs() <= MAX_COORD) {
                    None => {
                        out.push(b'=');
                        pe_number(&mut out, p.0);
                        pe_number(&mut out, p.1);
                    }
                    Some((dx, dy)) => {
                        pe_number(&mut out, dx);
                        pe_number(&mut out, dy);
                    }
                }
                at = Some(p);
            }
        }
        out.push(b';');
    }
    out.extend(b"PU;SP0;");
    out
}

/// `v` as a base-64 PE number: the sign in the low bit, the low digits from 63 up and the last
/// digit from 191 up.
fn pe_number(out: &mut Vec<u8>, v: i64) {
    let mut n = (v.unsigned_abs() << 1) | u64::from(v < 0);
    while n >= 64 {
        out.push(63 + (n % 64) as u8);
        n /= 64;
    }
    out.push(191 + n as u8);
}

/// One line the pen draws, in document space, and its color.
struct Run {
    rgb: [u8; 3],
    points: Vec<Point>,
}

/// The document walk: each visible path becomes runs, clipped, in paint order.
struct Walk<'a> {
    doc: &'a Document,
    symbols: SymbolBoxes<'a>,
    /// The region the art is cut at.
    region: Rect,
    edge: Option<Region>,
    /// The plotter's range and the region asked for, when that reaches past the range.
    range: Option<(Rect, Rect)>,
    /// The region asked for, to cut a line at before testing it against the range.
    asked: Option<Region>,
    tolerance: f64,
    /// The clipping masks around the current object, outermost first.
    clips: Vec<Region>,
    /// The points those masks hold ([`MAX_MASK_POINTS`]).
    mask_points: usize,
    /// Set while the stroke pieces of a clipping path whose fill paints are drawn: they close, as
    /// its fill closes its outline.
    closing: bool,
    runs: Vec<Run>,
    points: usize,
    clip_tests: u64,
    warnings: Vec<String>,
    nest: u32,
    /// Objects the symbol instances written held, together ([`vectorcraft_doc::MAX_SYMBOL_NODES`]).
    symbol_nodes: u64,
    /// Objects the live art written made, together ([`MAX_GENERATED`]).
    generated: u64,
    /// A copy of the document without its layers, to bake symbol art in ([`Walk::baked`]).
    scratch: Option<Document>,
    /// The symbols whose art holds geometry effects ([`Walk::baked`]), or instances of such
    /// symbols.
    effect_symbols: HashSet<String>,
}

impl<'a> Walk<'a> {
    fn new(doc: &'a Document, region: Rect, tolerance: f64) -> Self {
        Self {
            doc,
            symbols: doc.symbol_boxes().quick(),
            region,
            edge: Region::new(vec![corners(region)], FillRule::NonZero),
            range: None,
            asked: None,
            tolerance,
            clips: vec![],
            mask_points: 0,
            closing: false,
            runs: vec![],
            points: 0,
            clip_tests: 0,
            warnings: vec![],
            nest: 0,
            symbol_nodes: 0,
            generated: 0,
            scratch: None,
            effect_symbols: effect_symbols(doc),
        }
    }

    fn warn(&mut self, w: &str) {
        warn(&mut self.warnings, w);
    }

    fn full(&self) -> bool {
        self.points >= MAX_POINTS
    }

    fn node(&mut self, n: &Node, force: bool) {
        if n.is_ruler_guide() || n.is_template() {
            return;
        }
        if self.full() {
            self.warn(TOO_MANY_POINTS);
            return;
        }
        if !force && !n.visible {
            return;
        }
        // Art at no opacity shows nothing, and nor does anything inside it.
        if n.opacity <= 0.0 {
            return;
        }
        // Bounds don't measure the effects in symbol art, which apply only once an instance is
        // placed: an instance of such art, and what holds one, is not skipped by its bounds.
        let unmeasured = !self.effect_symbols.is_empty() && holds_instance_of(n, &self.effect_symbols);
        // The box round all the object can paint, a blend's steps on its spine included.
        if !n.is_layer() && !unmeasured {
            match n.reach_bounds_with(&self.symbols) {
                Some(b) if !overlaps(b, self.region) => {
                    // Art over the asked-for region but past the plotter's range is cut off.
                    if self.range.is_some_and(|(_, whole)| overlaps(b, whole)) {
                        self.warn(OUT_OF_RANGE);
                    }
                    return;
                }
                None if !n.is_container() => return,
                _ => {}
            }
        }
        if n.extras().mask.as_ref().is_some_and(|m| !m.disabled) {
            self.warn(MASKS);
        }
        let raster = |fx: &[vectorcraft_doc::Effect]| fx.iter().any(|e| e.visible && vectorcraft_effects::is_raster(&e.id));
        if raster(&n.appearance.effects) || n.appearance.items.iter().any(|i| raster(i.effects())) {
            self.warn(RASTER_FX);
        }
        match &n.kind {
            // Non-printing layers aren't plotted.
            NodeKind::Layer { children, printable, clip, .. } => {
                if *printable {
                    self.children(children, *clip);
                }
            }
            NodeKind::Group { children, clip } => self.children(children, *clip),
            NodeKind::Path { path, guide, .. } => {
                if !*guide {
                    self.shape(n, &path.to_bezpath());
                }
            }
            NodeKind::Compound { children, .. } => {
                let mut bp = BezPath::new();
                for p in children.iter().filter_map(|c| c.path_data()) {
                    bp.extend(p.to_bezpath());
                }
                self.shape(n, &bp);
            }
            NodeKind::Text(t) => {
                if t.runs.iter().any(|r| r.inline.is_some()) {
                    self.warn(INLINE_GRAPHICS);
                }
                if let Some(o) = vectorcraft_effects::outline_text(n) {
                    self.warn(TEXT_OUTLINES);
                    self.node(&o, true);
                }
            }
            NodeKind::Image(_) => self.warn(IMAGES),
            NodeKind::SymbolInstance { symbol, xf } => self.symbol(n, symbol, *xf),
            // A gradient mesh is its outline, in the average of its shown points' colors: its
            // patches are shading, not lines. A mesh whose every point is at 0% opacity shows
            // nothing.
            NodeKind::Mesh(m) => {
                let shown: Vec<[u8; 3]> = m.points.iter().filter(|p| p.opacity > 0.0).map(|p| rgb8(&p.color)).collect();
                if !shown.is_empty() {
                    self.draw(average(shown.into_iter()), &m.outline().to_bezpath(), true);
                }
            }
            // Live blends, envelopes and repeats are drawn as their evaluated art, a level at a
            // time, so a gradient mesh a blend makes is its outline too.
            NodeKind::Blend { .. } | NodeKind::Envelope { .. } | NodeKind::Repeat(_) | NodeKind::PlacedDocument(_) | NodeKind::Intertwine { .. } => {
                if self.nest >= MAX_NEST {
                    self.warn(TOO_DEEP);
                    return;
                }
                // Once the budget is spent, nothing more is evaluated.
                if self.generated >= MAX_GENERATED {
                    self.warn(LIVE_LEFT_OUT);
                    return;
                }
                let art = vectorcraft_effects::expand_live(Some(self.doc), n);
                let count = art.iter().map(|c| c.count() as u64).sum::<u64>();
                if self.generated.saturating_add(count) > MAX_GENERATED {
                    self.generated = MAX_GENERATED;
                    self.warn(LIVE_LEFT_OUT);
                    return;
                }
                self.generated += count;
                self.nest += 1;
                art.iter().for_each(|c| self.node(c, false));
                self.nest -= 1;
            }
            NodeKind::RulerGuide { .. } => {}
        }
    }

    /// A symbol instance's art, placed (clip groups included), within the budget for the export.
    fn symbol(&mut self, n: &Node, symbol: &str, xf: Affine) {
        let doc = self.doc;
        if self.symbol_nodes >= vectorcraft_doc::MAX_SYMBOL_NODES {
            self.warn(SYMBOLS_LEFT_OUT);
            return;
        }
        let Some(sym) = doc.symbols.iter().find(|s| s.name == symbol) else { return };
        if self.nest >= MAX_NEST {
            self.warn(TOO_DEEP);
            return;
        }
        // The instance's own changes and its stain, as the canvas draws it.
        let art = vectorcraft_brush::instance_art(&sym.art, n);
        let count = art.count_with_masks() as u64;
        let most = doc.symbol_slice_map(symbol, xf).map_or(count, |m| m.most_placed(&art, doc));
        let placed = vectorcraft_doc::charge_symbol_art(&mut self.symbol_nodes, most, || {
            let placed = doc.place_symbol_art(symbol, &art, xf);
            let n = placed.as_ref().map_or(0, |a| a.count_with_masks() as u64);
            (placed, n)
        });
        match placed {
            Some(Some(art)) => {
                let art = self.baked(art);
                self.nest += 1;
                self.node(&art, true);
                self.nest -= 1;
            }
            Some(None) => {}
            None => {
                self.symbol_nodes = vectorcraft_doc::MAX_SYMBOL_NODES;
                self.warn(SYMBOLS_LEFT_OUT);
            }
        }
    }

    /// Placed symbol art with its geometry effects applied: the document's bake reaches the
    /// layers, not the symbols' art.
    fn baked(&mut self, art: Node) -> Node {
        if !vectorcraft_effects::needs_bake(&art) {
            return art;
        }
        // Guides and layers left out go first, as for the document's layers.
        let art = Arc::new(art);
        let art = match plotted(std::slice::from_ref(&art), false) {
            Some(mut kept) => match kept.pop() {
                Some(a) => a,
                None => return Node::group(vectorcraft_doc::NodeId(0), vec![]),
            },
            None => art,
        };
        let art = Arc::unwrap_or_clone(art);
        let doc = self.doc;
        let scratch = self.scratch.get_or_insert_with(|| {
            let mut d = doc.clone();
            d.layers.clear();
            d
        });
        scratch.layers = vec![Arc::new(art)];
        let baked = vectorcraft_effects::bake_document(scratch).and_then(|b| b.layers.into_iter().next());
        let art = std::mem::take(&mut scratch.layers).into_iter().next();
        baked.or(art).map(Arc::unwrap_or_clone).unwrap_or_else(|| Node::group(vectorcraft_doc::NodeId(0), vec![]))
    }

    /// A container's children. A clipping container's first child cuts the rest; it is drawn
    /// itself, once and whole, when it paints: where its stroke paints (over the clipped art) when
    /// it has one, else where its fill paints (below it). Nothing to clip by hides the clipped art,
    /// as on the canvas.
    fn children(&mut self, children: &[Arc<Node>], clip: bool) {
        let Some((first, rest)) = children.split_first().filter(|_| clip) else {
            children.iter().for_each(|c| self.node(c, false));
            return;
        };
        let mut paint = first.clip_paint();
        // A stroke at 0% opacity isn't drawn, so the clipping path is drawn in its fill.
        let type_stroke = |s: &Node| matches!(&s.kind, NodeKind::Text(t) if t.runs.iter().any(|r| r.style.has_stroke()));
        // The strokes of a clipping path whose stroke effects were applied are a group of pieces,
        // which effects around it may have put in groups of their own.
        paint.stroke = paint.stroke.filter(|s| top_stroke(s).is_some() || type_stroke(s) || strokes_in_pieces(s));
        if paint.stroke.is_none()
            && let Some(fill) = &paint.fill
        {
            self.node(fill, false);
        }
        match vectorcraft_effects::clip_outline(first).map(|(bp, rule)| (self.rings(&bp), rule)) {
            Some((Some(rings), rule)) => {
                let held: usize = rings.iter().map(Vec::len).sum();
                if let Some(region) = Region::new(rings, rule) {
                    self.mask_points += held;
                    self.clips.push(region);
                    rest.iter().for_each(|c| self.node(c, false));
                    self.clips.pop();
                    self.mask_points -= held;
                }
            }
            // A mask past the budget isn't built: the art it would clip is drawn unclipped by it.
            Some((None, _)) => {
                self.warn(MASK_POINTS);
                rest.iter().for_each(|c| self.node(c, false));
            }
            None => {}
        }
        // Drawn whole where its stroke paints: a fill closes its outline, and type's characters
        // without a stroke are drawn too. Pieces of a clipping path whose fill and stroke effects
        // were applied are drawn in its stroke pieces alone, closed where its fill paints.
        if let Some(stroke) = &paint.stroke {
            if first.extras().clip_pieces {
                let closing = std::mem::replace(&mut self.closing, paint.fill.as_ref().is_some_and(fills_in_pieces));
                self.node(stroke, false);
                self.closing = closing;
            } else {
                self.node(first, false);
            }
        }
    }

    /// `bp` flattened into closed rings for a clipping mask; `None` when they would take the
    /// masks around it past [`MAX_MASK_POINTS`].
    fn rings(&self, bp: &BezPath) -> Option<Vec<Vec<Point>>> {
        let left = MAX_MASK_POINTS.saturating_sub(self.mask_points);
        let (mut rings, whole) = self.flatten_within(bp, true, left);
        if !whole || rings.iter().map(Vec::len).sum::<usize>() > left {
            return None;
        }
        for r in &mut rings {
            r.pop();
        }
        Some(rings)
    }

    /// A path drawn in its color: the topmost stroke's that paints, else the topmost fill's that
    /// paints (visible, with a paint and some opacity). A filled path's every subpath is closed,
    /// as its fill closes it, also when its stroke gives the color, and so is each stroke piece
    /// of a clipping path whose fill paints ([`Walk::closing`]).
    fn shape(&mut self, n: &Node, bp: &BezPath) {
        if bp.elements().is_empty() {
            return;
        }
        let fill = top_fill(n);
        let paint = match (top_stroke(n), fill) {
            (Some(s), _) => {
                if s.dash.as_ref().is_some_and(|d| d.is_dashed())
                    || s.brush.is_some()
                    || s.profile.is_some()
                    || s.start_arrow.is_some()
                    || s.end_arrow.is_some()
                {
                    self.warn(STROKE_LOOK);
                }
                &s.paint
            }
            (None, Some(f)) => f,
            (None, None) => return,
        };
        let rgb = self.flat(paint);
        self.draw(rgb, bp, fill.is_some() || self.closing);
    }

    /// `bp` drawn in `rgb`: flattened (with `close` every subpath closed), then cut and added.
    fn draw(&mut self, rgb: [u8; 3], bp: &BezPath, close: bool) {
        // Bounded by the plot's point budget; each curve by its own segment cap.
        let budget = MAX_POINTS.saturating_sub(self.points).saturating_mul(4).max(4);
        let (lines, whole) = self.flatten_within(bp, close, budget);
        if !whole {
            self.warn(TOO_MANY_POINTS);
        }
        for line in lines {
            self.add(rgb, line);
        }
    }

    /// One color for a paint: a solid color, the average of a gradient's stops, or a pattern's
    /// first solid fill (gray without one).
    fn flat(&self, p: &Paint) -> [u8; 3] {
        match p {
            Paint::None => [0; 3],
            Paint::Solid { color, .. } => rgb8(color),
            Paint::Gradient(g) => average(g.gradient.stops.iter().map(|s| rgb8(&s.color))),
            Paint::Pattern { pattern, .. } => {
                self.doc.pattern(pattern).and_then(|def| def.art.iter().find_map(|a| first_solid(a))).map_or([128; 3], |c| rgb8(&c))
            }
        }
    }

    /// `bp` as polylines (each subpath one), within the tolerance, stopping once about `budget`
    /// moves are made; with `close` every subpath ends at its start, else those that close. Also
    /// whether every element of `bp` was flattened.
    fn flatten_within(&self, bp: &BezPath, close: bool, budget: usize) -> (Vec<Vec<Point>>, bool) {
        let mut out: Vec<Vec<Point>> = vec![];
        let mut cur: Vec<Point> = vec![];
        let end = |cur: &mut Vec<Point>, out: &mut Vec<Vec<Point>>, closing: bool| {
            if (closing || close)
                && let Some(&s) = cur.first()
                && cur.last() != Some(&s)
            {
                cur.push(s);
            }
            out.push(std::mem::take(cur));
        };
        let (made, taken) = (std::cell::Cell::new(0usize), std::cell::Cell::new(0usize));
        let elements = bp.iter().take_while(|_| made.get() < budget).inspect(|_| taken.set(taken.get() + 1));
        vectorcraft_geom::flatten(elements, self.tolerance, |el| {
            made.set(made.get() + 1);
            match el {
                PathEl::MoveTo(p) => {
                    end(&mut cur, &mut out, false);
                    cur.push(p);
                }
                PathEl::LineTo(p) => {
                    if cur.last() != Some(&p) {
                        cur.push(p);
                    }
                }
                PathEl::ClosePath => {
                    let s = cur.first().copied();
                    end(&mut cur, &mut out, true);
                    // A subpath that goes on after its close starts where it closed.
                    if let Some(s) = s {
                        cur.push(s);
                    }
                }
                _ => {}
            }
        });
        let whole = taken.get() == bp.elements().len();
        // A subpath the budget cut short stays open: a move back to its start isn't on its outline.
        if whole {
            end(&mut cur, &mut out, false);
        } else {
            out.push(cur);
        }
        out.retain(|l| l.len() >= 2);
        (out, whole)
    }

    /// A polyline drawn in `rgb`, cut by the region and the clipping masks around it.
    fn add(&mut self, rgb: [u8; 3], line: Vec<Point>) {
        // Only the part over the region asked for counts: the rest is cut off anyway.
        if let (Some((range, _)), Some(asked)) = (self.range, &self.asked)
            && !self.warnings.iter().any(|w| w == OUT_OF_RANGE)
        {
            let mut unlimited = u64::MAX;
            if asked.cut(&line, &mut unlimited).unwrap_or_default().iter().flatten().any(|p| !holds(range, *p)) {
                self.warn(OUT_OF_RANGE);
            }
        }
        // The region has four edges, so its cut costs a few tests a point and needs no limit.
        let mut unlimited = u64::MAX;
        let mut pieces = self.edge.as_ref().and_then(|edge| edge.cut(&line, &mut unlimited)).unwrap_or_default();
        for clip in &self.clips {
            let mut left = MAX_CLIP_TESTS.saturating_sub(self.clip_tests);
            let cut: Option<Vec<Vec<Vec<Point>>>> = pieces.iter().map(|p| clip.cut(p, &mut left)).collect();
            self.clip_tests = MAX_CLIP_TESTS.saturating_sub(left);
            match cut {
                Some(cut) => pieces = cut.into_iter().flatten().collect(),
                None => {
                    // Spent: this art keeps the parts this mask and the ones inside it would cut,
                    // and later art that reaches a mask isn't clipped either.
                    self.clip_tests = MAX_CLIP_TESTS;
                    warn(&mut self.warnings, CLIP_WORK);
                    break;
                }
            }
        }
        for mut points in pieces {
            let left = MAX_POINTS.saturating_sub(self.points);
            if points.len() > left {
                self.warn(TOO_MANY_POINTS);
                points.truncate(left);
            }
            if points.len() < 2 {
                return;
            }
            self.points += points.len();
            self.runs.push(Run { rgb, points });
        }
    }
}

fn overlaps(a: Rect, b: Rect) -> bool {
    a.x0 <= b.x1 && b.x0 <= a.x1 && a.y0 <= b.y1 && b.y0 <= a.y1
}

/// Whether a plot draws nothing of `n` wherever it is, apart from what every export leaves out
/// (hidden objects, guides and template layers): an object at 0% opacity, a non-printing layer, a
/// placed image, a gradient mesh whose every point is at 0% opacity, or a path or compound path
/// without effects whose fills and strokes paint nothing. An image or a mesh in `doc` with a
/// visible Crop Marks effect, or with a Vector Halftone effect that makes dots, is not one of them.
/// A clipping path still clips when the plot draws nothing of it.
pub fn plots_nothing(doc: &Document, n: &Node) -> bool {
    let unpainted = || n.appearance.effects.is_empty() && top_stroke(n).is_none() && top_fill(n).is_none();
    let dots = || vectorcraft_effects::addons::halftone::halftone_art(doc, n).is_some_and(|g| g.children().is_some_and(|c| !c.is_empty()));
    let adds_art = || vectorcraft_effects::has_crop_marks(n) || dots();
    n.opacity <= 0.0
        || match &n.kind {
            NodeKind::Layer { printable, .. } => !printable,
            NodeKind::Image(_) => !adds_art(),
            NodeKind::Mesh(m) => !adds_art() && m.points.iter().all(|p| p.opacity <= 0.0),
            NodeKind::Path { .. } | NodeKind::Compound { .. } => unpainted(),
            _ => false,
        }
}

/// `nodes` (the children of a clipping container when `clipping`) without the layers and
/// sublayers a plot leaves out (hidden, non-printing, template or at 0% opacity) and without
/// guides, in layers and groups at any depth, so that baking can't wrap one in art that is drawn
/// (its Crop Marks); `None` when nothing changes. A guide that is a clipping path keeps its place
/// without its effects.
fn plotted(nodes: &[Arc<Node>], clipping: bool) -> Option<Vec<Arc<Node>>> {
    let mut changed = false;
    let mut out = Vec::with_capacity(nodes.len());
    for (i, n) in nodes.iter().enumerate() {
        match &n.kind {
            NodeKind::Layer { printable, template, .. } if !(n.visible && n.opacity > 0.0 && *printable && !*template) => {
                changed = true;
                continue;
            }
            NodeKind::Path { guide: true, .. } => {
                changed = true;
                if clipping && i == 0 {
                    let mut g = (**n).clone();
                    g.appearance.effects.clear();
                    out.push(Arc::new(g));
                }
                continue;
            }
            _ => {}
        }
        let inner = match &n.kind {
            NodeKind::Layer { children, clip, .. } | NodeKind::Group { children, clip } => plotted(children, *clip),
            _ => None,
        };
        match inner {
            Some(children) => {
                changed = true;
                let mut c = (**n).clone();
                if let Some(ch) = c.children_mut() {
                    *ch = children;
                }
                out.push(Arc::new(c));
            }
            None => out.push(n.clone()),
        }
    }
    changed.then_some(out)
}

/// The symbols of `doc` whose art holds geometry effects, and those whose art holds instances of
/// them, as deep as symbols are drawn ([`MAX_NEST`]).
fn effect_symbols(doc: &Document) -> HashSet<String> {
    let mut set: HashSet<String> = doc.symbols.iter().filter(|s| vectorcraft_effects::needs_bake(&s.art)).map(|s| s.name.clone()).collect();
    for _ in 0..MAX_NEST {
        if set.is_empty() {
            break;
        }
        let more: Vec<String> =
            doc.symbols.iter().filter(|s| !set.contains(&s.name) && holds_instance_of(&s.art, &set)).map(|s| s.name.clone()).collect();
        if more.is_empty() {
            break;
        }
        set.extend(more);
    }
    set
}

/// Is `n`, or anything in it, an instance of one of `symbols`?
fn holds_instance_of(n: &Node, symbols: &HashSet<String>) -> bool {
    match &n.kind {
        NodeKind::SymbolInstance { symbol, .. } => symbols.contains(symbol),
        _ => n.children().into_iter().flatten().any(|c| holds_instance_of(c, symbols)),
    }
}

fn rgb8(c: &vectorcraft_color::Color) -> [u8; 3] {
    let [r, g, b, _] = c.to_rgba8(1.0);
    [r, g, b]
}

/// The average of `colors` (black without any).
fn average(colors: impl Iterator<Item = [u8; 3]>) -> [u8; 3] {
    let (sum, n) = colors.fold(([0.0; 3], 0.0), |(a, n), c| ([0, 1, 2].map(|i| a[i] + f64::from(c[i])), n + 1.0));
    sum.map(|v| (v / f64::max(n, 1.0)).round().clamp(0.0, 255.0) as u8)
}

/// The first visible solid fill color in `n` (a pattern tile's art), hidden objects and objects
/// or fills at 0% opacity left out.
fn first_solid(n: &Node) -> Option<vectorcraft_color::Color> {
    if !n.visible || n.opacity <= 0.0 {
        return None;
    }
    let own = n.appearance.items.iter().find_map(|i| match i {
        AppearanceItem::Fill(f) if f.visible && f.opacity > 0.0 => f.paint.color(),
        _ => None,
    });
    own.or_else(|| n.children().into_iter().flatten().find_map(|c| first_solid(c)))
}

/// The topmost stroke of `n` that paints: visible, with a paint, a weight and some opacity.
fn top_stroke(n: &Node) -> Option<&StrokeLayer> {
    n.appearance.items.iter().rev().find_map(|i| match i {
        AppearanceItem::Stroke(s) if s.visible && !s.paint.is_none() && s.width > 0.0 && s.opacity > 0.0 => Some(s),
        _ => None,
    })
}

/// Whether a member of `n`, at any depth of its groups, has a stroke that paints ([`top_stroke`]),
/// with it and the groups around it shown and not fully transparent.
fn strokes_in_pieces(n: &Node) -> bool {
    n.children().is_some_and(|ch| ch.iter().filter(|c| c.visible && c.opacity > 0.0).any(|c| top_stroke(c).is_some() || strokes_in_pieces(c)))
}

/// Whether a member of `n`, at any depth of its groups, has a fill that paints ([`top_fill`]),
/// with it and the groups around it shown and not fully transparent.
fn fills_in_pieces(n: &Node) -> bool {
    n.children().is_some_and(|ch| ch.iter().filter(|c| c.visible && c.opacity > 0.0).any(|c| top_fill(c).is_some() || fills_in_pieces(c)))
}

/// The paint of the topmost fill of `n` that paints: visible, with a paint and some opacity.
fn top_fill(n: &Node) -> Option<&Paint> {
    n.appearance.items.iter().rev().find_map(|i| match i {
        AppearanceItem::Fill(f) if f.visible && !f.paint.is_none() && f.opacity > 0.0 => Some(&f.paint),
        _ => None,
    })
}

#[cfg(test)]
mod tests;