mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-17 21:27:00 +00:00
1488 lines
66 KiB
Rust
1488 lines
66 KiB
Rust
use std::collections::HashSet;
|
|
|
|
use super::analysis::{Scratch, finite, flatten_groups, has_effects, masked, outlined_text, overlapping, painted, reach};
|
|
use super::compose::{Builder, CLEAR, Composer, Elem, Fill, Kind, Px, WHITE};
|
|
use super::options::FlattenOptions;
|
|
use super::{
|
|
Affine, Appearance, AppearanceItem, Arc, BlendMode, Color, ColorMode, Document, EngineError, FillLayer, FillRule, ImageBlob, ImageObject, Inks,
|
|
Knockout, MAX_PIXELS, Node, NodeId, NodeKind, Paint, PathData, Rect, Result, composite, effects, isolated_doc, leaves, outline_strokes,
|
|
planes_cmyk, po, separate, shape_node, shapes, unique_key,
|
|
};
|
|
|
|
// ---------- plan ----------
|
|
|
|
/// What the flattening does, worked out before the document changes.
|
|
pub(super) struct Plan {
|
|
pub(super) flat: Vec<Flat>,
|
|
/// Objects without transparency (they stay, but for the outline options).
|
|
pub(super) kept: Vec<NodeId>,
|
|
/// What the outline and overprint options do to each of `kept`, in its order.
|
|
pub(super) work: Vec<Kept>,
|
|
/// The objects with transparency of their own.
|
|
pub(super) transparent: Vec<NodeId>,
|
|
}
|
|
|
|
/// One group of overlapping objects with transparency and what replaces it.
|
|
pub(super) struct Flat {
|
|
/// Its objects in paint order; the result takes the place of the last.
|
|
pub(super) roots: Vec<NodeId>,
|
|
pub(super) regions: Regions,
|
|
/// Where its image goes, and the image (once rendered).
|
|
pub(super) area: Option<Area>,
|
|
raster: Option<Raster>,
|
|
/// When the group is one block of type over several lines: its lines, to group the regions by.
|
|
lines: Option<Lines>,
|
|
}
|
|
|
|
/// The lines of a block of type: document space → its line space, where each line spans a band
|
|
/// across the lines (its ascent above the baseline to its descent below).
|
|
struct Lines {
|
|
to_lines: Affine,
|
|
bands: Vec<(f64, f64)>,
|
|
}
|
|
|
|
impl Lines {
|
|
/// The lines of `n` when it is type laid out in two lines or more (not on a path).
|
|
fn of(n: &Node) -> Option<Lines> {
|
|
let NodeKind::Text(t) = &n.kind else { return None };
|
|
if t.xf.determinant().abs() < 1e-12 {
|
|
return None;
|
|
}
|
|
let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
|
|
if layout.on_path {
|
|
return None;
|
|
}
|
|
let bands: Vec<(f64, f64)> = layout.lines.iter().filter(|l| l.x1 > l.x0).map(|l| (l.baseline - l.ascent, l.baseline + l.descent)).collect();
|
|
let to_lines = if layout.vertical { layout.line_xf.inverse() * t.xf.inverse() } else { t.xf.inverse() };
|
|
(bands.len() > 1).then_some(Lines { to_lines, bands })
|
|
}
|
|
|
|
/// The line nearest to the middle of `path`.
|
|
fn line_of(&self, path: &PathData) -> usize {
|
|
let Some(b) = path.bounds() else { return 0 };
|
|
let y = (self.to_lines * b.center()).y;
|
|
let away = |&(lo, hi): &(f64, f64)| if y < lo { lo - y } else { (y - hi).max(0.0) };
|
|
self.bands.iter().enumerate().min_by(|a, b| away(a.1).total_cmp(&away(b.1))).map_or(0, |(i, _)| i)
|
|
}
|
|
}
|
|
|
|
/// Where a group's image goes.
|
|
pub(super) struct Area {
|
|
rect: Rect,
|
|
ppi: f64,
|
|
/// The complex regions it is clipped to (Clip Complex Regions).
|
|
clip: Option<PathData>,
|
|
/// The raster/vector balance rasterizes the whole group (it splits into too many regions).
|
|
pub(super) whole: bool,
|
|
}
|
|
|
|
impl Area {
|
|
/// The area's outline.
|
|
pub(super) fn outline(&self) -> PathData {
|
|
self.clip.clone().unwrap_or_else(|| shapes::rectangle(self.rect))
|
|
}
|
|
}
|
|
|
|
/// Flat-colour regions: their outlines and paints.
|
|
pub(super) type Regions = Vec<(PathData, RegionFill)>;
|
|
|
|
/// A flat-colour region's paint.
|
|
pub(super) struct RegionFill {
|
|
paint: Paint,
|
|
alpha: f32,
|
|
overprint: bool,
|
|
}
|
|
|
|
/// A rendered image of complex regions, clipped to them or not.
|
|
struct Raster {
|
|
blob: ImageBlob,
|
|
width: u32,
|
|
height: u32,
|
|
xf: Affine,
|
|
clip: Option<PathData>,
|
|
}
|
|
|
|
/// The flattening of `roots` with `o`; `render` renders the images (the preview only needs where
|
|
/// they go). Fails only when an image can't be encoded.
|
|
pub(super) fn plan(src: &Document, roots: &[NodeId], o: &FlattenOptions, render: bool) -> Result<Plan> {
|
|
let tmp = isolated_doc(src, roots.iter().filter_map(|id| src.node(*id).cloned()).collect());
|
|
// Geometry effects first: what is left on the art are raster effects.
|
|
let baked = effects::bake_document(&tmp).unwrap_or(tmp);
|
|
let art: Vec<Node> = baked.layers[0].children().into_iter().flatten().map(|a| (**a).clone()).collect();
|
|
let mut sc = Scratch { brushes: vectorcraft_brush::library(&baked), doc: baked.clone() };
|
|
let plain: Vec<Node> = art.iter().map(|n| sc.plain(n)).collect();
|
|
// Each object as its clip groups and clipping layers show it.
|
|
let clipped: Vec<Node> = plain.iter().zip(roots).map(|(n, id)| clipped_by_ancestors(src, *id, n, None)).collect();
|
|
let reaches: Vec<Option<Rect>> = plain.iter().zip(&clipped).map(|(n, c)| reach(n).zip(reach(c)).map(|(a, b)| a.intersect(b))).collect();
|
|
let see_through: Vec<bool> = plain.iter().map(|n| o.shows_transparency(&baked, n) || o.draws_see_through_image(n)).collect();
|
|
let cmyk = src.color_mode == ColorMode::Cmyk;
|
|
let mut out = Plan {
|
|
flat: vec![],
|
|
kept: vec![],
|
|
work: vec![],
|
|
transparent: roots.iter().zip(&see_through).filter(|(_, t)| **t).map(|(id, _)| *id).collect(),
|
|
};
|
|
// Baking above stopped early when cancelled; each group is a place to stop (a plan changes nothing).
|
|
vectorcraft_doc::cancel::check()?;
|
|
let mut queue = groups(src, roots, &plain, &reaches, &see_through, o)?;
|
|
queue.reverse();
|
|
while let Some(g) = queue.pop() {
|
|
vectorcraft_doc::cancel::check()?;
|
|
// A group that stays inside the clip groups and clipping layers of its topmost object
|
|
// replaces only the objects inside them, over the others, which are flattened on their own.
|
|
let (g, under) = match inside_and_under(src, roots, &g) {
|
|
Some((inside, under)) => {
|
|
queue.push(under.clone());
|
|
(inside, under)
|
|
}
|
|
None => (g, vec![]),
|
|
};
|
|
// Composited over white, the group covers what it is drawn over, so it is composited over
|
|
// the fills of the clipping paths around it and the objects under it in the same kind of
|
|
// layer. Composited over nothing, it keeps its alpha and they show through.
|
|
let backdrop = !o.preserve_alpha;
|
|
let state = g.last().map(|&i| layer_state(src, roots[i]));
|
|
let top = g.last().map(|&i| roots[i]);
|
|
// A blend mode of a layer or group around the group alone would blend the art under it
|
|
// twice.
|
|
let blends = |i: usize| top.is_some_and(|t| own_layers(src, t, Some(roots[i])).iter().any(|a| a.blend != BlendMode::Normal));
|
|
// Art under an opacity mask, effects or a knockout group is left out: the group can't draw it
|
|
// as those do.
|
|
let drawn_plainly = |i: usize| {
|
|
own_layers(src, roots[i], top).iter().all(|a| !masked(a) && !has_effects(a) && !matches!(a.knockout, vectorcraft_doc::Knockout::On))
|
|
};
|
|
let under_shown = under.iter().copied().filter(|&i| backdrop && Some(layer_state(src, roots[i])) == state && !blends(i) && drawn_plainly(i));
|
|
let composited: Vec<usize> = under_shown.chain(g.iter().copied()).collect();
|
|
let below = composited.len() - g.len();
|
|
let extent = composited.iter().filter_map(|&i| reaches[i]).reduce(|a, b| a.union(b)).unwrap_or_default();
|
|
let shown = |nodes: &[Node]| -> Vec<Node> {
|
|
let mut seen = vec![];
|
|
let (mut under, mut out) = (vec![], vec![]);
|
|
for (k, &i) in composited.iter().enumerate() {
|
|
let n = clipped_by_ancestors(src, roots[i], &nodes[i], backdrop.then_some((&mut seen, extent)));
|
|
if k < below {
|
|
let groups = own_layers(src, roots[i], top).into_iter().filter(|a| !draws_as_is(a)).collect();
|
|
under.push((groups, n));
|
|
} else {
|
|
out.push(n);
|
|
}
|
|
}
|
|
let mut all = in_groups(under, 0);
|
|
all.extend(out);
|
|
all
|
|
};
|
|
let ids: Vec<NodeId> = g.iter().map(|&i| roots[i]).collect();
|
|
let group = g.iter().any(|&i| see_through[i]).then(|| {
|
|
let plain = shown(&plain);
|
|
flatten_group(&plain.iter().collect::<Vec<_>>(), o, cmyk)
|
|
});
|
|
let Some((regions, area)) = group.flatten() else {
|
|
// Transparent art that its clip groups or clipping layers hide entirely draws nothing:
|
|
// it is removed.
|
|
let hides = |i: usize| see_through[i] && reach(&plain[i]).is_some() && reach(&clipped[i]).is_none();
|
|
let (hidden, left): (Vec<usize>, Vec<usize>) = g.iter().partition(|&&i| hides(i));
|
|
if !hidden.is_empty() {
|
|
let roots = hidden.iter().map(|&i| roots[i]).collect();
|
|
out.flat.push(Flat { roots, regions: vec![], area: None, raster: None, lines: None });
|
|
}
|
|
out.kept.extend(left.iter().map(|&i| roots[i]));
|
|
continue;
|
|
};
|
|
let raster = match area.as_ref().filter(|_| render) {
|
|
Some(a) => {
|
|
// Drawn as planned: the image can land outside the clip groups and clipping layers
|
|
// around its art.
|
|
Some(render_raster(&baked, &shown(&art), a.rect, a.ppi, a.clip.clone(), o)?)
|
|
}
|
|
None => None,
|
|
};
|
|
let lines = match g.as_slice() {
|
|
[i] => Lines::of(&art[*i]),
|
|
_ => None,
|
|
};
|
|
out.flat.push(Flat { roots: ids, regions, area, raster, lines });
|
|
}
|
|
out.work = out.kept.iter().map(|id| Kept::of(src, *id, o)).collect();
|
|
Ok(out)
|
|
}
|
|
|
|
/// What the outline and overprint options do to one object without transparency, found in one
|
|
/// walk of it.
|
|
pub(super) struct Kept {
|
|
pub(super) id: NodeId,
|
|
/// Whether the options change it.
|
|
pub(super) changes: bool,
|
|
/// The type the text option outlines and the stroked paths the stroke option outlines, those
|
|
/// that show and are not pieces of a compound path: what the Flattener Preview highlights.
|
|
pub(super) shown_text: Vec<NodeId>,
|
|
pub(super) shown_strokes: Vec<NodeId>,
|
|
/// In paint order: the type the text option outlines and the leaf shapes ([`leaves`]) other
|
|
/// than type that the stroke option outlines.
|
|
steps: Vec<Step>,
|
|
/// The objects with overprints, each with the type or leaf shape that holds it (itself
|
|
/// included) when a step replaces that.
|
|
overprinted: Vec<(NodeId, Option<NodeId>)>,
|
|
}
|
|
|
|
/// One object [`apply`] outlines.
|
|
enum Step {
|
|
/// Type; `leaf`: only groups and layers hold it, so its outlines are leaf shapes for the
|
|
/// stroke option.
|
|
Text { id: NodeId, leaf: bool },
|
|
/// A leaf shape other than type.
|
|
Leaf(NodeId),
|
|
}
|
|
|
|
/// Where [`Kept::visit`] is in the object it walks.
|
|
#[derive(Clone, Copy)]
|
|
struct At {
|
|
/// Neither the node nor what holds it is hidden, and it is not a piece of a compound path.
|
|
shown: bool,
|
|
/// Only groups and layers hold the node.
|
|
leaf: bool,
|
|
/// The type or leaf shape holding the node that a step replaces.
|
|
holder: Option<NodeId>,
|
|
}
|
|
|
|
impl Kept {
|
|
/// What the options `o` do to `root` of `d`: nothing when `d` doesn't hold it.
|
|
fn of(d: &Document, root: NodeId, o: &FlattenOptions) -> Kept {
|
|
let mut k = Kept { id: root, changes: false, shown_text: vec![], shown_strokes: vec![], steps: vec![], overprinted: vec![] };
|
|
if let Some(n) = d.node(root) {
|
|
k.visit(n, o, At { shown: true, leaf: true, holder: None });
|
|
}
|
|
k
|
|
}
|
|
|
|
/// Note what the options `o` do to `n` and to everything under it.
|
|
fn visit(&mut self, n: &Node, o: &FlattenOptions, at: At) {
|
|
kept_seen(n);
|
|
let shown = at.shown && n.visible;
|
|
let mut holder = at.holder;
|
|
if matches!(n.kind, NodeKind::Text(_)) {
|
|
if o.text_to_outlines {
|
|
self.changes = true;
|
|
if shown {
|
|
self.shown_text.push(n.id);
|
|
}
|
|
self.steps.push(Step::Text { id: n.id, leaf: at.leaf });
|
|
holder = Some(n.id);
|
|
}
|
|
} else {
|
|
if o.strokes_to_outlines && stroked(n) {
|
|
self.changes = true;
|
|
if shown {
|
|
self.shown_strokes.push(n.id);
|
|
}
|
|
}
|
|
if o.strokes_to_outlines && at.leaf && matches!(n.kind, NodeKind::Path { guide: false, clipping: false, .. } | NodeKind::Compound { .. })
|
|
{
|
|
self.steps.push(Step::Leaf(n.id));
|
|
holder = Some(n.id);
|
|
}
|
|
}
|
|
if !o.preserve_overprints && overprints(n) {
|
|
self.changes = true;
|
|
self.overprinted.push((n.id, holder));
|
|
}
|
|
let Some(children) = n.children() else { return };
|
|
let inside = At {
|
|
shown: shown && !matches!(n.kind, NodeKind::Compound { .. }),
|
|
leaf: at.leaf && matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }),
|
|
holder,
|
|
};
|
|
for c in children {
|
|
self.visit(c, o, inside);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// `roots` of `src` (`plain`: as plain art; `reaches`: where each can paint, clipped) in the
|
|
/// groups that flatten together ([`flatten_groups`]), each in paint order, by their first object.
|
|
/// Objects that overlap (as [`overlapping`] groups them) stay in one group when one of them is
|
|
/// inside a clip group or clipping layer: [`inside_and_under`] and [`place_of`] then decide where
|
|
/// they go.
|
|
fn groups(
|
|
src: &Document,
|
|
roots: &[NodeId],
|
|
plain: &[Node],
|
|
reaches: &[Option<Rect>],
|
|
see_through: &[bool],
|
|
o: &FlattenOptions,
|
|
) -> Result<Vec<Vec<usize>>> {
|
|
// An image clipped to its regions, opaque over white, reaches a pixel past them; a group's
|
|
// image is no larger than the art it overlaps, so its pixels are no wider than this.
|
|
let opaque_edge = o.no_transparency.is_some() && o.clip_complex_regions && !o.preserve_alpha;
|
|
let ppi = o.line_art_ppi.min(o.gradient_ppi).max(1.0);
|
|
let extent = |ids: &mut dyn Iterator<Item = usize>| ids.filter_map(|i| reaches[i].filter(finite)).reduce(|a, b| a.union(b)).unwrap_or_default();
|
|
// Where the widest such pixel is wider than the margins of two reaches, objects that close
|
|
// overlap too.
|
|
let widest = if opaque_edge { 1.0 / raster_scale(extent(&mut (0..reaches.len())), ppi) } else { 0.0 };
|
|
let grow = ((widest - 2.0) / 2.0).max(0.0);
|
|
let near: Vec<Option<Rect>> = reaches.iter().map(|b| b.map(|b| b.inflate(grow, grow))).collect();
|
|
let mut out = vec![];
|
|
for g in overlapping(if grow > 0.0 { &near } else { reaches })? {
|
|
let clipped = || clips_count() && g.iter().any(|&i| !clip_ancestors(src, roots[i]).is_empty());
|
|
if g.len() < 2 || !g.iter().any(|&i| see_through[i]) || clipped() {
|
|
out.push(g);
|
|
continue;
|
|
}
|
|
let fringe = if opaque_edge { 1.0 / raster_scale(extent(&mut g.iter().copied()), ppi) } else { 0.0 };
|
|
let local = |v: &[Option<Rect>]| g.iter().map(|&i| v[i]).collect::<Vec<_>>();
|
|
let painted: Vec<Option<Rect>> = g.iter().map(|&i| painted(&plain[i])).collect();
|
|
let see: Vec<bool> = g.iter().map(|&i| see_through[i]).collect();
|
|
out.extend(flatten_groups(&local(reaches), &painted, &see, fringe)?.into_iter().map(|l| l.into_iter().map(|k| g[k]).collect::<Vec<_>>()));
|
|
}
|
|
out.sort_by_key(|g| g.first().copied());
|
|
Ok(out)
|
|
}
|
|
|
|
/// `plain` (object `id` of `src` as plain art) inside a clip group for each clip group and
|
|
/// clipping layer around `id`, innermost first, each clipped by that group's or layer's clipping
|
|
/// path. `plain` itself when nothing around it clips. With `fills` (clipping paths, and an area),
|
|
/// the fill of each clipping path not in them yet goes behind the art, inside the area, and the
|
|
/// path is added to them.
|
|
fn clipped_by_ancestors(src: &Document, id: NodeId, plain: &Node, mut fills: Option<(&mut Vec<NodeId>, Rect)>) -> Node {
|
|
let mut out = plain.clone();
|
|
if !clips_count() {
|
|
return out;
|
|
}
|
|
let ancestry = src.ancestry(id).unwrap_or_default();
|
|
for pair in ancestry.windows(2).rev() {
|
|
let Some(above) = src.node(pair[0]).filter(|n| n.clips()) else { continue };
|
|
let Some(clip) = above.children().and_then(|c| c.first()) else { continue };
|
|
// The clipping path itself is not clipped art.
|
|
if clip.id == pair[1] {
|
|
continue;
|
|
}
|
|
// Its outline, unpainted: the group or layer around the object still paints the path.
|
|
// Nothing to clip by hides the clipped art, as in the compositor.
|
|
let Some((outline, rule)) = effects::clip_outline(clip) else {
|
|
out.visible = false;
|
|
return out;
|
|
};
|
|
let mut path = Node::path(clip.id, PathData::from_bezpath(&outline), Appearance::default());
|
|
if let NodeKind::Path { rule: r, .. } = &mut path.kind {
|
|
*r = rule;
|
|
}
|
|
let mut children = vec![Arc::new(path)];
|
|
// The renderer paints the fill behind the clipped art.
|
|
if let Some((seen, r)) = fills.as_mut()
|
|
&& !seen.contains(&clip.id)
|
|
&& let Some(fill) = clip.clip_paint().fill
|
|
{
|
|
let r = *r;
|
|
seen.push(clip.id);
|
|
let mut at = Node::group(above.id, vec![Arc::new(Node::path(clip.id, shapes::rectangle(r), Appearance::default())), Arc::new(fill)]);
|
|
at.set_clips(true);
|
|
children.push(Arc::new(at));
|
|
}
|
|
children.push(Arc::new(out));
|
|
let mut g = Node::group(above.id, children);
|
|
g.set_clips(true);
|
|
out = g;
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Whether layer or group `n` draws what it holds as it is: opaque, in Normal mode, not isolated.
|
|
fn draws_as_is(n: &Node) -> bool {
|
|
n.opacity >= 1.0 && n.blend == BlendMode::Normal && !n.isolate
|
|
}
|
|
|
|
/// `items` (in paint order, each an object and the layers and groups around it, outermost first,
|
|
/// that don't draw it as it is) with the objects of each such layer or group in one group with its
|
|
/// opacity, blend mode and isolation, from the `depth`th around them on: they then composite
|
|
/// together as that layer or group draws them.
|
|
fn in_groups(items: Vec<(Vec<&Node>, Node)>, depth: usize) -> Vec<Node> {
|
|
let mut out = vec![];
|
|
let mut items = items.into_iter().peekable();
|
|
while let Some((around, n)) = items.next() {
|
|
let Some(a) = around.get(depth).copied() else {
|
|
out.push(n);
|
|
continue;
|
|
};
|
|
let mut run = vec![(around, n)];
|
|
while let Some(next) = items.next_if(|(around, _)| around.get(depth).is_some_and(|b| b.id == a.id)) {
|
|
run.push(next);
|
|
}
|
|
let mut g = Node::group(a.id, in_groups(run, depth + 1).into_iter().map(Arc::new).collect());
|
|
(g.opacity, g.blend, g.isolate) = (a.opacity, a.blend, a.isolate);
|
|
out.push(g);
|
|
}
|
|
out
|
|
}
|
|
|
|
/// The layers and groups around object `id` of `src` that are not also around `other`, outermost
|
|
/// first.
|
|
fn own_layers(src: &Document, id: NodeId, other: Option<NodeId>) -> Vec<&Node> {
|
|
let mine = src.ancestry(id).unwrap_or_default();
|
|
let theirs = other.and_then(|t| src.ancestry(t)).unwrap_or_default();
|
|
let shared = mine.iter().zip(&theirs).take_while(|(a, b)| a == b).count();
|
|
let own = mine.get(shared..mine.len().saturating_sub(1)).unwrap_or_default();
|
|
own.iter().filter_map(|a| src.node(*a)).collect()
|
|
}
|
|
|
|
/// The clip groups and clipping layers around object `id` of `d`, innermost first.
|
|
fn clip_ancestors(d: &Document, id: NodeId) -> Vec<NodeId> {
|
|
let mut a = d.ancestry(id).unwrap_or_default();
|
|
a.pop();
|
|
a.into_iter().rev().filter(|a| d.node(*a).is_some_and(Node::clips)).collect()
|
|
}
|
|
|
|
/// Whether the layers around object `id` of `d` all print, all show, and whether one is a
|
|
/// template.
|
|
fn layer_state(d: &Document, id: NodeId) -> (bool, bool, bool) {
|
|
let mut a = d.ancestry(id).unwrap_or_default();
|
|
a.pop();
|
|
a.iter().filter_map(|a| d.node(*a)).fold((true, true, false), |(print, show, template), n| match &n.kind {
|
|
NodeKind::Layer { printable, template: t, .. } => (print && *printable, show && n.visible, template || *t),
|
|
_ => (print, show, template),
|
|
})
|
|
}
|
|
|
|
/// For group `g` (indices of `roots` of `src`, in paint order) whose flattened group can't leave
|
|
/// the clip groups and clipping layers of its topmost object ([`place_of`]): the objects inside
|
|
/// them and the objects under them. `None` when the group can leave them, or every object is
|
|
/// inside them.
|
|
fn inside_and_under(src: &Document, roots: &[NodeId], g: &[usize]) -> Option<(Vec<usize>, Vec<usize>)> {
|
|
if !clips_count() || g.len() < 2 {
|
|
return None;
|
|
}
|
|
let ids: Vec<NodeId> = g.iter().map(|&i| roots[i]).collect();
|
|
let top = clip_ancestors(src, *ids.last()?);
|
|
if top.is_empty() {
|
|
return None;
|
|
}
|
|
let inside = |id: NodeId| {
|
|
let mine = clip_ancestors(src, id);
|
|
top.iter().all(|c| mine.contains(c))
|
|
};
|
|
if !inside(place_of(src, &ids)?) {
|
|
return None;
|
|
}
|
|
let (inside, under): (Vec<usize>, Vec<usize>) = g.iter().partition(|&&i| inside(roots[i]));
|
|
(!under.is_empty()).then_some((inside, under))
|
|
}
|
|
|
|
/// The regions and the image area replacing one group of overlapping objects (`plain`: the art as
|
|
/// composited; `cmyk`: in a CMYK document); `None` when it paints nothing.
|
|
fn flatten_group(plain: &[&Node], o: &FlattenOptions, cmyk: bool) -> Option<(Regions, Option<Area>)> {
|
|
let mut b = Builder { cmyk, ..Default::default() };
|
|
let elems: Vec<Elem> = plain.iter().filter_map(|n| b.elem(n)).collect();
|
|
if b.shapes.is_empty() {
|
|
return None;
|
|
}
|
|
// An unclipped full raster needs no regions.
|
|
let whole = o.balance <= 0.0 && !o.clip_complex_regions;
|
|
// Nor does one that splits into more regions than the balance allows: the build stops at the
|
|
// first region past the limit.
|
|
let (regions, over) = match o.region_limit().filter(|_| !every_region()) {
|
|
_ if whole => (vec![], false),
|
|
Some(limit) => po::regions_within(&b.shapes, limit).map_or((vec![], true), |r| (r, false)),
|
|
None => (po::regions(&b.shapes), false),
|
|
};
|
|
// An arrangement that failed (degenerate geometry) leaves only rasterizing.
|
|
let all = over || regions.is_empty() || o.rasterize_all(regions.len());
|
|
let mut vector: Vec<(usize, RegionFill)> = vec![];
|
|
let mut complex: Vec<usize> = vec![];
|
|
let mut gradients_only = !all;
|
|
for (k, r) in regions.iter().enumerate() {
|
|
// Art outside the clipping path of its clip group draws nothing there.
|
|
let shown = |i: &&usize| b.kinds[**i] == Kind::Vector || !(clips_count() && b.hidden(**i, &r.sources));
|
|
if all || r.sources.iter().filter(shown).any(|&i| b.kinds[i] != Kind::Vector) {
|
|
gradients_only &= r.sources.iter().filter(shown).all(|&i| b.kinds[i] == Kind::Gradient);
|
|
complex.push(k);
|
|
} else if let Some(fill) = region_fill(&elems, &r.sources, o, cmyk) {
|
|
vector.push((k, fill));
|
|
}
|
|
}
|
|
let bounds = |ks: &[usize]| ks.iter().filter_map(|&k| regions[k].path.bounds()).reduce(|a, b| a.union(b));
|
|
if !o.clip_complex_regions && !all {
|
|
// A rectangle of raster takes in every region it overlaps.
|
|
while let Some(r) = bounds(&complex) {
|
|
let before = complex.len();
|
|
let rect = shapes::rectangle(r);
|
|
vector.retain(|(k, _)| {
|
|
let path = ®ions[*k].path;
|
|
let hit = path.bounds().is_some_and(|b| b.intersect(r).area() > 0.0)
|
|
&& po::area(&po::boolean(path, FillRule::NonZero, &rect, FillRule::NonZero, po::BoolOp::Intersect), FillRule::NonZero) > 1e-6;
|
|
if hit {
|
|
complex.push(*k);
|
|
}
|
|
!hit
|
|
});
|
|
if complex.len() == before {
|
|
break;
|
|
}
|
|
gradients_only = false;
|
|
}
|
|
}
|
|
let raster_rect = if all { plain.iter().filter_map(|n| reach(n)).reduce(|a, b| a.union(b)) } else { bounds(&complex) };
|
|
let area = raster_rect.map(|rect| {
|
|
let clip = o.clip_complex_regions.then(|| PathData::new(complex.iter().flat_map(|&k| regions[k].path.subpaths.iter().cloned()).collect()));
|
|
let ppi = if gradients_only { o.gradient_ppi } else { o.line_art_ppi };
|
|
Area { rect, ppi, clip: clip.filter(|c| !c.is_empty()), whole: all }
|
|
});
|
|
let vector = vector.into_iter().map(|(k, f)| (regions[k].path.clone(), f)).collect();
|
|
Some((vector, area))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
thread_local! {
|
|
/// Groups flattened on this thread build all of their regions ([`with_every_region`]).
|
|
static EVERY_REGION: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
|
|
}
|
|
|
|
/// Whether groups build all of their regions, past the balance's limit too.
|
|
#[cfg(test)]
|
|
fn every_region() -> bool {
|
|
EVERY_REGION.with(std::cell::Cell::get)
|
|
}
|
|
|
|
#[cfg(not(test))]
|
|
fn every_region() -> bool {
|
|
false
|
|
}
|
|
|
|
/// `f` with every group it flattens building all of its regions, past the balance's limit too.
|
|
#[cfg(test)]
|
|
pub(crate) fn with_every_region<T>(f: impl FnOnce() -> T) -> T {
|
|
EVERY_REGION.with(|e| e.set(true));
|
|
let out = f();
|
|
EVERY_REGION.with(|e| e.set(false));
|
|
out
|
|
}
|
|
|
|
#[cfg(test)]
|
|
thread_local! {
|
|
/// Groups flattened on this thread rasterize art where its clip group or clipping layer hides
|
|
/// it too ([`with_clips_ignored`]).
|
|
static CLIPS_IGNORED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
|
|
}
|
|
|
|
/// Whether a region outside the clipping path of a clip group or clipping layer leaves out the
|
|
/// art it hides there.
|
|
#[cfg(test)]
|
|
fn clips_count() -> bool {
|
|
!CLIPS_IGNORED.with(std::cell::Cell::get)
|
|
}
|
|
|
|
#[cfg(not(test))]
|
|
fn clips_count() -> bool {
|
|
true
|
|
}
|
|
|
|
/// `f` with every group it flattens rasterizing art where its clip group or clipping layer hides
|
|
/// it too.
|
|
#[cfg(test)]
|
|
pub(crate) fn with_clips_ignored<T>(f: impl FnOnce() -> T) -> T {
|
|
CLIPS_IGNORED.with(|e| e.set(true));
|
|
let out = f();
|
|
CLIPS_IGNORED.with(|e| e.set(false));
|
|
out
|
|
}
|
|
|
|
/// The flat colour of a region covered by `sources` (CMYK in a `cmyk` document); `None` where
|
|
/// nothing paints it.
|
|
fn region_fill(elems: &[Elem], sources: &[usize], o: &FlattenOptions, cmyk: bool) -> Option<RegionFill> {
|
|
let mut c = Composer { sources, top: None, plane: 0 };
|
|
let alone = c.eval(elems, CLEAR);
|
|
if alone[3] < 0.5 / 255.0 {
|
|
return None;
|
|
}
|
|
// The white goes under the finished art, as under the renderer's: blend modes read only the art.
|
|
let on_page = |p: Px| if o.preserve_alpha { p } else { composite(BlendMode::Normal, WHITE, p) };
|
|
let px = on_page(alone);
|
|
let rgb = [px[0], px[1], px[2]];
|
|
// The K plane composites the same way.
|
|
let k = cmyk.then(|| {
|
|
c.plane = 1;
|
|
on_page(c.eval(elems, CLEAR))[0]
|
|
});
|
|
// A paint showing as it is keeps its colour (spot, process, swatch) and overprint.
|
|
let near = |a: &[f32], b: &[f32]| a.iter().zip(b).all(|(a, b)| (a - b).abs() < 1e-3);
|
|
let same = |f: &Fill| px[3] >= 1.0 - 1e-4 && near(&f.planes[0], &rgb) && k.is_none_or(|k| near(&f.planes[1][..1], &[k]));
|
|
let color = match k {
|
|
Some(k) => {
|
|
let [c, m, y, k] = planes_cmyk(rgb, k);
|
|
Color::cmyk(c, m, y, k)
|
|
}
|
|
None => Color::rgb(rgb[0], rgb[1], rgb[2]),
|
|
};
|
|
let (paint, overprint) = match c.top {
|
|
Some(f) if o.preserve_overprints && same(f) => (f.paint.clone(), f.overprint),
|
|
_ => (Paint::solid(color), false),
|
|
};
|
|
Some(RegionFill { paint, alpha: px[3], overprint })
|
|
}
|
|
|
|
/// `art` rendered over `rect` at `ppi`: over white with the white the art doesn't cover taken out
|
|
/// again, or over nothing with Preserve Alpha. The image and
|
|
/// its `clip` reach a pixel further. An opaque image in a CMYK document holds the art's ink
|
|
/// amounts (a CMYK TIFF), so its CMYK colours keep their numbers (#2160); other images are PNGs.
|
|
/// Fails when the image can't be encoded.
|
|
fn render_raster(doc: &Document, art: &[Node], rect: Rect, ppi: f64, clip: Option<PathData>, o: &FlattenOptions) -> Result<Raster> {
|
|
let scale = raster_scale(rect, ppi);
|
|
let px = 1.0 / scale;
|
|
let rect = rect.inflate(px, px);
|
|
let clip = clip.map(|c| Some(po::offset_path(&c, px, po::Join::Miter, 4.0)).filter(|g| !g.is_empty()).unwrap_or(c));
|
|
let region = Rect::new(
|
|
rect.x0,
|
|
rect.y0,
|
|
rect.x0 + (rect.width() * scale).ceil().max(1.0) / scale,
|
|
rect.y0 + (rect.height() * scale).ceil().max(1.0) / scale,
|
|
);
|
|
let xf = Affine::translate(region.origin().to_vec2()) * Affine::scale(1.0 / scale);
|
|
let tmp = isolated_doc(doc, art.to_vec());
|
|
let mut r = vectorcraft_render::Renderer::new();
|
|
let no_alpha = o.no_transparency.is_some() && clip.is_some() && !o.preserve_alpha;
|
|
if no_alpha && doc.color_mode == ColorMode::Cmyk {
|
|
// Drawn as inks over the paper: as screen colours, the file would separate them again,
|
|
// and a CMYK colour comes back with other inks (K moves into C, M and Y).
|
|
let opts = vectorcraft_render::RenderOptions { background: Some([255; 4]), skip_templates: true, ..Default::default() };
|
|
let inks = r.render_region_inks(&tmp, region, scale, &opts);
|
|
vectorcraft_doc::cancel::check()?;
|
|
let (width, height) = vectorcraft_render::region_pixels(region, scale);
|
|
// Past the size of a CMYK image: drawn in screen colours, below.
|
|
if let Some(blob) = Inks::new(width, height, inks).and_then(|i| ImageBlob::cmyk_tiff(&i)) {
|
|
return Ok(Raster { blob, width, height, xf, clip });
|
|
}
|
|
}
|
|
let mut img = r.render_region(&tmp, region, scale, !o.preserve_alpha);
|
|
// The drawing stops early when cancelled: this image is not whole.
|
|
vectorcraft_doc::cancel::check()?;
|
|
if no_alpha {
|
|
// Without transparency the clip alone shapes the image: it is opaque, over white (its
|
|
// edge pixels too).
|
|
for p in img.pixels.as_chunks_mut::<4>().0 {
|
|
p[3] = 255;
|
|
}
|
|
} else if !o.preserve_alpha || !o.anti_alias {
|
|
// The art's coverage: drawn opaque, so only its own edges (and soft effects) are partial.
|
|
let cover: Vec<Node> = art
|
|
.iter()
|
|
.map(|n| {
|
|
let mut c = n.clone();
|
|
opaque(&mut c);
|
|
c
|
|
})
|
|
.collect();
|
|
let cover = r.render_region(&isolated_doc(doc, cover), region, scale, false);
|
|
for (px, c) in img.pixels.as_chunks_mut::<4>().0.iter_mut().zip(cover.pixels.as_chunks::<4>().0) {
|
|
let k = c[3];
|
|
let k2 = if o.anti_alias || k == 0 || k == 255 {
|
|
k
|
|
} else if k >= 128 {
|
|
255
|
|
} else {
|
|
0
|
|
};
|
|
if o.preserve_alpha {
|
|
let f = k2 as f32 / k.max(1) as f32;
|
|
for v in px.iter_mut() {
|
|
*v = (*v as f32 * f).round().min(255.0) as u8;
|
|
}
|
|
} else {
|
|
let white = 255 - k2;
|
|
for v in &mut px[..3] {
|
|
*v = v.saturating_sub(white).min(k2);
|
|
}
|
|
px[3] = k2;
|
|
}
|
|
}
|
|
}
|
|
let png = img.to_png().map_err(|e| EngineError::Other(format!("Flatten Transparency: {e}")))?;
|
|
Ok(Raster { blob: ImageBlob::new("image/png", png), width: img.width, height: img.height, xf, clip })
|
|
}
|
|
|
|
/// Pixels per point of an image of `rect` at `ppi`: lower when the image would be larger than
|
|
/// [`MAX_PIXELS`], or have a side longer than the renderer draws (the image grows by a pixel on
|
|
/// each side and is rounded up to whole pixels).
|
|
fn raster_scale(rect: Rect, ppi: f64) -> f64 {
|
|
let scale = (ppi / 72.0).min((MAX_PIXELS / (rect.width() * rect.height()).max(1.0)).sqrt());
|
|
scale.min((f64::from(vectorcraft_render::MAX_RASTER_SIDE) - 4.0) / rect.width().max(rect.height()).max(1.0))
|
|
}
|
|
|
|
/// `n` at full opacity with Normal blending throughout (objects, fills and strokes).
|
|
pub(super) fn opaque(n: &mut Node) {
|
|
n.opacity = 1.0;
|
|
n.blend = BlendMode::Normal;
|
|
for i in &mut n.appearance.items {
|
|
match i {
|
|
AppearanceItem::Fill(f) => (f.opacity, f.blend) = (1.0, BlendMode::Normal),
|
|
AppearanceItem::Stroke(s) => (s.opacity, s.blend) = (1.0, BlendMode::Normal),
|
|
}
|
|
}
|
|
if let Some(ch) = n.children_mut() {
|
|
for c in ch {
|
|
opaque(Arc::make_mut(c));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Whether `doc` has pattern fills whose image tiles need transparency flattening with `o`
|
|
/// ([`expand_transparent_tile_images`]).
|
|
pub(crate) fn has_transparent_tile_images(doc: &Document, o: &FlattenOptions) -> bool {
|
|
let keys = o.no_transparency.clone().unwrap_or_default();
|
|
let colorize = |d: &Document, n: &Node| o.counts_colorize(d, n);
|
|
!doc.patterns.is_empty() && crate::cmd::expand::has_transparent_image_patterns(doc, &keys, &colorize)
|
|
}
|
|
|
|
/// Expand pattern fills whose image tiles need transparency flattening.
|
|
pub(crate) fn expand_transparent_tile_images(doc: &Document, o: &FlattenOptions) -> Result<Option<Document>> {
|
|
if !has_transparent_tile_images(doc, o) {
|
|
return Ok(None);
|
|
}
|
|
let keys = o.no_transparency.clone().unwrap_or_default();
|
|
let colorize = |d: &Document, n: &Node| o.counts_colorize(d, n);
|
|
let mut d = doc.clone();
|
|
let layers: Vec<NodeId> =
|
|
d.layers.iter().filter(|l| l.visible && !matches!(l.kind, NodeKind::Layer { template: true, .. })).map(|l| l.id).collect();
|
|
let mut changed = 0;
|
|
for id in layers {
|
|
changed += crate::cmd::expand::expand_transparent_image_patterns(&mut d, id, &keys, &colorize)?;
|
|
}
|
|
Ok((changed > 0).then_some(d))
|
|
}
|
|
|
|
/// `doc` with everything it draws flattened with `o`, as formats without transparency (EPS)
|
|
/// write it: every visible object of the visible layers, locked ones too (a clipping layer's
|
|
/// clipping path stays). Pattern tile images with opacity, blending or a colorize paint that
|
|
/// `o` counts ([`FlattenOptions::counts_colorize`]) are expanded; see-through tile pixels are
|
|
/// expanded when `o.no_transparency` counts them. `None` when nothing changes.
|
|
pub(crate) fn flatten_document(doc: &Document, o: &FlattenOptions) -> Result<Option<Document>> {
|
|
let expanded = expand_transparent_tile_images(doc, o)?;
|
|
Ok(flatten_expanded(expanded.as_ref().unwrap_or(doc), o)?.or(expanded))
|
|
}
|
|
|
|
fn has_layer_container_transparency(n: &Node) -> bool {
|
|
!n.has_default_transparency() || n.children().into_iter().flatten().any(|c| c.is_layer() && has_layer_container_transparency(c))
|
|
}
|
|
|
|
/// [`flatten_document`] for `doc` whose pattern tile images were expanded already
|
|
/// ([`expand_transparent_tile_images`]).
|
|
pub(crate) fn flatten_expanded(doc: &Document, o: &FlattenOptions) -> Result<Option<Document>> {
|
|
let outlining = o.text_to_outlines || o.strokes_to_outlines || !o.preserve_overprints;
|
|
let needs_flatten = outlining
|
|
|| doc.layers.iter().any(|l| {
|
|
(o.no_transparency.is_some() && has_layer_container_transparency(l)) || o.shows_transparency(doc, l) || o.draws_see_through_image(l)
|
|
});
|
|
if !needs_flatten {
|
|
return Ok(None);
|
|
}
|
|
let mut d = doc.clone();
|
|
let changed = o.no_transparency.is_some() && normalize_layer_transparency(&mut d, o);
|
|
let mut roots = vec![];
|
|
for l in d.layers.iter().filter(|l| l.visible && !matches!(l.kind, NodeKind::Layer { template: true, .. })) {
|
|
let children = l.children().map_or(&[][..], Vec::as_slice);
|
|
roots.extend(children.iter().skip(usize::from(l.clips())).filter(|c| c.visible && !c.is_ruler_guide()).map(|c| c.id));
|
|
}
|
|
let plan = plan(&d, &roots, o, true)?;
|
|
if plan.flat.is_empty() && !plan.work.iter().any(|k| k.changes) {
|
|
if changed {
|
|
if o.no_transparency.is_some() {
|
|
for l in &mut d.layers {
|
|
sanitize_container_transparency(Arc::make_mut(l));
|
|
}
|
|
}
|
|
return Ok(Some(d));
|
|
}
|
|
return Ok(None);
|
|
}
|
|
apply(&mut d, &mut vectorcraft_doc::Selection::default(), plan, o)?;
|
|
if o.no_transparency.is_some() {
|
|
for l in &mut d.layers {
|
|
sanitize_container_transparency(Arc::make_mut(l));
|
|
}
|
|
}
|
|
Ok(Some(d))
|
|
}
|
|
|
|
/// Flatten and normalize container-level transparency (on layers and sublayers) into groups
|
|
/// so that the flattener's plan includes them and leaves no container transparency behind.
|
|
fn normalize_layer_transparency(d: &mut Document, o: &FlattenOptions) -> bool {
|
|
if o.no_transparency.is_none() {
|
|
return false;
|
|
}
|
|
let mut changed = false;
|
|
let mut layers = std::mem::take(&mut d.layers);
|
|
for l in &mut layers {
|
|
changed |= normalize_node_transparency(d, Arc::make_mut(l));
|
|
}
|
|
d.layers = layers;
|
|
changed
|
|
}
|
|
|
|
fn clear_transparency(n: &mut Node) {
|
|
n.opacity = 1.0;
|
|
n.blend = BlendMode::Normal;
|
|
n.isolate = false;
|
|
n.knockout = Knockout::Neutral;
|
|
n.knockout_shape = false;
|
|
n.extras_mut().mask = None;
|
|
n.appearance = Appearance::default().into();
|
|
}
|
|
|
|
fn normalize_node_transparency(d: &mut Document, n: &mut Node) -> bool {
|
|
let mut changed = false;
|
|
let is_layer = n.is_layer();
|
|
let clips = n.clips();
|
|
|
|
if let Some(children) = n.children_mut() {
|
|
for c in children.iter_mut() {
|
|
if c.is_layer() {
|
|
changed |= normalize_node_transparency(d, Arc::make_mut(c));
|
|
}
|
|
}
|
|
}
|
|
|
|
let has_transparency = !n.has_default_transparency() || n.shows_own_transparency();
|
|
|
|
if is_layer && has_transparency {
|
|
let children = n.children().map_or(&[][..], Vec::as_slice);
|
|
let (guides, art): (Vec<_>, Vec<_>) = children.iter().cloned().partition(|c| c.is_ruler_guide());
|
|
|
|
if art.is_empty() {
|
|
clear_transparency(n);
|
|
n.set_clips(false);
|
|
changed = true;
|
|
} else {
|
|
let mut g = Node::group(d.alloc_id(), art);
|
|
if clips {
|
|
g.set_clips(true);
|
|
}
|
|
g.opacity = n.opacity;
|
|
g.blend = n.blend;
|
|
g.isolate = n.isolate;
|
|
g.knockout = n.knockout;
|
|
g.knockout_shape = n.knockout_shape;
|
|
g.appearance = n.appearance.clone();
|
|
g.extras_mut().mask = n.extras_mut().mask.take();
|
|
|
|
n.set_clips(false);
|
|
clear_transparency(n);
|
|
|
|
let mut new_children = vec![Arc::new(g)];
|
|
new_children.extend(guides);
|
|
if let Some(ch) = n.children_mut() {
|
|
*ch = new_children;
|
|
}
|
|
changed = true;
|
|
}
|
|
} else if is_layer && !n.visible {
|
|
clear_transparency(n);
|
|
}
|
|
|
|
changed
|
|
}
|
|
|
|
fn sanitize_container_transparency(n: &mut Node) {
|
|
if n.is_container() {
|
|
clear_transparency(n);
|
|
if let Some(children) = n.children_mut() {
|
|
for c in children.iter_mut() {
|
|
if c.is_container() {
|
|
sanitize_container_transparency(Arc::make_mut(c));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------- apply ----------
|
|
|
|
pub(super) fn apply(d: &mut Document, sel: &mut vectorcraft_doc::Selection, plan: Plan, o: &FlattenOptions) -> Result<(Vec<NodeId>, usize, usize)> {
|
|
let (mut vector, mut rasterized) = (0, 0);
|
|
let (mut ids, mut flat) = (vec![], vec![]);
|
|
// The groups replace their objects in one pass at the end. When an object is listed twice or
|
|
// lies inside another listed one, each group replaces its objects as it is made instead.
|
|
let one_pass = separate(d, &plan.flat.iter().flat_map(|f| f.roots.iter().copied()).collect::<Vec<_>>());
|
|
// A sublayer that becomes flat art gives its ruler guides to the layer that held it.
|
|
let guides = held_guides(d, plan.flat.iter().flat_map(|f| f.roots.iter().copied()));
|
|
for f in plan.flat {
|
|
// A group always has objects.
|
|
let Some(top) = place_of(d, &f.roots) else { continue };
|
|
// Art hidden entirely is removed.
|
|
if f.regions.is_empty() && f.area.is_none() {
|
|
if one_pass {
|
|
flat.extend(f.roots.iter().map(|r| (*r, vec![])));
|
|
} else {
|
|
for r in &f.roots {
|
|
d.remove(*r)?;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
let mut children = vec![];
|
|
// The image goes under the regions, reaching a pixel past its own: their edges then fall on
|
|
// matching pixels instead of on what is behind the group.
|
|
if let Some(r) = f.raster {
|
|
children.push(Arc::new(raster_node(d, r)));
|
|
rasterized += 1;
|
|
}
|
|
// Type over several lines gives a group per line.
|
|
let mut by_line: Vec<Vec<Arc<Node>>> = f.lines.as_ref().map_or(vec![], |l| vec![vec![]; l.bands.len()]);
|
|
for (path, fill) in f.regions {
|
|
let line = f.lines.as_ref().map(|l| l.line_of(&path));
|
|
let mut n = shape_node(d, path, None);
|
|
n.appearance = Appearance {
|
|
items: vec![AppearanceItem::Fill(FillLayer { overprint: fill.overprint, ..FillLayer::new(fill.paint) })],
|
|
..Appearance::default()
|
|
}
|
|
.into();
|
|
n.opacity = fill.alpha.min(1.0);
|
|
match line.and_then(|i| by_line.get_mut(i)) {
|
|
Some(l) => l.push(Arc::new(n)),
|
|
None => children.push(Arc::new(n)),
|
|
}
|
|
vector += 1;
|
|
}
|
|
by_line.retain(|l| !l.is_empty());
|
|
if by_line.len() > 1 {
|
|
for l in by_line {
|
|
children.push(Arc::new(Node::group(d.alloc_id(), l)));
|
|
}
|
|
} else {
|
|
children.extend(by_line.into_iter().flatten());
|
|
}
|
|
let g = Node::group(d.alloc_id(), children);
|
|
ids.push(g.id);
|
|
if one_pass {
|
|
// The group replaces the topmost object, and the other objects are removed.
|
|
flat.extend(f.roots.iter().filter(|r| **r != top).map(|r| (*r, vec![])));
|
|
flat.push((top, vec![g]));
|
|
} else {
|
|
let (par, idx, _) = d.position(top).ok_or(EngineError::NoNode(top))?;
|
|
d.insert(par, idx + 1, g)?;
|
|
for r in &f.roots {
|
|
d.remove(*r)?;
|
|
}
|
|
}
|
|
}
|
|
if !flat.is_empty() {
|
|
d.insert_beside(flat, true)?;
|
|
}
|
|
for (layer, guide) in guides {
|
|
d.insert(Some(layer), usize::MAX, guide)?;
|
|
}
|
|
let brushes = if o.strokes_to_outlines { vectorcraft_brush::library(d) } else { vec![] };
|
|
for k in plan.work {
|
|
ids.push(outline_kept(d, &brushes, k, o)?);
|
|
}
|
|
ids.sort_by_key(|id| d.index_path(*id));
|
|
sel.set(ids.iter().copied());
|
|
Ok((ids, vector, rasterized))
|
|
}
|
|
|
|
/// The object of `roots` (in paint order) whose place their flattened group takes: the topmost one
|
|
/// that no clip group or clipping layer clips unless it clips every object of `roots`, else the
|
|
/// topmost one. The group stays with the topmost object rather than move to a layer that prints,
|
|
/// shows or is a template where the topmost object's layer differs, out from a clip group or
|
|
/// clipping layer whose clipping path has a fill, which would then cover it, or out from a layer
|
|
/// or group with opacity, a blend mode or isolation.
|
|
fn place_of(d: &Document, roots: &[NodeId]) -> Option<NodeId> {
|
|
let top = roots.last().copied()?;
|
|
if !clips_count() || roots.len() < 2 {
|
|
return Some(top);
|
|
}
|
|
let fills = |clip: &NodeId| d.node(*clip).and_then(|n| n.children()?.first().map(|c| c.clip_paint().fill.is_some())).unwrap_or(false);
|
|
let all: Vec<Vec<NodeId>> = roots.iter().map(|r| clip_ancestors(d, *r)).collect();
|
|
let above = all.last().map_or(&[][..], Vec::as_slice);
|
|
let shared = |mine: &Vec<NodeId>| mine.iter().all(|c| all.iter().all(|theirs| theirs.contains(c)));
|
|
let leaves_fill = |mine: &Vec<NodeId>| above.iter().any(|c| !mine.contains(c) && fills(c));
|
|
// Out of a layer or group with opacity, a blend mode or isolation, the group would lose it.
|
|
let leaves_compositing = |r: NodeId| own_layers(d, top, Some(r)).iter().any(|a| !draws_as_is(a));
|
|
let state = layer_state(d, top);
|
|
let place =
|
|
roots.iter().zip(&all).rev().find(|(r, mine)| shared(mine) && !leaves_fill(mine) && layer_state(d, **r) == state && !leaves_compositing(**r));
|
|
Some(place.map_or(top, |(r, _)| *r))
|
|
}
|
|
|
|
/// The ruler guides of each of `roots` that is a sublayer (in its sublayers too), with the layer
|
|
/// that holds it, in order. Other objects hold none. Each root, and each child of it and of its
|
|
/// sublayers, is looked at once.
|
|
fn held_guides(d: &Document, roots: impl IntoIterator<Item = NodeId>) -> Vec<(NodeId, Node)> {
|
|
let mut out = vec![];
|
|
for id in roots {
|
|
let (Some(n), Some(parent)) = (d.node(id), d.parent_of(id)) else { continue };
|
|
guide_seen(n);
|
|
if n.is_layer() {
|
|
guides_of(n, parent, &mut out);
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Push each ruler guide of `layer` and of its sublayers onto `out` in paint order, with `parent`.
|
|
fn guides_of(layer: &Node, parent: NodeId, out: &mut Vec<(NodeId, Node)>) {
|
|
for c in layer.children().into_iter().flatten() {
|
|
guide_seen(c);
|
|
if c.is_ruler_guide() {
|
|
out.push((parent, Node::clone(c)));
|
|
} else if c.is_layer() {
|
|
guides_of(c, parent, out);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
thread_local! {
|
|
/// The nodes that [`held_guides`] has looked at on this thread, in order.
|
|
static GUIDES_SEEN: std::cell::RefCell<Vec<NodeId>> = const { std::cell::RefCell::new(Vec::new()) };
|
|
}
|
|
|
|
/// Note that [`held_guides`] looked at `n`.
|
|
#[cfg(test)]
|
|
fn guide_seen(n: &Node) {
|
|
GUIDES_SEEN.with(|s| s.borrow_mut().push(n.id));
|
|
}
|
|
|
|
#[cfg(not(test))]
|
|
fn guide_seen(_: &Node) {}
|
|
|
|
#[cfg(test)]
|
|
thread_local! {
|
|
/// The nodes that [`Kept::of`] has looked at on this thread, in order.
|
|
static KEPT_SEEN: std::cell::RefCell<Vec<NodeId>> = const { std::cell::RefCell::new(Vec::new()) };
|
|
}
|
|
|
|
/// Note that [`Kept::of`] looked at `n`.
|
|
#[cfg(test)]
|
|
fn kept_seen(n: &Node) {
|
|
KEPT_SEEN.with(|s| s.borrow_mut().push(n.id));
|
|
}
|
|
|
|
#[cfg(not(test))]
|
|
fn kept_seen(_: &Node) {}
|
|
|
|
/// An image of `r` (in a clip group when it is clipped).
|
|
fn raster_node(d: &mut Document, r: Raster) -> Node {
|
|
let key = unique_key(d, "flattened");
|
|
d.images.insert(key.clone(), r.blob);
|
|
let image = Node::new(
|
|
d.alloc_id(),
|
|
NodeKind::Image(Box::new(ImageObject {
|
|
key,
|
|
width: r.width,
|
|
height: r.height,
|
|
xf: r.xf,
|
|
link: None,
|
|
placement: Default::default(),
|
|
pixels: None,
|
|
})),
|
|
);
|
|
let Some(path) = r.clip else { return image };
|
|
crate::cmd::rasterfx::clip_group(d, path, FillRule::NonZero, image)
|
|
}
|
|
|
|
/// Do what [`Kept`] `k` found to its object of `d` (`brushes`: the document's brushes, for the
|
|
/// stroke option): its type outlined, then the strokes of its leaf shapes, the outlines of its
|
|
/// type included, then its overprints dropped. → the id now standing for the object.
|
|
fn outline_kept(d: &mut Document, brushes: &[vectorcraft_brush::Brush], k: Kept, o: &FlattenOptions) -> Result<NodeId> {
|
|
let mut root = k.id;
|
|
let mut replaced = HashSet::new();
|
|
let dropping = !o.preserve_overprints;
|
|
// Each replacement loses its overprints before it goes in: no new object is looked up.
|
|
let mut put = |d: &mut Document, old: NodeId, mut new: Node, root: &mut NodeId| -> Result<()> {
|
|
if dropping {
|
|
drop_overprints(&mut new);
|
|
}
|
|
let nid = new.id;
|
|
*d.node_mut(old).ok_or(EngineError::NoNode(old))? = new;
|
|
replaced.insert(old);
|
|
if old == *root {
|
|
*root = nid;
|
|
}
|
|
Ok(())
|
|
};
|
|
// The leaf shapes of each outlined type that only groups and layers hold, by step.
|
|
let mut outlined: Vec<Vec<Node>> = Vec::with_capacity(k.steps.len());
|
|
for step in &k.steps {
|
|
let mut lv = vec![];
|
|
if let Step::Text { id, leaf } = *step
|
|
&& let Some(out) = d.node(id).and_then(outlined_text)
|
|
{
|
|
let out = d.reid(&out);
|
|
if leaf && o.strokes_to_outlines {
|
|
leaves(&out, &mut lv);
|
|
}
|
|
put(d, id, out, &mut root)?;
|
|
}
|
|
outlined.push(lv);
|
|
}
|
|
if o.strokes_to_outlines {
|
|
for (step, lv) in k.steps.iter().zip(outlined) {
|
|
let shapes = match *step {
|
|
Step::Leaf(id) => d.node(id).cloned().into_iter().collect(),
|
|
Step::Text { .. } => lv,
|
|
};
|
|
for l in shapes.iter().filter(|l| !matches!(l.kind, NodeKind::Text(_))) {
|
|
if let Some(new) = outline_strokes(d, brushes, l) {
|
|
put(d, l.id, new, &mut root)?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if dropping {
|
|
for (id, holder) in k.overprinted {
|
|
if holder.is_some_and(|h| replaced.contains(&h)) {
|
|
continue;
|
|
}
|
|
if let Some(n) = d.node_mut(id) {
|
|
drop_own_overprints(n);
|
|
}
|
|
}
|
|
}
|
|
Ok(root)
|
|
}
|
|
|
|
/// Whether `n` is a path with a visible stroke (outlining turns it into a fill).
|
|
pub(super) fn stroked(n: &Node) -> bool {
|
|
matches!(n.kind, NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. })
|
|
&& n.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(s) if s.visible && !s.paint.is_none() && s.width > 0.0))
|
|
}
|
|
|
|
/// Drop the overprints of `n` itself.
|
|
fn drop_own_overprints(n: &mut Node) {
|
|
if overprints(n) {
|
|
for i in &mut n.appearance.items {
|
|
*i.overprint_mut() = false;
|
|
}
|
|
if let NodeKind::Text(t) = &mut n.kind {
|
|
for r in &mut t.runs {
|
|
(r.style.overprint_fill, r.style.overprint_stroke) = (false, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn overprints(n: &Node) -> bool {
|
|
n.appearance.items.iter().any(AppearanceItem::overprint)
|
|
|| matches!(&n.kind, NodeKind::Text(t) if t.runs.iter().any(|r| r.style.overprint_fill || r.style.overprint_stroke))
|
|
}
|
|
|
|
/// Drop the overprints of `n` and of everything under it.
|
|
fn drop_overprints(n: &mut Node) {
|
|
drop_own_overprints(n);
|
|
if let Some(ch) = n.children_mut() {
|
|
for c in ch {
|
|
drop_overprints(Arc::make_mut(c));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use serde_json::json;
|
|
|
|
use super::*;
|
|
use crate::Session;
|
|
|
|
#[test]
|
|
fn a_flattened_sublayer_gives_its_ruler_guides_to_its_layer() {
|
|
let mut s = Session::new();
|
|
s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
|
|
let layer = s.doc().unwrap().doc.layers[0].id;
|
|
let sub = NodeId(s.execute("layer.newSublayer", &json!({"parent": layer.0})).unwrap()["id"].as_u64().unwrap());
|
|
s.execute("layer.setCurrent", &json!({"id": sub.0})).unwrap();
|
|
let r = s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone();
|
|
s.execute("transparency.set", &json!({"ids": [r], "opacity": 50})).unwrap();
|
|
let d = Arc::make_mut(&mut s.doc_mut().unwrap().doc);
|
|
let g = Node::new(d.alloc_id(), NodeKind::RulerGuide { vertical: true, pos: 5.0, artboard: None });
|
|
let g = d.insert(Some(sub), usize::MAX, g).unwrap();
|
|
let flat = flatten_document(&s.doc().unwrap().doc, &FlattenOptions::default()).unwrap().unwrap();
|
|
assert!(flat.node(sub).is_none(), "the sublayer became flat art");
|
|
assert!(flat.node(g).is_some_and(Node::is_ruler_guide), "its guide is kept");
|
|
assert_eq!(flat.parent_of(g), Some(layer));
|
|
assert_eq!(flat.children(Some(layer)).and_then(|c| c.last()).map(|c| c.id), Some(g));
|
|
}
|
|
|
|
/// The guides of a sublayer and of its sublayers are gathered in paint order with the layer
|
|
/// that holds it, looking at the sublayer and each child of it and of its sublayers once.
|
|
/// Other roots give none.
|
|
#[test]
|
|
fn held_guides_look_at_each_node_once() {
|
|
let mut s = Session::new();
|
|
s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
|
|
let layer = s.doc().unwrap().doc.layers[0].id;
|
|
let sublayer =
|
|
|s: &mut Session, parent: NodeId| NodeId(s.execute("layer.newSublayer", &json!({"parent": parent.0})).unwrap()["id"].as_u64().unwrap());
|
|
let rect = |s: &mut Session, on: NodeId| {
|
|
s.execute("layer.setCurrent", &json!({"id": on.0})).unwrap();
|
|
NodeId(s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap())
|
|
};
|
|
let sub = sublayer(&mut s, layer);
|
|
let deep = sublayer(&mut s, sub);
|
|
let empty = sublayer(&mut s, layer);
|
|
let (a, b, c) = (rect(&mut s, sub), rect(&mut s, deep), rect(&mut s, empty));
|
|
let d = Arc::make_mut(&mut s.doc_mut().unwrap().doc);
|
|
let mut guide = |on: NodeId, pos: f64| {
|
|
let g = Node::new(d.alloc_id(), NodeKind::RulerGuide { vertical: true, pos, artboard: None });
|
|
d.insert(Some(on), usize::MAX, g).unwrap()
|
|
};
|
|
let (g1, g2, g3) = (guide(sub, 1.0), guide(deep, 2.0), guide(sub, 3.0));
|
|
let doc = &s.doc().unwrap().doc;
|
|
let ids = |n: &Node| {
|
|
let mut v = vec![];
|
|
n.walk(&mut |c| v.push(c.id));
|
|
v
|
|
};
|
|
assert_eq!(ids(doc.node(sub).unwrap()), vec![sub, deep, b, g2, a, g1, g3]);
|
|
let run = |roots: &[NodeId]| {
|
|
GUIDES_SEEN.with(|v| v.borrow_mut().clear());
|
|
let got: Vec<_> = held_guides(doc, roots.iter().copied()).into_iter().map(|(p, g)| (p, g.id)).collect();
|
|
(got, GUIDES_SEEN.with(|v| v.take()))
|
|
};
|
|
// Every node of the sublayer is looked at once, and the guides keep their paint order.
|
|
assert_eq!(run(&[sub]), (vec![(layer, g2), (layer, g1), (layer, g3)], vec![sub, deep, b, g2, a, g1, g3]));
|
|
// A sublayer that holds none gives none; a path holds none; a missing root and a top-level
|
|
// layer, which has no parent, are skipped.
|
|
assert_eq!(run(&[empty]), (vec![], vec![empty, c]));
|
|
assert_eq!(run(&[a]), (vec![], vec![a]));
|
|
assert_eq!(run(&[NodeId(u64::MAX), layer]), (vec![], vec![]));
|
|
// A deeper sublayer gives its guides to the sublayer that holds it.
|
|
assert_eq!(run(&[deep, deep]).0, vec![(sub, g2), (sub, g2)]);
|
|
}
|
|
|
|
/// The objects [`kept_session`] makes.
|
|
struct KeptArt {
|
|
/// Each group with its stroked rectangle (its fill overprints) and its stroked type.
|
|
groups: Vec<(NodeId, NodeId, NodeId)>,
|
|
/// A stroked rectangle and stroked type with an overprint, on their own.
|
|
rect: NodeId,
|
|
text: NodeId,
|
|
/// A stroked compound path and its pieces.
|
|
compound: NodeId,
|
|
pieces: Vec<NodeId>,
|
|
/// A group holding an unstroked rectangle and a hidden stroked rectangle.
|
|
hidden_group: NodeId,
|
|
hidden: NodeId,
|
|
/// An unstroked rectangle.
|
|
plain: NodeId,
|
|
}
|
|
|
|
/// A document without transparency: `n` groups, then the other objects of [`KeptArt`].
|
|
fn kept_session(n: usize) -> (Session, KeptArt) {
|
|
let mut s = Session::new();
|
|
s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
|
|
let id = |v: serde_json::Value| NodeId(v["id"].as_u64().unwrap());
|
|
let rect = |s: &mut Session, x: f64| id(s.execute("shape.rectangle", &json!({"x": x, "y": 10, "width": 20, "height": 20})).unwrap());
|
|
let text = |s: &mut Session, x: f64| {
|
|
let t = id(s.execute("text.create", &json!({"x": x, "y": 80, "text": "Hi", "size": 24})).unwrap());
|
|
s.execute("paint.setStroke", &json!({"color": "#000000", "ids": [t.0]})).unwrap();
|
|
t
|
|
};
|
|
let select = |s: &mut Session, ids: &[NodeId]| {
|
|
s.execute("select.set", &json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})).unwrap();
|
|
};
|
|
let overprint = |s: &mut Session, on: NodeId| {
|
|
s.execute("attributes.set", &json!({"ids": [on.0], "overprintFill": true})).unwrap();
|
|
};
|
|
let unstroked = |s: &mut Session, on: NodeId| {
|
|
s.execute("paint.setStroke", &json!({"none": true, "ids": [on.0]})).unwrap();
|
|
};
|
|
let mut groups = vec![];
|
|
for i in 0..n {
|
|
let x = (i % 10) as f64 * 30.0;
|
|
let (r, t) = (rect(&mut s, x), text(&mut s, x));
|
|
overprint(&mut s, r);
|
|
select(&mut s, &[r, t]);
|
|
groups.push((id(s.execute("object.group", &json!({})).unwrap()), r, t));
|
|
}
|
|
let (r, t) = (rect(&mut s, 0.0), text(&mut s, 100.0));
|
|
overprint(&mut s, t);
|
|
let (a, b) = (rect(&mut s, 200.0), rect(&mut s, 210.0));
|
|
select(&mut s, &[a, b]);
|
|
let compound = id(s.execute("object.compoundPath.make", &json!({})).unwrap());
|
|
s.execute("paint.setStroke", &json!({"color": "#000000", "ids": [compound.0]})).unwrap();
|
|
let pieces = s.doc().unwrap().doc.node(compound).unwrap().children().unwrap().iter().map(|c| c.id).collect();
|
|
let (shown, hidden) = (rect(&mut s, 300.0), rect(&mut s, 310.0));
|
|
unstroked(&mut s, shown);
|
|
select(&mut s, &[shown, hidden]);
|
|
let hidden_group = id(s.execute("object.group", &json!({})).unwrap());
|
|
s.execute("object.hide", &json!({"ids": [hidden.0]})).unwrap();
|
|
let plain = rect(&mut s, 350.0);
|
|
unstroked(&mut s, plain);
|
|
(s, KeptArt { groups, rect: r, text: t, compound, pieces, hidden_group, hidden, plain })
|
|
}
|
|
|
|
/// Every option on: type and strokes outlined, overprints dropped.
|
|
fn outlining() -> FlattenOptions {
|
|
FlattenOptions { text_to_outlines: true, strokes_to_outlines: true, preserve_overprints: false, ..FlattenOptions::default() }
|
|
}
|
|
|
|
/// The top-level objects of `d`'s first layer, in paint order.
|
|
fn top_level(d: &Document) -> Vec<NodeId> {
|
|
d.layers[0].children().unwrap().iter().map(|c| c.id).collect()
|
|
}
|
|
|
|
fn sorted(mut ids: Vec<NodeId>) -> Vec<NodeId> {
|
|
ids.sort();
|
|
ids
|
|
}
|
|
|
|
/// The nodes [`Kept::of`] looked at while `f` ran, sorted.
|
|
fn kept_seen_by(f: impl FnOnce()) -> Vec<NodeId> {
|
|
KEPT_SEEN.with(|v| v.borrow_mut().clear());
|
|
f();
|
|
sorted(KEPT_SEEN.with(|v| v.take()))
|
|
}
|
|
|
|
/// The Flattener Preview, `object.flattenTransparency` and flattening a whole document each look
|
|
/// at every node of the objects without transparency once, with type and strokes outlined and
|
|
/// overprints dropped, an object they leave as it is included.
|
|
#[test]
|
|
fn kept_objects_are_looked_at_once() {
|
|
let (mut s, _) = kept_session(100);
|
|
let o = outlining();
|
|
let doc = s.doc().unwrap().doc.clone();
|
|
let roots = top_level(&doc);
|
|
let mut nodes = vec![];
|
|
for r in &roots {
|
|
doc.node(*r).unwrap().walk(&mut |c| nodes.push(c.id));
|
|
}
|
|
nodes.sort();
|
|
assert_eq!(nodes.len(), 309);
|
|
let preview = kept_seen_by(|| drop(super::super::report::report(&doc, &roots, &o).unwrap()));
|
|
assert!(preview == nodes, "the preview looked at {} nodes of {}", preview.len(), nodes.len());
|
|
let whole = kept_seen_by(|| drop(flatten_document(&doc, &o).unwrap().unwrap()));
|
|
assert!(whole == nodes, "flattening the document looked at {} nodes of {}", whole.len(), nodes.len());
|
|
let ids: Vec<u64> = roots.iter().map(|r| r.0).collect();
|
|
let command = kept_seen_by(|| {
|
|
s.execute(
|
|
"object.flattenTransparency",
|
|
&json!({"ids": ids, "textToOutlines": true, "strokesToOutlines": true, "preserveOverprints": false}),
|
|
)
|
|
.unwrap();
|
|
});
|
|
assert!(command == nodes, "object.flattenTransparency looked at {} nodes of {}", command.len(), nodes.len());
|
|
}
|
|
|
|
/// [`apply`]'s outlining of `kept` (objects of `d` without transparency) with `o`, done as a
|
|
/// walk of each object for each option: → the ids standing for them, in paint order.
|
|
fn outlined_walk_by_walk(d: &mut Document, kept: &[NodeId], o: &FlattenOptions) -> Vec<NodeId> {
|
|
let brushes = if o.strokes_to_outlines { vectorcraft_brush::library(d) } else { vec![] };
|
|
let mut ids = vec![];
|
|
for &root in kept {
|
|
let mut id = root;
|
|
if o.text_to_outlines {
|
|
let mut texts = vec![];
|
|
d.node(id).unwrap().walk(&mut |c| {
|
|
if matches!(c.kind, NodeKind::Text(_)) {
|
|
texts.push(c.clone());
|
|
}
|
|
});
|
|
for t in texts {
|
|
let Some(out) = outlined_text(&t) else { continue };
|
|
let out = d.reid(&out);
|
|
if t.id == root {
|
|
id = out.id;
|
|
}
|
|
*d.node_mut(t.id).unwrap() = out;
|
|
}
|
|
}
|
|
if o.strokes_to_outlines {
|
|
id = crate::cmd::pathops::outline_strokes_under(d, &brushes, id).unwrap().0;
|
|
}
|
|
if !o.preserve_overprints {
|
|
drop_overprints(d.node_mut(id).unwrap());
|
|
}
|
|
ids.push(id);
|
|
}
|
|
ids.sort_by_key(|id| d.index_path(*id));
|
|
ids
|
|
}
|
|
|
|
/// With each mix of the text, stroke and overprint options, the objects without transparency
|
|
/// end as a walk of each of them for each option leaves them: the same art, ids and selection.
|
|
#[test]
|
|
fn kept_objects_change_as_a_walk_per_option_changes_them() {
|
|
let (s, _) = kept_session(3);
|
|
let doc = Document::clone(&s.doc().unwrap().doc);
|
|
let roots = top_level(&doc);
|
|
for bits in 0..8u8 {
|
|
let o = FlattenOptions {
|
|
text_to_outlines: bits & 1 != 0,
|
|
strokes_to_outlines: bits & 2 != 0,
|
|
preserve_overprints: bits & 4 != 0,
|
|
..FlattenOptions::default()
|
|
};
|
|
let p = plan(&doc, &roots, &o, true).unwrap();
|
|
assert!(p.flat.is_empty(), "{o:?}");
|
|
// In the order the plan's groups come in.
|
|
let kept = p.kept.clone();
|
|
assert_eq!(sorted(kept.clone()), sorted(roots.clone()), "{o:?}");
|
|
let mut once = doc.clone();
|
|
let mut sel = vectorcraft_doc::Selection::default();
|
|
let (ids, ..) = apply(&mut once, &mut sel, p, &o).unwrap();
|
|
let mut walked = doc.clone();
|
|
let want = outlined_walk_by_walk(&mut walked, &kept, &o);
|
|
assert_eq!(ids, want, "{o:?}");
|
|
assert!(once == walked, "{o:?}");
|
|
assert_eq!(once == doc, bits == 4, "{o:?}: only with every option off does nothing change");
|
|
}
|
|
}
|
|
|
|
/// The Flattener Preview lists the kept objects the options change, and of those the type and
|
|
/// the stroked paths that show and are not pieces of a compound path.
|
|
#[test]
|
|
fn the_preview_lists_what_the_options_change_in_kept_objects() {
|
|
let (s, a) = kept_session(2);
|
|
let doc = &s.doc().unwrap().doc;
|
|
let roots = top_level(doc);
|
|
let r = super::super::report::report(doc, &roots, &outlining()).unwrap();
|
|
let (g, rects, texts): (Vec<_>, Vec<_>, Vec<_>) =
|
|
(a.groups.iter().map(|g| g.0).collect(), a.groups.iter().map(|g| g.1).collect(), a.groups.iter().map(|g| g.2).collect());
|
|
assert_eq!(r.affected, [g.clone(), vec![a.rect, a.text, a.compound, a.hidden_group]].concat());
|
|
// Both lists come in the order the plan's groups do.
|
|
assert_eq!(sorted(r.text.clone()), sorted([texts, vec![a.text]].concat()));
|
|
assert_eq!(sorted(r.strokes.clone()), sorted([rects, vec![a.rect, a.compound]].concat()));
|
|
assert!(!r.strokes.contains(&a.hidden) && !r.strokes.iter().any(|id| a.pieces.contains(id)) && !r.affected.contains(&a.plain));
|
|
// Dropping overprints alone changes the objects that overprint.
|
|
let o = FlattenOptions { preserve_overprints: false, ..FlattenOptions::default() };
|
|
let r = super::super::report::report(doc, &roots, &o).unwrap();
|
|
assert_eq!((r.affected, r.text, r.strokes), ([g, vec![a.text]].concat(), vec![], vec![]));
|
|
// With every option off, nothing.
|
|
assert!(super::super::report::report(doc, &roots, &FlattenOptions::default()).unwrap().affected.is_empty());
|
|
}
|
|
|
|
/// In a file without transparency with Clip Complex Regions on, art under a group's opaque
|
|
/// image within one of its pixels joins the group, also where a long image is made at a lower
|
|
/// resolution and its pixels are wider than at the preset's.
|
|
#[test]
|
|
fn art_under_the_edge_of_a_long_opaque_image_joins_its_group() {
|
|
let mut s = Session::new();
|
|
s.execute("file.new", &json!({"width": 31000, "height": 100})).unwrap();
|
|
let rect = |s: &mut Session, x: f64, w: f64| {
|
|
let id = s.execute("shape.rectangle", &json!({"x": x, "y": 10, "width": w, "height": 10})).unwrap()["id"].as_u64().unwrap();
|
|
s.execute("paint.setStroke", &json!({"none": true, "ids": [id]})).unwrap();
|
|
NodeId(id)
|
|
};
|
|
// 0.5 pt left of A: wider than a pixel at 300 ppi, narrower than one of a 30,000 pt image.
|
|
let d = rect(&mut s, 40.0, 19.5);
|
|
let a = rect(&mut s, 60.0, 40.0);
|
|
let t = rect(&mut s, 95.0, 30_000.0);
|
|
s.execute("transparency.set", &json!({"ids": [t.0], "opacity": 50})).unwrap();
|
|
let o = FlattenOptions { no_transparency: Some(Default::default()), clip_complex_regions: true, ..FlattenOptions::default() };
|
|
let doc = &s.doc().unwrap().doc;
|
|
let long = plan(doc, &[d, a, t], &o, false).unwrap();
|
|
assert!(long.kept.is_empty(), "{:?}", long.kept);
|
|
assert_eq!(long.flat.iter().map(|f| f.roots.clone()).collect::<Vec<_>>(), vec![vec![d, a, t]]);
|
|
// Short, the image has 300 ppi pixels: D stays.
|
|
let short = rect(&mut s, 95.0, 40.0);
|
|
s.execute("transparency.set", &json!({"ids": [short.0], "opacity": 50})).unwrap();
|
|
let doc = &s.doc().unwrap().doc;
|
|
assert_eq!(plan(doc, &[d, a, short], &o, false).unwrap().kept, vec![d]);
|
|
// 100,000 pt long, its pixels are over 3 pt wide: art 3 pt away, whose reach doesn't touch
|
|
// A's, joins too.
|
|
let far = rect(&mut s, 40.0, 17.0);
|
|
let longer = rect(&mut s, 95.0, 100_000.0);
|
|
s.execute("transparency.set", &json!({"ids": [longer.0], "opacity": 50})).unwrap();
|
|
let doc = &s.doc().unwrap().doc;
|
|
let p = plan(doc, &[far, a, longer], &o, false).unwrap();
|
|
assert!(p.kept.is_empty(), "{:?}", p.kept);
|
|
assert_eq!(p.flat.iter().map(|f| f.roots.clone()).collect::<Vec<_>>(), vec![vec![far, a, longer]]);
|
|
}
|
|
}
|