2bc41aeb8602
tests_web.rs
use super::quantize::{Dither, Indexed, PaletteOptions, Reduction, quantize, quantize_locked};
use super::web::{ColorSort, gif_comment, jpeg_comment, lossy, snap, sort, to_transparent};
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)| [f(x, y)[0], f(x, y)[1], f(x, y)[2], 255]).collect()
}
fn colours(ix: &Indexed) -> Vec<[u8; 3]> {
ix.indices.iter().map(|&i| ix.palette[i as usize]).collect()
}
#[test]
fn locked_colours_survive_a_reduction() {
let px = image(64, 16, |x, y| [(x * 4) as u8, (y * 16) as u8, 90]);
let rare = [7, 200, 13];
let mut px = px;
px[..4].copy_from_slice(&[rare[0], rare[1], rare[2], 255]);
let o = PaletteOptions { colors: 4, dither: Dither::None, reduction: Reduction::Adaptive, ..Default::default() };
assert!(!quantize(&px, 64, 16, &o).palette.contains(&rare), "a lone pixel loses its colour");
let ix = quantize_locked(&px, 64, 16, &o, &[rare]);
assert!(ix.palette.contains(&rare) && ix.palette.len() <= 4, "{:?}", ix.palette);
assert_eq!(colours(&ix)[0], rare);
}
#[test]
fn snapping_to_web_colours() {
assert_eq!(snap([50, 103, 0], 0), None);
assert_eq!(snap([50, 103, 0], 10), Some([51, 102, 0]));
assert_eq!(snap([60, 103, 0], 10), None, "9 levels off is beyond 10%");
assert_eq!(snap([60, 103, 0], 100), Some([51, 102, 0]));
assert_eq!(snap([25, 25, 25], 100), Some([0, 0, 0]));
}
#[test]
fn mapped_colours_become_the_transparent_entry() {
let px = image(4, 1, |x, _| [[255, 0, 0], [0, 0, 255], [0, 255, 0], [255, 0, 0]][x as usize]);
let mut ix = quantize(&px, 4, 1, &PaletteOptions::default());
assert_eq!(ix.transparent, None);
let red = ix.palette.iter().position(|c| *c == [255, 0, 0]).unwrap();
let map = to_transparent(&mut ix, |i| i == red);
assert_eq!(map[red], None);
assert_eq!(ix.transparent, Some(0));
assert_eq!(ix.palette.len(), 3, "the transparent entry and blue and green");
assert_eq!((ix.indices[0], ix.indices[3]), (0, 0));
assert_eq!(ix.palette[ix.indices[1] as usize], [0, 0, 255]);
// Mapping nothing changes nothing.
let before = ix.clone();
to_transparent(&mut ix, |_| false);
assert_eq!(ix, before);
}
#[test]
fn sorting_keeps_every_pixel_colour() {
let px: Vec<u8> = image(8, 8, |x, y| [(x * 30) as u8, 255 - (y * 30) as u8, ((x + y) * 15) as u8])
.chunks(4)
.enumerate()
.flat_map(|(i, p)| [p[0], p[1], p[2], if i == 5 { 0 } else { 255 }])
.collect();
let ix = quantize(&px, 8, 8, &PaletteOptions { colors: 16, ..Default::default() });
for order in ColorSort::ALL {
let mut s = ix.clone();
let new = sort(&mut s, order);
assert_eq!(s.transparent, Some(0), "{order:?}: the transparent entry stays first");
assert_eq!(new[0], 0);
for (i, (&a, &b)) in ix.indices.iter().zip(&s.indices).enumerate() {
assert_eq!(ix.palette[a as usize], s.palette[b as usize], "{order:?} pixel {i}");
}
}
let mut s = ix.clone();
sort(&mut s, ColorSort::Luminance);
let luma = |c: &[u8; 3]| 299 * c[0] as u32 + 587 * c[1] as u32 + 114 * c[2] as u32;
assert!(s.palette[1..].windows(2).all(|w| luma(&w[0]) <= luma(&w[1])));
assert_eq!(ColorSort::from_id("popularity"), Some(ColorSort::Popularity));
}
#[test]
fn lossy_makes_runs_and_smaller_gifs() {
let px = image(96, 64, |x, y| [(x * 2 + y) as u8, (y * 3) as u8, ((x * y) % 255) as u8]);
let ix = quantize(&px, 96, 64, &PaletteOptions { colors: 64, dither: Dither::Diffusion, ..Default::default() });
let mut lossy_ix = ix.clone();
lossy(&mut lossy_ix, &px, 80, &[]);
let runs = |ix: &Indexed| ix.indices.windows(2).filter(|w| w[0] != w[1]).count();
assert!(runs(&lossy_ix) < runs(&ix));
let size = |ix: &Indexed| gif::encode(ix, false).unwrap().len();
assert!(size(&lossy_ix) < size(&ix), "{} vs {}", size(&lossy_ix), size(&ix));
let mut none = ix.clone();
lossy(&mut none, &px, 0, &[]);
assert_eq!(none, ix);
// A fixed entry keeps its pixels and takes no others.
let fixed: Vec<u8> = (0..ix.palette.len()).filter_map(|i| u8::try_from(i).ok()).collect();
let mut kept = ix.clone();
lossy(&mut kept, &px, 100, &fixed);
assert_eq!(kept, ix);
}
#[test]
fn comments_are_valid_files() {
let ix = quantize(&image(5, 4, |x, _| [x as u8 * 40, 0, 0]), 5, 4, &PaletteOptions::default());
let file = gif_comment(gif::encode(&ix, false).unwrap(), &"Copyright: Someone ".repeat(20));
assert!(file.windows(2).any(|w| w == [0x21, 0xFE]));
assert_eq!(
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()
.width(),
5
);
let px = vec![200u8; 5 * 4 * 3];
let jpg = jpeg::encode(&px, 5, 4, 80, Some(72.0), &jpeg::JpegOptions::default()).unwrap();
let with = jpeg_comment(jpg.clone(), "Copyright: Someone");
assert_eq!(with.len(), jpg.len() + 4 + 18);
assert!(with.windows(2).any(|w| w == [0xFF, 0xFE]));
assert_eq!(
craft_image_codecs::decode(&with)
.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()
.height(),
4
);
assert_eq!(jpeg_comment(vec![1, 2, 3], "x"), vec![1, 2, 3], "not a JPEG");
let png = png::with_srgb(png::encode(&[0, 0, 0, 255], 1, 1, &png::PngOptions::default()).unwrap());
assert!(png.windows(4).any(|w| w == b"sRGB"));
assert_eq!(
craft_image_codecs::decode(&png)
.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()
.width(),
1
);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.