Files
vectorcraft/crates/render/src/encode/tests_palette.rs
T
dotCooCoo 54e8d3046e Save for Web: Delete Color removes colors from the color table
The color table's trash button and Delete Color in its new menu delete
the selected GIF or PNG-8 colors. Pixels that used a deleted color take
the nearest color left, with the current reduction's color distance and
dither, and the preview matches the saved file. A click selects one
color and makes it the anchor, Shift-click selects the range from the
anchor, and Ctrl-click (Command-click on macOS) adds or removes one.

- colorTable.deleted lists the deleted colors by source. A deleted color
  leaves the locked, transparent and webShift lists.
- colorTable.customPalette fixes the palette at the first deletion, so a
  deleted color is not made again; the table reads Custom. Restore
  Generated Table in the menu, or another reduction, clears both.
- Deleting every opaque color, or every color not mapped to transparent,
  is an error and changes nothing.
- Presets and the remembered settings keep the edit.
- quantize_to uses all 256 fixed colors when no pixel is transparent.

Docs: docs/mcp.md, docs/target-app-parity.md.
2026-11-17 12:23:26 -08:00

255 lines
13 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, Node};
use vectorcraft_geom::shapes;
use super::png::{PngOptions, encode_indexed};
use super::quantize::{Dither, Indexed, PaletteOptions, Reduction, quantize, quantize_to};
use super::*;
/// A `w`×`h` opaque image of `f(x, y)` colours.
fn image(w: u32, h: u32, f: impl Fn(u32, u32) -> [u8; 3]) -> Vec<u8> {
(0..h)
.flat_map(|y| (0..w).map(move |x| (x, y)))
.flat_map(|(x, y)| {
let [r, g, b] = f(x, y);
[r, g, b, 255]
})
.collect()
}
/// Smooth colour ramps: thousands of colours.
fn ramps(w: u32, h: u32) -> Vec<u8> {
image(w, h, |x, y| [(x * 255 / w) as u8, (y * 255 / h) as u8, ((x + y) * 127 / (w + h)) as u8])
}
fn rgb(px: &[u8]) -> Vec<[u8; 3]> {
px.chunks(4).map(|p| [p[0], p[1], p[2]]).collect()
}
/// The colour each pixel gets back.
fn colours(ix: &Indexed) -> Vec<[u8; 3]> {
ix.indices.iter().map(|&i| ix.palette[i as usize]).collect()
}
/// The PNG chunk of type `ty` (first match).
fn chunk<'a>(file: &'a [u8], ty: &[u8; 4]) -> Option<&'a [u8]> {
let mut i = 8;
while i + 8 <= file.len() {
let len = u32::from_be_bytes(file[i..i + 4].try_into().unwrap()) as usize;
if &file[i + 4..i + 8] == ty {
return Some(&file[i + 8..i + 8 + len]);
}
i += 12 + len;
}
None
}
#[test]
fn two_colour_art_gives_two_entries() {
let px = image(9, 5, |x, _| if x < 4 { [200, 30, 40] } else { [10, 10, 90] });
for reduction in [Reduction::Perceptual, Reduction::Selective, Reduction::Adaptive] {
let ix = quantize(&px, 9, 5, &PaletteOptions { reduction, ..Default::default() });
assert_eq!(ix.palette.len(), 2, "{reduction:?}");
assert_eq!(ix.transparent, None);
assert_eq!(colours(&ix), rgb(&px), "exact, no dithering");
}
// A hard-edged circle exported on white: black and white only.
let mut d = Document::new(40.0, 30.0);
let id = d.alloc_id();
let l = d.layers[0].id;
let n = Node::path(id, shapes::ellipse(Rect::new(5.3, 4.7, 31.1, 26.2)), Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0));
d.insert(Some(l), 0, n).unwrap();
let o = RasterExportOptions { background: Some([255; 3]), anti_alias: AntiAlias::None, ..Default::default() };
let file = Renderer::new().export_region(&d, d.artboards[0].rect, RasterFormat::Png8, &o).unwrap();
assert_eq!(file[25], 3, "colour type 3");
assert_eq!(file[24], 1, "two entries fit one bit per pixel");
assert_eq!(chunk(&file, b"PLTE").unwrap().len(), 6);
}
#[test]
fn colours_cap_the_palette() {
let px = ramps(64, 48);
for colors in [2, 16, 64, 256] {
for dither in Dither::ALL {
for reduction in [Reduction::Perceptual, Reduction::Selective, Reduction::Adaptive, Reduction::Web, Reduction::Gray] {
let ix = quantize(&px, 64, 48, &PaletteOptions { colors, dither, reduction, ..Default::default() });
assert!(ix.palette.len() <= colors as usize, "{colors} {dither:?} {reduction:?}: {}", ix.palette.len());
assert!(ix.indices.iter().all(|&i| (i as usize) < ix.palette.len()));
}
}
}
// Many colours use most of the palette.
assert!(quantize(&px, 64, 48, &PaletteOptions { colors: 16, ..Default::default() }).palette.len() >= 12);
}
#[test]
fn fixed_palettes() {
let px = ramps(32, 32);
let web = quantize(&px, 32, 32, &PaletteOptions { reduction: Reduction::Web, ..Default::default() });
assert!(web.palette.iter().flatten().all(|v| v % 51 == 0), "web-safe");
let gray = quantize(&px, 32, 32, &PaletteOptions { reduction: Reduction::Gray, colors: 8, ..Default::default() });
assert!(gray.palette.iter().all(|[r, g, b]| r == g && g == b) && gray.palette.len() <= 8);
let bw = quantize(&px, 32, 32, &PaletteOptions { reduction: Reduction::BlackWhite, ..Default::default() });
assert_eq!(bw.palette, [[0, 0, 0], [255, 255, 255]]);
}
#[test]
fn a_given_palette_keeps_the_entries_pixels_use() {
let px: Vec<u8> = [[250, 10, 10, 255], [10, 10, 240, 255], [0, 0, 0, 40], [240, 20, 30, 255]].concat();
let given = [[0, 255, 0], [255, 0, 0], [0, 0, 255], [255, 255, 255]];
let o = PaletteOptions { dither: Dither::None, matte: None, ..Default::default() };
let ix = quantize_to(&px, 4, 1, &o, &given);
assert_eq!(ix.transparent, Some(0));
assert_eq!(ix.palette[1..], [[255, 0, 0], [0, 0, 255]], "unused entries left out, the order kept");
assert_eq!(ix.indices, [1, 2, 0, 1]);
// With no transparent pixel all 256 of the given colors can be used; with one, the first 255
// leave room for the transparent entry.
let many: Vec<[u8; 3]> = (0..300u32).map(|i| [(i % 256) as u8, (i / 256) as u8, 0]).collect();
let all = image(256, 2, |x, y| [x as u8, y as u8, 0]);
let ix = quantize_to(&all, 256, 2, &o, &many);
assert!(ix.palette.len() == 256 && ix.palette.iter().all(|c| many[..256].contains(c)), "{}", ix.palette.len());
assert!(ix.palette.contains(&many[255]), "the 256th color is used");
let mut clear = all.clone();
clear[3] = 0;
let ix = quantize_to(&clear, 256, 2, &o, &many);
assert_eq!(ix.transparent, Some(0));
assert!(ix.palette.len() <= 256 && ix.palette[1..].iter().all(|c| many[..255].contains(c)), "{}", ix.palette.len());
}
#[test]
fn dithering_keeps_the_average_colour() {
let px = image(64, 16, |x, _| [(x * 4) as u8; 3]);
let mean = |c: &[[u8; 3]]| c.iter().map(|p| p[0] as f64).sum::<f64>() / c.len().max(1) as f64;
// Per 8-pixel column band, how far the result's mean is from the original's.
let err = |dither| {
let ix = quantize(&px, 64, 16, &PaletteOptions { reduction: Reduction::BlackWhite, dither, ..Default::default() });
let (got, want) = (colours(&ix), rgb(&px));
let band = |c: &[[u8; 3]], b: usize| c.iter().enumerate().filter(|(i, _)| (i % 64) / 8 == b).map(|(_, p)| *p).collect::<Vec<_>>();
(0..8).map(|b| (mean(&band(&got, b)) - mean(&band(&want, b))).abs()).sum::<f64>()
};
let none = err(Dither::None);
for d in [Dither::Diffusion, Dither::Pattern, Dither::Noise] {
assert!(err(d) < none / 2.0, "{d:?}: {} vs {none}", err(d));
}
let noisy = PaletteOptions { dither: Dither::Noise, colors: 8, ..Default::default() };
assert_eq!(quantize(&px, 64, 16, &noisy), quantize(&px, 64, 16, &noisy), "noise is reproducible");
}
#[test]
fn transparent_pixels_get_their_own_entry() {
let px: Vec<u8> = (0..16u8).flat_map(|i| if i % 2 == 0 { [255, 0, 0, 255] } else { [0, 0, 255, if i < 8 { 0 } else { 100 }] }).collect();
let ix = quantize(&px, 4, 4, &PaletteOptions::default());
assert_eq!(ix.transparent, Some(0));
assert_eq!(ix.palette.len(), 2, "red and the transparent entry: alpha 100 is under half");
assert!(ix.indices.iter().enumerate().all(|(i, &v)| (v == 0) == (i % 2 == 1)));
let opaque = quantize(&px, 4, 4, &PaletteOptions { transparency: false, matte: Some([0, 0, 0]), ..Default::default() });
assert_eq!(opaque.transparent, None);
assert!(opaque.palette.contains(&[0, 0, 0]) && opaque.palette.contains(&[0, 0, 100]), "blended over the matte: {:?}", opaque.palette);
let file = encode_indexed(&ix, &PngOptions::default()).unwrap();
assert_eq!(chunk(&file, b"tRNS").unwrap(), [0]);
let back = craft_image_codecs::decode(&file)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgba8();
assert_eq!(back.get_pixel(0, 0).0, [255, 0, 0, 255]);
assert_eq!(back.get_pixel(1, 0)[3], 0);
}
#[test]
fn png8_decodes_at_every_bit_depth_and_interlaced() {
for (colors, depth) in [(2, 1), (4, 2), (16, 4), (200, 8)] {
let px = ramps(13, 11);
let ix = quantize(&px, 13, 11, &PaletteOptions { colors, ..Default::default() });
for interlaced in [false, true] {
let file = encode_indexed(&ix, &PngOptions { ppi: Some(144.0), interlaced }).unwrap();
assert_eq!((file[24], file[25], file[28]), (depth, 3, u8::from(interlaced)));
let back = craft_image_codecs::decode(&file)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgb8();
let want: Vec<u8> = colours(&ix).into_iter().flatten().collect();
assert_eq!(back.into_raw(), want, "{colors} colours, interlaced {interlaced}");
assert!(chunk(&file, b"pHYs").is_some());
}
}
}
#[test]
fn gif_decodes() {
let px: Vec<u8> = ramps(21, 17).chunks(4).enumerate().flat_map(|(i, p)| [p[0], p[1], p[2], if i % 5 == 0 { 0 } else { 255 }]).collect();
let ix = quantize(&px, 21, 17, &PaletteOptions { colors: 32, ..Default::default() });
for interlaced in [false, true] {
let file = gif::encode(&ix, interlaced).unwrap();
assert_eq!(&file[..6], b"GIF89a");
let back = craft_image_codecs::decode_as(craft_image_codecs::Format::Gif, &file)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgba8();
assert_eq!(back.dimensions(), (21, 17));
for (i, p) in back.pixels().enumerate() {
match ix.indices[i] {
0 => assert_eq!(p[3], 0, "transparent at {i}"),
v => {
let [r, g, b] = ix.palette[v as usize];
assert_eq!(p.0, [r, g, b, 255], "{i} interlaced {interlaced}");
}
}
}
}
let wide = Indexed { width: 70_000, height: 1, palette: vec![[0; 3]], transparent: None, indices: vec![0; 70_000] };
assert!(gif::encode(&wide, false).is_err());
}
#[test]
fn ids_round_trip() {
for r in Reduction::ALL {
assert_eq!(Reduction::from_id(r.id()), Some(r));
}
for d in Dither::ALL {
assert_eq!(Dither::from_id(d.id()), Some(d));
}
}