Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

PDF/EPS export: transparent images in patterns nested in tile art flatten

dotCooCooc09ea597319f
diff --git a/crates/engine/src/cmd/expand.rs b/crates/engine/src/cmd/expand.rs
index b3bfab9c6..eec854a74 100644
--- a/crates/engine/src/cmd/expand.rs
+++ b/crates/engine/src/cmd/expand.rs
@@ -451,47 +451,73 @@ fn expand_pattern_fills(s: &mut Session) -> Result<()> {
/// in the tile art, the fill, the shape or a group the shape is in has opacity or a blending
/// mode. Blends, envelopes, repeats and Intertwine groups that hold such a fill are expanded
/// first ([`expand_live_with_transparent_image_patterns`]). Hidden shapes and shapes in hidden
-/// groups or layers and in template layers stay as they are. Returns how many objects changed.
+/// groups or layers and in template layers stay as they are. A pattern fill in tile art counts
+/// too, down to the [`PATTERN_LEVELS`] the canvas draws, and the tile art the expansion makes is
+/// expanded again for it. Pattern fills stay once the expanded art holds
+/// [`MAX_GENERATED`](vectorcraft_doc::live::MAX_GENERATED) objects. Returns how many objects
+/// changed.
pub(crate) fn expand_transparent_image_patterns(
d: &mut Document,
root: NodeId,
see_through: &BTreeSet<String>,
colorize: &dyn Fn(&Document, &Node) -> bool,
) -> Result<usize> {
- let live = expand_live_with_transparent_image_patterns(d, root, see_through, colorize)?;
- let (_, n) = replace_leaves(d, root, |d, l| {
- // Most leaves have no pattern fill: skip the ancestry walk for them.
- if !l.appearance.items.iter().any(|i| pattern_fill(d, i).is_some()) {
- return None;
- }
- // The expanded art would be shown.
- if !d.ancestry(l.id).unwrap_or_default().iter().filter_map(|a| d.node(*a)).all(drawn) {
- return None;
+ let mut changed = 0;
+ let made = std::cell::Cell::new(0usize);
+ // Each pass brings the patterns in the expanded tiles' art up one level.
+ for levels in (1..=PATTERN_LEVELS).rev() {
+ let live = expand_live_with_transparent_image_patterns(d, root, see_through, colorize, levels)?;
+ let (_, n) = replace_leaves(d, root, |d, l| {
+ // Past the budget, and for most leaves, which have no pattern fill, skip the ancestry walk.
+ if made.get() >= vectorcraft_doc::live::MAX_GENERATED || !l.appearance.items.iter().any(|i| pattern_fill(d, i).is_some()) {
+ return None;
+ }
+ // The expanded art would be shown.
+ if !d.ancestry(l.id).unwrap_or_default().iter().filter_map(|a| d.node(*a)).all(drawn) {
+ return None;
+ }
+ let art = expand_patterns_where(d, l, |d, i| transparent_pattern_fill(d, l, i, see_through, colorize, levels))?;
+ made.set(made.get().saturating_add(art.count()));
+ Some(art)
+ })?;
+ if live + n == 0 {
+ break;
}
- expand_patterns_where(d, l, |d, i| transparent_pattern_fill(d, l, i, see_through, colorize))
- })?;
- Ok(live + n)
+ changed += live + n;
+ }
+ Ok(changed)
}
+/// How many levels of patterns the canvas draws: a pattern fill in the art of a pattern, and so
+/// on, as [`vectorcraft_render`] draws them.
+const PATTERN_LEVELS: u32 = 3;
+
/// Whether a layer of `d` holds a pattern fill that [`expand_transparent_image_patterns`] would
/// expand with `see_through` and `colorize` ([`holds_transparent_image_patterns`]).
pub(crate) fn has_transparent_image_patterns(d: &Document, see_through: &BTreeSet<String>, colorize: &dyn Fn(&Document, &Node) -> bool) -> bool {
- d.layers.iter().any(|l| holds_transparent_image_patterns(d, l, see_through, colorize))
+ d.layers.iter().any(|l| holds_transparent_image_patterns(d, l, see_through, colorize, PATTERN_LEVELS))
}
/// Whether `n`, art of `d`, is or holds a shown path or compound path (in groups, blends,
/// envelopes, repeats and Intertwine groups) with a pattern fill that
-/// [`transparent_pattern_fill`] counts. Guides, clipping paths and template layers don't count.
-fn holds_transparent_image_patterns(d: &Document, n: &Node, see_through: &BTreeSet<String>, colorize: &dyn Fn(&Document, &Node) -> bool) -> bool {
+/// [`transparent_pattern_fill`] counts with `levels`. Guides, clipping paths and template layers
+/// don't count.
+fn holds_transparent_image_patterns(
+ d: &Document,
+ n: &Node,
+ see_through: &BTreeSet<String>,
+ colorize: &dyn Fn(&Document, &Node) -> bool,
+ levels: u32,
+) -> bool {
if !drawn(n) {
return false;
}
match &n.kind {
NodeKind::Path { guide: true, .. } | NodeKind::Path { clipping: true, .. } => false,
NodeKind::Path { .. } | NodeKind::Compound { .. } => {
- n.appearance.items.iter().any(|i| transparent_pattern_fill(d, n, i, see_through, colorize))
+ n.appearance.items.iter().any(|i| transparent_pattern_fill(d, n, i, see_through, colorize, levels))
}
- _ => n.children().is_some_and(|ch| ch.iter().any(|c| holds_transparent_image_patterns(d, c, see_through, colorize))),
+ _ => n.children().is_some_and(|ch| ch.iter().any(|c| holds_transparent_image_patterns(d, c, see_through, colorize, levels))),
}
}
@@ -501,7 +527,7 @@ fn drawn(n: &Node) -> bool {
}
/// Expand the shown blends, envelopes, repeats and Intertwine groups under `root` that hold a
-/// pattern fill [`holds_transparent_image_patterns`] counts into the art the exporters write for
+/// pattern fill [`holds_transparent_image_patterns`] counts with `levels` into the art the exporters write for
/// them ([`expand_live_deep`](vectorcraft_render::effects::expand_live_deep), under one budget for
/// everything nested in each), so the shapes they draw are leaves. Returns how many were expanded.
fn expand_live_with_transparent_image_patterns(
@@ -509,19 +535,27 @@ fn expand_live_with_transparent_image_patterns(
root: NodeId,
see_through: &BTreeSet<String>,
colorize: &dyn Fn(&Document, &Node) -> bool,
+ levels: u32,
) -> Result<usize> {
- fn outermost(d: &Document, n: &Node, see_through: &BTreeSet<String>, colorize: &dyn Fn(&Document, &Node) -> bool, out: &mut Vec<NodeId>) {
+ fn outermost(
+ d: &Document,
+ n: &Node,
+ see_through: &BTreeSet<String>,
+ colorize: &dyn Fn(&Document, &Node) -> bool,
+ levels: u32,
+ out: &mut Vec<NodeId>,
+ ) {
if !drawn(n) {
return;
}
match &n.kind {
NodeKind::Blend { .. } | NodeKind::Envelope { .. } | NodeKind::Repeat(_) | NodeKind::Intertwine { .. } => {
- if holds_transparent_image_patterns(d, n, see_through, colorize) {
+ if holds_transparent_image_patterns(d, n, see_through, colorize, levels) {
out.push(n.id);
}
}
NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } => {
- children.iter().for_each(|c| outermost(d, c, see_through, colorize, out));
+ children.iter().for_each(|c| outermost(d, c, see_through, colorize, levels, out));
}
_ => {}
}
@@ -536,7 +570,7 @@ fn expand_live_with_transparent_image_patterns(
}
let mut live = vec![];
if let Some(n) = d.node(root) {
- outermost(d, n, see_through, colorize, &mut live);
+ outermost(d, n, see_through, colorize, levels, &mut live);
}
let mut count = 0;
for id in &live {
@@ -553,18 +587,36 @@ fn expand_live_with_transparent_image_patterns(
}
/// Whether `i`, an item of leaf `l`, is a pattern fill whose tile art holds a transparent image
-/// ([`transparent_image`]), counting the fill's and the shape's opacity and blending mode.
+/// ([`transparent_image`], through pattern fills in that art down to `levels` patterns),
+/// counting the fill's and the shape's opacity and blending mode.
fn transparent_pattern_fill(
d: &Document,
l: &Node,
i: &AppearanceItem,
see_through: &BTreeSet<String>,
colorize: &dyn Fn(&Document, &Node) -> bool,
+ levels: u32,
) -> bool {
- let Some((f, def, _)) = pattern_fill(d, i) else { return false };
let shape = d.ancestry(l.id).unwrap_or_default().iter().filter_map(|a| d.node(*a)).any(blended);
- let on = shape || f.opacity < 1.0 || f.blend != BlendMode::Normal;
- def.art.iter().any(|a| transparent_image(d, a, see_through, colorize, on))
+ pattern_fill_holds_transparent_image(d, i, see_through, colorize, shape, levels)
+}
+
+/// Whether `i` is a pattern fill whose tile art holds a transparent image ([`transparent_image`]),
+/// down to `levels` patterns, counting the fill's opacity and blending mode, or anything when `on`.
+fn pattern_fill_holds_transparent_image(
+ d: &Document,
+ i: &AppearanceItem,
+ keys: &BTreeSet<String>,
+ colorize: &dyn Fn(&Document, &Node) -> bool,
+ on: bool,
+ levels: u32,
+) -> bool {
+ if levels == 0 {
+ return false;
+ }
+ let Some((f, def, _)) = pattern_fill(d, i) else { return false };
+ let on = on || f.opacity < 1.0 || f.blend != BlendMode::Normal;
+ def.art.iter().any(|a| transparent_image(d, a, keys, colorize, on, levels - 1))
}
/// Whether `n` has opacity or a blending mode of its own.
@@ -574,12 +626,19 @@ fn blended(n: &Node) -> bool {
/// Whether `n` (art of `d`) is or holds an image with see-through pixels (key in `keys`), a
/// colorize paint that `colorize` counts, opacity or a blending mode of its own or of a group in
-/// `n`, or anywhere when `on`.
-fn transparent_image(d: &Document, n: &Node, keys: &BTreeSet<String>, colorize: &dyn Fn(&Document, &Node) -> bool, on: bool) -> bool {
+/// `n`, or anywhere when `on`, also in the tile art of the pattern fills of the paths in `n`, down
+/// to `levels` patterns. Hidden art doesn't count.
+fn transparent_image(d: &Document, n: &Node, keys: &BTreeSet<String>, colorize: &dyn Fn(&Document, &Node) -> bool, on: bool, levels: u32) -> bool {
+ if !n.visible {
+ return false;
+ }
let on = on || blended(n);
match &n.kind {
NodeKind::Image(im) => on || keys.contains(&im.key) || (n.extras().colorize.is_some() && colorize(d, n)),
- _ => n.children().is_some_and(|ch| ch.iter().any(|c| transparent_image(d, c, keys, colorize, on))),
+ NodeKind::Path { .. } | NodeKind::Compound { .. } => {
+ n.appearance.items.iter().any(|i| pattern_fill_holds_transparent_image(d, i, keys, colorize, on, levels))
+ }
+ _ => n.children().is_some_and(|ch| ch.iter().any(|c| transparent_image(d, c, keys, colorize, on, levels))),
}
}
diff --git a/crates/engine/src/tests/legacy_ai.rs b/crates/engine/src/tests/legacy_ai.rs
index 96878b043..ecac48bb7 100644
--- a/crates/engine/src/tests/legacy_ai.rs
+++ b/crates/engine/src/tests/legacy_ai.rs
@@ -855,6 +855,54 @@ fn pdf13_flattens_colorized_pattern_tile_images_in_a_repeat() {
assert_pdf13_draws_pattern_square_as_canvas(&mut s);
}
+/// [`colorized_pattern_over_blue`] with the square filled with a pattern named `outer` whose tile
+/// art is a 32 pt square filled with the colorized image pattern.
+fn nested_colorized_pattern_over_blue() -> Session {
+ let mut s = colorized_pattern_over_blue();
+ let square = pattern_square(&s);
+ s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 32, "height": 32})).unwrap();
+ let d = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+ let inner = d.patterns[0].name.clone();
+ let rect = d.layers[0].children().unwrap().last().unwrap().id;
+ let mut tile = d.remove(rect).unwrap();
+ let paint = vectorcraft_color::Paint::Pattern { pattern: inner, xf: Default::default() };
+ let tile_node = std::sync::Arc::make_mut(&mut tile);
+ tile_node.appearance.items.retain(|i| matches!(i, vectorcraft_doc::appearance::AppearanceItem::Fill(_)));
+ for i in &mut tile_node.appearance.items {
+ if let vectorcraft_doc::appearance::AppearanceItem::Fill(f) = i {
+ f.paint = paint.clone();
+ }
+ }
+ let mut outer = d.patterns[0].clone();
+ outer.name = "outer".into();
+ outer.art = vec![tile];
+ d.patterns.push(outer);
+ for i in &mut d.node_mut(square).unwrap().appearance.items {
+ if let vectorcraft_doc::appearance::AppearanceItem::Fill(f) = i {
+ f.paint = vectorcraft_color::Paint::Pattern { pattern: "outer".into(), xf: Default::default() };
+ }
+ }
+ s
+}
+
+#[test]
+fn pdf13_flattens_colorized_image_in_a_pattern_nested_in_tile_art() {
+ let mut s = nested_colorized_pattern_over_blue();
+ assert_eq!(colour_at(&s.doc().unwrap().doc, 72.0, 72.0), [255, 0, 0]);
+ assert!(crate::cmd::flatten::flatten_document(&s.doc().unwrap().doc, &crate::cmd::FlattenOptions::default()).unwrap().is_some());
+ assert_pdf13_draws_pattern_square_as_canvas(&mut s);
+}
+
+#[test]
+fn flattening_skips_a_pattern_nested_in_hidden_tile_art() {
+ let mut s = nested_colorized_pattern_over_blue();
+ let d = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+ let outer = d.pattern_mut("outer").unwrap();
+ std::sync::Arc::make_mut(&mut outer.art[0]).visible = false;
+ let d = &s.doc().unwrap().doc;
+ assert!(crate::cmd::flatten::flatten_document(d, &crate::cmd::FlattenOptions::default()).unwrap().is_none());
+}
+
#[test]
fn pdf13_leaves_a_hidden_shape_with_a_colorized_pattern_tile_image_hidden() {
let mut s = colorized_pattern_over_blue();