Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Images: EPS shows through its proxy at display time; simple PostScript (QR codes) is drawn

Govinda Roy677cafbf9c34
diff --git a/crates/images/src/eps.rs b/crates/images/src/eps.rs
index 01d959292..f86c4eaef 100644
--- a/crates/images/src/eps.rs
+++ b/crates/images/src/eps.rs
@@ -1,6 +1,7 @@
-//! EPS: there's no PostScript interpreter here, so a placed EPS shows (and prints) through a
-//! proxy, as InDesign does on screen: the file's TIFF preview when it has one, else a placeholder
-//! the size of its bounding box.
+//! EPS: there's no general PostScript interpreter here, so a placed EPS shows (and prints)
+//! through a proxy, as InDesign does on screen: the file's TIFF preview when it has one, else the
+//! rectangles of a simple one drawn here (InDesign's QR codes), else a placeholder the size of its
+//! bounding box.
/// An EPS file (plain, or DOS EPS with a binary header)?
pub fn is_eps(bytes: &[u8]) -> bool {
@@ -45,6 +46,10 @@ pub fn eps_proxy(bytes: &[u8]) -> Option<(Vec<u8>, (f64, f64))> {
{
return Some((tiff.to_vec(), (w, h)));
}
+ // Simple PostScript drawn here: InDesign's QR codes are coloured rectangles only.
+ if let Some(png) = render_rectangles(sections(bytes).0, bb) {
+ return Some((png, (w, h)));
+ }
let (pw, ph) = ((w * 2.0).round().clamp(2.0, 4000.0) as u32, (h * 2.0).round().clamp(2.0, 4000.0) as u32);
let mut img = image::RgbaImage::from_pixel(pw, ph, image::Rgba([228, 228, 228, 255]));
// Diagonals and a border mark it as a stand-in.
@@ -68,10 +73,146 @@ pub fn eps_proxy(bytes: &[u8]) -> Option<(Vec<u8>, (f64, f64))> {
Some((out, (w, h)))
}
+/// Pixels per point for rendered EPS (a QR code's modules stay crisp when scaled up on screen).
+const RENDER_SCALE: f64 = 8.0;
+/// The most rectangles and operators read from an EPS before giving up on drawing it.
+const MAX_RECTS: usize = 200_000;
+const MAX_TOKENS: usize = 2_000_000;
+/// The most pixels painted, in multiples of the image's area (overlapping rectangles repaint).
+const MAX_PAINT_AREAS: u64 = 64;
+
+/// PostScript that only fills rectangles in solid colours (`setcmykcolor`, `setrgbcolor`,
+/// `setgray`, `rectfill`, and procedures that stand for one of them, such as InDesign's
+/// `/rf { rectfill } bind def`), drawn as a PNG of the bounding box `bb`. None for anything else
+/// (paths, text, images, transforms), which keeps its placeholder, or when nothing is drawn.
+fn render_rectangles(ps: &[u8], bb: [f64; 4]) -> Option<Vec<u8>> {
+ let text = std::str::from_utf8(ps).ok()?;
+ let (w, h) = (bb[2] - bb[0], bb[3] - bb[1]);
+ if !(w > 0.0 && h > 0.0) {
+ return None;
+ }
+ let scale = RENDER_SCALE.min(4000.0 / w.max(h));
+ let (pw, ph) = ((w * scale).round().max(1.0) as u32, (h * scale).round().max(1.0) as u32);
+ let mut img = image::RgbaImage::from_pixel(pw, ph, image::Rgba([0, 0, 0, 0]));
+ let mut aliases: std::collections::HashMap<String, String> = std::collections::HashMap::new();
+ let mut stack: Vec<f64> = Vec::new();
+ let mut color = [0u8, 0, 0, 255];
+ let mut drawn = 0usize;
+ let mut painted = 0u64;
+ let paint_budget = u64::from(pw) * u64::from(ph) * MAX_PAINT_AREAS;
+ // Tokens without comments; `{ … }` procedures kept whole.
+ let mut tokens: Vec<String> = Vec::new();
+ for line in text.lines() {
+ let line = line.split('%').next().unwrap_or("");
+ let spaced = line.replace('{', " { ").replace('}', " } ");
+ tokens.extend(spaced.split_whitespace().map(str::to_string));
+ if tokens.len() > MAX_TOKENS {
+ return None;
+ }
+ }
+ let unit = |v: f64| v.clamp(0.0, 1.0);
+ let mut i = 0;
+ while let Some(tok) = tokens.get(i) {
+ i += 1;
+ if let Ok(v) = tok.parse::<f64>() {
+ if !v.is_finite() {
+ return None;
+ }
+ stack.push(v);
+ continue;
+ }
+ // `/name { op } bind def`: name stands for op.
+ if let Some(name) = tok.strip_prefix('/') {
+ // At most `{ op } bind`: anything longer isn't an alias this reader knows.
+ let body: Vec<&String> = tokens.iter().skip(i).take(5).take_while(|t| *t != "def").collect();
+ let op = match body.as_slice() {
+ [open, op, close] | [open, op, close, _] if *open == "{" && *close == "}" => (*op).clone(),
+ _ => return None,
+ };
+ aliases.insert(name.to_string(), op);
+ i += body.len() + 1;
+ continue;
+ }
+ let op = aliases.get(tok).map_or(tok.as_str(), String::as_str);
+ let mut pop = |n: usize| -> Option<Vec<f64>> { (stack.len() >= n).then(|| stack.split_off(stack.len() - n)) };
+ match op {
+ "setcmykcolor" => {
+ let v = pop(4)?;
+ let k = unit(v[3]);
+ let ch = |c: f64| ((1.0 - unit(c)) * (1.0 - k) * 255.0).round() as u8;
+ color = [ch(v[0]), ch(v[1]), ch(v[2]), 255];
+ }
+ "setrgbcolor" => {
+ let v = pop(3)?;
+ let ch = |c: f64| (unit(c) * 255.0).round() as u8;
+ color = [ch(v[0]), ch(v[1]), ch(v[2]), 255];
+ }
+ "setgray" => {
+ let v = pop(1)?;
+ let g = (unit(v[0]) * 255.0).round() as u8;
+ color = [g, g, g, 255];
+ }
+ "rectfill" => {
+ let v = pop(4)?;
+ drawn += 1;
+ if drawn > MAX_RECTS {
+ return None;
+ }
+ // PostScript y runs up; the image's down. Edges round to whole pixels, so
+ // touching rectangles (QR code modules) meet without gaps.
+ let (x0, x1) = ((v[0] - bb[0]) * scale, (v[0] + v[2] - bb[0]) * scale);
+ let (y0, y1) = ((bb[3] - (v[1] + v[3])) * scale, (bb[3] - v[1]) * scale);
+ let px = |a: f64, b: f64, max: u32| {
+ let (lo, hi) = (a.min(b).round().max(0.0), a.max(b).round().min(max as f64));
+ (lo as u32, hi.max(lo) as u32)
+ };
+ let ((xa, xb), (ya, yb)) = (px(x0, x1, pw), px(y0, y1, ph));
+ painted = painted.saturating_add(u64::from(xb - xa) * u64::from(yb - ya));
+ if painted > paint_budget {
+ return None;
+ }
+ for y in ya..yb {
+ for x in xa..xb {
+ img.put_pixel(x, y, image::Rgba(color));
+ }
+ }
+ }
+ "bind" | "gsave" | "grestore" | "newpath" | "showpage" | "save" | "restore" | "pop" | "end" | "begin" => {}
+ _ => return None,
+ }
+ }
+ if drawn == 0 {
+ return None;
+ }
+ let mut out = Vec::new();
+ image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).ok()?;
+ Some(out)
+}
+
#[cfg(test)]
mod tests {
use super::*;
+ #[test]
+ fn simple_rectangle_eps_is_drawn_like_a_qr_code() {
+ // As InDesign writes QR codes: a procedure for rectfill, a colour, then modules.
+ let eps = b"%!PS-Adobe-3.1 EPSF-3.0\n%%BoundingBox: 0 0 4 4\n%%EndComments\n/rf { rectfill } bind def\n0 0 0 1 setcmykcolor\n0 2 2 2 rf\n2 0 2 2 rf\n%%EOF\n";
+ let (png, size) = eps_proxy(eps).unwrap();
+ assert_eq!(size, (4.0, 4.0));
+ let img = image::load_from_memory(&png).unwrap().to_rgba8();
+ assert_eq!(img.dimensions(), (32, 32), "8 pixels per point");
+ // PostScript y runs up: (0, 2)–(2, 4) is the image's top left.
+ assert_eq!(img.get_pixel(4, 4).0, [0, 0, 0, 255]);
+ assert_eq!(img.get_pixel(28, 28).0, [0, 0, 0, 255]);
+ assert_eq!(img.get_pixel(28, 4).0[3], 0, "undrawn stays transparent");
+ assert_eq!(img.get_pixel(4, 28).0[3], 0);
+ // Anything else (here a path) keeps the placeholder.
+ let curve = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 4 4\n0 0 moveto 4 4 lineto stroke\n%%EOF\n";
+ let (png, _) = eps_proxy(curve).unwrap();
+ let img = image::load_from_memory(&png).unwrap().to_rgba8();
+ assert_eq!(img.get_pixel(2, 4).0, [228, 228, 228, 255]);
+ }
+
#[test]
fn eps_bounding_box_and_proxies() {
let eps = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 50\n%%HiResBoundingBox: 0 0 100.5 50.25\nnewpath\n%%EOF\n";
diff --git a/crates/images/src/lib.rs b/crates/images/src/lib.rs
index 4751263a4..7ce48c0a3 100644
--- a/crates/images/src/lib.rs
+++ b/crates/images/src/lib.rs
@@ -140,6 +140,10 @@ pub fn natural_size(bytes: &[u8]) -> Option<(f64, f64)> {
let s = svg_tree(bytes)?.size();
return Some((s.width() as f64 * PT_PER_PX, s.height() as f64 * PT_PER_PX));
}
+ if is_eps(bytes) {
+ let bb = eps::bounding_box(bytes)?;
+ return Some((bb[2] - bb[0], bb[3] - bb[1])).filter(|(w, h)| w.is_finite() && h.is_finite() && *w > 0.0 && *h > 0.0);
+ }
let (w, h) = pixel_size(bytes)?;
Some((w as f64, h as f64))
}
@@ -159,6 +163,11 @@ pub fn decode_rgba(bytes: &[u8]) -> Option<image::RgbaImage> {
if is_psd(bytes) {
return psd::decode(bytes);
}
+ // An EPS is drawn as its proxy (preview, simple PostScript or placeholder); the document
+ // keeps the EPS itself.
+ if is_eps(bytes) {
+ return decode_rgba(&eps_proxy(bytes)?.0);
+ }
Some(decode_to_rgba8(&image::load_from_memory(bytes).ok()?))
}
@@ -386,6 +395,19 @@ mod tests {
b
}
+ /// A placed EPS is measured by its bounding box in points and drawn through its proxy; the
+ /// bytes stay the EPS.
+ #[test]
+ fn eps_draws_through_its_proxy_at_its_bounding_box_size() {
+ let eps =
+ b"%!PS-Adobe-3.1 EPSF-3.0\n%%BoundingBox: 0 0 4 2\n%%EndComments\n/rf { rectfill } bind def\n0 0 0 1 setcmykcolor\n0 0 2 2 rf\n%%EOF\n";
+ assert_eq!(natural_size(eps), Some((4.0, 2.0)));
+ let img = decode_rgba(eps).expect("drawn");
+ assert_eq!(img.dimensions(), (32, 16));
+ assert_eq!(img.get_pixel(1, 1).0, [0, 0, 0, 255], "the rectangle");
+ assert_eq!(img.get_pixel(30, 1).0[3], 0, "outside it, transparent");
+ }
+
/// CMYK TIFFs read back as their ink values; RGB ones aren't CMYK.
#[test]
fn cmyk_tiff_keeps_inks() {