Image Trace: Noise merges a dark speck into the line beside it, not the ground

A region below Noise joined the color it shares the longest border with, so
the specks of a thin dark line on a light ground joined the ground and the
line broke into dashes. When that color is 10 or more apart from the region's
own (Oklab x 100), the region now joins the neighboring color nearest its
source pixels, among the colors sharing at least a tenth of the longest
border. A single pixel tied between colors still joins by border.

6 Colors and 16 Colors move from Noise 15 to 8, and Black and White Logo from
25 to 5.
This commit is contained in:
dotCooCoo
2026-11-15 07:20:42 -08:00
parent ea3f81d9c3
commit 1727c171ef
10 changed files with 314 additions and 28 deletions
+241 -10
View File
@@ -8,16 +8,49 @@ pub fn denoise(labels: &mut [u16], w: usize, h: usize, min_area: usize) {
denoise_keeping(labels, w, h, min_area, &[]);
}
/// How far apart (Oklab × 100) a small region's color and the color it shares the longest
/// border with must be before it merges into the color beside it that is nearest its source
/// pixels instead (among those with at least [`NEAREST_BORDER`] of the longest border): a dark
/// speck on the edge of a light area joins the dark outline beside it, not the light area.
pub(crate) const NEAREST_APART: f64 = 10.0;
/// See [`NEAREST_APART`].
pub(crate) const NEAREST_BORDER: f64 = 0.1;
/// The fewest pixels a region needs for [`NEAREST_APART`] to apply when two or more colors tie
/// for its longest border. Such a lone pixel merges by border alone: on an anti-aliased corner it
/// holds a mix of the colors on both sides, and joining the nearer one can cut the corner off a
/// shape.
pub(crate) const NEAREST_PIXELS: u32 = 2;
/// The colors [`denoise_nearest`] compares a small region with.
pub(crate) struct Source<'a> {
/// Each label's color in Oklab × 100 ([`super::palette_labs`]).
pub labs: &'a [[f64; 3]],
/// The image the labels were made from, 4 bytes a pixel.
pub rgba: &'a [u8],
/// Whether the labels are grays (Grayscale, Black and White): the source pixels are compared as their gray.
pub gray: bool,
}
/// [`denoise`], except that a region of a label `keep` marks (a rare colour kept on purpose, see
/// [`rare_colours`]) that is at least [`RARE_ISLAND`] pixels stays whatever `min_area` is: Noise
/// clears specks, not a colour's only regions. Smaller regions of it go as any other.
pub(crate) fn denoise_keeping(labels: &mut [u16], w: usize, h: usize, min_area: usize, keep: &[bool]) {
denoise_nearest(labels, w, h, min_area, keep, None);
}
/// [`denoise_keeping`]; with `source`, a region below `min_area` whose color is at least
/// [`NEAREST_APART`] from the color it shares the longest border with merges into the color
/// beside it nearest its source pixels, averaged, among those sharing at least [`NEAREST_BORDER`]
/// of the longest border ([`NEAREST_PIXELS`] limits this for a single pixel). Every region below
/// `min_area` still goes.
pub(crate) fn denoise_nearest(labels: &mut [u16], w: usize, h: usize, min_area: usize, keep: &[bool], source: Option<&Source>) {
use std::cmp::Reverse;
use std::collections::BinaryHeap;
// Every index below is a `u32`, so a pixel costs 8 bytes and a region 18 instead of a `Vec<usize>` per region. An image
// of `u32::MAX` pixels or more (far above the decoder's cap) is left as it is.
const NONE: u32 = u32::MAX;
if min_area <= 1 || w == 0 || h == 0 || w.checked_mul(h) != Some(labels.len()) || labels.len() >= NONE as usize {
return;
}
@@ -66,14 +99,8 @@ pub(crate) fn denoise_keeping(labels: &mut [u16], w: usize, h: usize, min_area:
colour.push(label);
parent.push(id);
}
fn find(parent: &mut [u32], mut a: u32) -> u32 {
while parent[a as usize] != a {
let up = parent[parent[a as usize] as usize];
parent[a as usize] = up;
a = up;
}
a
}
// Only when it can be read: the labels' colors and the source pixels must cover every label and every pixel.
let source = source.filter(|s| colour.iter().all(|&c| (c as usize) < s.labs.len()) && labels.len().checked_mul(4) == Some(s.rgba.len()));
// Only regions below `min_area` are ever taken from the queue; a larger one ends the loop.
let mut pending: BinaryHeap<_> =
(0..size.len() as u32).filter(|&id| (size[id as usize] as usize) < min_area).map(|id| Reverse((size[id as usize], id))).collect();
@@ -110,9 +137,24 @@ pub(crate) fn denoise_keeping(labels: &mut [u16], w: usize, h: usize, min_area:
by_colour.clear();
by_colour.extend(borders.iter().map(|&(other, border)| (colour[other as usize], border)));
merge_counts(&mut by_colour);
let Some(&(chosen, _)) = by_colour.iter().max_by_key(|(label, border)| (*border, Reverse(*label))) else {
let Some(&(mut chosen, longest)) = by_colour.iter().max_by_key(|(label, border)| (*border, Reverse(*label))) else {
continue; // an opaque island surrounded only by transparency stays intact
};
if let Some(source) = source
&& (area >= NEAREST_PIXELS || by_colour.iter().filter(|&&(_, border)| border == longest).count() == 1)
&& let Some(own) = source.labs.get(colour[id as usize] as usize)
&& distance(own, source.labs.get(chosen as usize)) >= NEAREST_APART
{
let mean = mean_lab(head[id as usize], &next, source);
let to = |c: u16| distance(&mean, source.labs.get(c as usize));
if let Some(&(nearest, _)) = by_colour
.iter()
.filter(|&&(_, border)| border as f64 >= NEAREST_BORDER * longest as f64)
.min_by(|a, b| to(a.0).total_cmp(&to(b.0)).then(b.1.cmp(&a.1)))
{
chosen = nearest;
}
}
// All adjacent regions of the chosen colour become connected by this merge. Absorb
// them together, keeping the largest one as the survivor.
let Some(target) = borders
@@ -143,6 +185,44 @@ pub(crate) fn denoise_keeping(labels: &mut [u16], w: usize, h: usize, min_area:
}
}
/// The end of a pixel list, and the region of a transparent pixel.
const NONE: u32 = u32::MAX;
/// The root of `a` in the union-find `parent`, halving the paths on the way.
fn find(parent: &mut [u32], mut a: u32) -> u32 {
while parent[a as usize] != a {
let up = parent[parent[a as usize] as usize];
parent[a as usize] = up;
a = up;
}
a
}
/// The source pixels of the list that starts at `first` (linked through `next`), averaged, in Oklab × 100.
fn mean_lab(first: u32, next: &[u32], source: &Source) -> [f64; 3] {
let (mut sum, mut n) = ([0.0f64; 3], 0.0f64);
let mut pixel = first;
while pixel != NONE {
if let Some(p) = source.rgba.get(pixel as usize * 4..pixel as usize * 4 + 3) {
for (s, &v) in sum.iter_mut().zip(p) {
*s += f64::from(v);
}
n += 1.0;
}
pixel = next.get(pixel as usize).copied().unwrap_or(NONE);
}
let mut mean = sum.map(|s| s / n.max(1.0));
if source.gray {
mean = [0.299 * mean[0] + 0.587 * mean[1] + 0.114 * mean[2]; 3];
}
super::oklab(mean)
}
/// The distance between two colors in Oklab × 100; infinite when `q` is missing.
fn distance(p: &[f64; 3], q: Option<&[f64; 3]>) -> f64 {
q.map_or(f64::INFINITY, |q| (0..3).map(|k| (p[k] - q[k]).powi(2)).sum::<f64>().sqrt())
}
/// Sort `(key, count)` pairs and add up the counts of equal keys.
fn merge_counts<K: Ord + Copy>(pairs: &mut Vec<(K, usize)>) {
pairs.sort_unstable_by_key(|p| p.0);
@@ -285,6 +365,157 @@ mod tests {
}
}
/// A light ground, a dark ink, a tone barely darker than the ground and a dark brown close to the ink.
const GROUND_INK_TONE_BROWN: [[u8; 3]; 4] = [[235, 225, 210], [30, 25, 20], [228, 218, 203], [50, 42, 35]];
/// `labels` denoised at `min_area`, reading the source image that paints each label its palette color.
fn denoised_nearest(labels: &[u16], w: usize, h: usize, min_area: usize) -> Vec<u16> {
let labs = crate::quantize::palette_labs(&GROUND_INK_TONE_BROWN);
let rgba: Vec<u8> =
labels.iter().flat_map(|&l| GROUND_INK_TONE_BROWN.get(l as usize).copied().unwrap_or([0; 3]).into_iter().chain([255])).collect();
let mut out = labels.to_vec();
denoise_nearest(&mut out, w, h, min_area, &[], Some(&Source { labs: &labs, rgba: &rgba, gray: false }));
out
}
/// A ground with a dark line two pixels wide down column 12 and 13, and a 2 × 2 speck of `speck` at (10, 10) that
/// touches the line on one side and the ground on three.
fn speck_beside_a_line(speck: u16) -> (Vec<u16>, usize, usize) {
let (w, h) = (30, 30);
let mut labels = vec![0u16; w * h];
for y in 0..h {
labels[y * w + 12] = 1;
labels[y * w + 13] = 1;
}
for (x, y) in SPECK {
labels[y * w + x] = speck;
}
(labels, w, h)
}
const SPECK: [(usize, usize); 4] = [(10, 10), (11, 10), (10, 11), (11, 11)];
/// A dark speck mostly on the light ground but touching a dark line joins the line, the color nearest it, not the
/// ground it shares more border with.
#[test]
fn a_dark_speck_beside_a_dark_line_joins_the_line() {
let (labels, w, h) = speck_beside_a_line(3);
let out = denoised_nearest(&labels, w, h, 15);
for (x, y) in SPECK {
assert_eq!(out[y * w + x], 1, "({x}, {y})");
}
let mut blind = labels.clone();
denoise_keeping(&mut blind, w, h, 15, &[]);
assert_eq!(blind[10 * w + 10], 0, "by border alone it joins the ground");
}
/// A speck whose color is close to the color it shares the longest border with joins that color, as before,
/// even though another color touches it.
#[test]
fn a_speck_close_to_its_longest_border_color_joins_it() {
let (labels, w, h) = speck_beside_a_line(2);
let out = denoised_nearest(&labels, w, h, 15);
let mut blind = labels.clone();
denoise_keeping(&mut blind, w, h, 15, &[]);
assert_eq!(out, blind);
assert_eq!(out[10 * w + 10], 0);
}
/// A color that touches the speck along less than a tenth of its longest border is not chosen, however near.
#[test]
fn a_color_with_a_short_border_is_not_chosen() {
let (w, h) = (30, 30);
let mut labels = vec![0u16; w * h];
// A 3 × 3 speck of brown in the ground, and a line of ink 16 pixels long (above Noise) that touches the speck at
// one pixel edge.
for y in 10..13 {
for x in 10..13 {
labels[y * w + x] = 3;
}
}
for x in 13..29 {
labels[10 * w + x] = 1;
}
// The brown speck has 11 pixel edges against the ground and 1 against the ink: 1 < 0.1 × 11.
let out = denoised_nearest(&labels, w, h, 15);
assert_eq!(out[11 * w + 11], 0);
assert!(out[10 * w + 13..10 * w + 29].iter().all(|&l| l == 1), "the line stays");
}
/// A lone pixel tied between two colors for its longest border merges by border alone, even when the other
/// color is nearer its source pixel.
#[test]
fn a_lone_pixel_tied_between_colors_merges_by_border() {
let (w, h) = (20, 20);
// Ground in the top-left, ink everywhere else, and one brown pixel at the corner with two edges on each.
let mut labels: Vec<u16> = (0..w * h).map(|i| u16::from(i % w >= 11 || i / w >= 11)).collect();
labels[10 * w + 10] = 3;
let out = denoised_nearest(&labels, w, h, 5);
let mut blind = labels.clone();
denoise_keeping(&mut blind, w, h, 5, &[]);
assert_eq!(out, blind);
assert_eq!(out[10 * w + 10], 0);
// With the ground one column wider the pixel has three edges on the ground and one on the ink: no longer tied,
// it joins the ink, the color nearest it.
for y in 0..11 {
labels[y * w + 11] = 0;
}
let out = denoised_nearest(&labels, w, h, 5);
assert_eq!(out[10 * w + 10], 1);
}
/// Every region below Noise still goes: the nearest-color merge only changes where it goes.
#[test]
fn noise_still_removes_every_region_below_it() {
let (w, h) = (60, 50);
for seed in 1..6 {
let labels = noisy(w, h, 4, 0, seed);
for min_area in [2, 3, 5, 8, 15, 25] {
let out = denoised_nearest(&labels, w, h, min_area);
let mut seen = vec![false; w * h];
for start in 0..w * h {
if seen[start] {
continue;
}
seen[start] = true;
let mut stack = vec![start];
let mut count = 0;
while let Some(i) = stack.pop() {
count += 1;
let (x, y) = (i % w, i / w);
for j in [(x > 0).then(|| i - 1), (x + 1 < w).then(|| i + 1), (y > 0).then(|| i - w), (y + 1 < h).then(|| i + w)]
.into_iter()
.flatten()
{
if !seen[j] && out[j] == out[i] {
seen[j] = true;
stack.push(j);
}
}
}
assert!(count >= min_area, "seed {seed}, Noise {min_area}: a region of {count} pixels at {start}");
}
}
}
}
/// Without colors or a source image for every label and pixel, every region merges as it always did.
#[test]
fn a_source_that_does_not_cover_the_labels_is_not_read() {
let (labels, w, h) = speck_beside_a_line(3);
let mut blind = labels.clone();
denoise_keeping(&mut blind, w, h, 15, &[]);
let labs = crate::quantize::palette_labs(&GROUND_INK_TONE_BROWN[..2]);
let rgba = vec![0u8; w * h * 4];
let mut out = labels.clone();
denoise_nearest(&mut out, w, h, 15, &[], Some(&Source { labs: &labs, rgba: &rgba, gray: false }));
assert_eq!(out, blind);
let labs = crate::quantize::palette_labs(&GROUND_INK_TONE_BROWN);
let mut out = labels.clone();
denoise_nearest(&mut out, w, h, 15, &[], Some(&Source { labs: &labs, rgba: &rgba[4..], gray: false }));
assert_eq!(out, blind);
}
/// A minimum so large that regions keep merging into big ones.
#[test]
fn compact_denoise_matches_the_reference_with_a_large_min_area() {