From e14312ae59243d3cc089cce8c00fccd8693d7396 Mon Sep 17 00:00:00 2001 From: dotCooCoo Date: Fri, 20 Nov 2026 19:29:36 -0800 Subject: [PATCH] PDF export: a color-masked CMYK image with an image mask keeps its hidden colors hidden A CMYK image with an opacity mask on its own pixel grid is written with the mask's alpha as its soft mask. That path recoded the image's own pixels and ignored its color mask, so the colors the color mask hides were drawn wherever the mask's alpha was not zero. The soft mask is now the mask's alpha multiplied by the alpha of the pixels the color mask shows, and the cache key includes the shown pixels. A test covers a plain and a distorted image. --- crates/pdf/src/export/images.rs | 44 +++++++++++++++++++++++------- crates/pdf/src/export/nodes.rs | 6 +++- crates/pdf/src/images.rs | 15 ++++++++++ crates/pdf/src/tests/cmykimages.rs | 39 ++++++++++++++++++++++++++ 4 files changed, 93 insertions(+), 11 deletions(-) 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]