856f865cf98d
gaussian_edge_profile.rs
//! #11528: Gaussian Blur's edge profile on an opaque interior edge, pinned at RGB8 and RGB16 and
//! across the direct command and an action (ATN) replay.
//!
//! The issue measures Photoshop 27.11 against PhotoCraft on a black/white step with no selection,
//! mask, transparency or smart object, so nothing but the kernel can explain the difference:
//! at radius 2.3 the reported red levels for x = 10..22 are
//!
//! ```text
//! Photoshop 0, 2,10,27,59,103,152,196,228,245,253,255,255
//! PhotoCraft 2, 6,16,35,65,105,150,190,220,239,249,253,255
//! ```
//!
//! PhotoCraft's row is what a Gaussian sampled at whole pixels with sigma = radius and a 3-sigma
//! window gives (its variance is 0.6 % short of 2.3^2 from that truncation), so the pipeline adds
//! no error of its own: the gap is the two applications' radius-to-blur mapping, 8 levels at
//! radius 2.3, 5 at radius 1 and 1 at radius 5 (where PhotoCraft already runs box passes). No
//! single factor maps one to the other, as the issue itself notes, so the kernel is deliberately
//! left alone here; what this file does is pin the profile that PhotoCraft produces today, at both
//! depths and on both routes, and ratchet the distance to Photoshop's measured row so a future
//! kernel change is a decision with a number attached to it instead of a silent drift.
use craft_psd::atn::{self, AtnAction, AtnEvent, AtnFile, AtnItem};
use craft_psd::descriptor::{Descriptor, UnicodeString, Value as D};
use photocraft_engine::actions_cmds::{ActionList, ActionsFile};
use photocraft_engine::{Session, atn_cmds};
use serde_json::json;
/// The issue's fixture: 33 px wide, black at x = 0..15, white from x = 16.
const WIDTH: i32 = 33;
/// The step is at x = 16; seven pixels of kernel reach keep x = 10..22 clear of both canvas ends.
const FROM: i32 = 10;
const TO: i32 = 22;
/// PhotoCraft 0.20.2 (`7c12f6471`) as published in #11528, and Photoshop 27.11 beside it.
const PHOTOCRAFT: [u32; 13] = [2, 6, 16, 35, 65, 105, 150, 190, 220, 239, 249, 253, 255];
const PHOTOSHOP: [u32; 13] = [0, 2, 10, 27, 59, 103, 152, 196, 228, 245, 253, 255, 255];
/// The measured gap at radius 2.3. May only shrink, never grow: raising it needs the new number
/// and the reason in #11528.
const GAP: i64 = 8;
/// The same blur on the same fixture at 16 bits; the issue's (13, 0) is 8929 against Photoshop's
/// 7012, a gap of 1917 of 65535 - the same eight-level distance in the other scale.
const PHOTOCRAFT_16: [u32; 13] = [490, 1561, 4069, 8929, 16726, 27078, 38457, 48809, 56606, 61466, 63974, 65045, 65424];
const PHOTOSHOP_16_AT_13: u32 = 7012;
const GAP_16: i64 = 1917;
fn edge_doc(depth: u32) -> Session {
let mut s = Session::new();
s.execute("file.new", json!({"width": WIDTH, "height": 1, "depth": depth, "background": "#000000"})).unwrap();
s.execute("select.rect", json!({"x": 16, "y": 0, "width": WIDTH - 16, "height": 1})).unwrap();
s.execute("edit.fill", json!({"contents": "color", "color": "#ffffff"})).unwrap();
s.execute("select.deselect", json!({})).unwrap();
s
}
/// The red levels across the edge, in the document's own sample values.
fn profile(s: &mut Session, scale: f32) -> Vec<u32> {
(FROM..=TO)
.map(|x| {
let px: Vec<f32> = serde_json::from_value(s.execute("document.pixel", json!({"x": x, "y": 0})).unwrap()).unwrap();
(px[0] * scale + 0.5).floor() as u32
})
.collect()
}
fn blurred(depth: u32) -> (Vec<u32>, Vec<u32>) {
let mut unblurred = edge_doc(depth);
let before = profile(&mut unblurred, 255.0);
let mut s = edge_doc(depth);
s.execute("filter.blur.gaussianBlur", json!({"radius": 2.3})).unwrap();
(before, profile(&mut s, if depth == 8 { 255.0 } else { 65535.0 }))
}
/// The action the issue plays: Photoshop's `GsnB` event with its `#Pxl` radius descriptor.
fn gaussian_recording() -> Vec<u8> {
atn::write(&AtnFile {
actions: vec![AtnAction {
name: UnicodeString::new_nul("Blur2_3"),
items: vec![AtnItem {
event: AtnEvent::Code(*b"GsnB"),
descriptor: Some(Descriptor::new("null").with("Rds ", D::UnitFloat { unit: *b"#Pxl", value: 2.3 })),
..Default::default()
}],
..Default::default()
}],
..Default::default()
})
.unwrap()
}
#[test]
fn edge_profile_at_radius_2_3_is_the_sampled_sigma_equals_radius_kernel_at_eight_bits() {
let (before, got) = blurred(8);
assert_eq!(before, [vec![0; 6], vec![255; 7]].concat(), "the unblurred fixture is the step itself");
assert_eq!(got, PHOTOCRAFT, "the 8-bit profile across the edge changed");
let gap = got.iter().zip(PHOTOSHOP).map(|(a, b)| (*a as i64 - b as i64).abs()).max().unwrap();
assert!(gap <= GAP, "{gap} levels from Photoshop's row in #11528, was {GAP}");
}
/// 16 bits must be the same curve rather than a second rounding decision, and it carries the
/// issue's own 16-bit measurement (8929 at (13, 0) against Photoshop's 7012).
#[test]
fn edge_profile_at_radius_2_3_at_sixteen_bits_is_the_same_curve_in_another_scale() {
let (_, got) = blurred(16);
assert_eq!(got, PHOTOCRAFT_16, "the 16-bit profile across the edge changed");
let gap = (got[3] as i64 - PHOTOSHOP_16_AT_13 as i64).abs();
assert!(gap <= GAP_16, "{gap} levels from Photoshop's 16-bit row in #11528, was {GAP_16}");
for (a, b) in PHOTOCRAFT.iter().zip(&got) {
assert!((*a as i64 * 257 - *b as i64).abs() <= 257, "{a} at 8 bits is {b} at 16 bits: more than one level apart");
}
}
/// #11528 also checks Photoshop's direct blur against its own action replay; PhotoCraft's two
/// routes must stay identical, at both depths, or the action path hides a second implementation.
#[test]
fn gaussian_recording_replays_the_direct_blur_pixels_and_radius() {
let imported = atn_cmds::import(&gaussian_recording()).unwrap();
assert!(imported.unsupported.is_empty());
assert_eq!(imported.actions[0].steps[0].command, "filter.blur.gaussianBlur");
assert_eq!(imported.actions[0].steps[0].params["radius"], 2.3, "the recorded radius must survive import");
for depth in [8u32, 16] {
let mut direct = edge_doc(depth);
direct.execute("filter.blur.gaussianBlur", json!({"radius": 2.3})).unwrap();
let mut s = edge_doc(depth);
s.actions.list = ActionList::from_file(ActionsFile::new(imported.actions.clone(), Vec::new()));
assert_eq!(s.execute("actions.play", json!({"action": "Blur2_3"})).unwrap()["ran"], 1);
assert_eq!(
photocraft_compose::flatten(&s.active().unwrap().doc).px,
photocraft_compose::flatten(&direct.active().unwrap().doc).px,
"{depth}-bit: the recording blurs differently from the command"
);
}
}
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.