2bc41aeb8602
quantize.rs
//! Colour reduction and noise removal. Colours are compared in Oklab, where equal distances look
//! equally different.
use crate::{Mode, Palette, Raster, TraceParams, parallel_map};
mod cut_edge;
mod denoise;
mod palette;
mod rare;
use cut_edge::{choosing_pixels, compact, settled, settled_wide, settles_wide};
pub(crate) use cut_edge::{continuous_tone, settle_cut_edges};
pub use denoise::denoise;
#[cfg(test)]
pub(crate) use denoise::denoise_keeping;
pub(crate) use denoise::{Source, denoise_nearest};
pub use palette::FULL_TONE_MAX;
use palette::{Bin, HistKey, TracedAs, Used, color_palette, flat_count, flat_palette, kmeans_1d, labs, nearest_1d, nearest_lab, nearest_library};
#[cfg(test)]
pub(crate) use rare::kept_rare;
use rare::{rare_colours, refine_around};
/// Label of a transparent (untraced) pixel.
pub const TRANSPARENT: u16 = u16::MAX;
/// A palette-indexed image.
#[derive(Clone, Debug, PartialEq)]
pub struct Quantized {
/// One palette index per pixel (row-major), or [`TRANSPARENT`].
pub labels: Vec<u16>,
pub palette: Vec<[u8; 3]>,
}
/// A pixel's gray (Rec. 601 luma): what Grayscale traces it as.
pub(crate) fn luma(p: [u8; 4]) -> u8 {
((p[0] as u32 * 299 + p[1] as u32 * 587 + p[2] as u32 * 114 + 500) / 1000) as u8
}
/// Reduce `img` to a palette according to `params.mode`. A raster whose bytes are not
/// `width * height * 4` (its fields are public) has no pixels to reduce: no labels, no palette.
pub fn quantize(img: &Raster, params: &TraceParams) -> Quantized {
let want = (img.width as usize).checked_mul(img.height as usize).and_then(|n| n.checked_mul(4));
if want != Some(img.rgba.len()) {
return Quantized { labels: vec![], palette: vec![] };
}
quantize_keeping(img, params).0
}
/// [`quantize`], and the palette colours that are rare but kept on purpose (see [`rare_colours`]):
/// noise removal must not erase their regions.
pub(crate) fn quantize_keeping(img: &Raster, params: &TraceParams) -> (Quantized, Vec<[u8; 3]>) {
let px = img.rgba.as_chunks::<4>().0.iter().map(|c| [c[0], c[1], c[2], c[3]]);
match params.mode {
Mode::BlackAndWhite => {
let t = params.threshold;
let labels = px
.map(|p| {
if p[3] < 128 {
TRANSPARENT
} else if luma(p) < t {
1
} else {
0
}
})
.collect();
(Quantized { labels, palette: vec![[255, 255, 255], [0, 0, 0]] }, vec![])
}
Mode::Grayscale => {
// The pixels that choose the grays: the opaque ones, except the semi-transparent ones
// along the cut edge (see `choosing_pixels`).
let choose = choosing_pixels(img, true);
let own = own_colours(img);
let own_choosing = own_colours_among(img, &choose);
let histogram = |only_own: bool| {
let mut hist = [0u64; 256];
for ((p, &f), &c) in img.rgba.as_chunks::<4>().0.iter().zip(&own_choosing).zip(&choose) {
if p[3] >= 128 && c && (f || !only_own) {
hist[luma([p[0], p[1], p[2], p[3]]) as usize] += 1;
}
}
hist
};
let (every, calm) = (histogram(false), histogram(true));
let hist = if palette_from_own(calm.iter().sum::<u64>() as f64, every.iter().sum::<u64>() as f64) { calm } else { every };
let levels = kmeans_1d(&hist, params.colors.clamp(2, 256) as usize);
let mut lut = [0u16; 256];
for (v, slot) in lut.iter_mut().enumerate() {
*slot = nearest_1d(&levels, v as f64) as u16;
}
let labels = px.map(|p| if p[3] < 128 { TRANSPARENT } else { lut[luma(p) as usize] }).collect();
let palette = levels.iter().map(|&l| {
let g = l.round().clamp(0.0, 255.0) as u8;
[g, g, g]
});
let q = merge_mixed(compact(labels, palette.collect()), img.width as usize, img.height as usize, &[], Alike::Rgb);
(if settles_wide(params) { settled_wide(q, img, &own, true) } else { settled(q, img, &own) }, vec![])
}
// Logo mode traces without quantising; asked directly, it quantises like Color.
Mode::Color | Mode::Logo => {
// 15-bit colour histogram with per-bin sums (exact bin means), fitted to the image's
// range per channel so that close tones (a dark, low-contrast photo) stay apart.
let hk = HistKey::new(img);
let pixels = img.rgba.as_chunks::<4>().0;
// The pixels that choose the colors: the opaque ones, except the semi-transparent ones
// along the cut edge (see `choosing_pixels`).
let choose = choosing_pixels(img, false);
let own = own_colours(img);
let own_choosing = own_colours_among(img, &choose);
let (mut all, mut every, mut calm) = (vec![Bin::default(); 1 << 15], vec![Bin::default(); 1 << 15], vec![Bin::default(); 1 << 15]);
for ((p, &f), &c) in pixels.iter().zip(&own_choosing).zip(&choose) {
if p[3] >= 128 {
let k = hk.key(p[0], p[1], p[2]);
all[k].add(p);
if c {
every[k].add(p);
if f {
calm[k].add(p);
}
}
}
}
let used =
|bins: &[Bin]| -> Vec<Used> { bins.iter().enumerate().filter(|(_, b)| b.n > 0).map(|(i, b)| (i, b.mean(), b.n as f64)).collect() };
let (all, every, calm) = (used(&all), used(&every), used(&calm));
let count = |u: &[Used]| u.iter().map(|b| b.2).sum::<f64>();
let from = if palette_from_own(count(&calm), count(&every)) { &calm } else { &every };
// Automatic on flat art: colours too rare for its count, but distinct and drawn as
// regions of their own, are added (see `rare_colours`).
let detail = (params.color_detail / 100.0).clamp(0.0, 1.0);
let flat = if params.palette == Palette::Automatic { flat_count(from, detail) } else { None };
let flat_auto = flat.is_some();
let mut rare: Vec<[u8; 3]> = vec![];
// The picture in the colors `params` asks for, or in one color per clean level when
// `levels` is given; fewer come back when it has fewer, or when noise made several of
// one (see `merge_mixed`). Also whether `merge_mixed` merged any.
let mut reduce = |levels: Option<usize>| {
rare.clear();
let mut centers = match levels {
Some(n) => flat_palette(from, n),
None => color_palette(from, params),
};
// The anti-aliasing beside a rare color along the cut edge, with the indexes of
// that color and of the color on the other side of it (see `rare_colours`).
let mut traced_as: Vec<TracedAs> = vec![];
if flat_auto {
let (found, blends) = rare_colours(img, &own_choosing, &choose, &hk, ¢ers);
if !found.is_empty() {
let common = centers.len();
traced_as = blends;
centers.extend(found);
centers = refine_around(from, centers, common);
rare = centers.iter().skip(common).map(|c| c.map(|v| v.round().clamp(0.0, 255.0) as u8)).collect();
}
}
let mut lut = vec![0u16; 1 << 15];
let center_labs = labs(¢ers.iter().copied().chain(traced_as.iter().map(|t| t.0)).collect::<Vec<_>>());
let library = params.palette == Palette::DocumentLibrary && !params.swatches.is_empty();
let nearest = if library { nearest_library } else { nearest_lab };
// Every opaque pixel takes a color, the cut edge's too. A bin takes the color
// nearest to the mean of the pixels in it that choose the colors, and a bin with
// none of them the color nearest to the mean of all its pixels. A bin nearest to
// the anti-aliasing beside a rare color takes that rare color when it is at least
// halfway from the color on the other side to it, and that color otherwise.
for (i, c, _) in all.iter().chain(&every) {
let n = nearest(¢er_labs, oklab(*c));
lut[*i] = n.checked_sub(centers.len()).and_then(|t| traced_as.get(t)).map_or(n, |&(_, rare, other)| {
let (Some(r), Some(o)) = (centers.get(rare), centers.get(other)) else { return rare };
let d2: f64 = (0..3).map(|q| (r[q] - o[q]).powi(2)).sum();
let t = if d2 > 0.0 { (0..3).map(|q| (c[q] - o[q]) * (r[q] - o[q])).sum::<f64>() / d2 } else { 1.0 };
if t >= 0.5 { rare } else { other }
}) as u16;
}
let labels =
img.rgba.as_chunks::<4>().0.iter().map(|p| if p[3] < 128 { TRANSPARENT } else { lut[hk.key(p[0], p[1], p[2])] }).collect();
let palette = centers.iter().map(|c| [c[0].round() as u8, c[1].round() as u8, c[2].round() as u8]).collect();
let q = compact(labels, palette);
// A swatch library's colours are used as they are. Full Tone's colors merge only when
// they look alike (see `Alike`).
if library {
return (q, false);
}
let alike = if params.palette == Palette::FullTone { Alike::Seen } else { Alike::Rgb };
let before = q.palette.len();
let q = merge_mixed(q, img.width as usize, img.height as usize, &rare, alike);
let merged = q.palette.len() < before;
(q, merged)
};
// Clean levels (see `flat_count`) each take a color unless `merge_mixed` finds two of
// them mixed (dithering, or a thin region of a level beside a close one): such a
// picture takes the colors median cut counts, with rare colors added.
let q = match flat {
Some((_, Some(levels))) => match reduce(Some(levels)) {
(q, false) => q,
(_, true) => reduce(None).0,
},
_ => reduce(None).0,
};
let q = if settles_wide(params) { settled_wide(q, img, &own, false) } else { settled(q, img, &own) };
rare.retain(|c| q.palette.contains(c));
(q, rare)
}
}
}
/// The opaque pixels whose colour is the picture's own, not a blend: a pixel is a blend when it
/// lies between the two pixels on opposite sides of it (left and right, above and below, or
/// across a diagonal) that differ by more than 20 levels, which is what anti-aliasing and blur
/// leave along an edge. A line one pixel wide is no blend (the pixels on its two sides are alike),
/// nor is noise.
fn own_colours(img: &Raster) -> Vec<bool> {
let opaque: Vec<bool> = img.rgba.as_chunks::<4>().0.iter().map(|p| p[3] >= 128).collect();
own_colours_among(img, &opaque)
}
/// [`own_colours`] among the pixels that `among` marks: the others are neither own colours nor
/// the neighbours a pixel is a blend of.
fn own_colours_among(img: &Raster, among: &[bool]) -> Vec<bool> {
own_colours_among_by(img, among, PIXELS_PER_SHARE)
}
/// [`own_colours_among`], with the rows worked on in bands of about `per_share` pixels (see [`over_rows`]).
fn own_colours_among_by(img: &Raster, among: &[bool], per_share: usize) -> Vec<bool> {
let (w, h) = (img.width as isize, img.height as isize);
let px = img.rgba.as_chunks::<4>().0;
let at = |x: isize, y: isize| {
let i = (x >= 0 && y >= 0 && x < w && y < h).then_some((y * w + x) as usize)?;
let p = px.get(i).filter(|_| among.get(i).copied().unwrap_or(false))?;
Some([f64::from(p[0]), f64::from(p[1]), f64::from(p[2])])
};
over_rows(img.width as usize, img.height as usize, per_share, |rows| {
let mut out = Vec::with_capacity(rows.len() * img.width as usize);
for y in rows.start as isize..rows.end as isize {
for x in 0..w {
let Some(p) = at(x, y) else {
out.push(false);
continue;
};
let blend = [(1, 0), (0, 1), (1, 1), (1, -1)].into_iter().any(|(dx, dy)| {
let (Some(a), Some(b)) = (at(x - dx, y - dy), at(x + dx, y + dy)) else { return false };
let d = [0, 1, 2].map(|k| b[k] - a[k]);
let len2: f64 = d.iter().map(|v| v * v).sum();
if len2 <= 400.0 {
return false;
}
let t = (0..3).map(|k| (p[k] - a[k]) * d[k]).sum::<f64>() / len2;
let off2: f64 = (0..3).map(|k| (p[k] - a[k] - t * d[k]).powi(2)).sum();
t > 0.06 && t < 0.94 && off2 < len2 / 16.0
});
out.push(!blend);
}
}
out
})
}
/// About how many pixels one thread works through at a time in the passes over every pixel that
/// [`over_rows`] spreads over the available cores. A picture of fewer pixels is worked through on
/// one thread.
const PIXELS_PER_SHARE: usize = 1 << 16;
/// `f` of each band of rows of a picture `w` pixels wide and `h` rows high, each band about
/// `per_share` pixels (at least one row), spread over the available cores (one thread on the web),
/// and the results joined in row order. Each band's result depends only on its rows, so the
/// joined result is the same however many threads there are. A picture with no pixels gives no
/// result.
fn over_rows<R: Send>(w: usize, h: usize, per_share: usize, f: impl Fn(std::ops::Range<usize>) -> Vec<R> + Sync) -> Vec<R> {
if w == 0 || h == 0 {
return Vec::new();
}
let rows = (per_share / w.max(1)).max(1);
let bands: Vec<std::ops::Range<usize>> = (0..h).step_by(rows).map(|y| y..(y + rows).min(h)).collect();
if bands.len() <= 1 {
return bands.into_iter().flat_map(&f).collect();
}
parallel_map(&bands, |rows| f(rows.clone())).into_iter().flatten().collect()
}
/// Whether the palette is made from the picture's own colours alone (`own` of `all` opaque
/// pixels), so that the blends along edges take none of its colours. A picture with next to none
/// is all soft edges: there every pixel counts.
fn palette_from_own(own: f64, all: f64) -> bool {
own >= 0.05 * all && own >= 16.0
}
/// sRGB (0–255) to Oklab × 100 (Björn Ottosson, "A perceptual color space for image processing",
/// 2020): equal distances look equally different, and 2 or 3 is about the least one sees.
fn oklab(c: [f64; 3]) -> [f64; 3] {
let lin = c.map(|v| {
let v = (v / 255.0).clamp(0.0, 1.0);
if v <= 0.04045 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
});
let l = (0.412_221_470_8 * lin[0] + 0.536_332_536_3 * lin[1] + 0.051_445_992_9 * lin[2]).cbrt();
let m = (0.211_903_498_2 * lin[0] + 0.680_699_545_1 * lin[1] + 0.107_396_956_6 * lin[2]).cbrt();
let s = (0.088_302_461_9 * lin[0] + 0.281_718_837_6 * lin[1] + 0.629_978_700_5 * lin[2]).cbrt();
[
100.0 * (0.210_454_255_3 * l + 0.793_617_785 * m - 0.004_072_046_8 * s),
100.0 * (1.977_998_495_1 * l - 2.428_592_205 * m + 0.450_593_709_9 * s),
100.0 * (0.025_904_037_1 * l + 0.782_771_766_2 * m - 0.808_675_766 * s),
]
}
/// [`oklab`] of each palette color.
pub(crate) fn palette_labs(palette: &[[u8; 3]]) -> Vec<[f64; 3]> {
palette.iter().map(|c| oklab(c.map(f64::from))).collect()
}
/// [`oklab`] of an sRGB colour, for the tests.
#[cfg(test)]
pub(crate) fn tests_oklab(c: [u8; 3]) -> [f64; 3] {
oklab(c.map(f64::from))
}
/// Which colors [`merge_mixed`] takes for one color that noise split.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Alike {
/// Close in RGB: under 30 levels apart and thoroughly mixed, or under 12 and mixed in patches.
/// Used for Grayscale and for every Color palette but Full Tone (Automatic included).
Rgb,
/// Close to the eye: under [`FULL_TONE_ALIKE`] apart in Oklab and thoroughly mixed, or under
/// [`FULL_TONE_PATCHES`] and mixed in patches (compression blocks). Full Tone's neighboring tones
/// of a smooth photo are about as close in RGB as noise makes one color, and mixed along their
/// soft border, so the RGB test would take most of them for one color.
Seen,
}
/// How far apart (Oklab × 100) two thoroughly mixed Full Tone colors may lie and still be merged
/// as one color that noise split: a little more than the least difference one sees (see [`oklab`]).
const FULL_TONE_ALIKE: f64 = 5.0;
/// How far apart (Oklab × 100) two Full Tone colors mixed in patches may lie and still be merged:
/// the blocks of one flat color that compression shifted by a few levels each.
const FULL_TONE_PATCHES: f64 = 1.5;
/// `q` with the colours that noise made of one colour merged, largest mix first.
///
/// Asked for more colours than a picture has, k-means splits a flat colour along its noise, and
/// the two halves would trace as specks of one all over the other. Such halves are close and
/// thoroughly mixed: the pixels of the lesser one have, on average, more than half a neighbour of
/// the other each; or they are closer still and mixed in patches (compression blocks). The bands
/// of a gradient are close too, but each keeps to itself and they stay apart. The colours in
/// `keep` merge with none. Close is under 30 RGB levels apart for thoroughly mixed colours and
/// under 12 for patches with [`Alike::Rgb`], and in Oklab under [`FULL_TONE_ALIKE`] and
/// [`FULL_TONE_PATCHES`] with [`Alike::Seen`].
fn merge_mixed(q: Quantized, w: usize, h: usize, keep: &[[u8; 3]], alike: Alike) -> Quantized {
let k = q.palette.len();
// A rare colour kept on purpose (see `rare_colours`) is distinct by choice: it merges with none.
let kept: Vec<bool> = q.palette.iter().map(|c| keep.contains(c)).collect();
if k < 2 || q.labels.len() != w * h {
return q;
}
// How many pixels each colour has, and how many neighbouring pairs each pair of colours.
let mut count = vec![0.0f64; k];
let mut touch = vec![0.0f64; k * k];
let label = |i: usize| q.labels.get(i).map(|&l| l as usize).filter(|&l| l < k);
for i in 0..w * h {
let Some(a) = label(i) else { continue };
count[a] += 1.0;
for j in [(i % w + 1 < w).then_some(i + 1), (i + w < w * h).then_some(i + w)].into_iter().flatten() {
if let Some(b) = label(j).filter(|&b| b != a) {
touch[a * k + b] += 1.0;
touch[b * k + a] += 1.0;
}
}
}
let mut color: Vec<[f64; 3]> = q.palette.iter().map(|c| c.map(f64::from)).collect();
// Each colour in Oklab, for `Alike::Seen`, worked out once and again only for a colour that
// takes in another.
let mut lab: Vec<[f64; 3]> = if alike == Alike::Seen { color.iter().map(|&c| oklab(c)).collect() } else { vec![] };
let seen_apart = |lab: &[[f64; 3]], a: usize, b: usize| match (lab.get(a), lab.get(b)) {
(Some(la), Some(lb)) => (0..3).map(|c| (la[c] - lb[c]).powi(2)).sum::<f64>().sqrt(),
_ => f64::INFINITY,
};
// Which colour each has merged into (itself when none).
let mut into: Vec<usize> = (0..k).collect();
loop {
let mut best: Option<(f64, usize, usize)> = None;
for a in 0..k {
for b in a + 1..k {
if into[a] != a || into[b] != b || count[a] <= 0.0 || count[b] <= 0.0 || kept[a] || kept[b] {
continue;
}
let mixed = touch[a * k + b] / count[a].min(count[b]);
// Two colours this little mixed merge under neither test.
if mixed <= 0.15 {
continue;
}
let merges = match alike {
Alike::Rgb => {
let apart = (0..3).map(|c| (color[a][c] - color[b][c]).powi(2)).sum::<f64>().sqrt();
mixed > 0.5 && apart < 30.0 || apart < 12.0
}
Alike::Seen => {
let apart = seen_apart(&lab, a, b);
mixed > 0.5 && apart < FULL_TONE_ALIKE || apart < FULL_TONE_PATCHES
}
};
if merges && best.is_none_or(|x| mixed > x.0) {
best = Some((mixed, a, b));
}
}
}
let Some((_, a, b)) = best else { break };
color[a] = [0, 1, 2].map(|c| (color[a][c] * count[a] + color[b][c] * count[b]) / (count[a] + count[b]));
if let Some(l) = lab.get_mut(a) {
*l = oklab(color[a]);
}
count[a] += count[b];
count[b] = 0.0;
into[b] = a;
for c in 0..k {
if c != a && c != b {
touch[a * k + c] += touch[b * k + c];
touch[c * k + a] = touch[a * k + c];
}
}
}
if into.iter().enumerate().all(|(i, &t)| i == t) {
return q;
}
// A colour may have merged into one that merged again: follow each to where it ended up.
for i in 0..k {
let mut to = into[i];
while into[to] != to {
to = into[to];
}
into[i] = to;
}
let labels = q.labels.iter().map(|&l| into.get(l as usize).map_or(l, |&t| t as u16)).collect();
compact(labels, color.iter().map(|c| [c[0].round() as u8, c[1].round() as u8, c[2].round() as u8]).collect())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn blend_pixels_are_found_the_same_however_the_picture_is_shared_out() {
// Slanted stripes of red and blue, blended over three pixels at each edge, with a little
// noise and a band of half-transparent pixels along the bottom. Odd sizes, so that the last
// band of rows is short.
let (w, h) = (173u32, 97u32);
let (red, blue) = ([200.0, 30.0, 40.0], [20.0, 60.0, 180.0]);
let img = Raster::from_fn(w, h, |x, y| {
let s = (x + y / 2) % 24;
let t = f64::from(s.saturating_sub(9).min(3)) / 3.0 - f64::from(s.saturating_sub(21).min(3)) / 3.0;
let noise = f64::from((x * 7 + y * 13) % 5) - 2.0;
let c = [0, 1, 2].map(|k| (red[k] + t * (blue[k] - red[k]) + noise).clamp(0.0, 255.0) as u8);
[c[0], c[1], c[2], if y + 2 >= h { 160 } else { 255 }]
});
let all = w as usize * h as usize;
let opaque: Vec<bool> = img.rgba.as_chunks::<4>().0.iter().map(|p| p[3] >= 128).collect();
// One row per share, a few rows per share, and the whole picture as one.
let own: Vec<Vec<bool>> = [1, 3 * w as usize + 5, all].iter().map(|&s| own_colours_among_by(&img, &opaque, s)).collect();
assert_eq!(own[0].len(), all);
assert!(own[0].iter().any(|&o| !o), "the edges have blend pixels");
assert!(own.iter().all(|o| *o == own[0]));
}
#[test]
fn full_tone_merges_only_mixed_colors_that_look_alike() {
// Two colors in a checkerboard: every pixel has four neighbors of the other color.
let mixed =
|a: [u8; 3], b: [u8; 3]| Quantized { labels: (0..16 * 16).map(|i| ((i % 16 + i / 16) % 2) as u16).collect(), palette: vec![a, b] };
let colors = |q: Quantized, alike: Alike| merge_mixed(q, 16, 16, &[], alike).palette.len();
// Gray and a greener gray, 22 levels apart (about 6.4 in Oklab): one color in RGB, two that look different.
let (gray, green) = ([128, 128, 128], [128, 150, 128]);
assert_eq!(colors(mixed(gray, green), Alike::Rgb), 1);
assert_eq!(colors(mixed(gray, green), Alike::Seen), 2);
// Two grays 3 levels apart (about 1 in Oklab): one color either way.
assert_eq!(colors(mixed(gray, [131; 3]), Alike::Rgb), 1);
assert_eq!(colors(mixed(gray, [131; 3]), Alike::Seen), 1);
// Side by side, not mixed: two colors either way.
let halves = Quantized { labels: (0..16 * 16).map(|i| u16::from(i % 16 >= 8)).collect(), palette: vec![[128; 3], [131; 3]] };
assert_eq!(colors(halves.clone(), Alike::Rgb), 2);
assert_eq!(colors(halves, Alike::Seen), 2);
// In 8 × 8 blocks, mixed in patches: grays 3 levels apart merge either way; grays 6 levels
// apart (about 10 in RGB, more than 1.5 in Oklab) merge only in RGB.
let blocks =
|b: [u8; 3]| Quantized { labels: (0..16 * 16).map(|i| ((i % 16 / 8 + i / 16 / 8) % 2) as u16).collect(), palette: vec![gray, b] };
assert_eq!(colors(blocks([131; 3]), Alike::Rgb), 1);
assert_eq!(colors(blocks([131; 3]), Alike::Seen), 1);
assert_eq!(colors(blocks([134; 3]), Alike::Rgb), 1);
assert_eq!(colors(blocks([134; 3]), Alike::Seen), 2);
}
#[test]
fn a_picture_with_no_pixels_is_not_shared_out() {
// No band for each of the rows of a picture with no columns, however many rows it has.
assert!(over_rows(0, usize::MAX, PIXELS_PER_SHARE, |_| vec![0u8]).is_empty());
assert!(over_rows(5, 0, PIXELS_PER_SHARE, |_| vec![0u8]).is_empty());
let img = Raster::new(0, u32::MAX, vec![]).unwrap();
assert!(own_colours_among(&img, &[]).is_empty());
}
}
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.