use super::exporter::Exporter; use super::paint::{append_path, norm}; use super::{ Arc, Fill, FillRule, Image, LineCap, LineJoin, NormalizedF32, Path, PathBuilder, Picture, PlacedItem, Rect, Size, Stroke, StrokeDash, Surface, Transform, krilla, rgb, }; use craft_metafile::Item; use kurbo::Shape as _; use wordcraft_doc::picfx::PicFx; /// Largest picture side we embed (pixels). const MAX_IMAGE_SIDE: u32 = 30_000; /// A metafile picture, parsed once. The geometry comes placed by the metafile crate; the bitmaps and /// pattern tiles are embedded images, one per picture item (None for paths, text and undecodable /// bitmaps). Fills that share a tile share its image. `averages` holds each pattern fill's tile /// average color (transparent for other items), computed once a tile. pub(crate) struct Vector { pic: Picture, images: Vec>, averages: Vec<[u8; 4]>, } /// Parses a metafile and embeds its bitmaps and pattern tiles. None when the picture has no usable /// size. pub(crate) fn build_vector(bytes: &[u8]) -> Option { let mut pic = craft_metafile::parse(bytes).ok()?; if !pic.has_size() { return None; } let mut tiles: std::collections::HashMap, [u8; 4])> = std::collections::HashMap::new(); let (images, averages) = pic .items .iter_mut() .map(|it| match it { Item::Pattern { tile, .. } => tiles .entry(Arc::as_ptr(tile) as usize) .or_insert_with(|| { let n = (tile.width as usize).saturating_mul(tile.height as usize).saturating_mul(4); let img = (tile.width > 0 && tile.height > 0 && tile.rgba.len() == n) .then(|| Image::from_rgba8(tile.rgba.clone(), tile.width, tile.height)); (img, wordcraft_layout::metafile_average_color(&tile.rgba)) }) .clone(), _ => (it.take_pixels().map(|(w, h, px)| Image::from_rgba8(px, w, h)), [0; 4]), }) .unzip(); Some(Vector { pic, images, averages }) } /// A straight RGBA colour as a krilla colour and opacity. pub(crate) fn paint_of(c: [u8; 4]) -> (rgb::Color, NormalizedF32) { (rgb::Color::new(c[0], c[1], c[2]), norm(f32::from(c[3]) / 255.0)) } /// Narrowest metafile stroke in points. Cosmetic (width 0) pens get it rather than PDF's 0-width /// "thinnest line": krilla bounds a 0-width stroke by the bare path, which is empty for a horizontal /// line, so a faded (grouped) picture would clip it away. const HAIRLINE: f64 = 0.25; /// Draws a metafile picture into the clip (the picture frame): paths are filled and stroked in page /// space (strokes keep their width under non-uniform scaling), bitmaps stretched (or turned by their /// transform), pattern fills tiled, each item inside its clip region and clip paths, all faded by /// `alpha`. Every path sets its fill and stroke, so none carries over; strokes take the pen's caps, /// joins and dashes. Text runs are drawn as text. pub(crate) fn vector_picture(ex: &mut Exporter, s: &mut Surface, v: &Vector, r: &Rect, crop: &[f32; 4], clip: &Path, alpha: f32) { let target = kurbo::Rect::new(f64::from(r.x), f64::from(r.y), f64::from(r.x + r.w), f64::from(r.y + r.h)); let fade = alpha < 0.999; if fade { s.push_opacity(norm(alpha)); } s.push_clip_path(clip, &FillRule::NonZero); for it in v.pic.place(target, wordcraft_layout::crop_sides(*crop)) { match it { PlacedItem::Path { path, fill, stroke, line, even_odd, region, clips } => { let Some(p) = path_from(&path) else { continue }; let fill = fill.map(|c| { let (paint, opacity) = paint_of(c); let rule = if even_odd { FillRule::EvenOdd } else { FillRule::NonZero }; Fill { paint: paint.into(), opacity, rule } }); let stroke = stroke.map(|(c, w)| { let (paint, opacity) = paint_of(c); pen(paint.into(), opacity, w, &line, &path) }); let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue }; s.set_fill(fill); s.set_stroke(stroke); s.draw_path(&p); pop_clips(s, n); } PlacedItem::Bitmap { index, rect, transform, region, clips } => { let Some(Some(img)) = v.images.get(index) else { continue }; let c = transform.as_coeffs(); // Upright and not mirrored: the bitmap fills `rect`. let upright = c[1] == 0.0 && c[2] == 0.0 && c[0] > 0.0 && c[3] > 0.0; let (tf, size) = if upright { (Transform::from_translate(rect.x0 as f32, rect.y0 as f32), Size::from_wh(rect.width() as f32, rect.height() as f32)) } else { // A turned, skewed or mirrored bitmap: `transform` maps the unit square onto its place. let c = c.map(|v| v as f32); (Transform::from_row(c[0], c[1], c[2], c[3], c[4], c[5]), Size::from_wh(1.0, 1.0)) }; let Some(size) = size else { continue }; let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue }; s.push_transform(&tf); s.draw_image(img.clone(), size); s.pop(); pop_clips(s, n); } PlacedItem::Pattern { index, path, even_odd, tile, region, clips } => { let Some(p) = path_from(&path) else { continue }; let Some(craft_metafile::Item::Pattern { tile: t, .. }) = v.pic.items.get(index) else { continue }; let rule = if even_odd { FillRule::EvenOdd } else { FillRule::NonZero }; let paint = match v.images.get(index) { Some(Some(img)) => tile_pattern(s, img, t.width, t.height, tile).map(|p| (p.into(), norm(1.0))), _ => None, }; let (paint, opacity) = paint.unwrap_or_else(|| { let (c, o) = paint_of(v.averages.get(index).copied().unwrap_or([0; 4])); (c.into(), o) }); let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue }; s.set_fill(Some(Fill { paint, opacity, rule })); s.set_stroke(None); s.draw_path(&p); pop_clips(s, n); } PlacedItem::Text { index, transform, clip, region, clips } => { let Some(craft_metafile::Item::Text(t)) = v.pic.items.get(index) else { continue }; let Some(n) = push_clips(s, region.as_deref(), &clips) else { continue }; let text_clip = clip.and_then(|c| path_from(&c.to_path(0.1))); if let Some(c) = &text_clip { s.push_clip_path(c, &FillRule::NonZero); } ex.vector_text(s, t, transform); if text_clip.is_some() { s.pop(); } pop_clips(s, n); } } } s.set_fill(None); s.set_stroke(None); s.pop(); if fade { s.pop(); } } /// Pushes a metafile item's clip region and clip paths; pop them with [`pop_clips`] and the count /// returned. None (nothing pushed) when a clip has no area to draw in. fn push_clips(s: &mut Surface, region: Option<&kurbo::BezPath>, clips: &[Arc]) -> Option { let mut paths = Vec::with_capacity(clips.len() + 1); if let Some(region) = region { paths.push((path_from(region)?, FillRule::NonZero)); } for c in clips { paths.push((path_from(&c.path)?, if c.even_odd { FillRule::EvenOdd } else { FillRule::NonZero })); } for (p, rule) in &paths { s.push_clip_path(p, rule); } Some(paths.len()) } fn pop_clips(s: &mut Surface, n: usize) { for _ in 0..n { s.pop(); } } /// A metafile pen for `path`: `width` (points, at least [`HAIRLINE`]), the pen's caps, joins, /// miter limit and dashes (`wordcraft_layout::metafile_dashes`, with the hairline as the pixel). fn pen(paint: krilla::paint::Paint, opacity: NormalizedF32, width: f64, line: &craft_metafile::LineStyle, path: &kurbo::BezPath) -> Stroke { let line_cap = match line.cap { craft_metafile::Cap::Round => LineCap::Round, craft_metafile::Cap::Square => LineCap::Square, craft_metafile::Cap::Flat => LineCap::Butt, }; let line_join = match line.join { craft_metafile::Join::Round => LineJoin::Round, craft_metafile::Join::Bevel => LineJoin::Bevel, craft_metafile::Join::Miter => LineJoin::Miter, }; let dash = if line.dash.is_empty() { None } else { wordcraft_layout::metafile_dashes(&line.dash, width == 0.0, HAIRLINE, path.perimeter(1.0)) }; Stroke { paint, width: width.max(HAIRLINE) as f32, miter_limit: wordcraft_layout::metafile_miter_limit(line.miter_limit), line_cap, line_join, opacity, dash: dash.map(|d| StrokeDash { array: d.iter().map(|v| *v as f32).collect(), offset: 0.0 }), } } /// A tiling pattern of `img` (`w` × `h` pixels); `tile` maps tile pixels to page space. None when /// the mapping is not finite. fn tile_pattern(s: &mut Surface, img: &Image, w: u32, h: u32, tile: kurbo::Affine) -> Option { let c = tile.as_coeffs().map(|v| v as f32); if !c.iter().all(|v| v.is_finite()) { return None; } let size = Size::from_wh(w as f32, h as f32)?; let mut sb = s.stream_builder(); let mut ps = sb.surface(); ps.draw_image(img.clone(), size); ps.finish(); let stream = sb.finish(); Some(krilla::paint::Pattern { stream, transform: Transform::from_row(c[0], c[1], c[2], c[3], c[4], c[5]), width: w as f32, height: h as f32 }) } /// A kurbo path as a krilla path (None when empty). fn path_from(b: &kurbo::BezPath) -> Option { let mut pb = PathBuilder::new(); append_path(&mut pb, b); pb.finish() } /// Decode a picture for embedding (validated with the `image` crate first, so a broken file /// can't fail the whole export), with its brightness and contrast `fx` applied to the pixels. /// /// A JPEG goes in as it is unless `fx` changes its pixels; corrected pixels go in raw and krilla /// compresses them (Flate), and `Exporter::image` embeds one picture with the same corrections /// once. Corrected or not, a picture goes through the same size checks and decode, so it never /// fails here only because it has corrections. pub(crate) fn load_image(data: &Arc>, fx: PicFx) -> Option { // The shared probe also charges what the decoder holds beside its output (#3644). if !wordcraft_geom::picture::probe(data).is_ok_and(|p| p.fits(wordcraft_geom::MAX_DECODED_BYTES)) { return None; } load_image_within(data, fx, wordcraft_geom::MAX_DECODED_BYTES) } /// [`load_image`] with an explicit RGBA byte budget (a small one in tests). pub(crate) fn load_image_within(data: &Arc>, fx: PicFx, budget: u64) -> Option { let fmt = wordcraft_geom::picture::guess_format(data)?; // The decision to draw or not is the shared one (`wordcraft_geom::picture`), the one strict // export checks with. let dec = wordcraft_geom::picture::decode_for_drawing(data, budget, MAX_IMAGE_SIDE).ok()?; let (w, h) = (dec.width(), dec.height()); if !fx.changes_pixels() && fmt == image::ImageFormat::Jpeg && matches!(dec.color(), image::ColorType::L8 | image::ColorType::Rgb8) { return Image::from_jpeg(data.clone().into(), true).ok(); } let mut px = dec.into_rgba8().into_raw(); fx.apply_rgba(&mut px); Some(Image::from_rgba8(px, w, h)) }