mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-14 21:44:57 +00:00
TIFF: a 16-bit CMYK or gray TIFF with alpha converts at 16 bits
Place, Open and relink read a CMYK or grayscale TIFF with an alpha channel through extra_samples_tiff_rgba, which cut every 16-bit sample to its high byte before converting it. A faint ink or a low alpha was lost: cyan 129 at full alpha showed as white, and an alpha of 129 became fully transparent. The samples are now normalized at the depth the file stores them, and only the resulting color and alpha are rounded to 8 bits (a 16-bit alpha to the nearest 8-bit value). Associated alpha is divided out at 16 bits. A pixel whose associated alpha is zero now has no color, instead of keeping its stored color. TIFF 6.0's Associated Alpha Handling section states this arithmetic and the zero-alpha rule for RGB data; applying them to CMYK and gray samples is VectorCraft's own rule.
This commit is contained in:
dotCooCoo
+109
-16
@@ -515,9 +515,10 @@ pub fn turned_cmyk(bytes: &[u8], orientation: image::metadata::Orientation, ppi:
|
||||
/// all, as RGBA pixels: CMYK with an alpha channel (5 samples), each colour converted by `rgb` (ink
|
||||
/// amounts 0..1 → sRGB 0..1; the inks can't be kept with the transparency, so they show as RGB),
|
||||
/// and grayscale with extra samples, of which the first is the alpha when the file says so (other
|
||||
/// channels are left out). Associated (premultiplied) alpha is divided back out. The samples may be
|
||||
/// stored together or one plane per channel. `None` for other images and ones larger than
|
||||
/// [`MAX_CMYK_PIXELS`].
|
||||
/// channels are left out). Associated (premultiplied) alpha is divided back out, and a pixel with
|
||||
/// no associated alpha has no color. 16-bit samples are converted at 16 bits, and only the result
|
||||
/// is rounded to 8 bits. The samples may be stored together or one plane per channel. `None` for
|
||||
/// other images and ones larger than [`MAX_CMYK_PIXELS`].
|
||||
pub fn extra_samples_tiff_rgba(bytes: &[u8], rgb: impl Fn([f32; 4]) -> [f32; 3]) -> Option<image::RgbaImage> {
|
||||
use tiff::tags::Tag;
|
||||
let (kind, mut d) = tiff(bytes)?;
|
||||
@@ -535,20 +536,33 @@ pub fn extra_samples_tiff_rgba(bytes: &[u8], rgb: impl Fn([f32; 4]) -> [f32; 3])
|
||||
_ => return None,
|
||||
};
|
||||
let n = usize::try_from(pixels(w, h)?).ok()?;
|
||||
let data = read_samples(&mut d, n, samples)?;
|
||||
let mut out = Vec::with_capacity(n * 4);
|
||||
for p in data.chunks_exact(samples) {
|
||||
let opacity = if alpha { p.get(colour).copied().unwrap_or(u8::MAX) } else { u8::MAX };
|
||||
let a = f32::from(opacity) / 255.0;
|
||||
let level = |v: u8| {
|
||||
let v = f32::from(v) / 255.0;
|
||||
if extra == Some(1) && a > 0.0 { (v / a).min(1.0) } else { v }
|
||||
let data = read_samples_at_depth(&mut d, n, samples)?;
|
||||
// Sample `i` of the image, 0..1.
|
||||
let level_at = |i: usize| match &data {
|
||||
Samples::Eight(v) => v.get(i).map(|&s| f32::from(s) / 255.0),
|
||||
Samples::Sixteen(v) => v.get(i).map(|&s| f32::from(s) / 65535.0),
|
||||
};
|
||||
// Sample `i` of the image as 8 bits, a 16-bit sample rounded to the nearest.
|
||||
let byte_at = |i: usize| match &data {
|
||||
Samples::Eight(v) => v.get(i).copied(),
|
||||
Samples::Sixteen(v) => v.get(i).map(|&s| u8::try_from((u32::from(s) + 128) / 257).unwrap_or(u8::MAX)),
|
||||
};
|
||||
let mut out = Vec::with_capacity(n.checked_mul(4)?);
|
||||
for first in (0..n).map(|p| p * samples) {
|
||||
let (opacity, a) = if alpha { (byte_at(first + colour).unwrap_or(u8::MAX), level_at(first + colour).unwrap_or(1.0)) } else { (u8::MAX, 1.0) };
|
||||
let level = |s: usize| {
|
||||
let v = level_at(first + s).unwrap_or(0.0);
|
||||
match extra {
|
||||
Some(1) if a > 0.0 => (v / a).min(1.0),
|
||||
// No associated alpha: the color is zero (TIFF 6.0, Associated Alpha Handling).
|
||||
Some(1) if alpha => 0.0,
|
||||
_ => v,
|
||||
}
|
||||
};
|
||||
let [r, g, b] = match *p {
|
||||
[c, m, y, k, ..] if colour == 4 => rgb([level(c), level(m), level(y), level(k)]),
|
||||
[v, ..] if photometric == Some(0) => [1.0 - level(v); 3],
|
||||
[v, ..] => [level(v); 3],
|
||||
[] => continue,
|
||||
let [r, g, b] = match colour {
|
||||
4 => rgb([level(0), level(1), level(2), level(3)]),
|
||||
_ if photometric == Some(0) => [1.0 - level(0); 3],
|
||||
_ => [level(0); 3],
|
||||
};
|
||||
out.extend([r, g, b].map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8));
|
||||
out.push(opacity);
|
||||
@@ -767,6 +781,85 @@ mod tests {
|
||||
assert_eq!(gray(0), [255, 255, 255, 255, 51, 51, 51, 255, 0, 0, 0, 255], "a channel that isn't alpha: opaque");
|
||||
}
|
||||
|
||||
/// Five 16-bit samples a pixel: the four inks and one extra sample, which the file's
|
||||
/// `ExtraSamples` names.
|
||||
struct Cmyka16;
|
||||
impl tiff::encoder::colortype::ColorType for Cmyka16 {
|
||||
type Inner = u16;
|
||||
const TIFF_VALUE: tiff::tags::PhotometricInterpretation = tiff::tags::PhotometricInterpretation::CMYK;
|
||||
const BITS_PER_SAMPLE: &'static [u16] = &[16; 5];
|
||||
const SAMPLE_FORMAT: &'static [tiff::tags::SampleFormat] = &[tiff::tags::SampleFormat::Uint; 5];
|
||||
fn horizontal_predict(row: &[u16], result: &mut Vec<u16>) {
|
||||
result.extend_from_slice(row);
|
||||
}
|
||||
}
|
||||
|
||||
/// Two 16-bit samples a pixel: gray and one extra sample.
|
||||
struct GrayExtra16;
|
||||
impl tiff::encoder::colortype::ColorType for GrayExtra16 {
|
||||
type Inner = u16;
|
||||
const TIFF_VALUE: tiff::tags::PhotometricInterpretation = tiff::tags::PhotometricInterpretation::BlackIsZero;
|
||||
const BITS_PER_SAMPLE: &'static [u16] = &[16, 16];
|
||||
const SAMPLE_FORMAT: &'static [tiff::tags::SampleFormat] = &[tiff::tags::SampleFormat::Uint; 2];
|
||||
fn horizontal_predict(row: &[u16], result: &mut Vec<u16>) {
|
||||
result.extend_from_slice(row);
|
||||
}
|
||||
}
|
||||
|
||||
/// A one-row TIFF of `C`'s pixels `data`, with the ExtraSamples value `extra`.
|
||||
fn extra_tiff<C: tiff::encoder::colortype::ColorType<Inner = u16>>(extra: u16, data: &[u16]) -> Vec<u8> {
|
||||
let samples = C::BITS_PER_SAMPLE.len();
|
||||
let mut file = Cursor::new(Vec::new());
|
||||
let mut enc = tiff::encoder::TiffEncoder::new(&mut file).unwrap();
|
||||
let mut img = enc.new_image::<C>(u32::try_from(data.len() / samples).unwrap(), 1).unwrap();
|
||||
img.encoder().write_tag(tiff::tags::Tag::ExtraSamples, &[extra][..]).unwrap();
|
||||
img.write_data(data).unwrap();
|
||||
file.into_inner()
|
||||
}
|
||||
|
||||
/// 16-bit CMYK with alpha converts its 16-bit inks and alpha, and rounds only the result to 8
|
||||
/// bits; the high byte of each sample alone would give other pixels.
|
||||
#[test]
|
||||
fn a_16_bit_cmyk_tiff_with_alpha_converts_at_16_bits() {
|
||||
let naive = |[c, m, y, k]: [f32; 4]| [(1.0 - c) * (1.0 - k), (1.0 - m) * (1.0 - k), (1.0 - y) * (1.0 - k)];
|
||||
let read = |extra: u16, data: &[u16]| extra_samples_tiff_rgba(&extra_tiff::<Cmyka16>(extra, data), naive).expect("CMYKA reads").into_raw();
|
||||
// Unassociated: 129 of cyan, opaque; no ink at an alpha of 129; no ink at an alpha of 386.
|
||||
let straight = [129, 0, 0, 0, 65535, 0, 0, 0, 0, 129, 0, 0, 0, 0, 386];
|
||||
assert_eq!(read(2, &straight), [254, 255, 255, 255, 255, 255, 255, 1, 255, 255, 255, 2]);
|
||||
// Associated: cyan 128 at an alpha of 256 (half cyan); K 255 at an alpha of 511 (about half K).
|
||||
let premultiplied = [128, 0, 0, 0, 256, 0, 0, 0, 255, 511];
|
||||
assert_eq!(read(1, &premultiplied), [128, 255, 255, 1, 128, 128, 128, 2], "divided by the 16-bit alpha");
|
||||
}
|
||||
|
||||
/// 16-bit gray with alpha converts at 16 bits as well.
|
||||
#[test]
|
||||
fn a_16_bit_grayscale_tiff_with_alpha_converts_at_16_bits() {
|
||||
let read = |extra: u16| {
|
||||
// A gray of 129, opaque, then 128 at an alpha of 256.
|
||||
let bytes = extra_tiff::<GrayExtra16>(extra, &[129, 65535, 128, 256]);
|
||||
extra_samples_tiff_rgba(&bytes, |_| [0.0; 3]).expect("gray with alpha reads").into_raw()
|
||||
};
|
||||
assert_eq!(read(2), [1, 1, 1, 255, 0, 0, 0, 1], "unassociated");
|
||||
assert_eq!(read(1), [1, 1, 1, 255, 128, 128, 128, 1], "associated, divided by the 16-bit alpha");
|
||||
}
|
||||
|
||||
/// With associated alpha, a pixel whose alpha is zero has no color (TIFF 6.0, Associated
|
||||
/// Alpha Handling), whatever its color samples hold.
|
||||
#[test]
|
||||
fn a_pixel_with_no_associated_alpha_has_no_color() {
|
||||
use tiff::encoder::{TiffEncoder, colortype::CMYKA8};
|
||||
let naive = |[c, m, y, k]: [f32; 4]| [(1.0 - c) * (1.0 - k), (1.0 - m) * (1.0 - k), (1.0 - y) * (1.0 - k)];
|
||||
let mut file = Cursor::new(Vec::new());
|
||||
let mut enc = TiffEncoder::new(&mut file).unwrap();
|
||||
let mut img = enc.new_image::<CMYKA8>(1, 1).unwrap();
|
||||
img.encoder().write_tag(tiff::tags::Tag::ExtraSamples, &[1u16][..]).unwrap();
|
||||
img.write_data(&[255, 0, 0, 0, 0]).unwrap();
|
||||
let cmyk = extra_samples_tiff_rgba(&file.into_inner(), naive).expect("CMYKA reads");
|
||||
assert_eq!(cmyk.into_raw(), [255, 255, 255, 0], "no ink");
|
||||
let gray = extra_samples_tiff_rgba(&extra_tiff::<GrayExtra16>(1, &[50_000, 0]), |_| [0.0; 3]).expect("gray reads");
|
||||
assert_eq!(gray.into_raw(), [0, 0, 0, 0], "a gray of zero");
|
||||
}
|
||||
|
||||
/// A header claiming more tiles than can be counted: (2^32 − 1)² pixels in tiles of one pixel,
|
||||
/// times 2 planes.
|
||||
#[test]
|
||||
|
||||
@@ -186,6 +186,22 @@ fn planar_tiffs_read_as_their_chunky_versions() {
|
||||
}
|
||||
}
|
||||
|
||||
/// A 16-bit CMYK TIFF with alpha places with its alpha rounded from 16 bits, planar as chunky.
|
||||
#[test]
|
||||
fn a_16_bit_cmyk_tiff_with_alpha_places_at_16_bits() {
|
||||
let none = vec![0u16; 6];
|
||||
let cyan = vec![129u16, 0, 300, 0, 128, 65535];
|
||||
let alpha = vec![65535u16, 129, 386, 0, 256, 65535];
|
||||
for extra in [1u16, 2] {
|
||||
let channels = [cyan.clone(), none.clone(), none.clone(), none.clone(), alpha.clone()];
|
||||
let chunky = kept(&format!("extra samples {extra}, chunky"), &hand_tiff(5, 16, &[extra], false, &channels));
|
||||
let planar = kept(&format!("extra samples {extra}, planar"), &hand_tiff(5, 16, &[extra], true, &channels));
|
||||
assert_eq!(planar, chunky, "extra samples {extra}: planar reads as chunky");
|
||||
let alphas: Vec<u8> = chunky.1.iter().skip(3).step_by(4).copied().collect();
|
||||
assert_eq!(alphas, [255, 1, 2, 0, 1, 255], "extra samples {extra}: the alpha, rounded from 16 bits");
|
||||
}
|
||||
}
|
||||
|
||||
/// A planar TIFF whose header claims more strips than the decoder can count (here 2^31 + 1 rows
|
||||
/// a strip each, times 5 planes) is refused as too large to draw, without a panic.
|
||||
#[test]
|
||||
|
||||
@@ -1749,6 +1749,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
- HP-GL export's `insideFirst` cuts each pen's paths inside before outside: a path is drawn only after the pen's paths that lie inside it (a letter's counter, a part's holes, rings within rings), touching outlines counted as inside and crossing ones not, in paint order or nearest first with `sortPaths`, within the plot's work budget; these order rules are VectorCraft's own (`crates/cad/src/hpgl/write/nest.rs`, `crates/cad/src/hpgl/write/tests.rs`, `crates/engine/src/cmd/fileio/tests_hpgl.rs`).
|
||||
- EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export; grayscale TIFFs with an alpha channel or other extra channels place, relink and open, the alpha as the image's transparency (#1466 in part); PSD and PSB files open and place, linked or embedded, as their merged image in every colour mode and depth (#918). EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read, and an image's several data sources are read in turn, as the reference defines (procedures that read one file get their own rows: such images came in banded, #498). `restore` puts dictionaries back as they were at the `save`, so programs that count their saves in a dictionary read to their end (part of #505). Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). PDF export writes type as real, searchable text in embedded subset fonts by default, as Illustrator's PDF presets do (Convert Text to Outlines is an option; printer's marks stay shapes), so text-heavy PDFs stay small (#733). DXF export writes each fill as its outlines followed by its hatch, so laser and cutter software, which skips hatches, gets filled art and type too (#546).
|
||||
- TIFFs that store each channel as its own plane (PlanarConfiguration 2) place, relink and open as the same image stored pixel by pixel does, 8 and 16 bits: grayscale with an alpha channel or other extra channels, and CMYK with or without them. A planar CMYK TIFF keeps its ink amounts and is stored as a CMYK TIFF with each pixel's inks together, at the file's resolution. A TIFF whose header claims more strips or tiles than can be counted is refused as too large to draw (#1466 in part; `crates/engine/src/cmd/fileio/tests.rs`).
|
||||
- A 16-bit CMYK or grayscale TIFF with an alpha channel is converted from its 16-bit samples, and only the resulting color and alpha are rounded to 8 bits; associated alpha is divided out at 16 bits, and a pixel whose associated alpha is zero has no color. [TIFF 6.0](https://printtechnologies.org/standards/files/tiff-v6.pdf) gives extra samples the depth in BitsPerSample, and its Associated Alpha Handling section states the arithmetic and the zero-alpha rule for RGB data; applying them to CMYK and gray samples is VectorCraft's own rule. Each sample was cut to its high byte first, so a faint ink or a low alpha could be lost (`crates/doc/src/cmyk.rs`, `crates/engine/src/cmd/fileio/tests.rs`).
|
||||
- 1-bit TIFFs compressed with CCITT Group 3 (ITU-T T.4) place, relink and open: Compression 2 (modified Huffman) and Compression 3 with one-dimensional rows or, with T4Options bit 0, two-dimensional ones, with or without fill bits, in strips or tiles, with either FillOrder and either polarity. Rows in T.4's uncompressed mode are not read. A file whose pixels would take more than the decoding allowance as RGBA is refused as too large to draw (#1466 in part; `crates/engine/src/cmd/fileio/tests.rs`).
|
||||
- EPS and PostScript import keeps a CMYK image's ink amounts, as PDF import does: the samples of `image` and `colorimage` in a CMYK color space, and of a CMYK JPEG read through `DCTDecode`, come in as a CMYK TIFF, read through the image's Decode array, and the pixels a `MaskColor` or `ImageType 3` mask hides become a grayscale opacity mask (`crates/eps/src/import/tests_images.rs`). Such images came in as RGB PNGs.
|
||||
- EPS and PostScript import reads image data through `CCITTFaxDecode`: Group 4 (ITU-T T.6) and Group 3 one-dimensional and mixed (ITU-T T.4) data, with the filter's `K`, `Columns`, `Rows`, `EndOfBlock`, `EndOfLine`, `EncodedByteAlign` and `BlackIs1` parameters, decodes to 1-bit rows for `image` and `imagemask`. Damaged data keeps the rows decoded before it (damage in the first row is a PostScript `ioerror`), and parameters out of range or past the 256 MiB limit on decoded data are refused (`crates/eps/src/import/tests_images.rs`). Reading such a file stopped at an error naming the filter, and the file opened from a fallback, such as its preview or the art drawn before the image, or did not open.
|
||||
|
||||
Reference in New Issue
Block a user