mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-18 08:15:29 +00:00
489 lines
20 KiB
Rust
489 lines
20 KiB
Rust
//! The flattener's writer: display lists written with krilla and separated again by `plates`.
|
||
//! Pages are 100 pt square and separated at 36 dpi; sample points are in points.
|
||
//!
|
||
//! Text cases with an embedded font need Inter from `CRAFT_PDF_TEST_FONT_DIR` or
|
||
//! `~/.cache/craft-pdf-test-fonts`, and are skipped when it is missing.
|
||
#![cfg(feature = "flatten")]
|
||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||
|
||
use std::path::PathBuf;
|
||
use std::sync::{Arc, OnceLock};
|
||
|
||
use craft_pdf::interpret::font::Glyph;
|
||
use craft_pdf::interpret::hayro_cmap::BfString;
|
||
use craft_pdf::interpret::{
|
||
BlendMode as HBlendMode, ClipPath, Context, Device, GlyphDrawMode, Image, InterpreterCache, InterpreterSettings, Paint as HPaint, PathDrawMode,
|
||
SoftMask, TransformExt, interpret_page,
|
||
};
|
||
use craft_pdf::syntax::object::{Dict, Name, Stream};
|
||
use craft_pdf::write::backend::SerializeSettings;
|
||
use craft_pdf::write::backend::configure::PdfVersion;
|
||
use craft_pdf::write::backend::page::PageSettings;
|
||
use craft_pdf::write::print::{self, PrintColor};
|
||
use craft_pdf::write::{Metadata, Writer};
|
||
use craft_prepress::flatten::kurbo::{Affine, BezPath, Point, Rect, Shape};
|
||
use craft_prepress::flatten::write::{WriteError, page_pdf, write_flattened};
|
||
use craft_prepress::flatten::{
|
||
BlendMode, ComplexRegion, DisplayList, FillItem, FillRule, FlattenOptions, GradientGeometry, GroupItem, ImageItem, ImageSpace, Item, Paint,
|
||
PlacedGlyph, TextFont, TextItem, flatten,
|
||
};
|
||
use craft_prepress::{Alternate, CmsConversion, Ink, InkColor, InkId, InkSet, Options, Overprint, Plates, Process, Spot, plates};
|
||
|
||
const C: InkId = InkId::process(Process::Cyan);
|
||
const M: InkId = InkId::process(Process::Magenta);
|
||
const Y: InkId = InkId::process(Process::Yellow);
|
||
const K: InkId = InkId::process(Process::Black);
|
||
const OVERPRINT: Overprint = Overprint { fill: true, stroke: false, nonzero: false };
|
||
|
||
fn fill(r: Rect, tints: &[(InkId, f32)], overprint: Overprint) -> Item {
|
||
Item::Fill(FillItem { path: r.to_path(0.1), rule: FillRule::NonZero, paint: Paint::Solid(InkColor::Tints(tints.to_vec())), overprint })
|
||
}
|
||
|
||
fn solid(r: Rect, tints: &[(InkId, f32)]) -> Item {
|
||
fill(r, tints, Overprint::default())
|
||
}
|
||
|
||
fn group(opacity: f32, children: Vec<Item>) -> Item {
|
||
Item::Group(GroupItem {
|
||
opacity,
|
||
blend: BlendMode::Normal,
|
||
isolated: false,
|
||
knockout: false,
|
||
clip: None,
|
||
clip_rule: FillRule::NonZero,
|
||
mask: None,
|
||
actual_text: None,
|
||
children,
|
||
})
|
||
}
|
||
|
||
fn page(inks: InkSet, items: Vec<Item>) -> DisplayList {
|
||
DisplayList { page: Rect::new(0.0, 0.0, 100.0, 100.0), inks, items }
|
||
}
|
||
|
||
fn pdf(list: &DisplayList) -> Vec<u8> {
|
||
// Reading the profile takes a quarter second in a debug build.
|
||
static SETTINGS: OnceLock<SerializeSettings> = OnceLock::new();
|
||
let settings = SETTINGS.get_or_init(|| print::settings(PrintColor::fogra39(craft_cms::builtin::COATED_FOGRA39_ICC)).unwrap());
|
||
page_pdf(list, settings.clone(), &CmsConversion::fogra39()).unwrap()
|
||
}
|
||
|
||
/// `list` flattened, with nothing left for the raster step, written.
|
||
fn flat_pdf(list: &DisplayList) -> Vec<u8> {
|
||
let flat = flatten(list, &FlattenOptions::default()).unwrap();
|
||
assert!(flat.complex.is_empty());
|
||
pdf(&DisplayList { items: flat.items, ..list.clone() })
|
||
}
|
||
|
||
fn separate(pdf: &[u8]) -> Plates {
|
||
plates(pdf, 0, 36.0, &Options::default()).unwrap()
|
||
}
|
||
|
||
/// Ink `name`'s tint at (`x`, `y`) in points, 0 when the page doesn't use the ink.
|
||
fn tint(p: &Plates, name: &str, x: u32, y: u32) -> u8 {
|
||
p.inks.lookup(name).and_then(|id| p.tint(id, x / 2, y / 2)).unwrap_or(0)
|
||
}
|
||
|
||
/// Each ink's tint at (`x`, `y`) is within 3 of `expected`.
|
||
fn assert_inks(p: &Plates, x: u32, y: u32, expected: &[(&str, u8)]) {
|
||
for (name, want) in expected {
|
||
let got = tint(p, name, x, y);
|
||
assert!(got.abs_diff(*want) <= 3, "{name} at ({x}, {y}): {got}, expected {want}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn half_black_over_cyan_in_a_group_composites_the_same_flattened_or_not() {
|
||
let list = page(
|
||
InkSet::new(),
|
||
vec![solid(Rect::new(0.0, 0.0, 60.0, 100.0), &[(C, 1.0)]), group(0.5, vec![solid(Rect::new(40.0, 0.0, 100.0, 100.0), &[(K, 1.0)])])],
|
||
);
|
||
for written in [pdf(&list), flat_pdf(&list)] {
|
||
let p = separate(&written);
|
||
assert_inks(&p, 50, 50, &[("Cyan", 128), ("Black", 128)]);
|
||
assert_inks(&p, 20, 50, &[("Cyan", 255), ("Black", 0)]);
|
||
assert_inks(&p, 80, 50, &[("Cyan", 0), ("Black", 128)]);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn group_opacity_applies_to_the_group_not_to_each_child() {
|
||
// Two overlapping K100 fills in a 50% group: K50 where they overlap, not K75.
|
||
let list = page(
|
||
InkSet::new(),
|
||
vec![group(0.5, vec![solid(Rect::new(0.0, 0.0, 60.0, 100.0), &[(K, 1.0)]), solid(Rect::new(40.0, 0.0, 100.0, 100.0), &[(K, 1.0)])])],
|
||
);
|
||
for written in [pdf(&list), flat_pdf(&list)] {
|
||
let p = separate(&written);
|
||
assert_inks(&p, 50, 50, &[("Black", 128)]);
|
||
assert_inks(&p, 20, 50, &[("Black", 128)]);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn an_even_odd_clip_keeps_its_hole_written_or_flattened() {
|
||
// Two nested squares drawn in the same direction: filled even-odd, the inner one is a hole.
|
||
let mut ring = Rect::new(0.0, 0.0, 100.0, 100.0).to_path(0.1);
|
||
ring.extend(Rect::new(25.0, 25.0, 75.0, 75.0).to_path(0.1));
|
||
let Item::Group(half_black) = group(0.5, vec![solid(Rect::new(0.0, 0.0, 100.0, 100.0), &[(K, 1.0)])]) else { unreachable!() };
|
||
let clipped = Item::Group(GroupItem { clip: Some(ring), clip_rule: FillRule::EvenOdd, ..half_black });
|
||
let list = page(InkSet::new(), vec![solid(Rect::new(0.0, 0.0, 100.0, 100.0), &[(C, 1.0)]), clipped]);
|
||
for written in [pdf(&list), flat_pdf(&list)] {
|
||
let p = separate(&written);
|
||
assert_inks(&p, 10, 50, &[("Cyan", 128), ("Black", 128)]);
|
||
assert_inks(&p, 50, 50, &[("Cyan", 255), ("Black", 0)]);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn black_overprint_keeps_the_cyan_under_it() {
|
||
let list = page(
|
||
InkSet::new(),
|
||
vec![solid(Rect::new(0.0, 0.0, 100.0, 100.0), &[(C, 1.0)]), fill(Rect::new(50.0, 0.0, 100.0, 100.0), &[(K, 1.0)], OVERPRINT)],
|
||
);
|
||
for written in [pdf(&list), flat_pdf(&list)] {
|
||
let p = separate(&written);
|
||
assert_inks(&p, 75, 50, &[("Cyan", 255), ("Black", 255)]);
|
||
assert_inks(&p, 25, 50, &[("Cyan", 255), ("Black", 0)]);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn overprinting_process_color_leaves_the_plates_of_inks_it_doesnt_list() {
|
||
let over = |tints: &[(InkId, f32)], nonzero: bool| {
|
||
let list = page(
|
||
InkSet::new(),
|
||
vec![
|
||
solid(Rect::new(0.0, 0.0, 100.0, 100.0), &[(C, 1.0)]),
|
||
fill(Rect::new(50.0, 0.0, 100.0, 100.0), tints, Overprint { nonzero, ..OVERPRINT }),
|
||
],
|
||
);
|
||
separate(&pdf(&list))
|
||
};
|
||
// Magenta and yellow only: cyan stays, black stays empty.
|
||
assert_inks(&over(&[(M, 1.0), (Y, 0.5)], false), 75, 50, &[("Cyan", 255), ("Magenta", 255), ("Yellow", 128), ("Black", 0)]);
|
||
// A listed cyan at 0 knocks cyan out under OPM 0 ...
|
||
assert_inks(&over(&[(C, 0.0), (M, 1.0)], false), 75, 50, &[("Cyan", 0), ("Magenta", 255)]);
|
||
// ... and leaves it under OPM 1.
|
||
assert_inks(&over(&[(C, 0.0), (M, 1.0)], true), 75, 50, &[("Cyan", 255), ("Magenta", 255)]);
|
||
// Nothing named paints nothing.
|
||
assert_inks(&over(&[(C, 0.0)], true), 75, 50, &[("Cyan", 255)]);
|
||
}
|
||
|
||
fn gold() -> Spot {
|
||
Spot { name: "Gold".into(), alternate: Alternate::Cmyk([0.0, 0.2, 0.8, 0.1]), solidity: None }
|
||
}
|
||
|
||
#[test]
|
||
fn spot_fills_print_on_their_plate_or_where_the_ink_manager_sends_them() {
|
||
let mut inks = InkSet::new();
|
||
let gold = inks.add(Ink::Spot(gold())).unwrap();
|
||
let list = page(inks.clone(), vec![solid(Rect::new(0.0, 0.0, 100.0, 100.0), &[(gold, 0.8)])]);
|
||
assert_inks(&separate(&pdf(&list)), 50, 50, &[("Gold", 204), ("Cyan", 0), ("Magenta", 0), ("Yellow", 0)]);
|
||
|
||
let mut aliased = inks.clone();
|
||
assert!(aliased.alias(gold, M));
|
||
let p = separate(&pdf(&DisplayList { inks: aliased, ..list.clone() }));
|
||
assert!(p.inks.lookup("Gold").is_none());
|
||
assert_inks(&p, 50, 50, &[("Magenta", 204), ("Yellow", 0)]);
|
||
|
||
let mut process = inks;
|
||
assert!(process.set_to_process(gold, true));
|
||
let p = separate(&pdf(&DisplayList { inks: process, ..list }));
|
||
assert!(p.inks.lookup("Gold").is_none());
|
||
assert_inks(&p, 50, 50, &[("Cyan", 0), ("Magenta", 41), ("Yellow", 163), ("Black", 20)]);
|
||
}
|
||
|
||
// ---- text ----------------------------------------------------------------------------------
|
||
|
||
const SAMPLE: &str = "Hamburg";
|
||
|
||
fn inter() -> Option<Vec<u8>> {
|
||
let dir = std::env::var_os("CRAFT_PDF_TEST_FONT_DIR")
|
||
.map(PathBuf::from)
|
||
.or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".cache/craft-pdf-test-fonts")));
|
||
let data = dir.as_ref().and_then(|d| std::fs::read(d.join("Inter-Regular.ttf")).ok());
|
||
if data.is_none() {
|
||
println!("note: Inter-Regular.ttf not found in {dir:?}; case skipped");
|
||
}
|
||
data
|
||
}
|
||
|
||
struct Outline(BezPath);
|
||
|
||
impl ttf_parser::OutlineBuilder for Outline {
|
||
fn move_to(&mut self, x: f32, y: f32) {
|
||
self.0.move_to((f64::from(x), f64::from(y)));
|
||
}
|
||
fn line_to(&mut self, x: f32, y: f32) {
|
||
self.0.line_to((f64::from(x), f64::from(y)));
|
||
}
|
||
fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {
|
||
self.0.quad_to((f64::from(x1), f64::from(y1)), (f64::from(x), f64::from(y)));
|
||
}
|
||
fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {
|
||
self.0.curve_to((f64::from(x1), f64::from(y1)), (f64::from(x2), f64::from(y2)), (f64::from(x), f64::from(y)));
|
||
}
|
||
fn close(&mut self) {
|
||
self.0.close_path();
|
||
}
|
||
}
|
||
|
||
/// `SAMPLE` in K100 at 18 pt on a baseline at (5, 60), with its outlines.
|
||
fn text_run(font: &[u8], embed: bool) -> TextItem {
|
||
let face = ttf_parser::Face::parse(font, 0).unwrap();
|
||
let upem = f64::from(face.units_per_em());
|
||
let size = 18.0;
|
||
let transform = Affine::new([1.0, 0.0, 0.0, -1.0, 5.0, 60.0]);
|
||
let (mut x, mut glyphs, mut outlines) = (0.0, Vec::new(), BezPath::new());
|
||
for (i, c) in SAMPLE.char_indices() {
|
||
let id = face.glyph_index(c).unwrap();
|
||
glyphs.push(PlacedGlyph { id: u32::from(id.0), origin: Point::new(x, 0.0), text: i..i + c.len_utf8() });
|
||
let mut outline = Outline(BezPath::new());
|
||
face.outline_glyph(id, &mut outline);
|
||
outlines.extend((transform * Affine::translate((x, 0.0)) * Affine::scale(size / upem) * outline.0).iter());
|
||
x += f64::from(face.glyph_hor_advance(id).unwrap()) * size / upem;
|
||
}
|
||
TextItem {
|
||
font: embed.then(|| Arc::new(TextFont { data: Arc::new(font.to_vec()), index: 0, key: 1 })),
|
||
size: size as f32,
|
||
transform,
|
||
glyphs,
|
||
text: Some(SAMPLE.to_owned()),
|
||
outlines,
|
||
paint: Paint::Solid(InkColor::Tints(vec![(K, 1.0)])),
|
||
overprint: Overprint::default(),
|
||
}
|
||
}
|
||
|
||
#[derive(Default)]
|
||
struct Reader {
|
||
unicode: String,
|
||
actual_text: String,
|
||
}
|
||
|
||
impl<'a> Device<'a> for Reader {
|
||
fn set_soft_mask(&mut self, _: Option<SoftMask<'a>>) {}
|
||
fn set_blend_mode(&mut self, _: HBlendMode) {}
|
||
fn draw_path(&mut self, _: &BezPath, _: Affine, _: &HPaint<'a>, _: &PathDrawMode) {}
|
||
fn push_clip_path(&mut self, _: &ClipPath) {}
|
||
fn push_transparency_group(&mut self, _: f32, _: Option<SoftMask<'a>>, _: HBlendMode) {}
|
||
fn draw_glyph(&mut self, glyph: &Glyph<'a>, _: Affine, _: Affine, _: &HPaint<'a>, _: &GlyphDrawMode) {
|
||
if let Glyph::Outline(o) = glyph {
|
||
match o.as_unicode() {
|
||
Some(BfString::Char(c)) => self.unicode.push(c),
|
||
Some(BfString::String(s)) => self.unicode.push_str(&s),
|
||
None => {}
|
||
}
|
||
}
|
||
}
|
||
fn draw_image(&mut self, _: Image<'a, '_>, _: Affine) {}
|
||
fn pop_clip_path(&mut self) {}
|
||
fn pop_transparency_group(&mut self) {}
|
||
fn actual_text(&mut self, text: &[u8]) {
|
||
self.actual_text.push_str(&match text {
|
||
[0xFE, 0xFF, rest @ ..] => String::from_utf16_lossy(&rest.as_chunks::<2>().0.iter().map(|c| u16::from_be_bytes(*c)).collect::<Vec<_>>()),
|
||
_ => text.iter().map(|&b| char::from(b)).collect(),
|
||
});
|
||
}
|
||
}
|
||
|
||
fn read_text(pdf: &[u8]) -> Reader {
|
||
let doc = craft_pdf::syntax::Pdf::new(Arc::new(pdf.to_vec())).unwrap();
|
||
let page = &doc.pages()[0];
|
||
let cache = InterpreterCache::new();
|
||
let bbox = Rect::new(0.0, 0.0, 100.0, 100.0);
|
||
let mut context = Context::new(page.initial_transform(true).to_kurbo(), bbox, &cache, page.xref(), InterpreterSettings::default());
|
||
let mut reader = Reader::default();
|
||
interpret_page(page, &mut context, &mut reader);
|
||
reader
|
||
}
|
||
|
||
#[test]
|
||
fn text_with_a_font_is_live_and_prints_like_its_outlines() {
|
||
let Some(font) = inter() else { return };
|
||
let live = pdf(&page(InkSet::new(), vec![Item::Text(text_run(&font, true))]));
|
||
let outlined = pdf(&page(InkSet::new(), vec![Item::Text(text_run(&font, false))]));
|
||
assert_eq!(read_text(&live).unicode, SAMPLE);
|
||
let (a, b) = (separate(&live), separate(&outlined));
|
||
let (a, b) = (a.plane(K).unwrap(), b.plane(K).unwrap());
|
||
assert!(a.iter().map(|v| u64::from(*v)).sum::<u64>() > 255 * 50, "the text prints");
|
||
let differ = a.iter().zip(b).filter(|(x, y)| x.abs_diff(**y) > 64).count();
|
||
assert!(differ <= a.len() / 200, "{differ} pixels differ between glyphs and outlines");
|
||
}
|
||
|
||
#[test]
|
||
fn text_without_a_font_is_drawn_as_outlines_with_its_text() {
|
||
let mut run = TextItem {
|
||
font: None,
|
||
size: 18.0,
|
||
transform: Affine::new([1.0, 0.0, 0.0, -1.0, 5.0, 60.0]),
|
||
glyphs: Vec::new(),
|
||
text: Some(SAMPLE.to_owned()),
|
||
outlines: Rect::new(5.0, 45.0, 80.0, 60.0).to_path(0.1),
|
||
paint: Paint::Solid(InkColor::Tints(vec![(K, 1.0)])),
|
||
overprint: Overprint::default(),
|
||
};
|
||
if let Some(font) = inter() {
|
||
run = TextItem { font: None, ..text_run(&font, false) };
|
||
}
|
||
let written = pdf(&page(InkSet::new(), vec![Item::Text(run)]));
|
||
let read = read_text(&written);
|
||
assert_eq!(read.actual_text, SAMPLE);
|
||
assert!(read.unicode.is_empty());
|
||
}
|
||
|
||
// ---- structure -----------------------------------------------------------------------------
|
||
|
||
/// Transparency left on a page: groups, soft masks, blend modes other than Normal and
|
||
/// constant opacity below 1, in its resources and those of the forms it uses.
|
||
fn transparency(pdf: &[u8]) -> Vec<String> {
|
||
let doc = craft_pdf::syntax::Pdf::new(Arc::new(pdf.to_vec())).unwrap();
|
||
let page = &doc.pages()[0];
|
||
let mut found = Vec::new();
|
||
if page.raw().get::<Dict<'_>>(b"Group".as_slice()).is_some() {
|
||
found.push("page group".to_owned());
|
||
}
|
||
visit(&page.resources().x_objects, &page.resources().ext_g_states, &mut found, 0);
|
||
found
|
||
}
|
||
|
||
fn visit(x_objects: &Dict<'_>, states: &Dict<'_>, found: &mut Vec<String>, depth: usize) {
|
||
assert!(depth < 16);
|
||
for key in states.keys() {
|
||
let Some(state) = states.get::<Dict<'_>>(key.as_ref()) else { continue };
|
||
if state.get::<Dict<'_>>(b"SMask".as_slice()).is_some() {
|
||
found.push("soft mask".to_owned());
|
||
}
|
||
if let Some(bm) = state.get::<Name<'_>>(b"BM".as_slice())
|
||
&& bm.as_str() != "Normal"
|
||
{
|
||
found.push(format!("blend mode {}", bm.as_str()));
|
||
}
|
||
for alpha in ["ca", "CA"] {
|
||
if state.get::<f32>(alpha.as_bytes()).is_some_and(|a| a < 1.0) {
|
||
found.push(alpha.to_owned());
|
||
}
|
||
}
|
||
}
|
||
for key in x_objects.keys() {
|
||
let Some(x) = x_objects.get::<Stream<'_>>(key.as_ref()) else { continue };
|
||
let dict = x.dict();
|
||
if dict.get::<Dict<'_>>(b"Group".as_slice()).is_some() {
|
||
found.push("group".to_owned());
|
||
}
|
||
if let Some(res) = dict.get::<Dict<'_>>(b"Resources".as_slice()) {
|
||
let sub = |key: &[u8]| res.get::<Dict<'_>>(key).unwrap_or_default();
|
||
visit(&sub(b"XObject"), &sub(b"ExtGState"), found, depth + 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_flattened_page_has_no_transparency_left() {
|
||
let multiply = Item::Group(GroupItem {
|
||
blend: BlendMode::Multiply,
|
||
isolated: true,
|
||
..match group(0.7, vec![solid(Rect::new(30.0, 30.0, 90.0, 90.0), &[(M, 1.0)]), solid(Rect::new(50.0, 10.0, 95.0, 60.0), &[(Y, 0.6)])]) {
|
||
Item::Group(g) => g,
|
||
_ => unreachable!(),
|
||
}
|
||
});
|
||
let list = page(
|
||
InkSet::new(),
|
||
vec![
|
||
solid(Rect::new(0.0, 0.0, 60.0, 100.0), &[(C, 1.0)]),
|
||
group(0.5, vec![solid(Rect::new(40.0, 0.0, 100.0, 100.0), &[(K, 1.0)])]),
|
||
multiply,
|
||
],
|
||
);
|
||
let unflattened = transparency(&pdf(&list));
|
||
assert!(unflattened.iter().any(|t| t == "ca") && unflattened.iter().any(|t| t.starts_with("blend mode")), "{unflattened:?}");
|
||
assert_eq!(transparency(&flat_pdf(&list)), Vec::<String>::new());
|
||
}
|
||
|
||
// ---- images, gradients and complex regions ------------------------------------------------
|
||
|
||
fn axial(from: InkColor, to: InkColor) -> Paint {
|
||
Paint::Gradient {
|
||
stops: vec![(0.0, from), (1.0, to)],
|
||
geometry: GradientGeometry::Axial {
|
||
start: Point::new(0.0, 0.0),
|
||
end: Point::new(100.0, 0.0),
|
||
extend: [true, true],
|
||
transform: Affine::IDENTITY,
|
||
},
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn an_overprinting_cyan_gradient_keeps_the_yellow_under_it() {
|
||
let ramp = Item::Fill(FillItem {
|
||
path: Rect::new(0.0, 0.0, 100.0, 100.0).to_path(0.1),
|
||
rule: FillRule::NonZero,
|
||
paint: axial(InkColor::Tints(vec![(C, 0.0)]), InkColor::Tints(vec![(C, 1.0)])),
|
||
overprint: OVERPRINT,
|
||
});
|
||
let p = separate(&pdf(&page(InkSet::new(), vec![solid(Rect::new(0.0, 0.0, 100.0, 100.0), &[(Y, 1.0)]), ramp])));
|
||
assert_inks(&p, 26, 50, &[("Cyan", 66), ("Yellow", 255)]);
|
||
assert_inks(&p, 74, 50, &[("Cyan", 189), ("Yellow", 255)]);
|
||
}
|
||
|
||
#[test]
|
||
fn ink_images_print_through_the_ink_manager() {
|
||
let mut inks = InkSet::new();
|
||
let gold = inks.add(Ink::Spot(gold())).unwrap();
|
||
assert!(inks.alias(gold, C));
|
||
let image = Item::Image(ImageItem {
|
||
space: ImageSpace::Inks(vec![C, gold]),
|
||
size: (2, 1),
|
||
samples: Arc::from(&[128, 128, 0, 255][..]),
|
||
transform: Affine::new([100.0, 0.0, 0.0, 100.0, 0.0, 0.0]),
|
||
smask: None,
|
||
overprint: Overprint::default(),
|
||
jpeg: None,
|
||
});
|
||
let p = separate(&pdf(&page(inks, vec![image])));
|
||
// Two half tints on one plate overlap as halftones: 1 − 0.5 × 0.5.
|
||
assert_inks(&p, 25, 50, &[("Cyan", 191)]);
|
||
assert_inks(&p, 75, 50, &[("Cyan", 255)]);
|
||
assert!(p.inks.lookup("Gold").is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn complex_regions_are_drawn_where_the_flattened_items_put_them() {
|
||
let ramp = Item::Fill(FillItem {
|
||
path: Rect::new(40.0, 0.0, 100.0, 100.0).to_path(0.1),
|
||
rule: FillRule::NonZero,
|
||
paint: axial(InkColor::Tints(vec![(K, 0.2)]), InkColor::Tints(vec![(K, 1.0)])),
|
||
overprint: Overprint::default(),
|
||
});
|
||
let list = page(InkSet::new(), vec![solid(Rect::new(0.0, 0.0, 60.0, 100.0), &[(C, 1.0)]), group(0.5, vec![ramp])]);
|
||
let flat = flatten(&list, &FlattenOptions::default()).unwrap();
|
||
assert!(!flat.complex.is_empty());
|
||
// A stand-in for the raster step: magenta over each region's bounds.
|
||
let mut raster = |region: &ComplexRegion| -> Result<Option<ImageItem>, WriteError> {
|
||
let b = region.path.bounding_box();
|
||
Ok(Some(ImageItem {
|
||
space: ImageSpace::Inks(vec![M]),
|
||
size: (1, 1),
|
||
samples: Arc::from(&[255][..]),
|
||
transform: Affine::new([b.width(), 0.0, 0.0, b.height(), b.x0, b.y0]),
|
||
smask: None,
|
||
overprint: Overprint::default(),
|
||
jpeg: None,
|
||
}))
|
||
};
|
||
let settings = print::settings(PrintColor::fogra39(craft_cms::builtin::COATED_FOGRA39_ICC)).unwrap();
|
||
let mut writer = Writer::new(settings, Metadata::default());
|
||
let mut page_builder = writer.document_mut().start_page_with(PageSettings::from_wh(100.0, 100.0).unwrap());
|
||
let mut surface = page_builder.surface();
|
||
write_flattened(&mut surface, &list, &flat, &CmsConversion::fogra39(), PdfVersion::default(), &mut raster).unwrap();
|
||
surface.finish();
|
||
page_builder.finish();
|
||
let p = separate(&writer.finish().unwrap());
|
||
assert_inks(&p, 20, 50, &[("Cyan", 255), ("Magenta", 0)]);
|
||
assert_inks(&p, 50, 50, &[("Cyan", 0), ("Magenta", 255)]);
|
||
assert_inks(&p, 80, 50, &[("Cyan", 0), ("Magenta", 255), ("Black", 0)]);
|
||
}
|