mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-18 13:33:51 +00:00
EMF/WMF: Use Artboards applies live effects once for all artboards
An EMF or WMF export with Use Artboards applied the document's live effects (geometry effects, and symbol art with effects) once for each chosen artboard. vectorcraft_metafile::export_regions now checks every region, applies the effects once and writes one metafile per region. export is its one-region case, and the engine's encode calls export_regions once for all chosen artboards. Each file's bytes and warnings are unchanged.
This commit is contained in:
@@ -26,13 +26,16 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>, kin
|
||||
Some(true) => pick.resolve(n).map_err(|e| bad(C, e))?.unwrap_or_else(|| (0..n).collect()),
|
||||
_ => vec![pick.one(n).map_err(|e| bad(C, e))?],
|
||||
};
|
||||
let rects = boards
|
||||
.iter()
|
||||
.map(|&b| doc.artboards.get(b).map(|a| a.rect).ok_or_else(|| bad(C, format!("no artboard {}", b + 1))))
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
// Raster effects (shadows, glows, blurs) as images, as PDF export does.
|
||||
let flat = crate::flatten_raster_effects(doc);
|
||||
let src = flat.as_ref().unwrap_or(doc);
|
||||
let outs = vectorcraft_metafile::export_regions(src, &rects, kind).map_err(|e| bad(C, e))?;
|
||||
let mut enc = Encoded::default();
|
||||
for b in boards {
|
||||
let region = doc.artboards.get(b).ok_or_else(|| bad(C, format!("no artboard {}", b + 1)))?.rect;
|
||||
let out = vectorcraft_metafile::export(src, region, kind).map_err(|e| bad(C, e))?;
|
||||
for (b, out) in boards.into_iter().zip(outs) {
|
||||
enc.files.push((Some(b), out.bytes));
|
||||
for w in out.warnings {
|
||||
if !enc.warnings.contains(&w) {
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Windows metafiles: hand-written EMF and WMF writers and readers.
|
||||
//!
|
||||
//! [`export`] writes the visible art over one region of a document (an artboard) as a metafile:
|
||||
//! [`export`] writes the visible art over one region of a document (an artboard) as a metafile,
|
||||
//! and [`export_regions`] one metafile per region:
|
||||
//!
|
||||
//! - **EMF**: paths keep their Bézier curves, fills are solid brushes, strokes geometric pens with
|
||||
//! their width, caps, joins, miter limit and dashes; strokes a pen can't draw (aligned inside or
|
||||
@@ -79,20 +80,36 @@ pub struct Output {
|
||||
/// not); template layers, hidden objects and guides are left out. Raster effects should be turned
|
||||
/// into images before (the engine does); the ones left are reported and left out.
|
||||
pub fn export(doc: &Document, region: Rect, kind: Kind) -> Result<Output, String> {
|
||||
let r = region.abs();
|
||||
if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) || r.width() <= 0.0 || r.height() <= 0.0 {
|
||||
Ok(export_regions(doc, &[region], kind)?.pop().unwrap_or_default())
|
||||
}
|
||||
|
||||
/// Write the visible art of `doc` over each of `regions` as `kind`, one metafile per region in the
|
||||
/// same order, each as [`export`] writes it over that region. The live effects are applied once
|
||||
/// for all of them. When any region is empty, nothing is written and the result is an error.
|
||||
pub fn export_regions(doc: &Document, regions: &[Rect], kind: Kind) -> Result<Vec<Output>, String> {
|
||||
let regions: Vec<Rect> = regions.iter().map(|r| r.abs()).collect();
|
||||
if regions.iter().any(|r| ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) || r.width() <= 0.0 || r.height() <= 0.0) {
|
||||
return Err("the export region is empty".into());
|
||||
}
|
||||
if regions.is_empty() {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
// The scene writes layers that do not print and leaves hidden layers and objects out.
|
||||
let layers = vectorcraft_effects::WrittenLayers { hidden: false, non_printing: true, hidden_objects: false };
|
||||
let baked = vectorcraft_effects::bake_document_placing_symbols(doc, kind == Kind::Emf, layers);
|
||||
let doc = baked.as_ref().unwrap_or(doc);
|
||||
let (ops, mut warnings) = scene::Scene::new(doc, r, kind == Kind::Emf).run();
|
||||
let bytes = match kind {
|
||||
Kind::Emf => emf::write(&ops, r, doc.info_title()),
|
||||
Kind::Wmf => wmf::write(&ops, r, &mut warnings),
|
||||
};
|
||||
Ok(Output { bytes, warnings })
|
||||
let outputs = regions
|
||||
.into_iter()
|
||||
.map(|r| {
|
||||
let (ops, mut warnings) = scene::Scene::new(doc, r, kind == Kind::Emf).run();
|
||||
let bytes = match kind {
|
||||
Kind::Emf => emf::write(&ops, r, doc.info_title()),
|
||||
Kind::Wmf => wmf::write(&ops, r, &mut warnings),
|
||||
};
|
||||
Output { bytes, warnings }
|
||||
})
|
||||
.collect();
|
||||
Ok(outputs)
|
||||
}
|
||||
|
||||
/// A metafile read into a document.
|
||||
|
||||
@@ -396,6 +396,177 @@ fn hidden_and_offboard_art_is_left_out() {
|
||||
assert!(export(&d, Rect::new(0.0, 0.0, 0.0, 10.0), Kind::Emf).is_err(), "an empty region");
|
||||
}
|
||||
|
||||
/// One metafile of `doc` over `region`, applying the live effects for this region alone: what
|
||||
/// [`export`] did for each region before [`export_regions`] applied them once for all regions.
|
||||
fn export_baking_each_region(doc: &Document, region: Rect, kind: Kind) -> Result<Output, String> {
|
||||
let r = region.abs();
|
||||
if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) || r.width() <= 0.0 || r.height() <= 0.0 {
|
||||
return Err("the export region is empty".into());
|
||||
}
|
||||
let layers = vectorcraft_effects::WrittenLayers { hidden: false, non_printing: true, hidden_objects: false };
|
||||
let baked = vectorcraft_effects::bake_document_placing_symbols(doc, kind == Kind::Emf, layers);
|
||||
let doc = baked.as_ref().unwrap_or(doc);
|
||||
let (ops, mut warnings) = crate::scene::Scene::new(doc, r, kind == Kind::Emf).run();
|
||||
let bytes = match kind {
|
||||
Kind::Emf => crate::emf::write(&ops, r, doc.info_title()),
|
||||
Kind::Wmf => crate::wmf::write(&ops, r, &mut warnings),
|
||||
};
|
||||
Ok(Output { bytes, warnings })
|
||||
}
|
||||
|
||||
/// A Zig Zag effect with its default settings.
|
||||
fn zig_zag() -> vectorcraft_doc::Effect {
|
||||
vectorcraft_doc::Effect { id: "distort.zigZag".into(), params: Default::default(), visible: true }
|
||||
}
|
||||
|
||||
/// `boards` 100 pt squares side by side, each holding `paths` rectangles with a live Zig Zag
|
||||
/// and a gradient-filled one, and every second one an instance of a symbol whose art has a Zig
|
||||
/// Zag too; `boards` regions, one over each square.
|
||||
fn zig_zag_boards(boards: usize, paths: usize) -> (Document, Vec<Rect>) {
|
||||
let mut d = Document::new(100.0 * boards as f64, 100.0);
|
||||
let mut art = path(shapes::rectangle(Rect::new(0.0, 0.0, 30.0, 20.0)), blue(), red(), 1.0);
|
||||
art.appearance.effects.push(zig_zag());
|
||||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Zig".into(), art: Arc::new(art) });
|
||||
let g = Paint::Gradient(Box::new(GradientPaint::new(Gradient::default())));
|
||||
for b in 0..boards {
|
||||
let x = 100.0 * b as f64;
|
||||
for i in 0..paths {
|
||||
let at = (i % 9) as f64 * 9.0;
|
||||
let mut n = path(shapes::rectangle(Rect::new(x + at + 2.0, at + 2.0, x + at + 20.0, at + 15.0)), red(), blue(), 0.5);
|
||||
n.appearance.effects.push(zig_zag());
|
||||
add(&mut d, n);
|
||||
}
|
||||
add(&mut d, path(shapes::rectangle(Rect::new(x + 60.0, 60.0, x + 90.0, 90.0)), g.clone(), Paint::None, 0.0));
|
||||
if b % 2 == 1 {
|
||||
let inst = Node::new(NodeId(0), NodeKind::SymbolInstance { symbol: "Zig".into(), xf: Affine::translate((x + 50.0, 10.0)) });
|
||||
add(&mut d, inst);
|
||||
}
|
||||
}
|
||||
let regions = (0..boards).map(|b| Rect::new(100.0 * b as f64, 0.0, 100.0 * (b + 1) as f64, 100.0)).collect();
|
||||
(d, regions)
|
||||
}
|
||||
|
||||
/// Each region's metafile is byte for byte, and warning for warning, what a separate export of
|
||||
/// that region writes, in EMF and WMF, in the regions' order and in reverse.
|
||||
#[test]
|
||||
fn export_regions_writes_what_each_region_writes_alone() {
|
||||
let (d, mut regions) = zig_zag_boards(3, 2);
|
||||
let layers = vectorcraft_effects::WrittenLayers { hidden: false, non_printing: true, hidden_objects: false };
|
||||
assert!(vectorcraft_effects::bake_document_placing_symbols(&d, true, layers).is_some(), "the document has live effects to apply");
|
||||
for _ in 0..2 {
|
||||
for kind in [Kind::Emf, Kind::Wmf] {
|
||||
let outs = export_regions(&d, ®ions, kind).unwrap();
|
||||
assert_eq!(outs.len(), regions.len());
|
||||
for (r, out) in regions.iter().zip(&outs) {
|
||||
let alone = export_baking_each_region(&d, *r, kind).unwrap();
|
||||
assert!(out.bytes == alone.bytes, "{kind:?} over {r:?}: the bytes differ");
|
||||
assert_eq!(out.warnings, alone.warnings, "{kind:?} over {r:?}");
|
||||
let one = export(&d, *r, kind).unwrap();
|
||||
assert!(one.bytes == alone.bytes, "{kind:?} over {r:?}: export's bytes differ");
|
||||
assert_eq!(one.warnings, alone.warnings, "{kind:?} over {r:?}");
|
||||
}
|
||||
if kind == Kind::Wmf {
|
||||
assert!(outs.iter().all(|o| o.warnings.iter().any(|w| w.contains("gradients"))), "{:?}", outs[0].warnings);
|
||||
}
|
||||
}
|
||||
regions.reverse();
|
||||
}
|
||||
}
|
||||
|
||||
/// An empty region among valid ones writes nothing and is the one error; no region writes no
|
||||
/// metafile.
|
||||
#[test]
|
||||
fn export_regions_with_an_empty_region_writes_nothing() {
|
||||
let (d, regions) = zig_zag_boards(2, 1);
|
||||
for kind in [Kind::Emf, Kind::Wmf] {
|
||||
for empty in [Rect::new(10.0, 10.0, 10.0, 50.0), Rect::new(0.0, 0.0, f64::NAN, 10.0), Rect::new(0.0, 0.0, f64::INFINITY, 10.0)] {
|
||||
let with_empty = [regions[0], empty, regions[1]];
|
||||
assert_eq!(export_regions(&d, &with_empty, kind).map(|o| o.len()), Err("the export region is empty".to_string()), "{kind:?}");
|
||||
}
|
||||
assert!(export_regions(&d, &[], kind).unwrap().is_empty(), "{kind:?}");
|
||||
// A region given right to left or bottom to top is the same region.
|
||||
let flipped = Rect::new(regions[1].x1, regions[1].y1, regions[1].x0, regions[1].y0);
|
||||
let outs = export_regions(&d, &[flipped], kind).unwrap();
|
||||
assert!(outs[0].bytes == export(&d, regions[1], kind).unwrap().bytes, "{kind:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The CPU time all of this process's threads have used, from Linux's scheduler statistics; `None`
|
||||
/// elsewhere.
|
||||
fn process_cpu() -> Option<std::time::Duration> {
|
||||
let mut ns = 0u64;
|
||||
for task in std::fs::read_dir("/proc/self/task").ok()? {
|
||||
let stat = std::fs::read_to_string(task.ok()?.path().join("schedstat")).ok()?;
|
||||
ns += stat.split_whitespace().next()?.parse::<u64>().ok()?;
|
||||
}
|
||||
Some(std::time::Duration::from_nanos(ns))
|
||||
}
|
||||
|
||||
/// The time `f` takes: this process's CPU time where Linux reports it, otherwise the wall clock.
|
||||
fn time<T>(f: impl FnOnce() -> T) -> (std::time::Duration, T) {
|
||||
match process_cpu() {
|
||||
Some(before) => {
|
||||
let t = f();
|
||||
(process_cpu().map_or(std::time::Duration::ZERO, |after| after.saturating_sub(before)), t)
|
||||
}
|
||||
None => {
|
||||
let start = std::time::Instant::now();
|
||||
let t = f();
|
||||
(start.elapsed(), t)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Timings of an export of 1, 2 and 8 artboards that applies the live effects once for each
|
||||
/// artboard and of [`export_regions`], which applies them once, in EMF and WMF: 500 rectangles with
|
||||
/// a live Zig Zag on each artboard. The two take turns going first, 7 runs each, and every run's
|
||||
/// files are compared. Ignored by default; it prints the median, fastest and slowest run and sets
|
||||
/// no bound on them:
|
||||
/// `cargo test --release -p vectorcraft-metafile --lib export_regions_perf -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore = "a benchmark: run with --ignored --nocapture"]
|
||||
fn export_regions_perf() {
|
||||
const RUNS: usize = 7;
|
||||
let ms = |d: std::time::Duration| d.as_secs_f64() * 1000.0;
|
||||
eprintln!("export_regions_perf: {}", if process_cpu().is_some() { "process CPU time" } else { "wall clock" });
|
||||
eprintln!("export_regions_perf: {:>6} {:<4} {:>32} {:>32}", "boards", "kind", "bake per board ms (min-max)", "bake once ms (min-max)");
|
||||
for boards in [1, 2, 8] {
|
||||
let (d, regions) = zig_zag_boards(boards, 500);
|
||||
for kind in [Kind::Emf, Kind::Wmf] {
|
||||
let each = || regions.iter().map(|r| export_baking_each_region(&d, *r, kind).unwrap()).collect::<Vec<_>>();
|
||||
let once = || export_regions(&d, ®ions, kind).unwrap();
|
||||
let (mut old, mut new) = (Vec::new(), Vec::new());
|
||||
for run in 0..RUNS {
|
||||
let ((to, a), (tn, b)) = if run % 2 == 0 {
|
||||
let o = time(each);
|
||||
(o, time(once))
|
||||
} else {
|
||||
let n = time(once);
|
||||
(time(each), n)
|
||||
};
|
||||
old.push(to);
|
||||
new.push(tn);
|
||||
assert_eq!(a.len(), b.len());
|
||||
for (a, b) in a.iter().zip(&b) {
|
||||
assert!(a.bytes == b.bytes && a.warnings == b.warnings, "{boards} boards, {kind:?}");
|
||||
}
|
||||
}
|
||||
old.sort();
|
||||
new.sort();
|
||||
eprintln!(
|
||||
"export_regions_perf: {boards:>6} {:<4} {:>12.1} ({:>8.1}-{:>8.1}) {:>12.1} ({:>8.1}-{:>8.1})",
|
||||
kind.id(),
|
||||
ms(old[RUNS / 2]),
|
||||
ms(old[0]),
|
||||
ms(old[RUNS - 1]),
|
||||
ms(new[RUNS / 2]),
|
||||
ms(new[0]),
|
||||
ms(new[RUNS - 1]),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_instance_whose_art_reaches_the_artboard_is_written() {
|
||||
// The symbol's red rectangle, (100, 100) to (140, 140), drawn from (-50, -50): on the artboard,
|
||||
|
||||
@@ -1823,6 +1823,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
A geometry effect on a symbol instance's fill reshapes the filled shapes of the symbol's art and leaves their strokes as they are; one on the instance's stroke reshapes the stroked shapes and leaves their fills as they are. The shapes keep their colors. Only the instance's topmost fill and topmost stroke count, and only while they are visible with an opacity above 0. The canvas and Object › Expand Appearance use the same art, SVG and PDF export bake the same shapes, and Expand Appearance turns the instance into an editable group in one undo step. A group's own fills and strokes in the art take the effects too. An instance inside the art passes the effects on to its own art, and a dynamic symbol's instance reshapes the fills and strokes it paints on the art. How the effects map onto the symbol's art is VectorCraft's own rule. The help page <https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/apply-and-modify-effects.html> describes effects on one fill or stroke, and the help page <https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/expand-objects.html> describes Expand Appearance (engine `expand::a_symbol_instance_fill_effect_reshapes_its_filled_art_and_expands`, `a_symbol_instance_stroke_effect_reshapes_its_stroked_art_and_expands`, `a_stroke_effect_reshapes_a_stroke_a_dynamic_instance_adds`, `a_fill_effect_reshapes_the_fill_of_a_group_in_the_art`, `only_the_topmost_visible_instance_fill_reshapes_the_art`, `a_nested_symbol_instance_takes_the_outer_fill_effect`, `export_bakes_a_symbol_instance_fill_effect`, `a_fill_effect_on_an_instance_of_a_symbol_that_holds_itself_ends`). Existing documents with a geometry effect on a symbol instance's fill or stroke draw differently: before, the effect drew nothing.
|
||||
Live effects inside a symbol's art (geometry effects, color adjustments and the rest that export bakes) are written where each instance places the art in PDF, print, EPS and DXF, as the canvas draws them: the art is placed first and its effects are applied after, so an instance that scales its art does not scale the distance a Transform effect moves it. Symbols nested in the art, a dynamic symbol instance's own paint changes and the stain an instance's fill gives its art are kept, and the art is stained before its effects apply. A linked instance's PDF link covers its art where the effects draw it. A symbol whose art holds itself stops at the nesting limit, and the symbols' own art keeps its effects. An instance stays an instance in these exports when the objects its art makes once baked (the copies a Transform effect makes included) would take the export's placed symbol art past 16,000,000 objects, or when its baked art would draw deeper than the 128 levels a document may draw; these are VectorCraft's own limits. Art baked for an instance that then stays an instance still counts toward that limit, and while an instance's art bakes, the art's own objects are held in the limit for the instances nested in it. Instances the export leaves out (hidden ones, those in hidden groups, on template layers, and on hidden layers or layers that do not print when the export leaves those out) are not placed and do not count toward that limit. Before, these exports wrote the art without its effects (effects `bake::placing_symbols_bakes_their_art_where_each_instance_places_it`, `placing_symbols_reaches_the_art_of_nested_instances`, `placing_a_symbol_that_holds_itself_stops`, `placing_symbols_keeps_dynamic_instances_changes`, `placing_symbols_keeps_the_instances_stain`, `placing_symbols_counts_the_baked_art`, `placing_symbols_counts_nested_art_once`, `placing_symbols_holds_the_outer_art_while_it_bakes`, `placing_symbols_counts_the_art_it_drops`, `placing_symbols_counts_art_dropped_for_depth_against_later_baked_art`, `placing_symbols_keeps_the_baked_art_within_the_drawn_depth`, `placing_symbols_skips_instances_the_export_leaves_out`; doc `depth::tests::drawn_heights_measure_objects_outside_the_layers`; PDF, print, EPS and DXF `symbol_art_effects_are_written_where_they_draw`, `symbol_art_effects_print_where_they_draw`; PDF `a_stained_instance_keeps_its_stain_when_its_art_has_effects`, `a_linked_instance_keeps_its_link_when_its_art_has_effects`).
|
||||
EMF, WMF and SVG export write the same symbol art the same way: an instance of a symbol whose art, or the art of a symbol nested in it, has such effects is written as that art placed by the instance and then baked, so a square that a Transform effect moves 100 pt right draws 100 pt right of where the instance places it at any scale or rotation, and art the effect moves onto the artboard is written. EMF and SVG clip 9-slice cells and WMF does not, as each places other instances. In SVG those instances use no `<symbol>`, and instances of symbols without such effects still share one; named objects in a symbol's art take no ids there, as in an instance with its own copy of the art, so two instances do not write the same id; with Hidden Layers on, hidden instances are placed too and written hidden. An SVG instance nested in another instance's art is shared through `<use>` only when the transform it is drawn with, the outer instances' included, keeps the shared art as the canvas draws it, so a nested stroke keeps its weight in a scaled instance. Preserve Editing still embeds the document with its live effects. Before, these exports wrote the art without its effects (metafile `tests::import::symbol_art_effects_are_written_where_they_draw`; SVG `symbols_layers::symbol_art_effects_are_written_where_the_canvas_draws_them`, `a_kept_hidden_instance_is_written_with_its_symbols_effects`, `instances_written_as_their_art_give_its_names_no_id`, `a_nested_instance_is_shared_only_under_the_transform_it_is_drawn_with`; effects `bake::placing_symbols_skips_instances_the_export_leaves_out`).
|
||||
EMF and WMF export with Use Artboards applies the document's live effects once for all the chosen artboards instead of once for each, and writes the same files byte for byte (metafile `tests::export_regions_writes_what_each_region_writes_alone`; `export_regions_perf` times it).
|
||||
When an export bakes a symbol instance with geometry effects inside the art of another such instance, it counts the art the inner instance bakes to, the copies its symbol's effects make included, against the 262,144 objects of symbol art one export bakes that way; it counted only the symbol's art before its effects. An instance whose baked art would pass that count stays an instance with its effects, and the art baked for it still counts against the instances after it. These are VectorCraft's own limits (effects `bake::nested_reshape_counts_baked_art`, `nested_reshape_refusal_keeps_its_work_counted`, `nested_reshape_refused_siblings_bake_once`, `nested_reshape_counts_successful_descendants_once`).
|
||||
A raster effect (Drop Shadow, Outer Glow, Gaussian Blur and the other effects that paint pixels) on a symbol instance's topmost fill draws on each filled shape of the symbol's art, and one on its topmost stroke draws on each stroked shape, after any geometry effects listed before it, under the same rules as geometry effects: only a visible fill or stroke with an opacity above 0 counts, a group's own fills and strokes in the art take the effect, and an instance inside the art passes it on. Each shape gets its own shadow or glow, which is VectorCraft's own rule. The canvas, Use Preview Bounds and the drawn bounds, SVG and PDF export draw it, and Object › Expand Appearance is enabled for such an instance and makes the effect an image at the document's raster effects resolution, in one undo step (engine `expand::a_symbol_instance_fill_shadow_shadows_its_filled_art`, `a_symbol_instance_stroke_shadow_shadows_only_its_stroked_art`, `a_symbol_instance_fill_shadow_follows_the_fill_offset_before_it`, `a_nested_symbol_instance_takes_the_outer_fill_shadow`, `export_draws_a_symbol_instance_fill_shadow`). Existing documents with a raster effect on a symbol instance's fill or stroke draw differently: before, the effect drew nothing.
|
||||
Object › Expand Appearance turns a symbol instance whose topmost fill or stroke has only raster effects into its art as well, with the effect's image under the art (a shadow or glow) or in its place (a blur, feather or inner glow). A symbol instance inside the art whose topmost fill or stroke has a geometry or raster effect, its own or one the outer instance passes on, becomes its art and image the same way, and so do the instances in that art, within the nesting and symbol art limits; an instance of a missing symbol stays an instance. One Expand Appearance makes at most 1,024 images of raster effects, holding 256 megapixels in all (VectorCraft's own limits); an object or instance whose image would go past them stays as it is, with its raster effects, and the result reports how many with `rasterLeft` and a warning. Within those limits no live instance or raster effect is left from those effects, so the result no longer changes with the symbols; an instance left by the image limits still follows its symbol. The help page <https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/expand-objects.html> describes Expand Appearance turning appearance attributes into objects, and the help page <https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/vector-and-raster-effects.html> describes expanding an effect into permanent raster data; expanding nested instances this way is VectorCraft's own rule (engine `expand::a_nested_instance_fill_shadow_becomes_an_image_when_the_outer_art_expands`, `an_outer_fill_shadow_expands_the_instance_and_reaches_the_nested_art`, `a_nested_instance_fill_blur_becomes_an_image_when_the_outer_art_expands`, `a_hidden_nested_instance_fill_shadow_makes_no_image`, `a_nested_instance_of_a_missing_symbol_stays_an_instance`, `nested_instance_raster_effects_stop_at_the_image_limit`). Before, an instance whose fill or stroke had only a shadow or glow stayed an instance over the image, and a raster effect on an instance in the art stayed live.
|
||||
|
||||
Reference in New Issue
Block a user