113 lines
4.2 KiB
Rust
113 lines
4.2 KiB
Rust
|
|
fn debug_pixels(psd_path: &str, ref_path: &str, label: &str) {
|
|
let layers = match hcie_psd::import_psd(std::path::Path::new(psd_path)) {
|
|
Ok(l) => l,
|
|
Err(e) => { println!("FAILED {}: {}", label, e); return; }
|
|
};
|
|
if layers.is_empty() { println!("No layers for {}", label); return; }
|
|
|
|
let comp_layers: Vec<hcie_composite::Layer> = layers.iter().map(|l| hcie_composite::Layer {
|
|
name: l.name.clone(),
|
|
layer_type: l.layer_type.clone(),
|
|
data: l.data.clone(),
|
|
pixels: l.pixels.clone(),
|
|
width: l.width,
|
|
height: l.height,
|
|
visible: l.visible,
|
|
opacity: l.opacity,
|
|
blend_mode: l.blend_mode.clone(),
|
|
locked: l.locked,
|
|
dirty: l.dirty,
|
|
id: l.id,
|
|
parent_id: l.parent_id,
|
|
styles: l.styles.clone(),
|
|
clipping_mask: l.clipping_mask,
|
|
collapsed: l.collapsed,
|
|
adjustment: l.adjustment.clone(),
|
|
mask_pixels: l.mask_pixels.clone(),
|
|
mask_bounds: l.mask_bounds,
|
|
mask_default_color: l.mask_default_color,
|
|
curve_points: l.curve_points.clone(),
|
|
fill_opacity: l.fill_opacity,
|
|
effects: l.effects.clone(),
|
|
effects_dirty: std::sync::atomic::AtomicBool::new(false),
|
|
effects_cache: std::sync::Mutex::new(None),
|
|
adjustment_raw: None,
|
|
is_section_divider: false,
|
|
image_resources_raw: None,
|
|
}).collect();
|
|
|
|
let w = comp_layers[0].width;
|
|
let h = comp_layers[0].height;
|
|
let rendered = hcie_composite::composite_layers(&comp_layers, w, h);
|
|
|
|
let ref_img = match image::open(ref_path) {
|
|
Ok(i) => i.to_rgba8(),
|
|
Err(e) => { println!("FAILED ref {}: {}", label, e); return; }
|
|
};
|
|
|
|
// Save rendered output
|
|
let out_path = format!("/tmp/sultan_debug_{}.png", label.replace(' ', "_"));
|
|
image::save_buffer(&out_path, &rendered, w, h, image::ColorType::Rgba8).unwrap();
|
|
|
|
// Find top-10 worst pixels
|
|
let mut diffs: Vec<(u32, u32, f64, [u8;4], [u8;4])> = Vec::new();
|
|
for y in 0..h.min(ref_img.height()) {
|
|
for x in 0..w.min(ref_img.width()) {
|
|
let i = (y * w + x) as usize * 4;
|
|
let ri = (y * ref_img.width() + x) as usize * 4;
|
|
let d: f64 = (0..4).map(|c| (rendered[i+c] as f64 - ref_img.as_raw()[ri+c] as f64).abs()).sum();
|
|
if d > 1.0 {
|
|
diffs.push((x, y, d, [rendered[i], rendered[i+1], rendered[i+2], rendered[i+3]], [ref_img.as_raw()[ri], ref_img.as_raw()[ri+1], ref_img.as_raw()[ri+2], ref_img.as_raw()[ri+3]]));
|
|
}
|
|
}
|
|
}
|
|
diffs.sort_by(|a, b| b.2.partial_cmp(&a.2).unwrap());
|
|
|
|
println!("\n=== {} (worst pixels) ===", label);
|
|
println!("Total differing pixels: {}", diffs.len());
|
|
for (x, y, d, our, refv) in diffs.iter().take(10) {
|
|
println!(" ({},{}) diff={:.1} ours=({},{},{},{}) ref=({},{},{},{})",
|
|
x, y, d, our[0], our[1], our[2], our[3], refv[0], refv[1], refv[2], refv[3]);
|
|
}
|
|
|
|
// Area analysis: find where the biggest differences cluster
|
|
if !diffs.is_empty() {
|
|
let avg_x: f64 = diffs.iter().map(|d| d.0 as f64).sum::<f64>() / diffs.len() as f64;
|
|
let avg_y: f64 = diffs.iter().map(|d| d.1 as f64).sum::<f64>() / diffs.len() as f64;
|
|
let max_x = diffs.iter().map(|d| d.0).max().unwrap();
|
|
let max_y = diffs.iter().map(|d| d.1).max().unwrap();
|
|
let min_x = diffs.iter().map(|d| d.0).min().unwrap();
|
|
let min_y = diffs.iter().map(|d| d.1).min().unwrap();
|
|
println!(" Diff area: x=[{},{}] y=[{},{}] center=({:.0},{:.0})", min_x, max_x, min_y, max_y, avg_x, avg_y);
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let base = "_images/_psd_stil_test/sultan_test/sultan";
|
|
|
|
debug_pixels(
|
|
&format!("{}/sultan_0003_Layer 2.psd", base),
|
|
&format!("{}/Layer 2.png", base),
|
|
"Layer 2 (Bevel&Emboss)",
|
|
);
|
|
|
|
debug_pixels(
|
|
&format!("{}/sultan_0000_Layer 1.psd", base),
|
|
&format!("{}/Layer 1.png", base),
|
|
"Layer 1 (Outer Glow)",
|
|
);
|
|
|
|
debug_pixels(
|
|
&format!("{}/sultan_0002_Layer 3.psd", base),
|
|
&format!("{}/Layer 3.png", base),
|
|
"Layer 3 (Inner Glow)",
|
|
);
|
|
|
|
debug_pixels(
|
|
&format!("{}/sultan_0001_Layer 4.psd", base),
|
|
&format!("{}/Layer 4.png", base),
|
|
"Layer 4 (Drop Shadow)",
|
|
);
|
|
}
|