//! Image Tools (`addon.image.*`), a built-in add-on. Remove Background makes the background of the //! selected images transparent in their own pixels, as one undo step. The background is the most //! common color along an image's edges, the average of its four corners, or colors the caller //! picks. It is cleared where it reaches in from an edge, or wherever it is. The work is done here, //! on the pixels; nothing is sent anywhere. Color Mask ([`mask`]) hides colors matched the same //! way while the image keeps its pixels. They are VectorCraft additions. Its submenu (Object › //! Plug-ins › Image Tools) and dialogs are the UI's. mod mask; #[cfg(test)] mod tests; pub(crate) use mask::refresh as refresh_color_masks; use std::collections::{HashMap, HashSet}; use std::sync::{Arc, Weak}; use image::{ImageBuffer, Rgba}; use serde_json::{Value, json}; use vectorcraft_color::Color; use vectorcraft_doc::{ImageBlob, ImageObject, NodeId, NodeKind}; use vectorcraft_geom::Affine; use super::super::fileio::{MAX_RASTER_ALLOC, ppi}; use super::super::menucmds::has_image; use super::super::paint::{PROCESS_ON_TRANSPARENCY, colorized_with_process}; use super::super::{CommandSpec, Result, Session, bad, checked_ids_param, cmd, hex_with_alpha, number_or, switch_or, text_param}; /// Remove Background's command. pub const REMOVE_BACKGROUND: &str = "addon.image.removeBackground"; const C: &str = REMOVE_BACKGROUND; /// The most colors `colors` lists. const MAX_COLORS: usize = 16; /// Bytes a pixel takes while it is worked on, beside its pixels: its level, whether the edge search /// reached it, and its place in the search's stack (4 bytes, twice that while the stack grows). const WORK_BYTES: u64 = 10; pub fn specs() -> Vec { let mut v = vec![cmd!( "addon.image.removeBackground", "Remove Background…", ["Object", "Plug-ins", "Image Tools"], None, "{background?: \"edges\" (default: the most common color along the image's edges; nothing is cleared when the edges hold at least as many clear pixels as pixels of that color) | \"corners\" (the average of the image's four corner pixels that are not clear; nothing is cleared when all four are clear) | \"colors\" (the colors in `colors`), colors?: [color…] or one string of them split by commas or spaces (1 to 16 colors, each a hex color \"#rrggbb\" or \"#rgb\" with or without the # or one of black, white, red, green and blue; needed with background: colors, and checked but not used with edges or corners), contiguous?: bool (true: only background pixels that reach in from an edge are cleared; false: they are cleared wherever they are; true), match?: \"distance\" (default: a color's RGB distance from a background color) | \"channels\" (its largest difference on one of red, green and blue), tolerance?: 0..100 (with distance, % of the largest RGB distance; with channels, % of 255 steps on one channel; a pixel this near a background color is cleared; 10), softness?: 0..100 (% past the tolerance over which pixels fade from cleared to kept; 10), ids?: [id…] (default: the selected images)} make the background of each image transparent in its own pixels, as one undo step: the image stays an image, embedded as a PNG with an alpha channel at the depth of its pixels (16-bit images keep 16 bits and grayscale images stay gray) with the source's color profile and resolution, and a linked image is embedded; a CMYK image, a linked image that shows its preview (embed or relink it first), an image too large to change, a result with no pixel left, and a grayscale image colorized with a process color (which can't colorize gray pixels with transparency) are refused, and an image whose pixels do not change is left as it is (no undo step when none changes) → {changed: the images changed, ids, cleared: the pixels made fully clear in them}", has_image, remove_background )]; v.extend(mask::specs()); v } /// Where the background's colors come from. #[derive(Clone, Debug, PartialEq)] pub(crate) enum Background { /// The most common color along the image's edges. Edges, /// The average of the image's four corner pixels that are not clear. Corners, /// These colors. Colors(Vec<[u8; 3]>), } /// How near a color is to a background color. #[derive(Clone, Copy, Debug, PartialEq)] pub(crate) enum Match { /// The RGB distance, as a percentage of the largest one (black to white). Distance, /// The largest difference on one of red, green and blue, as a percentage of a channel's range. Channels, } /// What Remove Background clears: the background, whether only where it reaches in from an edge, /// and how near a color must be to it (a percentage, measured as `measure` says) to be cleared, and /// to fade out past that. #[derive(Clone, Debug, PartialEq)] pub(crate) struct Settings { pub background: Background, pub contiguous: bool, pub measure: Match, pub tolerance: f64, pub softness: f64, } impl Settings { /// The settings `p` gives to command `cmd`, each checked. fn read(p: &Value, cmd: &str) -> Result { let percent = |key: &str| -> Result { let v = number_or(p, key, 10.0, cmd)?; if v.is_finite() && (0.0..=100.0).contains(&v) { Ok(v) } else { Err(bad(cmd, format!("`{key}` must be from 0 to 100"))) } }; let (tolerance, softness) = (percent("tolerance")?, percent("softness")?); let colors = match p.get("colors") { None | Some(Value::Null) => None, Some(v) => Some(colors(v, cmd)?), }; let background = match text_param(p, "background", cmd)? { None | Some("edges") => Background::Edges, Some("corners") => Background::Corners, Some("colors") => Background::Colors(colors.ok_or_else(|| colors_error(cmd))?), Some(_) => return Err(bad(cmd, "`background` must be edges, corners or colors")), }; let measure = match text_param(p, "match", cmd)? { None | Some("distance") => Match::Distance, Some("channels") => Match::Channels, Some(_) => return Err(bad(cmd, "`match` must be distance or channels")), }; let contiguous = switch_or(p, "contiguous", true, cmd)?; Ok(Self { background, contiguous, measure, tolerance, softness }) } } fn colors_error(cmd: &str) -> crate::EngineError { bad(cmd, "`colors` must list 1 to 16 colors, each hex (#rrggbb or #rgb) or black, white, red, green or blue") } /// The colors `v` lists to command `cmd`: an array of strings, or one string of them split by /// commas or spaces. Each is read as [`Color::from_hex`] reads it; one with an alpha part is refused. fn colors(v: &Value, cmd: &str) -> Result> { // One past the most is enough to tell a list that is too long. let texts: Vec<&str> = match v { Value::String(s) => s.split([',', ' ', '\t', '\n']).filter(|t| !t.is_empty()).take(MAX_COLORS + 1).collect(), Value::Array(a) => a.iter().take(MAX_COLORS + 1).map(Value::as_str).collect::>().ok_or_else(|| colors_error(cmd))?, _ => return Err(colors_error(cmd)), }; if texts.is_empty() || texts.len() > MAX_COLORS { return Err(colors_error(cmd)); } texts.into_iter().map(|t| rgb8(t).ok_or_else(|| colors_error(cmd))).collect() } /// The 8-bit RGB of the color `t` writes. fn rgb8(t: &str) -> Option<[u8; 3]> { if hex_with_alpha(t) { return None; } let [r, g, b] = Color::from_hex(t)?.to_rgb_uncalibrated(); Some([r, g, b].map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8)) } fn remove_background(s: &mut Session, p: &Value) -> Result { let settings = Settings::read(p, C)?; // A preview step keeps the pixels it decodes for the next step; other runs keep none. let mut kept = std::mem::take(&mut s.decoded_images); let previewing = s.previewing; let found = changes(s, p, &settings, previewing.then_some(&mut kept)); s.decoded_images = kept; let changes = found?; let ids: Vec = changes.iter().map(|(id, ..)| id.0).collect(); let made_clear: u64 = changes.iter().map(|(_, out, _)| out.cleared).sum(); if !changes.is_empty() { s.edit("Remove Background", |d, _| { for (id, out, xf) in changes { let key = out.blob.content_key(); d.images.entry(key.clone()).or_insert(out.blob); if let Some(NodeKind::Image(im)) = d.node_mut(id).map(|n| &mut n.kind) { im.key = key; (im.width, im.height, im.xf) = (out.width, out.height, xf); im.link = None; } } Ok(()) })?; } Ok(json!({ "changed": ids.len(), "ids": ids, "cleared": made_clear })) } /// The images `p` names (`ids`, or the selected images) whose pixels change, each with its pixels /// cleared as `settings` say and the transform that keeps its place and size. Decoded pixels are /// taken from and kept in `kept` when it is given. fn changes(s: &Session, p: &Value, settings: &Settings, mut kept: Option<&mut DecodedImages>) -> Result> { let images = images(s, p, C)?; // The result has an alpha channel, which a grayscale image colorized with a process color // can't take. The pixels that are cleared are checked, the image's own, not the ones a color // mask shows. let st = s.doc()?; for (id, _, blob) in &images { if blob.gray_source().is_some() && st.doc.node(*id).is_some_and(|n| colorized_with_process(&st.doc, n)) { return Err(bad(C, PROCESS_ON_TRANSPARENCY)); } } // Each image's pixels once, however many objects show them. let mut cleared: HashMap<&str, Option> = HashMap::new(); let mut changes = vec![]; for (id, im, blob) in images { let out = match cleared.get(im.key.as_str()) { Some(out) => out.clone(), None => { let out = clear(blob, settings, kept.as_deref_mut(), C)?; cleared.insert(&im.key, out.clone()); out } }; if let Some(out) = out { // A file read at another size than the object's keeps the object's place and size. let xf = if (out.width, out.height) == (im.width, im.height) { im.xf } else { im.xf * Affine::scale_non_uniform(f64::from(im.width) / f64::from(out.width), f64::from(im.height) / f64::from(out.height)) }; changes.push((id, out, xf)); } } Ok(changes) } /// The image objects command `cmd` acts on (`ids`, each once, or the selected images), each with /// its pixels, all checked before any is decoded: an object that is not an image, missing pixels, /// a linked image that shows its preview and a CMYK image are errors, as is no image at all. fn images<'a>(s: &'a Session, p: &Value, cmd: &str) -> Result> { let st = s.doc()?; let mut images = vec![]; for id in targets(s, p, cmd)? { let Some(NodeKind::Image(im)) = st.doc.node(id).map(|n| &n.kind) else { continue }; let blob = st.doc.images.get(&im.key).ok_or_else(|| bad(cmd, "the image's pixels are missing"))?; // The preview stands in for a file that hasn't been read, or that is kept at its preview. if im.link.is_some() && blob.is_proxy() { return Err(bad(cmd, "the linked image shows its preview: embed or relink it first")); } if blob.is_cmyk() { return Err(cmyk_refusal(cmd)); } images.push((id, &**im, blob)); } Ok(images) } /// The image objects command `cmd` acts on: `ids`, each once, or the selected images. An object in /// `ids` that is not an image is an error, as is no image at all. fn targets(s: &Session, p: &Value, cmd: &str) -> Result> { let st = s.doc()?; let ids: Vec = if p.get("ids").is_some_and(|v| !v.is_null()) { // Each image once, however often `ids` names it. let mut given = HashSet::new(); let ids: Vec = checked_ids_param(s, p, "ids", cmd)?.into_iter().filter(|id| given.insert(*id)).collect(); if let Some(id) = ids.iter().find(|id| !matches!(st.doc.node(**id).map(|n| &n.kind), Some(NodeKind::Image(_)))) { return Err(bad(cmd, format!("object {} is not an image", id.0))); } ids } else { st.selection.objects.iter().copied().filter(|id| matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::Image(_)))).collect() }; if ids.is_empty() { return Err(bad(cmd, "select an image")); } Ok(ids) } /// Whether `cmd` is one of Color Mask's commands, which hide pixels instead of clearing them. fn masks(cmd: &str) -> bool { matches!(cmd, mask::COLOR_MASK | mask::REMOVE_COLOR_MASK | mask::APPLY_COLOR_MASK) } /// Command `cmd`'s refusal of a CMYK image. fn cmyk_refusal(cmd: &str) -> crate::EngineError { if masks(cmd) { bad(cmd, "a CMYK image can't take a color mask") } else { bad(cmd, "a CMYK image has no transparency to set") } } /// An image with its background cleared: its PNG, its size in pixels, and how many of its pixels /// were made fully clear. #[derive(Clone, Debug)] pub(crate) struct Cleared { pub blob: ImageBlob, pub width: u32, pub height: u32, pub cleared: u64, } /// An image's pixels as straight RGBA, at 8 or 16 bits a sample. #[derive(Clone)] enum Pixels { Eight(image::RgbaImage), Sixteen(ImageBuffer, Vec>), } /// The most bytes of decoded pixels and ICC profiles [`DecodedImages`] keeps (128 MiB, or 32 MiB in /// the web app). const KEEP_BYTES: u64 = MAX_RASTER_ALLOC / 16; /// The images Remove Background decoded during an interaction's preview steps, the most recently /// used first, at most [`KEEP_BYTES`] in all. The next preview step runs the command again on the /// same bytes and takes their pixels from here instead of decoding them again. The session holds /// it and empties it when the interaction ends (OK or Cancel). A run that is not a preview step /// does not read or fill it. #[derive(Default)] pub(crate) struct DecodedImages(Vec); /// An image decoded by [`clear`]: the bytes it was decoded from (held weakly, so they are not kept /// alive for it, and an entry whose bytes are gone is dropped), its pixels, whether it was gray, /// and its ICC profile. struct Decoded { source: Weak>, pixels: Arc, gray: bool, icc: Option>, } #[cfg(test)] thread_local! { /// How many times this thread decoded an image in [`clear`]. pub(crate) static DECODES: std::cell::Cell = const { std::cell::Cell::new(0) }; } impl DecodedImages { /// Drops every image kept. pub(crate) fn empty(&mut self) { self.0.clear(); } /// How many images are kept. #[cfg(test)] pub(crate) fn len(&self) -> usize { self.0.len() } /// The pixels, gray flag and ICC profile kept for `bytes`, if they are kept. Images whose bytes /// are gone are dropped first. fn get(&mut self, bytes: &Arc>) -> Option<(Arc, bool, Option>)> { self.0.retain(|d| d.source.strong_count() > 0); let at = self.0.iter().position(|d| std::ptr::eq(d.source.as_ptr(), Arc::as_ptr(bytes)))?; let d = self.0.remove(at); let found = (Arc::clone(&d.pixels), d.gray, d.icc.clone()); self.0.insert(0, d); Some(found) } /// Keeps `pixels` decoded from `bytes` first, in place of anything kept for the same bytes, and /// drops images whose bytes are gone and the least recently used past [`KEEP_BYTES`]. fn keep(&mut self, bytes: &Arc>, pixels: Arc, gray: bool, icc: Option>) { self.0.retain(|d| d.source.strong_count() > 0 && !std::ptr::eq(d.source.as_ptr(), Arc::as_ptr(bytes))); self.0.insert(0, Decoded { source: Arc::downgrade(bytes), pixels, gray, icc }); let mut total = 0u64; self.0.retain(|d| { total = total.saturating_add(d.bytes()); total <= KEEP_BYTES }); } } impl Decoded { /// How many bytes the entry keeps: its pixels and its ICC profile. fn bytes(&self) -> u64 { self.pixels.bytes().saturating_add(self.icc.as_ref().map_or(0, |icc| icc.len() as u64)) } } impl Pixels { /// How many bytes the pixels take. fn bytes(&self) -> u64 { match self { Self::Eight(img) => img.as_raw().len() as u64, Self::Sixteen(img) => img.as_raw().len() as u64 * 2, } } /// The width and height in pixels. fn dimensions(&self) -> (u32, u32) { match self { Self::Eight(img) => img.dimensions(), Self::Sixteen(img) => img.dimensions(), } } /// Pixel `i` (row by row from the top left) at 16 bits a sample (an 8-bit sample `v` is /// `v * 257`). fn rgba16(&self, i: usize) -> [u16; 4] { let mut out = [0u16; 4]; match self { Self::Eight(img) => { for (o, v) in out.iter_mut().zip(img.as_raw().get(i * 4..i * 4 + 4).unwrap_or_default()) { *o = u16::from(*v) * 257; } } Self::Sixteen(img) => { for (o, v) in out.iter_mut().zip(img.as_raw().get(i * 4..i * 4 + 4).unwrap_or_default()) { *o = *v; } } } out } } /// `blob` with its background cleared as `settings` say, or `None` when no pixel changes. A CMYK /// image, one that can't be decoded or is too large to change, and a result with no pixel left are /// errors of command `cmd`. The PNG keeps the source's ICC profile and resolution. The decoded /// pixels are taken from and kept in `kept` when it is given. pub(crate) fn clear(blob: &ImageBlob, settings: &Settings, mut kept: Option<&mut DecodedImages>, cmd: &str) -> Result> { if blob.is_cmyk() { return Err(cmyk_refusal(cmd)); } let found = kept.as_deref_mut().and_then(|k| k.get(&blob.bytes)); let (source, gray, icc) = match found { Some(found) => found, None => decode(blob, kept, cmd)?, }; // The pixels kept for the next run stay as they are; ones not kept are worked on in place. let mut px = Arc::try_unwrap(source).unwrap_or_else(|kept| Pixels::clone(&kept)); let (w, h) = px.dimensions(); let levels = levels(w as usize, h as usize, &|i| px.rgba16(i), settings); let Some(cleared) = apply(&mut px, &levels) else { return Ok(None) }; let left = match &px { Pixels::Eight(img) => img.pixels().any(|p| p.0[3] > 0), Pixels::Sixteen(img) => img.pixels().any(|p| p.0[3] > 0), }; if !left { return Err(if masks(cmd) { bad(cmd, "the mask would hide every pixel") } else { bad(cmd, "every pixel matches the background: no image would be left") }); } let raw = match (px, gray) { (Pixels::Eight(img), false) => { craft_image_codecs::Image::from_raw(w, h, craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, img.into_raw()) } (Pixels::Sixteen(img), false) => craft_image_codecs::Image::from_raw( w, h, craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U16, img.into_raw().into_iter().flat_map(u16::to_ne_bytes).collect(), ), (Pixels::Eight(img), true) => craft_image_codecs::Image::from_raw( w, h, craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8, img.pixels().flat_map(|p| [p.0[0], p.0[3]]).collect(), ), (Pixels::Sixteen(img), true) => craft_image_codecs::Image::from_raw( w, h, craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U16, img.pixels().flat_map(|p| [p.0[0], p.0[3]]).flat_map(u16::to_ne_bytes).collect(), ), } .map_err(|e| bad(cmd, e.to_string()))? .with_icc(icc); let mut png = craft_image_codecs::encode(&raw, craft_image_codecs::Format::Png, &craft_image_codecs::EncodeOptions::default()) .map_err(|e| bad(cmd, e.to_string()))?; // The resolution the file declares, which sizes the image at 100% when it is replaced or relinked. if let Some(r) = ppi::resolution(&blob.bytes) { png = ppi::with_png_resolution(&png, r); } Ok(Some(Cleared { blob: ImageBlob::png(png), width: w, height: h, cleared })) } /// The image's size and the bytes a pixel of it takes to change, read from its header: its /// samples as decoded (bitmaps as 8-bit gray, palettes as RGB, or RGBA with a transparent entry), /// those worked on and kept for the PNG, and the work. A header that gives only the size (one /// whose file can't hold its pixels) counts the fewest: one 8-bit sample. `None` when the header /// doesn't say. fn header_pixels(bytes: &[u8]) -> Option<(u32, u32, u64)> { use craft_image_codecs::RasterColorType as T; let Some(i) = craft_image_codecs::inspect_raster(bytes).ok().flatten() else { return vectorcraft_doc::header_size(bytes).map(|(w, h)| (w, h, 1 + 2 * 4 + WORK_BYTES)); }; let deep = i.bits_per_sample > 8 && i.color_type != T::Indexed; let channels = match i.color_type { T::Indexed => 3 + u64::from(i.transparent_index.is_some()), T::Bitmap => 1, _ => u64::from(i.channels.max(1)), }; let samples = channels * if deep { 2 } else { 1 }; Some((i.width, i.height, samples + 2 * if deep { 8 } else { 4 } + WORK_BYTES)) } /// `blob`'s pixels as straight RGBA, whether they were gray, and its ICC profile. An image that /// can't be decoded or is too large to change is an error. The pixels are kept in `kept`, when it /// is given, if a copy of them fits the decode allowance beside the work. Errors are command `cmd`'s. fn decode(blob: &ImageBlob, kept: Option<&mut DecodedImages>, cmd: &str) -> Result<(Arc, bool, Option>)> { // The file's pixels, those worked on (as many again for the PNG made of them) and the work, // checked from the header before anything is decoded. let too_large = |w: u32, h: u32, per_pixel: u64| { u64::from(w).checked_mul(u64::from(h)).and_then(|n| n.checked_mul(per_pixel)).is_none_or(|n| n > MAX_RASTER_ALLOC) }; let header = header_pixels(&blob.bytes); if let Some((w, h, per_pixel)) = header && too_large(w, h, per_pixel) { return Err(bad(cmd, format!("an image of {w} × {h} pixels is too large to change"))); } let mut opts = craft_image_codecs::DecodeOptions::default(); opts.limits.max_alloc = MAX_RASTER_ALLOC; let img = craft_image_codecs::decode_with(&blob.bytes, &opts).map_err(|e| match e { // Within the allowance from its header: a file that can't hold the pixels it declares. craft_image_codecs::CodecError::LimitExceeded(_) if header.is_none() => bad(cmd, "the image is too large to change"), _ => bad(cmd, format!("the image's pixels can't be read: {e}")), })?; let (w, h) = img.dimensions(); let icc = img.icc.clone(); let deep = img.sample_type() == craft_image_codecs::SampleType::U16; let gray = matches!(img.layout(), craft_image_codecs::ChannelLayout::Gray | craft_image_codecs::ChannelLayout::GrayA); let per_pixel = u64::from(img.layout().channels() as u32 * img.sample_type().bytes() as u32) + 2 * if deep { 8 } else { 4 } + WORK_BYTES; if too_large(w, h, per_pixel) { return Err(bad(cmd, format!("an image of {w} × {h} pixels is too large to change"))); } #[cfg(test)] DECODES.with(|c| c.set(c.get() + 1)); let px = Arc::new(if deep { let rgba16 = match (img.layout(), img.to_u16_samples()) { (craft_image_codecs::ChannelLayout::Rgba, Some(v)) => v, (craft_image_codecs::ChannelLayout::Rgb, Some(v)) => v.as_chunks::<3>().0.iter().flat_map(|c| [c[0], c[1], c[2], u16::MAX]).collect(), (craft_image_codecs::ChannelLayout::GrayA, Some(v)) => v.as_chunks::<2>().0.iter().flat_map(|c| [c[0], c[0], c[0], c[1]]).collect(), (craft_image_codecs::ChannelLayout::Gray, Some(v)) => v.into_iter().flat_map(|g| [g, g, g, u16::MAX]).collect(), _ => img.to_rgba8().into_iter().map(|b| u16::from(b) * 257).collect(), }; Pixels::Sixteen(ImageBuffer::from_raw(w, h, rgba16).ok_or_else(|| bad(cmd, "invalid 16-bit pixel buffer"))?) } else { Pixels::Eight(ImageBuffer::from_raw(w, h, img.to_rgba8()).ok_or_else(|| bad(cmd, "invalid 8-bit pixel buffer"))?) }); // A kept copy is worked on as a copy: one more set of the pixels worked on. let with_copy = per_pixel + if deep { 8 } else { 4 }; if let Some(kept) = kept && u64::from(w).checked_mul(u64::from(h)).and_then(|n| n.checked_mul(with_copy)).is_some_and(|n| n <= MAX_RASTER_ALLOC) && px.bytes().saturating_add(icc.as_ref().map_or(0, |icc| icc.len() as u64)) <= KEEP_BYTES { kept.keep(&blob.bytes, Arc::clone(&px), gray, icc.clone()); } Ok((px, gray, icc)) } /// Each pixel's alpha scaled by its level (255 keeps it). Returns how many pixels were made fully /// clear, or `None` when no pixel changed. fn apply(px: &mut Pixels, levels: &[u8]) -> Option { let (mut changed, mut cleared) = (false, 0u64); match px { Pixels::Eight(img) => { for (p, &l) in img.pixels_mut().zip(levels) { let a = ((u32::from(p.0[3]) * u32::from(l) + 127) / 255) as u8; changed |= a != p.0[3]; cleared += u64::from(a == 0 && p.0[3] != 0); p.0[3] = a; } } Pixels::Sixteen(img) => { for (p, &l) in img.pixels_mut().zip(levels) { let a = ((u32::from(p.0[3]) * u32::from(l) + 127) / 255) as u16; changed |= a != p.0[3]; cleared += u64::from(a == 0 && p.0[3] != 0); p.0[3] = a; } } } changed.then_some(cleared) } /// How much of each of the `w` × `h` pixels `px` gives (row by row, straight RGBA at 16 bits a /// sample) stays, from 0 (cleared) to 255 (kept), as `settings` say. Each pixel's distance to the /// background is worked out once. A pixel past the first `u32::MAX` is left kept by the edge search. pub(crate) fn levels(w: usize, h: usize, px: &dyn Fn(usize) -> [u16; 4], settings: &Settings) -> Vec { let n = w.saturating_mul(h); let refs: Vec<[u16; 3]> = match &settings.background { Background::Colors(refs) => refs.iter().map(|c| c.map(|v| u16::from(v) * 257)).collect(), Background::Edges => match edge_color(w, h, px) { Some(edge) => vec![edge], None => return vec![255; n], }, Background::Corners => match corner_color(w, h, px) { Some(corner) => vec![corner], None => return vec![255; n], }, }; let mut out: Vec = (0..n) .map(|i| { let [r, g, b, _] = px(i); level([r, g, b], &refs, settings) }) .collect(); if settings.contiguous { // Out from the edges, through clear pixels and pixels that lose some alpha; the pixels it // doesn't reach are kept. let reaches = |out: &[u8], i: usize| out.get(i).is_some_and(|l| *l < 255) || px(i)[3] == 0; let mut seen = vec![false; n]; let mut stack: Vec = vec![]; for i in border(w, h).filter(|&i| reaches(&out, i)) { if let (Some(s), Ok(at)) = (seen.get_mut(i), u32::try_from(i)) { *s = true; stack.push(at); } } while let Some(at) = stack.pop() { let i = at as usize; let (x, y) = (i % w, i / w); let next = [(x > 0).then(|| i - 1), (x + 1 < w).then(|| i + 1), (y > 0).then(|| i - w), (y + 1 < h).then(|| i + w)]; for j in next.into_iter().flatten() { if let Some(s) = seen.get_mut(j) && !*s && reaches(&out, j) && let Ok(at) = u32::try_from(j) { *s = true; stack.push(at); } } } for (l, s) in out.iter_mut().zip(&seen) { if !*s { *l = 255; } } } out } /// The level of a pixel of color `c`: 0 within the tolerance of the nearest of `refs`, 255 from /// the tolerance plus the softness on, and in proportion between them. fn level(c: [u16; 3], refs: &[[u16; 3]], settings: &Settings) -> u8 { let Settings { tolerance, softness, measure, .. } = *settings; let d = percent(refs.iter().map(|r| gap(c, *r, measure)).fold(f64::INFINITY, f64::min), measure); if d <= tolerance { 0 } else if d >= tolerance + softness { 255 } else { ((d - tolerance) / softness * 255.0).round().clamp(0.0, 255.0) as u8 } } /// How far apart `a` and `b` are, measured as `measure` says, before `percent` converts it: the /// squared RGB distance, or the largest difference on one channel. fn gap(a: [u16; 3], b: [u16; 3], measure: Match) -> f64 { match measure { Match::Distance => a.iter().zip(b).map(|(x, y)| (f64::from(*x) - f64::from(y)).powi(2)).sum(), Match::Channels => f64::from(a.iter().zip(b).map(|(x, y)| x.abs_diff(y)).max().unwrap_or(0)), } } /// A `gap` as a percentage: of the largest RGB distance (black to white) with distance, or of the /// channel's range with channels. A difference of `k` 8-bit steps on one channel is exactly /// `k / 255 × 100` with channels. fn percent(gap: f64, measure: Match) -> f64 { match measure { Match::Distance => gap.sqrt() / (65_535.0 * 3f64.sqrt()) * 100.0, Match::Channels => gap / 65_535.0 * 100.0, } } /// The pixels on the edges of a `w` × `h` image, each once. fn border(w: usize, h: usize) -> impl Iterator { let top = (0..w).filter(move |_| h > 0); let bottom = (0..w).filter(move |_| h > 1).map(move |x| (h - 1) * w + x); let sides = (1..h.saturating_sub(1)).flat_map(move |y| [Some(y * w), (w > 1).then(|| y * w + w - 1)].into_iter().flatten()); top.chain(bottom).chain(sides) } /// The most common color along an image's edges: its edge pixels grouped by 16 levels a channel, /// with the clear ones as a group of their own, as the average of the largest group. `None` when /// the clear edge pixels are at least as many as that group: the background is already cleared. fn edge_color(w: usize, h: usize, px: &dyn Fn(usize) -> [u16; 4]) -> Option<[u16; 3]> { let mut groups: HashMap<[u16; 3], (u64, [u64; 3])> = HashMap::new(); let mut clear = 0u64; for i in border(w, h) { let [r, g, b, a] = px(i); if a == 0 { clear += 1; continue; } let e = groups.entry([r >> 12, g >> 12, b >> 12]).or_default(); e.0 += 1; for (s, v) in e.1.iter_mut().zip([r, g, b]) { *s += u64::from(v); } } // Equal groups go by color, so the result doesn't depend on the map's order. let (_, (n, sums)) = groups.into_iter().max_by(|a, b| a.1.0.cmp(&b.1.0).then(b.0.cmp(&a.0)))?; if clear >= n { return None; } Some(sums.map(|s| ((s + n / 2) / n.max(1)) as u16)) } /// The average of the four corner pixels of a `w` × `h` image that are not clear (a corner of a /// one-pixel-wide image counts twice). `None` when all four are clear: the background is already /// cleared. fn corner_color(w: usize, h: usize, px: &dyn Fn(usize) -> [u16; 4]) -> Option<[u16; 3]> { if w == 0 || h == 0 { return None; } let corners = [0, w - 1, (h - 1) * w, (h - 1) * w + w - 1]; let (mut n, mut sums) = (0u64, [0u64; 3]); for [r, g, b, a] in corners.map(px) { if a > 0 { n += 1; for (s, v) in sums.iter_mut().zip([r, g, b]) { *s += u64::from(v); } } } (n > 0).then(|| sums.map(|s| ((s + n / 2) / n) as u16)) }