diff --git a/crates/effects/src/distort.rs b/crates/effects/src/distort.rs index 33a864516..b7cb564d5 100644 --- a/crates/effects/src/distort.rs +++ b/crates/effects/src/distort.rs @@ -145,11 +145,17 @@ const MAX_REACH: f64 = 1.0e9; /// a 2000-anchor path. Stacked Transform effects multiply their copies (three of 1000 copies make /// a thousand million of one square), so the limit is on the result, not on each effect's count. pub(crate) const MAX_COPY_ANCHORS: usize = 2_000_000; -/// Most image nodes a Transform effect's copies make of an art, the originals included: 1000 -/// copies of a 2000-image art. Stacked Transform effects multiply their copies (three of 1000 -/// copies make a thousand million of one image), so the limit is on the result, not on each -/// effect's count. -pub(crate) const MAX_COPY_IMAGES: usize = 2_000_000; +/// Most image and symbol instance nodes a Transform effect's copies make of an art, the originals +/// included: 1000 copies of a 2000-image art. Stacked Transform effects multiply their copies +/// (three of 1000 copies make a thousand million of one image), so the limit is on the result, +/// not on each effect's count. +pub(crate) const MAX_COPY_OBJECTS: usize = 2_000_000; + +/// Does `r` stay within [`MAX_REACH`] of the origin? A Transform effect's copies stop before one +/// doesn't. +pub(crate) fn within_reach(r: Rect) -> bool { + [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.abs() <= MAX_REACH) +} /// Transform effect: scale, rotate and reflect about reference point `reference` of the bounds /// (the 9-point grid, 4 = centre), then move; `copies` more times, each from the last. With @@ -166,7 +172,6 @@ pub(crate) fn transform_within(path: &PathData, b: Rect, p: &Value, seed: u64, m if copies == 0 { return path.transformed(m); } - let within = |r: Rect| [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.abs() <= MAX_REACH); // Each copy adds the path once more, and a Transform after this one copies the lot again: // copies stop where the result would pass [`MAX_COPY_ANCHORS`] (#1705). let each = path.anchor_count(); @@ -179,7 +184,7 @@ pub(crate) fn transform_within(path: &PathData, b: Rect, p: &Value, seed: u64, m break; } cur = cur.transformed(m); - if !cur.bounds().is_some_and(within) { + if !cur.bounds().is_some_and(within_reach) { break; } out.subpaths.extend(cur.subpaths.iter().cloned()); @@ -191,7 +196,7 @@ pub(crate) fn transform_within(path: &PathData, b: Rect, p: &Value, seed: u64, m /// `b` (the reference point lies on them), params `p` and the object's `seed` for Random: the map /// applies to the object itself when `copies` is 0, and once more to each of `copies` copies /// otherwise (see [`transform_within`], and images, whose copies count nodes against -/// [`MAX_COPY_IMAGES`]). +/// [`MAX_COPY_OBJECTS`]). pub(crate) fn transform_map(b: Rect, p: &Value, seed: u64) -> (Affine, usize) { let random = flag(p, "random", false); // The share (0..1) of value `k` applied. diff --git a/crates/effects/src/reshape.rs b/crates/effects/src/reshape.rs index 712d07ab7..1113000c0 100644 --- a/crates/effects/src/reshape.rs +++ b/crates/effects/src/reshape.rs @@ -244,9 +244,9 @@ pub(crate) fn geometry_effects(n: &Node) -> Vec<&Effect> { } /// Apply `fx` to every path under `art` as one piece: each effect takes the whole art's bounds as -/// its reference box and the art's seed (a random Transform moves the pieces together). Images -/// follow a Transform effect the same way ([`transform_images`]); other geometry effects leave -/// them as they are (a raster follows a non-affine map only as a mesh warp). +/// its reference box and the art's seed (a random Transform moves the pieces together). Images and +/// symbol instances follow a Transform effect the same way ([`transform_placed`]); other geometry +/// effects leave them as they are (a raster follows a non-affine map only as a mesh warp). pub(crate) fn reshape_leaves(art: &mut Node, fx: &[&Effect]) { let seed = art.id.0; // The placed gradients of type's outlines in `art` (`outline_text`) move and scale with the @@ -263,7 +263,7 @@ pub(crate) fn reshape_leaves(art: &mut Node, fx: &[&Effect]) { }); if e.id == "distort.transform" { let (m, copies) = crate::distort::transform_map(bounds, ¶ms, seed); - transform_images(art, m, copies); + transform_placed(art, m, copies); } } if !fx.is_empty() && outlines.iter().any(Option::is_some) { @@ -342,36 +342,46 @@ fn box_map(from: Rect, to: Rect) -> vectorcraft_geom::Affine { vectorcraft_geom::Affine::new([sx, 0.0, 0.0, sy, tx, ty]) } -/// Apply the Transform effect's map `m` to every image under `n`, as [`for_each_leaf`] does to -/// paths: the map goes into the image's placement (pixel space → document), and `copies` more -/// images follow, each mapped once more than the last. Without copies the image itself takes the -/// map, as a path does. -fn transform_images(n: &mut Node, m: Affine, copies: usize) { - transform_images_within(n, m, copies, crate::distort::MAX_COPY_IMAGES) +/// Apply the Transform effect's map `m` to every image and symbol instance under `n`, as +/// [`for_each_leaf`] does to paths: the map goes into the object's placement, and `copies` more +/// follow, each mapped once more than the last. Without copies the object itself takes the map, +/// as a path does. +fn transform_placed(n: &mut Node, m: Affine, copies: usize) { + transform_placed_within(n, m, copies, crate::distort::MAX_COPY_OBJECTS) } -/// [`transform_images`] whose copies make at most `max` image nodes of the art, the originals -/// included: each copy adds the image once more, and a Transform after this one copies the lot -/// again, so copies stop where the result would pass `max` (#2042). -pub(crate) fn transform_images_within(n: &mut Node, m: Affine, copies: usize, max: usize) { - let mut room = max.saturating_sub(image_count(n)); - copy_images(n, m, copies, &mut room); +/// [`transform_placed`] whose copies make at most `max` image and symbol instance nodes of the art, +/// the originals included: each copy adds the object once more, and a Transform after this one +/// copies the lot again, so copies stop where the result would pass `max` (#2042). +pub(crate) fn transform_placed_within(n: &mut Node, m: Affine, copies: usize, max: usize) { + let mut room = max.saturating_sub(placed_count(n)); + copy_placed(n, m, copies, &mut room); } -/// The walk of [`transform_images`]: the map and its copies go to each image in document order, -/// each copy taking one from `room` (what the art can still grow by), until the budget is full. -fn copy_images(n: &mut Node, m: Affine, copies: usize, room: &mut usize) { +/// An object that a Transform effect places through its transform rather than reshapes: an image +/// (pixel space to document) or a symbol instance (the symbol's art to document). +fn is_placed(n: &Node) -> bool { + matches!(n.kind, NodeKind::Image(_) | NodeKind::SymbolInstance { .. }) +} + +/// The walk of [`transform_placed`]: the map and its copies go to each image and symbol instance in +/// document order, each copy taking one from `room` (what the art can still grow by), until the +/// budget is full. As with a path, the copies stop before one reaches past +/// [`crate::distort::within_reach`]. +fn copy_placed(n: &mut Node, m: Affine, copies: usize, room: &mut usize) { let Some(children) = n.children_mut() else { return }; for c in children.iter_mut() { - if !matches!(c.kind, NodeKind::Image(_)) { - copy_images(Arc::make_mut(c), m, copies, room); + if !is_placed(c) { + copy_placed(Arc::make_mut(c), m, copies, room); continue; } let src = (**c).clone(); let placed = |xf: Affine| { let mut one = src.clone(); - if let NodeKind::Image(im) = &mut one.kind { - im.xf = xf * im.xf; + match &mut one.kind { + NodeKind::Image(im) => im.xf = xf * im.xf, + NodeKind::SymbolInstance { xf: at, .. } => *at = xf * *at, + _ => {} } one }; @@ -379,26 +389,28 @@ fn copy_images(n: &mut Node, m: Affine, copies: usize, room: &mut usize) { *c = Arc::new(placed(m)); continue; } - let made = copies.min(*room); - *room -= made; - // The copies become image nodes of their own, under a group with the image's id, name and - // place in the art (as the runs an outlined text gets). - let mut images: Vec> = Vec::with_capacity(made + 1); - images.push(Arc::new(placed(Affine::IDENTITY))); + // The copies become nodes of their own, under a group with the object's id, name and place + // in the art (as the runs an outlined text gets). + let mut placements: Vec> = vec![Arc::new(placed(Affine::IDENTITY))]; let mut xf = Affine::IDENTITY; - for _ in 0..made { + for _ in 0..copies.min(*room) { xf *= m; - images.push(Arc::new(placed(xf))); + let copy = placed(xf); + if !copy.geometric_bounds().is_some_and(crate::distort::within_reach) { + break; + } + placements.push(Arc::new(copy)); } - let mut g = Node::group(src.id, images); + *room -= placements.len() - 1; + let mut g = Node::group(src.id, placements); g.name = src.name.clone(); *c = Arc::new(g); } } -/// How many image nodes `n` holds below itself. -fn image_count(n: &Node) -> usize { - n.children().into_iter().flatten().map(|c| usize::from(matches!(c.kind, NodeKind::Image(_))) + image_count(c)).sum() +/// How many images and symbol instances `n` holds below itself. +fn placed_count(n: &Node) -> usize { + n.children().into_iter().flatten().map(|c| usize::from(is_placed(c)) + placed_count(c)).sum() } /// `n` with type anywhere inside it outlined and live objects evaluated, so geometry effects on diff --git a/crates/effects/src/tests.rs b/crates/effects/src/tests.rs index 7b238c496..c89144583 100644 --- a/crates/effects/src/tests.rs +++ b/crates/effects/src/tests.rs @@ -18,6 +18,16 @@ fn image_xs(n: &Node, out: &mut Vec) { } } +/// Every symbol instance under `n`, in document order (its placement's x). +fn instance_xs(n: &Node, out: &mut Vec) { + if let NodeKind::SymbolInstance { xf, .. } = &n.kind { + out.push(xf.as_coeffs()[4]); + } + for c in n.children().into_iter().flatten() { + instance_xs(c, out); + } +} + fn square() -> PathData { shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)) } @@ -264,13 +274,13 @@ fn stacked_transform_copies_stay_within_the_image_budget() { let mut art = Node::group(id, vec![Arc::new(image())]); let mut counts = vec![]; for _ in 0..3 { - crate::reshape::transform_images_within(&mut art, m, 1000, 100); + crate::reshape::transform_placed_within(&mut art, m, 1000, 100); counts.push(count(&art)); } assert_eq!(counts, [100, 100, 100], "99 copies, then no room for a copy of them"); // Within the budget every copy is made, and the effect's own budget takes a thousand copies. let mut art = Node::group(id, vec![Arc::new(image())]); - crate::reshape::transform_images_within(&mut art, m, 24, 100); + crate::reshape::transform_placed_within(&mut art, m, 24, 100); assert_eq!(count(&art), 25); let mut g = Node::group(id, vec![Arc::new(image())]); g.appearance.effects.push(fx("distort.transform", json!({"moveH": 70, "copies": 1000}))); @@ -333,6 +343,87 @@ fn transform_on_a_group_moves_and_copies_its_images() { assert_eq!(xs, [30.0], "scaled about its own bottom-right corner"); } +/// #2023: a Transform effect on a group moves and copies its symbol instances as it does its paths +/// and images: the map goes into each instance's placement, and every copy is an instance of its +/// own. +#[test] +fn transform_on_a_group_moves_and_copies_its_symbol_instances() { + use std::sync::Arc; + + use vectorcraft_doc::{Appearance, Node, NodeId, NodeKind}; + let id = NodeId(9); + let instance = || Node::new(id, NodeKind::SymbolInstance { symbol: "s".into(), xf: Affine::translate((5.0, 40.0)) }); + let xs = |art: &Node| { + let mut xs = vec![]; + instance_xs(art, &mut xs); + xs.sort_by(f64::total_cmp); + xs + }; + let mut g = Node::group(id, vec![Arc::new(Node::path(id, square(), Appearance::default())), Arc::new(instance())]); + g.appearance.effects.push(fx("distort.transform", json!({"moveH": 70, "copies": 2}))); + assert_eq!(xs(&evaluate_container(&g).unwrap()), [5.0, 75.0, 145.0], "the instance and its two copies, 70 pt apart"); + // Without copies the instance itself takes the transform, as a path does. + let mut g = Node::group(id, vec![Arc::new(instance())]); + g.appearance.effects.push(fx("distort.transform", json!({"moveH": 70}))); + assert_eq!(xs(&evaluate_container(&g).unwrap()), [75.0]); +} + +/// Images and symbol instances share the copy budget: copies of one leave less room for the other. +#[test] +fn images_and_symbol_instances_share_the_copy_budget() { + use std::sync::Arc; + + use vectorcraft_doc::{ImageObject, NodeId}; + let id = NodeId(9); + let image = Node::new( + id, + NodeKind::Image(Box::new(ImageObject { + key: "k".into(), + width: 40, + height: 40, + xf: Affine::translate((10.0, 0.0)), + link: None, + placement: Default::default(), + })), + ); + let instance = Node::new(id, NodeKind::SymbolInstance { symbol: "s".into(), xf: Affine::IDENTITY }); + let mut art = Node::group(id, vec![Arc::new(image), Arc::new(instance)]); + crate::reshape::transform_placed_within(&mut art, Affine::translate((70.0, 0.0)), 1000, 100); + let (mut images, mut instances) = (vec![], vec![]); + image_xs(&art, &mut images); + instance_xs(&art, &mut instances); + // The image takes the 98 copies there is room for; none is left for the instance. + assert_eq!((images.len(), instances.len()), (99, 1)); +} + +/// As a path's do, a Transform effect's copies of an image stop before one reaches further than +/// `MAX_REACH` from the origin. +#[test] +fn transform_copies_of_images_stop_at_the_reach_limit() { + use std::sync::Arc; + + use vectorcraft_doc::{ImageObject, NodeId}; + let id = NodeId(9); + let image = Node::new( + id, + NodeKind::Image(Box::new(ImageObject { + key: "k".into(), + width: 40, + height: 40, + xf: Affine::translate((10.0, 0.0)), + link: None, + placement: Default::default(), + })), + ); + let mut g = Node::group(id, vec![Arc::new(image)]); + // The largest move: every copy is 1e7 pt further right, so the 100th would end past 1e9. + g.appearance.effects.push(fx("distort.transform", json!({"moveH": 1.0e7, "copies": 1000}))); + let mut xs = vec![]; + image_xs(&evaluate_container(&g).unwrap(), &mut xs); + assert_eq!(xs.len(), 100, "the image and the 99 copies that stay within reach"); + assert!(xs.iter().all(|x| x + 40.0 <= 1.0e9)); +} + #[test] fn pucker_bloat_moves_anchors_in_opposite_directions() { let bloat = run("distort.puckerBloat", json!({"amount": 50}), &square()); diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs index bccdc720d..c34b649a6 100644 --- a/crates/pdf/src/tests.rs +++ b/crates/pdf/src/tests.rs @@ -538,6 +538,36 @@ fn image_roundtrip() { assert_eq!(decoded.get_pixel(3, 0).0, [0, 0, 0, 255]); } +/// #2023: a group's Transform effect copies an image among its members as it does the paths: the +/// PDF draws the image three times, where the effect put it. +#[test] +fn a_group_transform_effect_exports_its_image_copies() { + let mut d = doc(200.0, 100.0); + d.images.insert("img1".into(), ImageBlob::new("image/png", tiny_png())); + let im = ImageObject { + key: "img1".into(), + width: 4, + height: 2, + xf: Affine::translate((20.0, 30.0)) * Affine::scale(5.0), + link: None, + placement: Default::default(), + }; + let image = Arc::new(Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)))); + let mut square = rect_node(Rect::new(20.0, 60.0, 30.0, 70.0), Color::BLACK); + square.id = d.alloc_id(); + let mut g = Node::group(NodeId(0), vec![Arc::new(square), image]); + g.appearance.effects.push(vectorcraft_doc::Effect { + id: "distort.transform".into(), + params: serde_json::json!({"moveH": 50, "copies": 2}), + visible: true, + }); + add(&mut d, g); + let out = roundtrip(&d); + let lefts: Vec = + leaves(&out).iter().filter(|n| matches!(n.kind, NodeKind::Image(_))).filter_map(|n| n.geometric_bounds()).map(|b| b.x0.round()).collect(); + assert_eq!(lefts, [20.0, 70.0, 120.0]); +} + /// Build a PDF with a correct xref table from object bodies. fn handmade_pdf(content: &str, media: &str) -> Vec { let objs = [ diff --git a/crates/svg/tests/container_export.rs b/crates/svg/tests/container_export.rs index 12f0b44b4..0a69c8a54 100644 --- a/crates/svg/tests/container_export.rs +++ b/crates/svg/tests/container_export.rs @@ -8,8 +8,8 @@ use std::sync::Arc; use serde_json::json; use vectorcraft_color::{Color, Paint}; -use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, FillLayer, Node}; -use vectorcraft_geom::{Rect, shapes}; +use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, FillLayer, ImageBlob, ImageObject, Node, NodeKind}; +use vectorcraft_geom::{Affine, Rect, shapes}; use vectorcraft_svg::{ExportOptions, export}; /// A group of a red and a blue square with a green fill of its own (`below`: under the members). @@ -63,3 +63,28 @@ fn group_effects_bake_into_the_members_and_filter_the_group() { g.walk(&mut |n| assert!(ids.insert(n.id), "duplicate id {}", n.id)); assert!(g.appearance.items.is_empty() && g.appearance.effects.is_empty()); } + +/// #2023: a group's Transform effect copies an image among its members, as it does the paths: the +/// exported file draws the image three times, where the effect put it. +#[test] +fn a_group_transform_copies_its_images() { + let mut d = Document::new(200.0, 100.0); + d.images.insert("red".into(), ImageBlob::new("image/png", vec![1, 2, 3])); + let im = ImageObject { key: "red".into(), width: 20, height: 20, xf: Affine::translate((20.0, 20.0)), link: None, placement: Default::default() }; + let image = Arc::new(Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)))); + let black = Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0); + let square = Arc::new(Node::path(d.alloc_id(), shapes::rectangle(Rect::new(20.0, 60.0, 30.0, 70.0)), black)); + let mut g = Node::group(d.alloc_id(), vec![square, image]); + g.appearance.effects.push(Effect { id: "distort.transform".into(), params: json!({"moveH": 40, "copies": 2}), visible: true }); + let l = d.layers[0].id; + d.insert(Some(l), 0, g).unwrap(); + let svg = export(&d, &ExportOptions::default()); + // Each drawing of the image: an ``, or a `` of one the defs share. + let placed: Vec<&str> = svg + .lines() + .map(str::trim_start) + .filter(|l| l.starts_with("