2bc41aeb8602
web.rs
//! Web image optimisation on top of [`super::quantize`] (Save for Web): web snap, the colour
//! table's edits (map to transparent, sort), lossy GIF compression, and comments in GIF and JPEG
//! files.
use super::quantize::{Indexed, web_safe};
/// How the colour table is ordered.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ColorSort {
/// As the reduction made it.
#[default]
None,
Hue,
Luminance,
/// Most used first.
Popularity,
}
impl ColorSort {
pub const ALL: [ColorSort; 4] = [ColorSort::None, ColorSort::Hue, ColorSort::Luminance, ColorSort::Popularity];
pub fn id(self) -> &'static str {
match self {
ColorSort::None => "none",
ColorSort::Hue => "hue",
ColorSort::Luminance => "luminance",
ColorSort::Popularity => "popularity",
}
}
pub fn label(self) -> &'static str {
match self {
ColorSort::None => "Unsorted",
ColorSort::Hue => "Sort by Hue",
ColorSort::Luminance => "Sort by Luminance",
ColorSort::Popularity => "Sort by Popularity",
}
}
pub fn from_id(s: &str) -> Option<Self> {
Self::ALL.into_iter().find(|v| v.id().eq_ignore_ascii_case(s) || v.label().eq_ignore_ascii_case(s))
}
}
/// `c` as its nearest web-safe colour when every channel is within `tolerance` percent (0โ100) of
/// it: 100 snaps every colour, 0 none.
pub fn snap(c: [u8; 3], tolerance: u8) -> Option<[u8; 3]> {
// The farthest a channel can be from a web-safe value is 25 (half the step of 51).
let max = u32::from(tolerance.min(100)) * 26 / 100;
let s = web_safe(c);
(tolerance > 0 && (0..3).all(|i| u32::from(c[i].abs_diff(s[i])) <= max)).then_some(s)
}
/// Make the palette entries `mapped` names (by index) transparent: their pixels use the
/// transparent entry (added at index 0 when there is none) and the entries go. Returns the old
/// index โ new index map (`None`: the entry went).
pub fn to_transparent(ix: &mut Indexed, mapped: impl Fn(usize) -> bool) -> Vec<Option<u8>> {
let n = ix.palette.len();
let gone: Vec<bool> = (0..n).map(|i| Some(i) != ix.transparent.map(usize::from) && mapped(i)).collect();
if !gone.contains(&true) {
return (0..n).map(|i| u8::try_from(i).ok()).collect();
}
let clear = ix.transparent.map(usize::from);
let mut palette = Vec::with_capacity(n);
// The transparent entry first: the old one, or a new one (the first entry mapped's colour).
let first_gone = gone.iter().position(|g| *g).unwrap_or(0);
palette.push(ix.palette.get(clear.unwrap_or(first_gone)).copied().unwrap_or_default());
let mut map = vec![Some(0u8); n];
for (i, c) in ix.palette.iter().enumerate() {
if gone[i] || Some(i) == clear {
continue;
}
map[i] = u8::try_from(palette.len()).ok();
palette.push(*c);
}
for v in &mut ix.indices {
*v = map.get(*v as usize).copied().flatten().unwrap_or(0);
}
ix.palette = palette;
ix.transparent = Some(0);
map.into_iter().enumerate().map(|(i, m)| if gone[i] { None } else { m }).collect()
}
/// Lossy GIF compression: a pixel takes the entry of the pixel left of it when that entry is
/// within `amount` (0โ100) of its own colour in `rgba` (the straight pixels it was reduced from).
/// Longer runs of one index compress better in a GIF, at the cost of some noise. No pixel moves
/// into or out of the transparent entry or an entry in `fixed`.
pub fn lossy(ix: &mut Indexed, rgba: &[u8], amount: u8, fixed: &[u8]) {
let w = ix.width as usize;
if amount == 0 || w == 0 || rgba.len() != ix.indices.len() * 4 {
return;
}
// Up to 64 levels apart in each channel at 100.
let limit = (f32::from(amount.min(100)) / 100.0 * 64.0).powi(2) * 3.0;
let mut held = [false; 256];
for i in fixed.iter().chain(&ix.transparent) {
held[usize::from(*i)] = true;
}
let px = rgba.as_chunks::<4>().0;
for (row, src) in ix.indices.chunks_mut(w).zip(px.chunks(w)) {
for x in 1..row.len() {
let (prev, cur) = (row[x - 1], row[x]);
if prev == cur || held[usize::from(prev)] || held[usize::from(cur)] {
continue;
}
let (Some(c), Some(p)) = (src.get(x), ix.palette.get(prev as usize)) else { continue };
let d: f32 = (0..3).map(|i| (f32::from(c[i]) - f32::from(p[i])).powi(2)).sum();
if d <= limit {
row[x] = prev;
}
}
}
}
/// Reorder the palette by `order`, the transparent entry staying first. Returns the new order (the
/// old index of each entry).
pub fn sort(ix: &mut Indexed, order: ColorSort) -> Vec<usize> {
let n = ix.palette.len();
let identity: Vec<usize> = (0..n).collect();
if order == ColorSort::None || n < 2 {
return identity;
}
let mut count = vec![0u64; n];
for &v in &ix.indices {
if let Some(c) = count.get_mut(v as usize) {
*c += 1;
}
}
let fixed = ix.transparent.map(usize::from);
let mut rest: Vec<usize> = identity.into_iter().filter(|i| Some(*i) != fixed).collect();
let key = |i: usize| -> (f32, f32) {
let [r, g, b] = ix.palette.get(i).copied().unwrap_or_default().map(|v| f32::from(v) / 255.0);
let luma = 0.299 * r + 0.587 * g + 0.114 * b;
match order {
ColorSort::Hue => (hue(r, g, b), luma),
ColorSort::Luminance => (luma, 0.0),
_ => (-(count.get(i).copied().unwrap_or(0) as f32), luma),
}
};
rest.sort_by(|a, b| {
let (x, y) = (key(*a), key(*b));
x.0.total_cmp(&y.0).then(x.1.total_cmp(&y.1)).then(a.cmp(b))
});
let order: Vec<usize> = fixed.into_iter().chain(rest).collect();
let mut remap = vec![0u8; n];
for (new, &old) in order.iter().enumerate() {
if let (Some(r), Ok(v)) = (remap.get_mut(old), u8::try_from(new)) {
*r = v;
}
}
ix.palette = order.iter().filter_map(|&i| ix.palette.get(i).copied()).collect();
for v in &mut ix.indices {
*v = remap.get(*v as usize).copied().unwrap_or(0);
}
if fixed.is_some() {
ix.transparent = Some(0);
}
order
}
/// Hue in 0..1 (greys first, at -1).
fn hue(r: f32, g: f32, b: f32) -> f32 {
let (max, min) = (r.max(g).max(b), r.min(g).min(b));
let d = max - min;
if d <= f32::EPSILON {
return -1.0;
}
let h = if max == r {
((g - b) / d).rem_euclid(6.0)
} else if max == g {
(b - r) / d + 2.0
} else {
(r - g) / d + 4.0
};
h / 6.0
}
/// `gif` with a comment extension holding `text` before its trailer (unchanged when it isn't a
/// GIF or `text` is empty).
pub fn gif_comment(mut gif: Vec<u8>, text: &str) -> Vec<u8> {
if text.is_empty() || !gif.starts_with(b"GIF8") || gif.last() != Some(&0x3B) {
return gif;
}
gif.pop();
gif.extend_from_slice(&[0x21, 0xFE]);
for block in text.as_bytes().chunks(255) {
gif.push(block.len() as u8);
gif.extend_from_slice(block);
}
gif.extend_from_slice(&[0x00, 0x3B]);
gif
}
/// `jpeg` with a comment segment (`COM`) holding `text` after its JFIF header (unchanged when it
/// isn't a JPEG or `text` is empty; text past a segment's 65 533 bytes is cut at a character).
pub fn jpeg_comment(jpeg: Vec<u8>, text: &str) -> Vec<u8> {
if text.is_empty() || !jpeg.starts_with(&[0xFF, 0xD8]) {
return jpeg;
}
// After SOI, and after the APP0 (JFIF) segment when it comes first.
let at = match jpeg.get(2..6) {
Some([0xFF, 0xE0, hi, lo]) => 4 + usize::from(u16::from_be_bytes([*hi, *lo])),
_ => 2,
};
if at > jpeg.len() {
return jpeg;
}
let mut end = text.len().min(65_533);
while !text.is_char_boundary(end) {
end -= 1;
}
let data = &text.as_bytes()[..end];
let mut out = Vec::with_capacity(jpeg.len() + data.len() + 4);
out.extend_from_slice(&jpeg[..at]);
out.extend_from_slice(&[0xFF, 0xFE]);
out.extend_from_slice(&((data.len() + 2) as u16).to_be_bytes());
out.extend_from_slice(data);
out.extend_from_slice(&jpeg[at..]);
out
}
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.