VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Image Trace: Flat Logo traces named colors a few levels off at the image's own size
dotCooCoo76c014b732a9
diff --git a/crates/trace/src/logo/pipeline.rs b/crates/trace/src/logo/pipeline.rsindex 97c8e303f..777f1e47c 100644--- a/crates/trace/src/logo/pipeline.rs+++ b/crates/trace/src/logo/pipeline.rs@@ -20,7 +20,7 @@ const FIELD_CELLS_MAX: usize = 6_000_000;const MIN_FLAT: f64 = 0.93;/// Most outlines of one colour (above the noise threshold) we will fit; more is refused, not truncated.const MAX_LOOPS_PER_CLASS: usize = if cfg!(test) { 500 } else { 20_000 };-/// Most pixels `unmix` may have to work on (those that are not exactly one colour). A busier image is+/// Most distinct pixel values `unmix` may have to work on (those that are not exactly one color). A busier image is/// averaged down further first, which bounds the time on pathological input.const EDGE_BUDGET: usize = 150_000;/// Palette colours closer than this (RGB distance) are one colour.diff --git a/crates/trace/src/logo/tests.rs b/crates/trace/src/logo/tests.rsindex 2c712828a..f5e52bdf7 100644--- a/crates/trace/src/logo/tests.rs+++ b/crates/trace/src/logo/tests.rs@@ -244,6 +244,38 @@ fn a_trace_averaged_down_says_the_size_it_worked_at() {assert_eq!(res.worked_at, None);}+#[test]+fn named_colors_a_few_levels_off_trace_an_image_up_to_1024_px_at_full_size() {+ // A light disc in a dark ring with a blue square on it, hard edges, 800 px square, and a dark+ // 2 px dot on the disc at odd pixels: averaged down by 2, the dot would be a quarter of each of+ // four pixels and leave no shape.+ let img = Raster::from_fn(800, 800, |x, y| {+ let (fx, fy) = (f64::from(x) / 5.0, f64::from(y) / 5.0);+ let d = (fx - 80.0).hypot(fy - 80.0);+ if (401..=402).contains(&x) && (201..=202).contains(&y) {+ [4, 4, 3, 255]+ } else if (70.0..=110.0).contains(&fx) && (70.0..=110.0).contains(&fy) {+ [34, 124, 250, 255]+ } else if d <= 60.0 {+ [252, 248, 227, 255]+ } else if d <= 68.0 {+ [4, 4, 3, 255]+ } else {+ [0, 0, 0, 0]+ }+ });+ for (off, names) in [(8, ["#0C0C0B", "#F4F0DB", "#1A74F2"]), (12, ["#10100F", "#F0ECD7", "#1670EE"])] {+ let p = TraceParams { logo_colors: names.iter().map(|s| s.to_string()).collect(), ..logo_params() };+ let res = trace(&img, &p);+ let color_at = |p: Point| res.paths.iter().rev().find(|t| t.path.to_bezpath().winding(p) != 0).map(|t| t.color);+ assert_eq!(res.paths.len(), 4, "names {off} levels off");+ let (dark, cream, blue) = ([4 + off, 4 + off, 3 + off], [252 - off, 248 - off, 227 - off], [34 - off, 124 - off, 250 - off]);+ assert_eq!(color_at(Point::new(402.0, 202.0)), Some(dark), "names {off} levels off");+ assert_eq!(color_at(Point::new(450.0, 450.0)), Some(blue), "names {off} levels off");+ assert_eq!(color_at(Point::new(200.0, 400.0)), Some(cream), "names {off} levels off");+ }+}+/// Every anchor of every path is finite and inside (a small margin around) the image.fn assert_sane(res: &TraceResult, w: u32, h: u32) {for t in &res.paths {diff --git a/crates/trace/src/logo/unmix.rs b/crates/trace/src/logo/unmix.rsindex 16aff8c5b..cdfdfe52f 100644--- a/crates/trace/src/logo/unmix.rs+++ b/crates/trace/src/logo/unmix.rs@@ -5,6 +5,8 @@//! runs, so each pixel is instead explained as a mix of at most three classes, whichever mix//! reproduces the pixel best.+use std::collections::{HashMap, HashSet};+/// Premultiplied RGBA in `0..=1`.pub(crate) type Px = [f32; 4];@@ -88,14 +90,17 @@ fn subsets(classes: &[[f64; 4]]) -> Vec<Subset> {out}-/// How many pixels are not (nearly) exactly one class: the ones `unmix` has to work on.+/// How many distinct pixel values are not (nearly) exactly one class: the ones `unmix` has to work+/// on. A flat area whose color is near but not exactly a class counts once, however large it is.pub(crate) fn count_ambiguous(pix: &[Px], classes: &[[f64; 4]]) -> usize {- pix.iter()- .filter(|px| {- let p = [f64::from(px[0]), f64::from(px[1]), f64::from(px[2]), f64::from(px[3])];- !classes.iter().any(|cv| (0..4).map(|j| (p[j] - cv[j]).powi(2)).sum::<f64>().sqrt() < PURE)- })- .count()+ let mut seen = HashSet::new();+ for px in pix {+ let p = [f64::from(px[0]), f64::from(px[1]), f64::from(px[2]), f64::from(px[3])];+ if !classes.iter().any(|cv| (0..4).map(|j| (p[j] - cv[j]).powi(2)).sum::<f64>().sqrt() < PURE) {+ seen.insert(px.map(f32::to_bits));+ }+ }+ seen.len()}/// Coverage planes, one `width × height` plane per class (each pixel's weights sum to 1).@@ -106,6 +111,9 @@ pub(crate) fn unmix(pix: &[Px], width: usize, height: usize, classes: &[[f64; 4]// Squared error left over by the best mix: large where no mix of the classes explains the pixel.let mut residual = vec![0.0f32; n];let subs = subsets(classes);+ // Each distinct pixel value is mixed once: a flat area that is near but not exactly a class+ // repeats one value.+ let mut mixed: HashMap<[u32; 4], Mix> = HashMap::new();for (i, px) in pix.iter().take(n).enumerate() {let p = [f64::from(px[0]), f64::from(px[1]), f64::from(px[2]), f64::from(px[3])];// Fast path: a pixel that is (nearly) exactly one class.@@ -122,54 +130,64 @@ pub(crate) fn unmix(pix: &[Px], width: usize, height: usize, classes: &[[f64; 4]}continue;}- // Best single class is the starting point; try every two- and three-class mix.- let mut best = (near.0, vec![(near.1, 1.0f64)]);- let mut best_penalty = 0.0;- for s in &subs {- let mut rhs = [0.0f64; 3];- for (j, r) in rhs.iter_mut().enumerate().take(s.n) {- *r = (0..4).map(|c| s.cols[j][c] * p[c]).sum::<f64>() + LAMBDA * LAMBDA;- }- let mut w = [0.0f64; 3];- for (a, wa) in w.iter_mut().enumerate().take(s.n) {- *wa = (0..s.n).map(|b| s.ninv[a * s.n + b] * rhs[b]).sum();- }- if w.iter().take(s.n).any(|&x| x < -0.02) {- continue;- }- let mut sum = 0.0;- for wa in w.iter_mut().take(s.n) {- *wa = wa.clamp(0.0, 1.0);- sum += *wa;- }- if sum < 1e-9 {- continue;- }- for wa in w.iter_mut().take(s.n) {- *wa /= sum;- }- let mut res = s.penalty;- for (c, &pc) in p.iter().enumerate() {- let m: f64 = (0..s.n).map(|j| w[j] * s.cols[j][c]).sum();- res += (pc - m).powi(2);- }- if res < best.0 {- best = (res, (0..s.n).map(|j| (s.idx[j], w[j])).collect());- best_penalty = s.penalty;- }- }+ let (res, weights) = mixed.entry(px.map(f32::to_bits)).or_insert_with(|| best_mix(p, near, &subs));if let Some(r) = residual.get_mut(i) {- *r = (best.0 - best_penalty).max(0.0) as f32;+ *r = *res;}- for (c, wv) in best.1 {+ for &(c, wv) in weights.iter() {if let Some(v) = planes.get_mut(c).and_then(|pl| pl.get_mut(i)) {- *v = wv as f32;+ *v = wv;}}}(planes, residual)}+/// A pixel's mix: the squared error it leaves and each class's weight.+type Mix = (f32, Vec<(usize, f32)>);++/// The mix of at most three classes that reproduces `p` best, starting from the nearest single+/// class `near` (squared distance, class).+fn best_mix(p: [f64; 4], near: (f64, usize), subs: &[Subset]) -> Mix {+ // Best single class is the starting point; try every two- and three-class mix.+ let mut best = (near.0, vec![(near.1, 1.0f64)]);+ let mut best_penalty = 0.0;+ for s in subs {+ let mut rhs = [0.0f64; 3];+ for (j, r) in rhs.iter_mut().enumerate().take(s.n) {+ *r = (0..4).map(|c| s.cols[j][c] * p[c]).sum::<f64>() + LAMBDA * LAMBDA;+ }+ let mut w = [0.0f64; 3];+ for (a, wa) in w.iter_mut().enumerate().take(s.n) {+ *wa = (0..s.n).map(|b| s.ninv[a * s.n + b] * rhs[b]).sum();+ }+ if w.iter().take(s.n).any(|&x| x < -0.02) {+ continue;+ }+ let mut sum = 0.0;+ for wa in w.iter_mut().take(s.n) {+ *wa = wa.clamp(0.0, 1.0);+ sum += *wa;+ }+ if sum < 1e-9 {+ continue;+ }+ for wa in w.iter_mut().take(s.n) {+ *wa /= sum;+ }+ let mut res = s.penalty;+ for (c, &pc) in p.iter().enumerate() {+ let m: f64 = (0..s.n).map(|j| w[j] * s.cols[j][c]).sum();+ res += (pc - m).powi(2);+ }+ if res < best.0 {+ best = (res, (0..s.n).map(|j| (s.idx[j], w[j])).collect());+ best_penalty = s.penalty;+ }+ }+ ((best.0 - best_penalty).max(0.0) as f32, best.1.into_iter().map(|(c, w)| (c, w as f32)).collect())+}+#[cfg(test)]mod tests {use super::*;@@ -211,6 +229,21 @@ mod tests {assert!(res[1] < 1e-3, "an explained blend residual {}", res[1]);}+ #[test]+ fn a_repeated_color_near_a_class_is_counted_once_and_mixed_alike() {+ // A flat area a few levels off red, a blend, and pure red and transparent pixels.+ let off = [0.97, 0.02, 0.02, 1.0];+ let mut pix = vec![off; 1000];+ pix.extend([[0.3, 0.0, 0.7, 1.0], [1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 0.0]]);+ assert_eq!(count_ambiguous(&pix, &classes()), 2);+ let (pl, res) = unmix(&pix, pix.len(), 1, &classes());+ assert!(pl[0][0] > 0.95, "red {}", pl[0][0]);+ for i in 1..1000 {+ assert_eq!((pl[0][i], pl[1][i], pl[2][i], res[i]), (pl[0][0], pl[1][0], pl[2][0], res[0]), "pixel {i}");+ }+ assert!((pl[0][1000] - 0.3).abs() < 0.02 && (pl[1][1000] - 0.7).abs() < 0.02);+ }+#[test]fn weights_sum_to_one() {let pix = vec![[0.2, 0.1, 0.5, 0.8], [0.9, 0.0, 0.05, 0.95]];diff --git a/docs/image-trace-adjustments.md b/docs/image-trace-adjustments.mdindex 60c8b1092..17dbaef28 100644--- a/docs/image-trace-adjustments.md+++ b/docs/image-trace-adjustments.md@@ -39,7 +39,11 @@ page describes the same warning for images over 1500 px). An image of more than192) is traced from a copy scaled down to 64 megapixels, and the trace says that too. Flat Logo traces atmost 1024 pixels on a side: a larger decoded raster is averaged down in whole-number blocks first (a 1025-pixelimage is traced at 513, and a 16,000 × 12,000 image, decoded at 9,459 × 7,094, is traced at 946 × 710), and the trace names both sizes in `warnings`. Flat Logo gives that note in place-of the slower-trace note for an image over 1500 pixels and in place of the 64-megapixel note. A trace that would+of the slower-trace note for an image over 1500 pixels and in place of the 64-megapixel note. An image at most+1024 pixels on a side is traced at its own size, also when the named `logoColors` differ slightly from the+image's colors. Only an image with more than 150,000 different pixel values that are not exactly one traced+color is averaged down further: the factor doubles until at most 150,000 remain or the working copy has at+most 16,384 pixels (at most six times). A trace that wouldmake more than 8,000,000 anchor points (2,000,000 on the web) is refused to protect memory, with advice:raise Noise, lower Paths or Colors, or pick a lower-fidelity preset. A trace keepsabout 90 bytes an anchor; a 4000 × 3000 photo at High Fidelity Photo makes about 1.9 million.