Magic Wand: Anti-alias keeps the region whole and softens only near-matching neighbours (#11776)

This commit is contained in:
Hector Villarreal committed 2026-11-07 12:00:07 -06:00
1 parent b9e8859f89
commit e25be5e77b
3 files changed
+174 -47

No files matched your search

+43 -46
View File
@@ -219,11 +219,44 @@ pub fn magic_wand(px: &[[f32; 4]], area: Rect, seed: (i32, i32), tolerance: f32,
}
}
if anti_alias {
antialias(&mut m, w, h);
let tol = (tolerance + 1e-3).floor().max(0.0);
let src = m.clone();
for (i, v) in m.iter_mut().enumerate() {
if src[i] == 0.0 && touches_region(i % w, i / w, w, h, |x, y| src[y * w + x] > 0.0) {
let p = px[i];
let over = (0..3).map(|c| (p[c] - target[c]).abs() * 255.0).fold(0.0f32, f32::max) - tol;
*v = f32::from(fringe_coverage(over, p[3].min(target[3]) * 255.0)) / 255.0;
}
}
}
m
}
/// How many levels past the tolerance the anti-aliased fringe fades over, from fully selected to
/// nothing. Measured in the reference application (#11776): 3 levels past gives 251, 5 gives
/// 249 and 123 gives 110; a straight fade to zero at 216 levels gives all three.
const FRINGE_LEVELS: f32 = 216.0;
/// Coverage (0–255) of an anti-aliased fringe pixel: a neighbour of the region whose most
/// different colour channel is `over` levels past the tolerance, and `alpha` (0–255) the lower
/// of its and the clicked pixel's opacity. Photoshop keeps the region itself fully selected and
/// softens only the pixels just outside it, fading with the distance past the tolerance; a
/// neighbour without colour (transparent, next to a shape on its own layer) gets none.
fn fringe_coverage(over: f32, alpha: f32) -> u8 {
let k = (1.0 - over.max(0.0) / FRINGE_LEVELS).clamp(0.0, 1.0) * (alpha / 255.0).clamp(0.0, 1.0);
(k * 255.0).round() as u8
}
/// True when one of the 8 neighbours of `(x, y)` (inside a `w` x `h` area) is in the region.
fn touches_region(x: usize, y: usize, w: usize, h: usize, selected: impl Fn(usize, usize) -> bool) -> bool {
(-1i32..=1).any(|dy| {
(-1i32..=1).any(|dx| {
let (nx, ny) = (x as i32 + dx, y as i32 + dy);
(dx, dy) != (0, 0) && nx >= 0 && ny >= 0 && (nx as usize) < w && (ny as usize) < h && selected(nx as usize, ny as usize)
})
})
}
/// Straight RGBA8 copy of `area` of a surface, read in parallel bands on native.
pub fn rgba8_image(s: &Surface, area: Rect) -> Vec<[u8; 4]> {
let (w, h) = (area.width() as usize, area.height() as usize);
@@ -356,25 +389,12 @@ pub fn wand_region(img: &[[u8; 4]], area: Rect, seed: (i32, i32), tolerance: f32
let x = x0 + xx;
let v = at(x, y);
*o = v;
if !anti_alias {
continue;
}
// Same rule as `antialias`: edge pixels blend with their 3×3 neighbourhood; neighbours
// outside the area count as the pixel itself.
let mut sum = 0u32;
let mut edge = false;
for dy in -1i32..=1 {
for dx in -1i32..=1 {
let (nx, ny) = (x as i32 + dx, y as i32 + dy);
let n = if nx < 0 || ny < 0 || nx >= w as i32 || ny >= h as i32 { v } else { at(nx as usize, ny as usize) };
edge |= n != v;
sum += n as u32;
}
}
if edge {
let avg = sum as f32 / (9.0 * 255.0);
let f = if v > 127 { 0.5 + 0.5 * avg } else { 0.5 * avg };
*o = (f * 255.0).round() as u8;
// Same rule as `magic_wand`: the region stays fully selected; a pixel just outside
// it gets a fringe by how far its colour is past the tolerance.
if anti_alias && v == 0 && touches_region(x, y, w, h, |nx, ny| at(nx, ny) != 0) {
let p = img[y * w + x];
let d = (0..3).map(|c| (p[c] as i32 - target[c] as i32).abs()).max().unwrap_or(0);
*o = fringe_coverage((d - tol) as f32, f32::from(p[3].min(target[3])));
}
}
};
@@ -435,32 +455,6 @@ pub fn combine_region(old: Option<&Surface>, new: Option<&Region>, mode: Selecti
}
}
/// Softens hard mask edges: edge pixels become the 3×3 average.
fn antialias(m: &mut [f32], w: usize, h: usize) {
let src = m.to_vec();
for y in 0..h {
for x in 0..w {
let i = y * w + x;
let mut sum = 0.0;
let mut cnt = 0.0;
let mut edge = false;
for dy in -1i32..=1 {
for dx in -1i32..=1 {
let (xx, yy) = (x as i32 + dx, y as i32 + dy);
let v = if xx < 0 || yy < 0 || xx >= w as i32 || yy >= h as i32 { src[i] } else { src[yy as usize * w + xx as usize] };
edge |= v != src[i];
sum += v;
cnt += 1.0;
}
}
if edge {
// Keep selected pixels mostly selected, add a soft fringe.
m[i] = if src[i] > 0.5 { 0.5 + 0.5 * sum / cnt } else { 0.5 * sum / cnt };
}
}
}
}
/// Colour Range: coverage falls off linearly with the per-channel colour
/// distance; `fuzziness` in levels (0–200).
pub fn color_range(px: &[[f32; 4]], color: [f32; 3], fuzziness: f32) -> Vec<f32> {
@@ -780,10 +774,13 @@ pub fn tone_range(px: &[[f32; 4]], lo: f32, hi: f32, falloff: f32) -> Vec<f32> {
mod distance;
#[cfg(test)]
mod ellipse_aa_edge_tests;
mod inverse;
mod lasso;
mod marquee;
mod morphology;
#[cfg(test)]
mod wand_antialias_tests;
pub use distance::edt;
pub use inverse::inverse_surface;
+3 -1
View File
@@ -106,7 +106,9 @@ fn wand_contiguous_vs_global() {
let g = magic_wand(&px, a, (3, 3), 10.0, false, false);
assert_eq!(g.iter().filter(|v| **v > 0.0).count(), 80);
let aa = magic_wand(&px, a, (3, 3), 10.0, true, true);
assert!(aa[3 * 20 + 6] > 0.0 && aa[3 * 20 + 6] < 1.0);
// #11776: anti-aliasing keeps the region whole and adds no fringe next to a colour this far
// past the tolerance (white is 245 levels from red, beyond the fringe's fade).
assert_eq!((aa[3 * 20 + 5], aa[3 * 20 + 6]), (1.0, 0.0));
assert!(magic_wand(&px, a, (50, 3), 10.0, true, false).iter().all(|v| *v == 0.0));
}
@@ -0,0 +1,128 @@
//! The Magic Wand's Anti-alias against the reference measurement (#11776): the region itself
//! stays fully selected, and a one-pixel soft fringe lies only outside it, next to colours just
//! past the tolerance. Document 800 x 600: a solid red rectangle 100,100–300,250 on a transparent
//! layer, and a grey ramp of ten 40 px blocks (grey 100, 105, …, 145) from x 100 at y 350–450,
//! on its own transparent layer or composited on white (Sample All Layers).
use photocraft_geom::Rect;
use super::{Region, magic_wand, wand_region};
const AREA: Rect = Rect { x0: 0, y0: 0, x1: 800, y1: 600 };
const W: usize = 800;
const H: usize = 600;
fn red_rectangle() -> Vec<[u8; 4]> {
let mut img = vec![[0u8; 4]; W * H];
for y in 100..250 {
for x in 100..300 {
img[y * W + x] = [220, 30, 30, 255];
}
}
img
}
/// The grey ramp at y 350–450 on a transparent layer, or on white when `on_white`.
fn ramp(on_white: bool) -> Vec<[u8; 4]> {
let mut img = vec![if on_white { [255u8; 4] } else { [0u8; 4] }; W * H];
for y in 350..450 {
for b in 0..10u8 {
let g = 100 + 5 * b;
for x in 100 + 40 * b as usize..140 + 40 * b as usize {
img[y * W + x] = [g, g, g, 255];
}
}
}
img
}
/// (bounds of every touched pixel, fully selected count, partly selected count).
fn stats(r: &Region) -> (Rect, usize, usize) {
let (mut x0, mut y0, mut x1, mut y1) = (i32::MAX, i32::MAX, i32::MIN, i32::MIN);
let (mut full, mut part) = (0, 0);
for y in r.bbox.y0..r.bbox.y1 {
for x in r.bbox.x0..r.bbox.x1 {
let v = (r.at(x, y) * 255.0).round() as u8;
if v == 0 {
continue;
}
(x0, y0, x1, y1) = (x0.min(x), y0.min(y), x1.max(x + 1), y1.max(y + 1));
if v == 255 { full += 1 } else { part += 1 }
}
}
(Rect::new(x0, y0, x1, y1), full, part)
}
fn coverage(r: &Region, x: i32, y: i32) -> u8 {
(r.at(x, y) * 255.0).round() as u8
}
#[test]
fn a_shape_next_to_a_clearly_different_colour_gets_no_fringe() {
let img = red_rectangle();
for aa in [true, false] {
let r = wand_region(&img, AREA, (150, 150), 32.0, true, aa).unwrap();
assert_eq!(stats(&r), (Rect::new(100, 100, 300, 250), 30000, 0), "anti-alias {aa}");
}
}
#[test]
fn the_grey_ramp_gets_one_nearly_selected_column_past_the_tolerance() {
let img = ramp(false);
// Tolerance 32 from grey 100: blocks 100 to 130 (x 100–380) fully selected; the 135 block
// is 3 levels past it, so its first column is nearly selected.
let r = wand_region(&img, AREA, (110, 400), 32.0, true, true).unwrap();
let (bounds, full, part) = stats(&r);
assert_eq!((full, part), (280 * 100, 100), "{bounds:?}");
assert_eq!(bounds, Rect::new(100, 350, 381, 450));
for y in [350, 400, 449] {
assert_eq!(coverage(&r, 379, y), 255, "the region's last column stays fully selected");
assert_eq!(coverage(&r, 380, y), 251, "one fringe column of the next block, as measured");
assert_eq!(coverage(&r, 381, y), 0, "only one column");
}
// Transparent pixels above and below the ramp have no colour: no fringe there.
assert_eq!(coverage(&r, 200, 349), 0);
assert_eq!(coverage(&r, 200, 450), 0);
// Tolerance 10: x 100–220 plus one partly selected column of the 115 block.
let r = wand_region(&img, AREA, (110, 400), 10.0, true, true).unwrap();
let (bounds, full, part) = stats(&r);
assert_eq!((bounds, full, part), (Rect::new(100, 350, 221, 450), 120 * 100, 100));
assert_eq!(coverage(&r, 220, 400), 249, "5 levels past tolerance 10, as measured");
}
#[test]
fn anti_alias_off_has_no_partly_selected_pixels() {
let img = ramp(false);
let r = wand_region(&img, AREA, (110, 400), 32.0, true, false).unwrap();
assert_eq!(stats(&r), (Rect::new(100, 350, 380, 450), 28000, 0));
}
#[test]
fn the_8_bit_and_f32_wands_draw_the_same_fringe() {
let img = ramp(false);
let f: Vec<[f32; 4]> = img.iter().map(|p| p.map(|v| f32::from(v) / 255.0)).collect();
for (tol, contiguous) in [(32.0, true), (10.0, true), (32.0, false)] {
let r = wand_region(&img, AREA, (110, 400), tol, contiguous, true).unwrap();
let m = magic_wand(&f, AREA, (110, 400), tol, contiguous, true);
for y in 340..460 {
for x in 90..520 {
let want = (m[y as usize * W + x as usize] * 255.0).round() as u8;
assert_eq!(coverage(&r, x, y), want, "tolerance {tol}, contiguous {contiguous} at {x},{y}");
}
}
}
}
#[test]
fn on_the_composite_the_white_around_the_ramp_gets_the_measured_fringe() {
// Sample All Layers: the ramp on white. White is 155 levels from grey 100, 123 past
// tolerance 32; the reference application's fringe there reads 110 (Photoshop 2025, the
// same points; the issue reports 131–177 around the ramp).
let img = ramp(true);
let r = wand_region(&img, AREA, (110, 400), 32.0, true, true).unwrap();
for (x, y) in [(200, 349), (200, 450), (99, 400), (99, 349)] {
assert_eq!(coverage(&r, x, y), 110, "{x},{y}");
}
assert_eq!(coverage(&r, 380, 400), 251, "the near-miss block still gets the stronger fringe");
assert_eq!(coverage(&r, 200, 400), 255, "inside stays fully selected");
}