diff --git a/crates/pdf/src/export/images.rs b/crates/pdf/src/export/images.rs index 3da2079b9b..dfaf9a2c7c 100644 --- a/crates/pdf/src/export/images.rs +++ b/crates/pdf/src/export/images.rs @@ -183,22 +183,33 @@ impl Exporter<'_> { /// CMYK image `im` with the alpha of its opacity mask `m`, when the mask is a greyscale image /// on the image's own pixel grid (an image's soft mask as it opens): the alpha is written as the /// image's soft mask, as an RGBA image's is, rather than as a luminosity soft mask over it, - /// through which CoreGraphics draws CMYK images on black boxes (#2159). `None` for other - /// images and masks; cached like [`Self::load_image`], `interpolate` as there. - pub(super) fn masked_image(&mut self, im: &vectorcraft_doc::ImageObject, m: &vectorcraft_doc::OpacityMask, interpolate: bool) -> Option { + /// through which CoreGraphics draws CMYK images on black boxes (#2159). `shown` is `im` as it is + /// shown ([`vectorcraft_doc::Document::shown_image`]). When a color mask shows other pixels + /// that are not CMYK (`im`'s own pixels with the hidden colors clear), `im`'s inks are written + /// with the mask's alpha multiplied by the shown pixels' alpha, so the hidden colors stay + /// hidden; shown pixels that are CMYK are written themselves. `None` for other images and + /// masks, and for shown pixels of another size; cached like [`Self::load_image`], + /// `interpolate` as there. + pub(super) fn masked_image( + &mut self, + im: &vectorcraft_doc::ImageObject, + shown: &vectorcraft_doc::ImageObject, + m: &vectorcraft_doc::OpacityMask, + interpolate: bool, + ) -> Option { let art = &m.art; let NodeKind::Image(mi) = &art.kind else { return None }; // A color-masked image in the mask's art masks with the pixels it shows. - let shown = self.doc.shown_image(art, mi); - let mi = &*shown; + let shown_mask = self.doc.shown_image(art, mi); + let mi = &*shown_mask; let plain = art.opacity >= 1.0 && art.blend == BlendMode::Normal && art.extras().mask.is_none() && !art.appearance.effects.iter().any(|e| e.visible); if m.invert || !plain || (mi.xf, mi.width, mi.height) != (im.xf, im.width, im.height) { return None; } - let size = self.image_size(im); + let size = self.image_size(shown); let interpolate = interpolate && self.interpolate; - let mut cache = format!("{}\u{0}{}\u{0}{}", im.key, mi.key, m.clip); + let mut cache = format!("{}\u{0}{}\u{0}{}\u{0}{}", im.key, shown.key, mi.key, m.clip); if self.downsampled() { cache.push_str(&format!("\u{0}{:.3}x{:.3}", size.0, size.1)); } @@ -209,8 +220,20 @@ impl Exporter<'_> { return i.clone(); } let doc = self.doc; - let img = doc.image_blob(im).filter(|b| b.is_cmyk()).and_then(|blob| { - let alpha = crate::images::mask_alpha(doc.image_blob(mi)?, im.width, im.height, m.clip)?; + // Pixels a color mask shows that are not CMYK carry the hidden colors as their alpha. + let shown_blob = doc.image_blob(shown); + let (source, hidden) = match shown_blob { + Some(b) if shown.key != im.key && !b.is_cmyk() => (doc.image_blob(im), Some(b)), + b => (b, None), + }; + let img = source.filter(|b| b.is_cmyk()).and_then(|blob| { + let mut alpha = crate::images::mask_alpha(doc.image_blob(mi)?, im.width, im.height, m.clip)?; + if let Some(hidden) = hidden { + let shown_alpha = crate::images::image_alpha(hidden, im.width, im.height)?; + for (a, s) in alpha.iter_mut().zip(shown_alpha) { + *a = ((u32::from(*a) * u32::from(s) + 127) / 255) as u8; + } + } let icc = self.out.cmyk_image_icc(blob); let tag = self.out.cmyk_tag(icc.as_deref()); let r = crate::images::recode_cmyk(blob, size, self.compression, interpolate, self.out.cmyk_pixels(), Some(alpha), tag); @@ -452,7 +475,8 @@ mod tests { assert!(exporter.colorized_image(&image("pic", scale), &paint, true).is_some(), "colorized at {scale}"); let art = vectorcraft_doc::Node::new(doc.layers[0].id, vectorcraft_doc::NodeKind::Image(Box::new(image("alpha", scale)))); let mask = vectorcraft_doc::OpacityMask::new(art, true); - assert!(exporter.masked_image(&image("inks", scale), &mask, true).is_some(), "masked at {scale}"); + let inks = image("inks", scale); + assert!(exporter.masked_image(&inks, &inks, &mask, true).is_some(), "masked at {scale}"); } assert_eq!(exporter.images.len(), 2, "{:?}", exporter.images.keys().collect::>()); } diff --git a/crates/pdf/src/export/nodes.rs b/crates/pdf/src/export/nodes.rs index 94b1c819c5..d84e8f7124 100644 --- a/crates/pdf/src/export/nodes.rs +++ b/crates/pdf/src/export/nodes.rs @@ -375,7 +375,11 @@ impl Exporter<'_> { let mask = n.extras().mask.as_deref().filter(|m| !m.disabled); let alpha = match (&n.kind, mask) { // The mask's image shares the pixel grid only when it has the same corners (or none). - (NodeKind::Image(im), Some(m)) if n.image_quad() == m.art.image_quad() => self.masked_image(im, m, !n.extras().pixelated), + // A color-masked image keeps the colors it hides hidden. + (NodeKind::Image(im), Some(m)) if n.image_quad() == m.art.image_quad() => { + let shown = self.doc.shown_image(n, im); + self.masked_image(im, &shown, m, !n.extras().pixelated) + } _ => None, }; if let Some(m) = mask diff --git a/crates/pdf/src/images.rs b/crates/pdf/src/images.rs index eaff6c781f..d08f1069b4 100644 --- a/crates/pdf/src/images.rs +++ b/crates/pdf/src/images.rs @@ -840,6 +840,21 @@ pub(crate) fn mask_alpha(blob: &ImageBlob, width: u32, height: u32, clip: bool) Some(img.pixels().map(|p| ((u32::from(p[0]) * u32::from(p[3]) + back * (255 - u32::from(p[3])) + 127) / 255) as u8).collect()) } +/// The alpha of each pixel of image `blob` (255 for an image without alpha), when it is `width` × +/// `height` pixels. `None` for a CMYK image, another size, or one too large to hold as RGBA or +/// that can't be decoded; as in [`mask_alpha`], the size is read from the header first. +pub(crate) fn image_alpha(blob: &ImageBlob, width: u32, height: u32) -> Option> { + if blob.is_cmyk() { + return None; + } + let reader = ImageReader::new(Cursor::new(blob.bytes.as_slice())).with_guessed_format().ok()?; + if reader.into_dimensions().ok()? != (width, height) || u64::from(width) * u64::from(height) * 4 > MAX_DECODE { + return None; + } + let img = decoded(&blob.bytes)?.into_rgba8(); + (img.dimensions() == (width, height)).then(|| img.pixels().map(|p| p[3]).collect()) +} + /// Opaque colour `samples` (grey, RGB, or CMYK ink amounts, as `space` says) as a JPEG at /// `quality`, tagged with ICC profile `icc` when given. CMYK JPEGs hold Adobe's inverted samples, /// which the PDF writer's Decode array undoes. diff --git a/crates/pdf/src/tests/cmykimages.rs b/crates/pdf/src/tests/cmykimages.rs index b5f6185ea9..9d333eecb3 100644 --- a/crates/pdf/src/tests/cmykimages.rs +++ b/crates/pdf/src/tests/cmykimages.rs @@ -1210,6 +1210,45 @@ fn a_distorted_cmyk_image_and_its_grid_mask_with_the_same_corners_write_it_as_it } } +/// A color-masked CMYK image with a gray mask of its grid keeps its inks and its hidden colors +/// hidden: the image's `/SMask` is the mask's alpha times the alpha of the pixels the color mask +/// shows, so a hidden pixel stays clear where the mask's alpha is not zero, for a distorted image +/// too. +#[test] +fn a_color_masked_cmyk_image_with_a_grid_mask_keeps_its_hidden_colors_hidden() { + for distorted in [false, true] { + let mut d = masked_doc(png(image::GrayImage::from_raw(2, 2, vec![255, 128, 0, 64]).unwrap()), true, false); + // The first pixel hidden, where the mask is fully opaque, and the last half shown. + let alpha = [0, 255, 255, 128]; + let shown = image::RgbaImage::from_fn(2, 2, |x, y| image::Rgba([0, 90, 200, alpha[(y * 2 + x) as usize]])); + d.images.insert("shown".into(), ImageBlob::new("image/png", png(shown))); + let id = d.layers[0].children().unwrap()[0].id; + let q = [(16.0, 0.0), (24.0, 0.0), (40.0, 40.0), (0.0, 40.0)].map(|(x, y)| Point::new(x, y)); + let mut mask = d.node(id).unwrap().extras().mask.clone().unwrap(); + if distorted { + Arc::make_mut(&mut mask.art).set_image_corners(q).unwrap(); + } + let n = d.node_mut(id).unwrap(); + n.extras_mut().mask = Some(mask); + n.extras_mut().color_mask = Some(Box::new(vectorcraft_doc::color_mask::ColorMask { + key: "shown".into(), + from: "img".into(), + background: vectorcraft_doc::color_mask::MaskBackground::Colors, + colors: vec![[255, 255, 255]], + contiguous: false, + measure: vectorcraft_doc::color_mask::MaskMatch::Distance, + tolerance: 0.0, + softness: 0.0, + })); + if distorted { + n.set_image_corners(q).unwrap(); + } + let (bytes, smasks) = export_smasks(&d); + assert!(!smasks.is_empty() && smasks.iter().all(|m| m.as_deref() == Some(&[0, 128, 0, 32][..])), "{distorted}: {smasks:?}"); + assert!(distorted || !String::from_utf8_lossy(&bytes).contains("/S/Luminosity"), "no luminosity soft mask"); + } +} + /// A grey mask image with a color mask masks the CMYK image with the pixels it shows: its hidden /// pixels are clear in the image's `/SMask`. #[test]