From 303fc3cbcafa9421e355cfc3d033cec7c482605d Mon Sep 17 00:00:00 2001 From: bflatastic Date: Mon, 5 Oct 2026 12:00:35 +0700 Subject: [PATCH] M4.42: SVG import reads linked images from the SVG's folder, intersects nested clips, keeps hidden objects and expands reflected gradients document.open {path} (and File > Place) find an SVG's relative links in its folder: raster files stay linked images (LinkInfo with size, time and hash), SVG files and data: SVGs import as vector art, and a file that can't be read becomes a placeholder in its box that keeps the link, with a warning and a missingLinks row (Update Links / Relink read it later). The SVG library itself reads no file unless given a reader. Nested clip paths become clip groups in clip groups; undisplayed objects (display:none) come back hidden; spreadMethod reflect and repeat are expanded into stops over the painted area (matching resvg). Midpoint stops and focal points keep folding back as before. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/clipboard.rs | 2 +- crates/engine/src/cmd/fileio/load.rs | 23 +- crates/engine/src/cmd/fileio/mod.rs | 5 +- .../engine/src/cmd/fileio/tests_svgimport.rs | 104 ++++++++ crates/svg/src/import.rs | 211 ++++++++++----- crates/svg/src/import/files.rs | 247 ++++++++++++++++++ crates/svg/src/import/spread.rs | 162 ++++++++++++ crates/svg/src/lib.rs | 35 ++- crates/svg/tests/import_details.rs | 183 +++++++++++++ crates/svg/tests/import_text.rs | 12 +- docs/mcp.md | 5 +- 11 files changed, 910 insertions(+), 79 deletions(-) create mode 100644 crates/engine/src/cmd/fileio/tests_svgimport.rs create mode 100644 crates/svg/src/import/files.rs create mode 100644 crates/svg/src/import/spread.rs create mode 100644 crates/svg/tests/import_details.rs diff --git a/crates/engine/src/cmd/clipboard.rs b/crates/engine/src/cmd/clipboard.rs index 12e05c8a..21bfcb80 100644 --- a/crates/engine/src/cmd/clipboard.rs +++ b/crates/engine/src/cmd/clipboard.rs @@ -188,7 +188,7 @@ fn import_svg(s: &mut Session, p: &Value) -> Result { } (None, None) => return Err(bad(C, "give svg, or dataBase64 of an SVG or SVGZ file")), }; - let src = vectorcraft_svg::import(&svg).map_err(|e| bad(C, e.to_string()))?; + let (src, _) = super::fileio::import_svg(&svg, None).map_err(|e| bad(C, e.to_string()))?; let clip = Clipboard::from_document(&src); if clip.is_empty() { return Err(bad(C, "the SVG has no drawable objects")); diff --git a/crates/engine/src/cmd/fileio/load.rs b/crates/engine/src/cmd/fileio/load.rs index cdba10f5..efec2464 100644 --- a/crates/engine/src/cmd/fileio/load.rs +++ b/crates/engine/src/cmd/fileio/load.rs @@ -8,7 +8,7 @@ use vectorcraft_geom::Affine; use super::super::*; use super::pdfimport::LoadOptions; -use super::{Format, SAVE_FORMATS, format, format_for_name, read_file}; +use super::{Format, SAVE_FORMATS, absolute_path, file_stamp, format, format_for_name, read_file}; use crate::EngineError; /// A file read into a document, with its format and non-fatal import notes. @@ -102,7 +102,8 @@ fn restore_or_import( Ok((doc, warnings, false)) } -/// Read a file of any readable format (`name`: its file name or path, for the extension and title). +/// Read a file of any readable format (`name`: its file name or path, for the extension and title; +/// a path's folder is where an SVG's relative image links are found). pub fn load(name: &str, bytes: &[u8]) -> Result { load_with(name, bytes, &LoadOptions::default()) } @@ -129,7 +130,9 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result "svg" | "svgz" => { let text = vectorcraft_svg::text_of(bytes).map_err(err)?; let editing = vectorcraft_svg::editing(&text).map(|e| (e.intact, move || vectorcraft_format::base64_decode(&e.data))); - restore_or_import(editing, || vectorcraft_svg::import_with_report(&text).map_err(err))? + // Relative links are found in the SVG's folder (when `name` is a path). + let folder = std::path::Path::new(name).parent().map(|f| f.to_string_lossy()).filter(|f| !f.is_empty()).map(|f| absolute_path(&f)); + restore_or_import(editing, || import_svg(&text, folder.as_deref()))? } "pdf" | "ai" | "ait" => { // Saved with Preserve Editing: the document it carries, unless some pages are picked. @@ -150,6 +153,20 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result Ok(Loaded { doc, format, warnings, restored, converted }) } +/// Import SVG text, reading the files its images link to (relative links from `folder`, the SVG's +/// own): rasters stay linked, SVG files become art, missing ones placeholders (see +/// [`vectorcraft_svg::ImportOptions`]). +pub(crate) fn import_svg(text: &str, folder: Option<&str>) -> Result<(Document, Vec)> { + let read = |path: &str| { + // Only files (not folders or devices) are read. + file_stamp(path)?; + let bytes = read_file(path).ok()?; + let link = crate::cmd::links::link_info(path, &bytes); + Some((bytes, link)) + }; + vectorcraft_svg::import_with(text, &vectorcraft_svg::ImportOptions { folder, read: Some(&read) }).map_err(err) +} + /// Open a file's bytes as the new active document (what `document.open` does) → /// `{index, title, format, warnings, restored, missingLinks, modifiedLinks, updatedLinks}`. The /// document keeps `path` (and its format, for Save) when Save can write that format back: not a diff --git a/crates/engine/src/cmd/fileio/mod.rs b/crates/engine/src/cmd/fileio/mod.rs index 06439831..2f75c915 100644 --- a/crates/engine/src/cmd/fileio/mod.rs +++ b/crates/engine/src/cmd/fileio/mod.rs @@ -35,6 +35,7 @@ pub use encode::{ARTBOARD_PARAMS, ArtboardPick, Encoded, encode, encode_all, enc pub(crate) use encode::{anti_alias, background, with_single_artboard}; pub use export::export_source; use load::err; +pub(crate) use load::import_svg; pub(crate) use load::source; pub use load::{Loaded, RasterImage, detect, file_name, load, load_with, open_bytes, open_bytes_with, open_template, raster_image}; pub use pdfimport::{LoadOptions, page_document}; @@ -51,7 +52,7 @@ pub fn specs() -> Vec { "Open Document", [], None, - "{path} or {name, dataBase64}, PDF/.ai: pages?: \"2-3, 5\" (1-based, default all; one artboard and layer each) | page?: n, cropTo?: bounding|art|crop (default)|trim|bleed|media (the box each artboard gets; bounding: the art's bounds), password? (encrypted PDFs; see document.pdfInfo), colorMode?: rgb|cmyk (the mode the document opens in, its colours converted as file.documentColorMode does; default: the file's — a PDF keeps CMYK, Gray and spot inks (spot swatches at a tint) and opens in CMYK when painted mostly in CMYK) → {index, title, format, warnings, restored, missingLinks, modifiedLinks, updatedLinks: [{name, path, ids}]}; any readable format (see document.formats): .vectorcraft/.drawcraft, .svg/.svgz, .pdf/.ai, .ait, PNG/JPEG/GIF/WebP/TIFF/BMP (an image opens as a document of its pixel size). A PDF/.ai/.ait or SVG saved with Preserve Editing restores the native document it carries (restored: true; a PDF only when no pages are picked), unless the file was changed elsewhere since or the data can't be read: then its artwork is imported and the first warning says why. Templates (native templates, .ait) open as a new untitled document; a restored .ai keeps its path (Save writes .ai again). Linked images are read from their files (looked for at their path, then relative to the document): missing ones show their saved preview (links.relink), modified ones are read again only with Preferences › Update Links: Automatically (else links.update)", + "{path} or {name, dataBase64}, PDF/.ai: pages?: \"2-3, 5\" (1-based, default all; one artboard and layer each) | page?: n, cropTo?: bounding|art|crop (default)|trim|bleed|media (the box each artboard gets; bounding: the art's bounds), password? (encrypted PDFs; see document.pdfInfo), colorMode?: rgb|cmyk (the mode the document opens in, its colours converted as file.documentColorMode does; default: the file's — a PDF keeps CMYK, Gray and spot inks (spot swatches at a tint) and opens in CMYK when painted mostly in CMYK) → {index, title, format, warnings, restored, missingLinks, modifiedLinks, updatedLinks: [{name, path, ids}]}; any readable format (see document.formats): .vectorcraft/.drawcraft, .svg/.svgz, .pdf/.ai, .ait, PNG/JPEG/GIF/WebP/TIFF/BMP (an image opens as a document of its pixel size). A PDF/.ai/.ait or SVG saved with Preserve Editing restores the native document it carries (restored: true; a PDF only when no pages are picked), unless the file was changed elsewhere since or the data can't be read: then its artwork is imported and the first warning says why. Templates (native templates, .ait) open as a new untitled document; a restored .ai keeps its path (Save writes .ai again). Linked images are read from their files (looked for at their path, then relative to the document): missing ones show their saved preview (links.relink), modified ones are read again only with Preferences › Update Links: Automatically (else links.update). An SVG's files (relative links from the SVG's folder) stay linked, SVG files become art, missing ones a placeholder in their box (a warning and missingLinks)", always, load::open ), @@ -656,3 +657,5 @@ mod tests_text; #[cfg(test)] mod tests_dxf; +#[cfg(test)] +mod tests_svgimport; diff --git a/crates/engine/src/cmd/fileio/tests_svgimport.rs b/crates/engine/src/cmd/fileio/tests_svgimport.rs new file mode 100644 index 00000000..46fc2f88 --- /dev/null +++ b/crates/engine/src/cmd/fileio/tests_svgimport.rs @@ -0,0 +1,104 @@ +//! `document.open` of an SVG whose images link to files: relative links are found in the SVG's +//! folder and stay linked (Links reports them), missing ones warn and are listed in +//! `missingLinks` with a placeholder; File → Place reads them the same way. + +use std::path::PathBuf; + +use serde_json::json; +use vectorcraft_doc::{ImageObject, NodeKind}; + +use super::*; + +/// A fresh folder for one test (removed when dropped). +struct Folder(PathBuf); + +impl Folder { + fn new(name: &str) -> Self { + let dir = std::env::temp_dir().join(format!("vectorcraft-svgimport-{name}-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(dir.join("img")).unwrap(); + Self(dir) + } + fn file(&self, name: &str) -> String { + self.0.join(name).to_string_lossy().into_owned() + } +} + +impl Drop for Folder { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +fn png(w: u32, h: u32) -> Vec { + let mut out = vec![]; + image::RgbaImage::from_pixel(w, h, image::Rgba([230, 20, 20, 255])) + .write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png) + .unwrap(); + out +} + +/// An SVG linking to `img/photo.png` (here) and `img/gone.png` (missing). +fn write_svg(dir: &Folder) -> String { + std::fs::write(dir.file("img/photo.png"), png(300, 200)).unwrap(); + let svg = r#" + + "#; + let path = dir.file("art.svg"); + std::fs::write(&path, svg).unwrap(); + path +} + +fn images(s: &Session) -> Vec { + let mut out = vec![]; + s.documents()[s.active_index().unwrap()].doc.walk(|n| { + if let NodeKind::Image(im) = &n.kind { + out.push(im.clone()); + } + }); + out +} + +#[test] +fn opening_an_svg_links_its_images_from_its_folder() { + let dir = Folder::new("open"); + let path = write_svg(&dir); + let mut s = Session::new(); + let r = s.execute("document.open", &json!({"path": path})).unwrap(); + assert!(r["warnings"].as_array().unwrap().iter().any(|w| w.as_str().unwrap().contains("gone.png")), "{r}"); + let missing = r["missingLinks"].as_array().unwrap(); + assert_eq!(missing.len(), 1, "{r}"); + assert_eq!(missing[0]["name"], "gone.png"); + assert_eq!(r["modifiedLinks"], json!([])); + let ims = images(&s); + assert_eq!(ims.len(), 2); + let photo = ims[0].link.as_ref().unwrap(); + assert_eq!(PathBuf::from(&photo.path), PathBuf::from(dir.file("img/photo.png"))); + assert!(photo.modified.is_some() && photo.hash.is_some(), "{photo:?}"); + assert_eq!((ims[0].width, ims[0].height), (300, 200)); + // Links reports the found file as it is, the missing one as missing. + let c = s.execute("links.check", &json!({})).unwrap(); + assert_eq!((c["missing"].as_u64(), c["modified"].as_u64()), (Some(1), Some(0)), "{c}"); + // Once the file is there, Update Links reads it into the placeholder's box. + std::fs::write(dir.file("img/gone.png"), png(50, 50)).unwrap(); + let r = s.execute("links.update", &json!({})).unwrap(); + assert_eq!(r["updated"].as_array().unwrap().len(), 1, "{r}"); + let gone = &images(&s)[1]; + assert_eq!((gone.width, gone.height), (50, 50)); + let b = gone.xf.transform_rect_bbox(vectorcraft_geom::Rect::new(0.0, 0.0, 50.0, 50.0)); + assert!((b.x0 - 200.0).abs() < 1e-6 && (b.width() - 100.0).abs() < 1e-6, "{b:?}"); +} + +#[test] +fn placing_an_svg_reads_its_linked_images() { + let dir = Folder::new("place"); + let path = write_svg(&dir); + let mut s = Session::new(); + s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap(); + s.execute("file.place", &json!({"path": path})).unwrap(); + let ims = images(&s); + assert_eq!(ims.len(), 2); + assert!(ims.iter().all(|im| im.link.is_some())); + let doc = &s.documents()[s.active_index().unwrap()].doc; + assert!(!doc.images[&ims[0].key].is_proxy(), "the file's pixels"); +} diff --git a/crates/svg/src/import.rs b/crates/svg/src/import.rs index 188d2d05..1c5e367f 100644 --- a/crates/svg/src/import.rs +++ b/crates/svg/src/import.rs @@ -14,26 +14,36 @@ use vectorcraft_doc::{ use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, Vec2, shapes}; use crate::export::Reuse; -use crate::{SvgError, fnv1a}; +use crate::{ImportOptions, SvgError, fnv1a}; use css::XNode; use text::TextSlots; pub(crate) use fx::BLEND; mod css; +mod files; mod fx; +mod spread; mod text; -pub(crate) fn import(svg: &str) -> Result<(Document, Vec), SvgError> { - let (svg, found) = prepass(svg); +pub(crate) fn import(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec), SvgError> { + let (svg, found) = prepass(svg, opts); let svg = svg.as_ref(); let xml = roxmltree::Document::parse_with_options(svg, roxmltree::ParsingOptions { allow_dtd: true, ..Default::default() }) .map_err(|e| SvgError::Parse(e.to_string()))?; let units = RootUnits::of(xml.root_element()); - let mut warnings = Vec::new(); + let mut warnings = found.warnings; let (src, slots) = text::prepare(svg, &xml, units.dpi, &mut warnings); - let opt = usvg::Options { dpi: units.dpi as f32, font_size: DEFAULT_FONT_SIZE as f32, ..usvg::Options::default() }; - let tree = usvg::Tree::from_str(&src, &opt).map_err(|e| SvgError::Parse(e.to_string()))?; + let files = found.files; + let tree = { + let opt = usvg::Options { + dpi: units.dpi as f32, + font_size: DEFAULT_FONT_SIZE as f32, + image_href_resolver: files.resolver(), + ..usvg::Options::default() + }; + usvg::Tree::from_str(&src, &opt).map_err(|e| SvgError::Parse(e.to_string()))? + }; let size = tree.size(); let (kx, ky) = units.k; let mut doc = Document::new(size.width() as f64 * kx, size.height() as f64 * ky); @@ -51,7 +61,11 @@ pub(crate) fn import(svg: &str) -> Result<(Document, Vec), SvgError> { uses: found.uses, symbols: HashMap::new(), blends: fx::blends(&xml), + files, }; + if im.files.nested_text() { + im.warn("text inside an SVG image isn't imported".into()); + } // usvg wraps everything in an id-less group carrying the viewBox transform when needed. let mut top = tree.root(); @@ -144,6 +158,9 @@ impl RootUnits { } } +/// How many clip paths deep (``) an object's clip is read. +const MAX_CLIP_NEST: usize = 16; + /// Points per inch. pub(super) const PT_PER_IN: f64 = 72.0; /// CSS pixels per inch. @@ -164,7 +181,7 @@ struct Importer { midpoints: HashMap>>, /// Object names by element id (see [`labels`]). labels: HashMap, - /// Ids of the hidden groups shown for usvg ([`prepass`]). + /// Ids of the undisplayed objects shown for usvg ([`prepass`]). hidden: HashSet, /// The `` id each `` of a symbol shows, by the ``'s id ([`prepass`]). uses: HashMap, @@ -172,6 +189,8 @@ struct Importer { symbols: HashMap, /// Blend modes of the shadows and glows our export wrote, by filter id ([`fx::blends`]). blends: HashMap, + /// The files `` elements link to. + files: files::Files, } /// A `` made a symbol: its name, its art with no object ids (what each `` has to show @@ -271,15 +290,18 @@ pub(super) fn href<'a>(a: XNode<'a, '_>) -> Option<&'a str> { struct Found { /// The URL of each ``'s group, by its id. links: HashMap, - /// Ids of the hidden groups shown for usvg: they come back hidden. + /// Ids of the undisplayed objects shown for usvg: they come back hidden. hidden: HashSet, /// The `` id each `` of a symbol shows, by the ``'s id. uses: HashMap, + /// The files `` elements link to. + files: files::Files, + warnings: Vec, } /// Changes to the SVG text: `(range, replacement)`, an empty range inserting. #[derive(Default)] -struct Edits { +pub(super) struct Edits { list: Vec<(std::ops::Range, String)>, /// The ids made up so far, by element. ids: HashMap, @@ -305,7 +327,7 @@ impl Edits { } /// Set attribute `name` of element `n` (in `svg`) to `value` (XML-escaped already). - fn set(&mut self, svg: &str, n: XNode, name: &str, value: &str) { + pub(super) fn set(&mut self, svg: &str, n: XNode, name: &str, value: &str) { match n.attributes().find(|a| a.name() == name && a.namespace().is_none()) { Some(a) => self.list.push((a.range_value(), value.to_string())), None => self.insert(tag_name_end(svg, n), format!(" {name}=\"{value}\"")), @@ -333,16 +355,17 @@ impl Edits { } } -/// usvg reads `` and `` as plain groups and drops what isn't displayed. Before it -/// runs, the SVG is changed so that what we keep can be found: +/// usvg reads `` and `` as plain groups, drops what isn't displayed and reads linked +/// files on its own. Before it runs, the SVG is changed so that what we keep can be found: /// * every `` and every `` of a `` gets an id when it has none /// ([`MADE_UP_ID`]…), recorded with its URL or symbol; -/// * hidden layers (as Save writes them: `display: none` on a top-level ``, or on such a -/// group inside groups) are shown and recorded, to come back hidden; a group something links to -/// (a `` template) stays as it is. -fn prepass(svg: &str) -> (Cow<'_, str>, Found) { +/// * undisplayed objects (`display: none`, as Save writes hidden layers) are shown and recorded, +/// to come back hidden; one something links to (a `` template) stays as it is; +/// * linked files are read ([`files`]). +fn prepass<'s>(svg: &'s str, opts: &ImportOptions) -> (Cow<'s, str>, Found) { let mut found = Found::default(); - if !["`.) + if ![" (Cow<'_, str>, Found) { } } if svg.contains("display") { - hidden_groups(svg, &xml, &mut edits, &mut found.hidden); + hidden_objects(svg, &xml, &mut edits, &mut found.hidden); } + found.files = files::Files::read(svg, &xml, opts, &mut edits, &mut found.warnings); (edits.apply(svg), found) } -/// Show the hidden `` layers for usvg, recording their ids. -fn hidden_groups(svg: &str, xml: &roxmltree::Document, edits: &mut Edits, ids: &mut HashSet) { +/// The elements that are objects (what [`hidden_objects`] shows). +const OBJECTS: &[&str] = &["g", "a", "path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "image", "text", "use"]; + +/// Show the undisplayed objects outside `` (and the like) for usvg, recording their ids. +fn hidden_objects(svg: &str, xml: &roxmltree::Document, edits: &mut Edits, ids: &mut HashSet) { let css = css::Styles::new(xml); let linked: HashSet<&str> = xml.descendants().filter_map(href).filter_map(|h| h.strip_prefix('#')).collect(); - let group = |n: &XNode| n.is_element() && n.tag_name().name() == "g" && n.attribute("id").is_none_or(|id| !linked.contains(id)); - let mut groups: Vec = xml.root_element().children().filter(group).collect(); - while let Some(g) = groups.pop() { - groups.extend(g.children().filter(group)); - let Some(id) = g.attribute("id").filter(|id| !id.is_empty()) else { continue }; - if css.own(g, "display").as_deref() != Some("none") { + let mut todo: Vec = xml.root_element().children().filter(XNode::is_element).collect(); + while let Some(n) = todo.pop() { + let tag = n.tag_name().name(); + if !OBJECTS.contains(&tag) || n.attribute("id").is_some_and(|id| linked.contains(id)) { continue; } - ids.insert(id.to_string()); + if matches!(tag, "g" | "a") { + todo.extend(n.children().filter(XNode::is_element)); + } + if css.own(n, "display").as_deref() != Some("none") { + continue; + } + ids.insert(edits.id(svg, n)); // A `style` declaration wins over the attribute and style sheet rules. - match g.attributes().find(|a| a.name() == "style" && a.namespace().is_none()) { + match n.attributes().find(|a| a.name() == "style" && a.namespace().is_none()) { Some(a) => edits.insert(a.range_value().end, ";display:inline".to_string()), - None => edits.insert(tag_name_end(svg, g), " style=\"display:inline\"".to_string()), + None => edits.insert(tag_name_end(svg, n), " style=\"display:inline\"".to_string()), } } } @@ -634,7 +665,10 @@ impl Importer { let to_text = obj.xf.inverse(); let resolved: Vec = (0..paints) .map(|k| match kids.get(main + 1 + k) { - Some(usvg::Node::Path(p)) => p.fill().map_or(Paint::None, |f| self.paint(f.paint(), to_text)), + Some(usvg::Node::Path(p)) => p.fill().map_or(Paint::None, |f| { + let area = kurbo::Shape::bounding_box(&bezpath(p.data(), to_text)); + self.paint(f.paint(), to_text, Some(area)) + }), _ => Paint::None, }) .collect(); @@ -686,11 +720,25 @@ impl Importer { inner.appearance.effects = effects.clone(); children = vec![Arc::new(inner)]; } - if cp.clip_path().is_some() { - self.warn(format!("nested clip path on {label} approximated by its outer clip")); + // A clip path clipped in turn (``): one clip group in another, so + // the clips intersect. + let mut clips = vec![self.clip_node(cp, ts)?]; + let mut next = cp.clip_path(); + while let Some(c) = next { + if clips.len() > MAX_CLIP_NEST { + self.warn(format!("clip paths nested more than {MAX_CLIP_NEST} deep on {label}: the deeper ones are ignored")); + break; + } + clips.push(self.clip_node(c, ts)?); + next = c.clip_path(); } - let clip = self.clip_node(cp, ts)?; - let mut ch = vec![Arc::new(clip)]; + let outer = clips.pop()?; + for clip in clips { + let mut ch = vec![Arc::new(clip)]; + ch.extend(children); + children = vec![Arc::new(self.named("", NodeKind::Group { children: ch, clip: true }))]; + } + let mut ch = vec![Arc::new(outer)]; ch.extend(children); self.named(id, NodeKind::Group { children: ch, clip: true }) } else { @@ -788,35 +836,23 @@ impl Importer { Some(self.named(&id, NodeKind::Compound { children, rule: r })) } - fn paint(&mut self, p: &usvg::Paint, m: Affine) -> Paint { - let gp = |kind, stops, geom: GradientGeom| { - Paint::Gradient(Box::new(GradientPaint { - gradient: Gradient { kind, stops }, - geom: Some(geom), - angle: geom.angle_deg(), - swatch: None, - freeform: None, - })) - }; - match p { - usvg::Paint::Color(c) => Paint::solid(Color::rgb8(c.red, c.green, c.blue)), + /// A usvg paint mapped by `m`, for art covering `area` (after `m`: where a reflected or + /// repeated gradient has to reach). + fn paint(&mut self, p: &usvg::Paint, m: Affine, area: Option) -> Paint { + let (kind, base, mut geom) = match p { + usvg::Paint::Color(c) => return Paint::solid(Color::rgb8(c.red, c.green, c.blue)), + usvg::Paint::Pattern(pt) => return self.pattern(pt, m), usvg::Paint::LinearGradient(lg) => { - if lg.spread_method() != usvg::SpreadMethod::Pad { - self.warn(format!("gradient '{}': spreadMethod approximated as pad", lg.id())); - } - let mut geom = GradientGeom { + let geom = GradientGeom { start: Point::new(lg.x1() as f64, lg.y1() as f64), end: Point::new(lg.x2() as f64, lg.y2() as f64), aspect: 1.0, focal: None, }; - geom.transform(m * aff(lg.transform()), GradientKind::Linear); - gp(GradientKind::Linear, self.stops(lg), geom) + let base: &usvg::BaseGradient = lg; + (GradientKind::Linear, base, geom) } usvg::Paint::RadialGradient(rg) => { - if rg.spread_method() != usvg::SpreadMethod::Pad { - self.warn(format!("gradient '{}': spreadMethod approximated as pad", rg.id())); - } if rg.fr().get() > 1e-4 { self.warn(format!("gradient '{}': focal radius ignored", rg.id())); } @@ -824,11 +860,33 @@ impl Importer { let mut geom = GradientGeom { start: c, end: c + Vec2::new(rg.r().get() as f64, 0.0), aspect: 1.0, focal: None }; // A focal point outside the circle is pulled inside it. geom.set_focal(Some(Point::new(rg.fx() as f64, rg.fy() as f64))); - geom.transform(m * aff(rg.transform()), GradientKind::Radial); - gp(GradientKind::Radial, self.stops(rg), geom) + let base: &usvg::BaseGradient = rg; + (GradientKind::Radial, base, geom) + } + }; + geom.transform(m * aff(base.transform()), kind); + let mut stops = self.stops(base); + let reflect = match base.spread_method() { + usvg::SpreadMethod::Pad => None, + usvg::SpreadMethod::Reflect => Some(true), + usvg::SpreadMethod::Repeat => Some(false), + }; + if let Some(reflect) = reflect { + match area.map(|a| spread::expand(kind, &mut geom, &mut stops, reflect, a)) { + Some(spread::Expanded::Whole) => {} + Some(spread::Expanded::Capped) => { + self.warn(format!("gradient '{}': spreadMethod repeats more than {} times; it pads after that", base.id(), spread::MAX_PERIODS)) + } + None => self.warn(format!("gradient '{}': spreadMethod approximated as pad", base.id())), } - usvg::Paint::Pattern(pt) => self.pattern(pt, m), } + Paint::Gradient(Box::new(GradientPaint { + gradient: Gradient { kind, stops }, + geom: Some(geom), + angle: geom.angle_deg(), + swatch: None, + freeform: None, + })) } /// `` → a pattern swatch painted with the pattern's tile placement. The swatch art is @@ -859,11 +917,12 @@ impl Importer { Paint::Pattern { pattern: name, xf } } - fn appearance(&mut self, p: &usvg::Path, m: Affine) -> (Appearance, FillRule) { + /// The fill and stroke of `p` mapped by `m`; `area`: the bounds of the path after `m`. + fn appearance(&mut self, p: &usvg::Path, m: Affine, area: Option) -> (Appearance, FillRule) { let mut fill = None; let mut r = FillRule::NonZero; if let Some(f) = p.fill() { - let paint = self.paint(f.paint(), m); + let paint = self.paint(f.paint(), m, area); let mut fl = FillLayer::new(paint); fl.opacity = f.opacity().get(); r = rule(f.rule()); @@ -872,7 +931,9 @@ impl Importer { let mut stroke = None; if let Some(s) = p.stroke() { let scale = m.determinant().abs().sqrt(); - let paint = self.paint(s.paint(), m); + // The stroke reaches past the path (miters further: a generous margin). + let reach = s.width().get() as f64 * scale * (s.miterlimit().get() as f64).max(1.0); + let paint = self.paint(s.paint(), m, area.map(|a| a.inflate(reach, reach))); let mut sl = StrokeLayer::new(paint, s.width().get() as f64 * scale); sl.opacity = s.opacity().get(); sl.cap = match s.linecap() { @@ -910,7 +971,7 @@ impl Importer { if path.is_empty() { return None; } - let (appearance, r) = self.appearance(p, acc); + let (appearance, r) = self.appearance(p, acc, path.bounds()); let mut n = if path.subpaths.len() > 1 { // Multi-subpath SVG paths are compound paths (as in Illustrator). let children = path @@ -940,10 +1001,7 @@ impl Importer { usvg::ImageKind::PNG(d) => (d, "image/png"), usvg::ImageKind::GIF(d) => (d, "image/gif"), usvg::ImageKind::WEBP(d) => (d, "image/webp"), - usvg::ImageKind::SVG(_) => { - self.warn("embedded SVG image skipped".into()); - return None; - } + usvg::ImageKind::SVG(tree) => return self.svg_image(tree, acc), }; let size = i.size(); let (pw, ph) = image::ImageReader::new(std::io::Cursor::new(&bytes[..])) @@ -952,8 +1010,25 @@ impl Importer { .and_then(|r| r.into_dimensions().ok()) .unwrap_or((size.width().round().max(1.0) as u32, size.height().round().max(1.0) as u32)); let key = format!("img-{:016x}", fnv1a(bytes)); - self.doc.images.entry(key.clone()).or_insert_with(|| ImageBlob::new(mime, bytes.to_vec())); + // A linked file keeps a preview; a placeholder is all a missing one has (its preview). + let linked = self.files.linked(i.kind()); + let missing = linked.is_some_and(|l| l.missing); + let link = linked.map(|l| l.link.clone()); + self.doc.images.entry(key.clone()).or_insert_with(|| { + let blob = ImageBlob { mime: mime.into(), bytes: bytes.clone(), proxy: missing.then(|| bytes.clone()) }; + if link.is_some() && !missing { blob.with_proxy() } else { blob } + }); let xf = acc * Affine::scale_non_uniform(size.width() as f64 / pw as f64, size.height() as f64 / ph as f64); - Some(self.named(i.id(), NodeKind::Image(ImageObject { key, width: pw, height: ph, xf, link: None }))) + Some(self.named(i.id(), NodeKind::Image(ImageObject { key, width: pw, height: ph, xf, link }))) + } + + /// An SVG shown as an image (a data URL or a linked file) → its art, `acc` mapping its size. + /// Its ids are its own: they mean nothing in the SVG around it. + fn svg_image(&mut self, tree: &usvg::Tree, acc: Affine) -> Option { + let outer = + (std::mem::take(&mut self.links), std::mem::take(&mut self.hidden), std::mem::take(&mut self.uses), std::mem::take(&mut self.labels)); + let art = self.group_node(tree.root(), acc); + (self.links, self.hidden, self.uses, self.labels) = outer; + art } } diff --git a/crates/svg/src/import/files.rs b/crates/svg/src/import/files.rs new file mode 100644 index 00000000..bbe33d84 --- /dev/null +++ b/crates/svg/src/import/files.rs @@ -0,0 +1,247 @@ +//! Files `` elements link to (`href="photo.png"`, `file:///…`): read before usvg runs, +//! through [`ImportOptions::read`], relative paths from [`ImportOptions::folder`]. A raster file +//! stays a linked image ([`LinkInfo`]); an SVG file becomes vector art. One that can't be read +//! (missing, remote, not an image) becomes a placeholder that keeps the link and its place, so it +//! can be relinked, and a warning. + +use std::collections::HashMap; +use std::path::Path; +use std::sync::Arc; +use std::sync::atomic::{AtomicBool, Ordering}; + +use usvg::{ImageHrefResolver, ImageKind, roxmltree}; +use vectorcraft_doc::LinkInfo; + +use super::{Edits, href}; +use crate::ImportOptions; + +/// The files an SVG's images link to. +#[derive(Default)] +pub(in crate::import) struct Files { + /// What usvg gets for each linked href. + sources: HashMap, + /// The link of each linked raster or placeholder, by the address of the bytes usvg got. + links: HashMap, + /// An SVG image had text (which isn't imported). + text: AtomicBool, +} + +enum Source { + /// A raster file of the kind usvg reads it as. + Raster(fn(Arc>) -> ImageKind, Arc>), + /// An SVG file, parsed by usvg as an image. + Svg(Arc>), +} + +/// A linked raster image (or the placeholder of a missing one). +pub(in crate::import) struct Linked { + pub link: LinkInfo, + /// The file wasn't read: the bytes are a placeholder. + pub missing: bool, +} + +/// The side of the placeholder image, in pixels. +const MARKER: u32 = 64; + +/// The placeholder of a missing linked image: a light tile, crossed out (drawn here). +fn marker() -> Option> { + let last = MARKER - 1; + let img = image::RgbaImage::from_fn(MARKER, MARKER, |x, y| { + let edge = x == 0 || y == 0 || x == last || y == last; + let cross = x.abs_diff(y) <= 1 || (x + y).abs_diff(last) <= 1; + image::Rgba(if edge || cross { [200, 60, 60, 255] } else { [236, 236, 236, 255] }) + }); + let mut png = Vec::new(); + img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).ok()?; + Some(png) +} + +/// `s` with `%XX` escapes decoded (an href is a URL). +fn percent_decoded(s: &str) -> String { + if !s.contains('%') { + return s.to_string(); + } + let mut out = Vec::with_capacity(s.len()); + let mut rest = s.as_bytes(); + while let Some((&b, tail)) = rest.split_first() { + let hex = tail.get(..2).and_then(|h| std::str::from_utf8(h).ok()).and_then(|h| u8::from_str_radix(h, 16).ok()); + match hex { + Some(v) if b == b'%' => { + out.push(v); + rest = tail.get(2..).unwrap_or_default(); + } + _ => { + out.push(b); + rest = tail; + } + } + } + String::from_utf8_lossy(&out).into_owned() +} + +/// Is `p` an absolute path here or on another system (`/…`, `C:/…`, `C:\…`)? +fn is_absolute(p: &str) -> bool { + Path::new(p).is_absolute() || p.starts_with('/') || matches!(p.as_bytes(), [d, b':', b'/' | b'\\', ..] if d.is_ascii_alphabetic()) +} + +/// Where href `h` points (a path, made absolute from `folder`, or a URL) and whether it is a +/// file that can be read. +fn target(h: &str, folder: Option<&str>) -> (String, bool) { + let h = percent_decoded(h.trim()); + let path = match h.strip_prefix("file://") { + Some(rest) => { + let rest = rest.strip_prefix("localhost").unwrap_or(rest); + // `file:///C:/art.png` → `C:/art.png`. + match rest.as_bytes() { + [b'/', d, b':', ..] if d.is_ascii_alphabetic() => rest.get(1..).unwrap_or(rest).to_string(), + _ => rest.to_string(), + } + } + None if h.contains("://") => return (h, false), + None => h, + }; + if is_absolute(&path) { + return (path, true); + } + match folder { + Some(f) => (Path::new(f).join(&path).to_string_lossy().into_owned(), true), + None => (path, false), + } +} + +/// The address of image bytes, to find their link again. +fn key(bytes: &Arc>) -> usize { + Arc::as_ptr(bytes) as usize +} + +impl Files { + /// Read the files the `` elements of `xml` (the text `svg`) link to. Placeholders + /// stretch to the image's box (`preserveAspectRatio="none"`), which the file fills once + /// relinked. + pub(in crate::import) fn read(svg: &str, xml: &roxmltree::Document, opts: &ImportOptions, edits: &mut Edits, warnings: &mut Vec) -> Self { + let mut files = Files::default(); + let mut placeholder = None; + for n in xml.descendants().filter(|n| n.is_element() && n.tag_name().name() == "image") { + let Some(h) = href(n).filter(|h| !h.trim_start().starts_with("data:")) else { continue }; + if !files.sources.contains_key(h) { + let (path, local) = target(h, opts.folder); + let read = if local { opts.read.and_then(|read| read(&path)) } else { None }; + let source = match read { + Some((bytes, link)) => files.source(bytes, link).ok_or("is not an image VectorCraft reads"), + None => Err("not found"), + }; + let source = source.or_else(|why| { + warnings.push(format!("linked image '{h}' {why}: a placeholder keeps its place until it is relinked")); + let bytes = Arc::new(placeholder.get_or_insert_with(marker).clone().ok_or(why)?); + files.links.insert(key(&bytes), Linked { link: LinkInfo::new(path), missing: true }); + Ok::<_, &str>(Source::Raster(ImageKind::PNG, bytes)) + }); + let Ok(source) = source else { continue }; + files.sources.insert(h.to_string(), source); + } + if files.placeholder(h) { + edits.set(svg, n, "preserveAspectRatio", "none"); + } + } + files + } + + /// What usvg gets for a file read (`bytes`, linked by `link`): a raster usvg reads (others are + /// stored as PNG) or an SVG; `None` for anything else. + fn source(&mut self, bytes: Vec, link: LinkInfo) -> Option { + use image::ImageFormat as F; + let Ok(format) = image::guess_format(&bytes) else { + let svg = crate::text_of(&bytes).is_ok_and(|t| t.contains(" ImageKind::PNG, + F::Jpeg => ImageKind::JPEG, + F::Gif => ImageKind::GIF, + F::WebP => ImageKind::WEBP, + _ => { + let img = image::load_from_memory_with_format(&bytes, format).ok()?; + let mut png = Vec::new(); + img.write_to(&mut std::io::Cursor::new(&mut png), F::Png).ok()?; + let png = Arc::new(png); + self.links.insert(key(&png), Linked { link, missing: false }); + return Some(Source::Raster(ImageKind::PNG, png)); + } + }; + let bytes = Arc::new(bytes); + self.links.insert(key(&bytes), Linked { link, missing: false }); + Some(Source::Raster(kind, bytes)) + } + + /// Does href `h` show a placeholder? + fn placeholder(&self, h: &str) -> bool { + matches!(self.sources.get(h), Some(Source::Raster(_, b)) if self.links.get(&key(b)).is_some_and(|l| l.missing)) + } + + /// The link of the image whose data usvg got as `kind`. + pub(in crate::import) fn linked(&self, kind: &ImageKind) -> Option<&Linked> { + match kind { + ImageKind::PNG(b) | ImageKind::JPEG(b) | ImageKind::GIF(b) | ImageKind::WEBP(b) => self.links.get(&key(b)), + ImageKind::SVG(_) => None, + } + } + + /// Did an SVG image have text (which isn't imported)? + pub(in crate::import) fn nested_text(&self) -> bool { + self.text.load(Ordering::Relaxed) + } + + fn note_text(&self, svg: &[u8]) { + if svg.windows(5).any(|w| w == b" ImageHrefResolver<'_> { + let data = ImageHrefResolver::default_data_resolver(); + ImageHrefResolver { + resolve_data: Box::new(move |mime, bytes, opts| { + if mime == "image/svg+xml" { + self.note_text(&bytes); + } + data(mime, bytes, opts) + }), + resolve_string: Box::new(move |h, opts| match self.sources.get(h).or_else(|| self.sources.get(h.trim()))? { + Source::Raster(kind, bytes) => Some(kind(bytes.clone())), + Source::Svg(bytes) => { + self.note_text(bytes); + usvg::Tree::from_data_nested(bytes, opts).ok().map(ImageKind::SVG) + } + }), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn hrefs_resolve_against_the_folder() { + let sep = std::path::MAIN_SEPARATOR; + assert_eq!(target("photo%20one.png", Some("/art")), (format!("/art{sep}photo one.png"), true)); + assert_eq!(target("photo.png", None), ("photo.png".into(), false)); + assert_eq!(target("/abs/photo.png", Some("/art")), ("/abs/photo.png".into(), true)); + assert_eq!(target("file:///C:/art/a.png", None), ("C:/art/a.png".into(), true)); + assert_eq!(target("file:///home/a.png", None), ("/home/a.png".into(), true)); + assert_eq!(target("https://example.com/a.png", Some("/art")), ("https://example.com/a.png".into(), false)); + } + + #[test] + fn percent_escapes_decode() { + assert_eq!(percent_decoded("a%20b%2"), "a b%2"); + assert_eq!(percent_decoded("%E2%82%AC"), "€"); + } + + #[test] + fn the_placeholder_is_a_png() { + let png = marker().unwrap(); + assert_eq!(image::load_from_memory(&png).unwrap().width(), MARKER); + } +} diff --git a/crates/svg/src/import/spread.rs b/crates/svg/src/import/spread.rs new file mode 100644 index 00000000..b88ecf3e --- /dev/null +++ b/crates/svg/src/import/spread.rs @@ -0,0 +1,162 @@ +//! `spreadMethod="reflect"` and `"repeat"`: gradients only pad past their ends, so the stops are +//! repeated (every other period mirrored, for reflect) as many times as the painted area needs, +//! and the gradient stretched over those periods. + +use vectorcraft_color::{GradientGeom, GradientKind, GradientStop}; +use vectorcraft_geom::{Point, Rect}; + +/// Most periods a gradient is expanded to. +pub(super) const MAX_PERIODS: usize = 64; + +/// What [`expand`] did. +#[derive(Debug, PartialEq, Eq)] +pub(super) enum Expanded { + /// Every period the area shows. + Whole, + /// [`MAX_PERIODS`] of them: the gradient pads past those. + Capped, +} + +/// Expand `stops` and `geom` (document space) so the gradient paints `area` as the spread method +/// does: `reflect` mirrors every other period, else they repeat. +pub(super) fn expand(kind: GradientKind, geom: &mut GradientGeom, stops: &mut Vec, reflect: bool, area: Rect) -> Expanded { + let corners = [Point::new(area.x0, area.y0), Point::new(area.x1, area.y0), Point::new(area.x1, area.y1), Point::new(area.x0, area.y1)]; + let ts = corners.map(|p| geom.param_at(kind, p)); + if ts.iter().any(|t| !t.is_finite()) || stops.is_empty() { + return Expanded::Whole; + } + let radial = kind == GradientKind::Radial; + // The parameter's range over the area: a corner holds its extremes (radial levels are nested + // convex rings from the focal point, where the parameter is 0). + let lo = if radial { 0.0 } else { ts.iter().copied().fold(f64::INFINITY, f64::min).floor() }; + let hi = ts.iter().copied().fold(f64::NEG_INFINITY, f64::max).ceil().max(lo + 1.0); + if lo >= 0.0 && hi <= 1.0 { + return Expanded::Whole; + } + let capped = hi - lo > MAX_PERIODS as f64; + // Capped, the periods kept start no further back than half of them. + let lo = if capped { lo.max(-(MAX_PERIODS as f64) / 2.0) } else { lo }; + let n = (hi - lo).min(MAX_PERIODS as f64); + let period = whole_period(stops); + let mut out = Vec::with_capacity(period.len() * n as usize); + for j in 0..n as usize { + let mirrored = reflect && (lo as i64 + j as i64).rem_euclid(2) == 1; + let one = if mirrored { mirror(&period) } else { period.clone() }; + out.extend(one.into_iter().map(|s| GradientStop { offset: ((j as f64 + s.offset as f64) / n) as f32, ..s })); + } + *stops = out; + let u = geom.end - geom.start; + if radial { + // Level t of an off-centre radial is the extent ellipse scaled by t about the line from the + // focal point to the centre; level n·t' of the new one: the centre moves away from the + // focal point n times as far, and the radius grows n times. + let Some(frame) = geom.unit_frame() else { return Expanded::Whole }; + let f = geom.focal.map_or(Point::ORIGIN, |f| frame.inverse() * f); + geom.start = frame * (f.to_vec2() * (1.0 - n)).to_point(); + geom.end = geom.start + u * n; + } else { + let start = geom.start; + geom.start = start + u * lo; + geom.end = start + u * (lo + n); + } + if capped { Expanded::Capped } else { Expanded::Whole } +} + +/// The stops of one period, from offset 0 to 1: the end colours held out to the ends. +fn whole_period(stops: &[GradientStop]) -> Vec { + let mut out = stops.to_vec(); + if let Some(first) = out.first().filter(|s| s.offset > 0.0).cloned() { + out.insert(0, GradientStop { offset: 0.0, ..first }); + } + if let Some(last) = out.last_mut() { + // The last stop's midpoint leads nowhere; the copy at 1 takes over. + if last.offset < 1.0 { + let end = GradientStop { offset: 1.0, ..last.clone() }; + out.push(end); + } + } + out +} + +/// A period mirrored: the stops in reverse, each midpoint measured from the other side. +fn mirror(period: &[GradientStop]) -> Vec { + let rev: Vec<&GradientStop> = period.iter().rev().collect(); + rev.iter() + .enumerate() + .map(|(i, s)| GradientStop { + offset: 1.0 - s.offset, + // The midpoint from this stop to the next one is the mirror of the one the next stop + // had towards this one. + midpoint: rev.get(i + 1).map_or(0.5, |next| 1.0 - next.midpoint), + ..(*s).clone() + }) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + use vectorcraft_color::Color; + + fn stops() -> Vec { + let mut a = GradientStop::new(0.0, Color::BLACK); + a.midpoint = 0.3; + vec![a, GradientStop::new(1.0, Color::WHITE)] + } + + #[test] + fn a_linear_gradient_repeats_over_the_area() { + let mut geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(10.0, 0.0), aspect: 1.0, focal: None }; + let mut s = stops(); + let r = expand(GradientKind::Linear, &mut geom, &mut s, false, Rect::new(-5.0, 0.0, 25.0, 10.0)); + assert_eq!(r, Expanded::Whole); + // From -10 to 30: four periods. + assert_eq!((geom.start, geom.end), (Point::new(-10.0, 0.0), Point::new(30.0, 0.0))); + let offsets: Vec = s.iter().map(|s| s.offset).collect(); + assert_eq!(offsets, [0.0, 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1.0]); + assert!(s.iter().step_by(2).all(|s| s.color == Color::BLACK && (s.midpoint - 0.3).abs() < 1e-6)); + } + + #[test] + fn reflect_mirrors_every_other_period_and_its_midpoints() { + let mut geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(10.0, 0.0), aspect: 1.0, focal: None }; + let mut s = stops(); + expand(GradientKind::Linear, &mut geom, &mut s, true, Rect::new(0.0, 0.0, 20.0, 10.0)); + let colours: Vec = s.iter().map(|s| s.color).collect(); + assert_eq!(colours, [Color::BLACK, Color::WHITE, Color::WHITE, Color::BLACK]); + // Black → white with the midpoint at 0.3 mirrors to white → black with it at 0.7. + assert!((s[2].midpoint - 0.7).abs() < 1e-6, "{s:?}"); + } + + #[test] + fn stops_inside_the_period_hold_their_colours_to_its_ends() { + let mut geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(10.0, 0.0), aspect: 1.0, focal: None }; + let mut s = vec![GradientStop::new(0.25, Color::BLACK), GradientStop::new(0.75, Color::WHITE)]; + expand(GradientKind::Linear, &mut geom, &mut s, false, Rect::new(0.0, 0.0, 20.0, 10.0)); + let offsets: Vec = s.iter().map(|s| s.offset).collect(); + assert_eq!(offsets, [0.0, 0.125, 0.375, 0.5, 0.5, 0.625, 0.875, 1.0]); + } + + #[test] + fn a_radial_gradient_grows_about_its_focal_point() { + let c = Point::new(50.0, 50.0); + let mut geom = GradientGeom { start: c, end: Point::new(60.0, 50.0), aspect: 1.0, focal: Some(Point::new(55.0, 50.0)) }; + let before = geom.param_at(GradientKind::Radial, Point::new(72.0, 61.0)); + let mut s = stops(); + expand(GradientKind::Radial, &mut geom, &mut s, false, Rect::new(0.0, 0.0, 100.0, 100.0)); + let n = s.len() / 2; + assert!(n >= 5, "{n}"); + assert_eq!(geom.focal, Some(Point::new(55.0, 50.0))); + // Every point keeps its level: the new parameter is the old one over n. + let after = geom.param_at(GradientKind::Radial, Point::new(72.0, 61.0)); + assert!((after * n as f64 - before).abs() < 1e-9, "{before} {after}"); + } + + #[test] + fn far_repeats_are_capped() { + let mut geom = GradientGeom { start: Point::new(0.0, 0.0), end: Point::new(0.01, 0.0), aspect: 1.0, focal: None }; + let mut s = stops(); + assert_eq!(expand(GradientKind::Linear, &mut geom, &mut s, false, Rect::new(0.0, 0.0, 100.0, 1.0)), Expanded::Capped); + assert_eq!(s.len(), 2 * MAX_PERIODS); + } +} diff --git a/crates/svg/src/lib.rs b/crates/svg/src/lib.rs index d6f5f51b..f367555e 100644 --- a/crates/svg/src/lib.rs +++ b/crates/svg/src/lib.rs @@ -36,7 +36,7 @@ //! unit of the root `width` (pixels when it has none). //! * `` imports as a luminance opacity mask; a mask we exported keeps its options and art //! (its `data-vectorcraft-mask="noclip invert"` lists the options that differ from clipping and -//! not inverted). Nested clip paths use the outer clip only. +//! not inverted). Nested clip paths (``) are clip groups in clip groups. //! * Filters that are a Gaussian blur, a drop shadow (`feDropShadow` or the usual chains of offset, //! blur, flood or colour matrix, composite and merge), a glow or a feather (as we export them) //! become those live effects; other filters are ignored (reported as warnings). @@ -47,8 +47,12 @@ //! differently (see the export's symbol rules) becomes plain art, as do ``s of other //! elements. //! * A `` layer (top-level, or inside one) that isn't displayed (`display: none`) comes back -//! as a hidden layer or group, unless a `` refers to it. Other undisplayed elements are left -//! out. +//! as a hidden layer; other undisplayed objects as hidden objects, unless a `` refers to +//! them. +//! * `spreadMethod` reflect and repeat are expanded into stops over the painted area (at most +//! 64 periods). +//! * `` files are read through [`ImportOptions`]: rasters stay linked, SVG files (and SVG +//! `data:` URLs) become art (without their text), missing ones a placeholder keeping the link. //! * Text lines after the first start at the first line's x; text in a clip path is ignored; //! absolute positions inside type on a path are ignored; vertical text sets every glyph sideways. //! @@ -336,8 +340,31 @@ pub fn import(svg: &str) -> Result { } /// Import an SVG document, also returning warnings about unsupported or approximated features. +/// Linked files (``) aren't read: see [`import_with`]. pub fn import_with_report(svg: &str) -> Result<(Document, Vec), SvgError> { - import::import(svg) + import_with(svg, &ImportOptions::default()) +} + +/// Import an SVG document reading the files it links to as `opts` says, also returning warnings. +pub fn import_with(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec), SvgError> { + import::import(svg, opts) +} + +/// Reads a linked file: its bytes and the link to it (absolute path, size, time and hash), or +/// `None` when there is no readable file at the (absolute) path. +pub type ReadFile<'a> = &'a dyn Fn(&str) -> Option<(Vec, vectorcraft_doc::LinkInfo)>; + +/// How [`import_with`] reads the files an SVG's `` elements link to. +/// +/// A raster file stays linked ([`vectorcraft_doc::ImageObject::link`]); an SVG file imports as +/// vector art. A file that can't be read imports as a placeholder that keeps the link (and a +/// warning), so it can be relinked. +#[derive(Clone, Copy, Default)] +pub struct ImportOptions<'a> { + /// The folder relative links are found in: the SVG file's own. Without it they can't be read. + pub folder: Option<&'a str>, + /// Reads a linked file. Without it no file is read. + pub read: Option>, } /// FNV-1a: a stable content hash (image keys, unique id prefixes). diff --git a/crates/svg/tests/import_details.rs b/crates/svg/tests/import_details.rs new file mode 100644 index 00000000..13031e05 --- /dev/null +++ b/crates/svg/tests/import_details.rs @@ -0,0 +1,183 @@ +//! SVG import details: linked images read from the SVG's folder and kept linked (a placeholder +//! and a warning when missing), SVG images as vector art, nested clips, undisplayed objects as +//! hidden objects, and reflected or repeated gradients. +// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness). +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] + +use std::path::{Path, PathBuf}; + +use vectorcraft_doc::{Document, ImageObject, LinkInfo, Node, NodeKind}; +use vectorcraft_geom::Rect; +use vectorcraft_svg::{ImportOptions, import_with, import_with_report}; +use vectorcraft_testkit::raster::{Image, assert_similar, render_artboard}; + +fn svg(body: &str) -> String { + format!(r#"{body}"#) +} + +/// All non-layer nodes in paint order. +fn art(d: &Document) -> Vec<&Node> { + let mut v = Vec::new(); + d.walk(|n| { + if !n.is_layer() { + v.push(n) + } + }); + v +} + +fn images(d: &Document) -> Vec<(&Node, &ImageObject)> { + art(d) + .into_iter() + .filter_map(|n| match &n.kind { + NodeKind::Image(im) => Some((n, im)), + _ => None, + }) + .collect() +} + +/// The SVG rendered by resvg on white at 1 px/pt. +fn resvg_render(svg: &str, w: u32, h: u32) -> Image { + let tree = resvg::usvg::Tree::from_str(svg, &resvg::usvg::Options::default()).expect("parse"); + let mut pm = resvg::tiny_skia::Pixmap::new(w, h).unwrap(); + pm.fill(resvg::tiny_skia::Color::WHITE); + resvg::render(&tree, resvg::tiny_skia::Transform::identity(), &mut pm.as_mut()); + Image { width: w, height: h, rgba: pm.data().to_vec() } +} + +fn png(w: u32, h: u32) -> Vec { + let mut out = vec![]; + image::RgbaImage::from_pixel(w, h, image::Rgba([10, 200, 30, 255])) + .write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png) + .unwrap(); + out +} + +/// A fresh folder for one test's files. +fn folder(name: &str) -> PathBuf { + let dir = std::env::temp_dir().join(format!("vectorcraft-svg-{name}-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(dir.join("img")).unwrap(); + dir +} + +/// Reads files as the app does (the link knows the size and hash). +fn read(path: &str) -> Option<(Vec, LinkInfo)> { + let bytes = std::fs::read(path).ok()?; + let link = LinkInfo { size: Some(bytes.len() as u64), hash: Some(vectorcraft_doc::links::hash_bytes(&bytes)), ..LinkInfo::new(path) }; + Some((bytes, link)) +} + +fn open_in(dir: &Path, body: &str) -> (Document, Vec) { + let folder = dir.to_string_lossy(); + import_with(&svg(body), &ImportOptions { folder: Some(&folder), read: Some(&read) }).unwrap() +} + +#[test] +fn a_linked_png_resolves_against_the_svg_folder_and_stays_linked() { + let dir = folder("linked"); + let bytes = png(40, 20); + std::fs::write(dir.join("img").join("photo one.png"), &bytes).unwrap(); + let (d, w) = open_in(&dir, r#""#); + assert!(w.is_empty(), "{w:?}"); + let [(_, im)] = images(&d)[..] else { panic!("{:?}", art(&d)) }; + let link = im.link.as_ref().unwrap(); + assert_eq!(Path::new(&link.path), dir.join("img").join("photo one.png")); + assert_eq!(link.hash, Some(vectorcraft_doc::links::hash_bytes(&bytes))); + assert_eq!((im.width, im.height), (40, 20)); + assert_eq!(*d.images[&im.key].bytes, bytes, "the file's pixels"); + let b = im.xf.transform_rect_bbox(Rect::new(0.0, 0.0, 40.0, 20.0)); + assert!((b.x0 - 10.0).abs() < 1e-6 && (b.y0 - 20.0).abs() < 1e-6 && (b.width() - 80.0).abs() < 1e-6, "{b:?}"); +} + +#[test] +fn a_missing_link_warns_and_keeps_a_placeholder_in_its_box() { + let dir = folder("missing"); + let (d, w) = open_in(&dir, r#""#); + assert!(w.iter().any(|w| w.contains("gone.png") && w.contains("not found")), "{w:?}"); + let [(_, im)] = images(&d)[..] else { panic!("{:?}", art(&d)) }; + assert_eq!(Path::new(&im.link.as_ref().unwrap().path), dir.join("img").join("gone.png")); + assert!(d.images[&im.key].is_proxy(), "a placeholder, not the file"); + // Stretched to the image's box, whatever its aspect. + let b = im.xf.transform_rect_bbox(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)); + assert!((b.x0 - 10.0).abs() < 1e-6 && (b.width() - 100.0).abs() < 1e-6 && (b.height() - 50.0).abs() < 1e-6, "{b:?}"); + // Without a reader nothing is read: the same placeholder. + let (d, w) = import_with_report(&svg(r#""#)).unwrap(); + assert_eq!(images(&d)[0].1.link.as_ref().unwrap().path, "/abs/photo.png"); + assert!(!w.is_empty()); +} + +#[test] +fn svg_images_import_as_vector_art() { + let dir = folder("svgimage"); + let inner = + r##""##; + std::fs::write(dir.join("img").join("logo.svg"), inner).unwrap(); + let data = format!("data:image/svg+xml;base64,{}", vectorcraft_svg::base64_encode(inner.as_bytes())); + let body = + format!(r#""#); + let (d, w) = open_in(&dir, &body); + assert!(w.is_empty(), "{w:?}"); + assert!(images(&d).is_empty()); + let mut boxes: Vec = art(&d).iter().filter(|n| n.path_data().is_some()).filter_map(|n| n.geometric_bounds()).collect(); + boxes.sort_by(|a, b| a.x0.total_cmp(&b.x0)); + assert_eq!(boxes.len(), 2, "{:?}", art(&d)); + assert!((boxes[0].x0 - 10.0).abs() < 1e-6 && (boxes[0].width() - 20.0).abs() < 1e-6, "{boxes:?}"); + assert!((boxes[1].x0 - 100.0).abs() < 1e-6 && (boxes[1].height() - 20.0).abs() < 1e-6, "{boxes:?}"); +} + +#[test] +fn nested_clips_intersect() { + let body = r##" + + "##; + let (d, w) = import_with_report(&svg(body)).unwrap(); + assert!(w.is_empty(), "{w:?}"); + let a = art(&d); + assert!(matches!(&a[0].kind, NodeKind::Group { clip: true, children } if matches!(children[1].kind, NodeKind::Group { clip: true, .. }))); + let mine = render_artboard(&d); + assert_similar(&mine, &resvg_render(&svg(body), 200, 120), 24.0, 0.003); + // The left half of the circle is cut. + assert_eq!(mine.over_white(45, 60), [255, 255, 255]); + assert_ne!(mine.over_white(90, 60), [255, 255, 255]); +} + +#[test] +fn undisplayed_objects_import_hidden() { + let body = r##" +