mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-18 07:49:26 +00:00
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:
@@ -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() {
|
||||
|
||||
Reference in New Issue
Block a user