125 lines
5.1 KiB
Rust
125 lines
5.1 KiB
Rust
use std::path::Path;
|
|
|
|
fn main() {
|
|
let orig_path = Path::new("/mnt/extra/00_PROJECTS/hcie-rust-_images/_test_images/example3/Example3-mini.psd");
|
|
let saved_path = Path::new("/mnt/extra/00_PROJECTS/hcie-rust-v4/_tmp/Example3-mini-roundtrip.psd");
|
|
|
|
let orig_layers = hcie_psd::import_psd(orig_path).unwrap();
|
|
let saved_layers = hcie_psd::import_psd(saved_path).unwrap();
|
|
|
|
let orig_db = orig_layers.iter().find(|l| l.name == "D&B with Retouch4me").unwrap();
|
|
let saved_db = saved_layers.iter().find(|l| l.name == "D&B with Retouch4me").unwrap();
|
|
|
|
println!("=== Original D&B layer ===");
|
|
println!(" Width: {}, Height: {}", orig_db.width, orig_db.height);
|
|
println!(" Pixel buffer len: {}", orig_db.pixels.len());
|
|
println!(" Mask bounds: {:?}", orig_db.mask_bounds);
|
|
println!(" Mask default color: {}", orig_db.mask_default_color);
|
|
if let Some(ref mask) = orig_db.mask_pixels {
|
|
println!(" Mask pixels len: {}", mask.len());
|
|
let mut zero_count = 0;
|
|
let mut non_zero_count = 0;
|
|
for &v in mask {
|
|
if v == 0 { zero_count += 1; } else { non_zero_count += 1; }
|
|
}
|
|
println!(" Mask pixels (0 vs non-zero): {} vs {}", zero_count, non_zero_count);
|
|
} else {
|
|
println!(" No mask pixels");
|
|
}
|
|
let mut o_alpha_counts = [0usize; 256];
|
|
for chunk in orig_db.pixels.chunks_exact(4) {
|
|
o_alpha_counts[chunk[3] as usize] += 1;
|
|
}
|
|
println!(" Alpha distribution (0, 1..254, 255): {}, {}, {}",
|
|
o_alpha_counts[0],
|
|
o_alpha_counts[1..255].iter().sum::<usize>(),
|
|
o_alpha_counts[255]
|
|
);
|
|
|
|
println!("=== Saved D&B layer ===");
|
|
println!(" Width: {}, Height: {}", saved_db.width, saved_db.height);
|
|
println!(" Pixel buffer len: {}", saved_db.pixels.len());
|
|
println!(" Mask bounds: {:?}", saved_db.mask_bounds);
|
|
println!(" Mask default color: {}", saved_db.mask_default_color);
|
|
if let Some(ref mask) = saved_db.mask_pixels {
|
|
println!(" Mask pixels len: {}", mask.len());
|
|
let mut zero_count = 0;
|
|
let mut non_zero_count = 0;
|
|
for &v in mask {
|
|
if v == 0 { zero_count += 1; } else { non_zero_count += 1; }
|
|
}
|
|
println!(" Mask pixels (0 vs non-zero): {} vs {}", zero_count, non_zero_count);
|
|
} else {
|
|
println!(" No mask pixels");
|
|
}
|
|
let mut s_alpha_counts = [0usize; 256];
|
|
for chunk in saved_db.pixels.chunks_exact(4) {
|
|
s_alpha_counts[chunk[3] as usize] += 1;
|
|
}
|
|
println!(" Alpha distribution (0, 1..254, 255): {}, {}, {}",
|
|
s_alpha_counts[0],
|
|
s_alpha_counts[1..255].iter().sum::<usize>(),
|
|
s_alpha_counts[255]
|
|
);
|
|
|
|
// Dump raw mask data bytes
|
|
println!("\n=== Raw Mask Section Comparison ===");
|
|
dump_raw_mask_bytes("Original", orig_path);
|
|
dump_raw_mask_bytes("Saved", saved_path);
|
|
}
|
|
|
|
fn dump_raw_mask_bytes(label: &str, path: &Path) {
|
|
let bytes = std::fs::read(path).unwrap();
|
|
let mut r = hcie_psd::psd_reader::PsdReader::new(&bytes);
|
|
r.read(26).unwrap();
|
|
let color_mode_len = r.read_u32().unwrap() as usize;
|
|
r.read(color_mode_len).unwrap();
|
|
let img_res_len = r.read_u32().unwrap() as usize;
|
|
r.read(img_res_len).unwrap();
|
|
let _lmi_len = r.read_u32().unwrap();
|
|
let _li_len = r.read_u32().unwrap();
|
|
let layer_count_raw = r.read_i16().unwrap();
|
|
let layer_count = layer_count_raw.abs() as usize;
|
|
|
|
let mut layers_meta = Vec::new();
|
|
for _ in 0..layer_count {
|
|
let _top = r.read_i32().unwrap();
|
|
let _left = r.read_i32().unwrap();
|
|
let _bottom = r.read_i32().unwrap();
|
|
let _right = r.read_i32().unwrap();
|
|
let channel_count = r.read_u16().unwrap() as usize;
|
|
for _ in 0..channel_count {
|
|
let _id = r.read_i16().unwrap();
|
|
let _len = r.read_u32().unwrap();
|
|
}
|
|
r.read(4).unwrap(); // sig
|
|
r.read(4).unwrap(); // blend
|
|
r.read_u8().unwrap(); // opacity
|
|
r.read_u8().unwrap(); // clipping
|
|
r.read_u8().unwrap(); // flags
|
|
r.read(1).unwrap(); // filler
|
|
|
|
let extra_data_len = r.read_u32().unwrap() as usize;
|
|
let start = r.pos();
|
|
let mask_len = r.read_u32().unwrap() as usize;
|
|
let mask_bytes = r.read(mask_len).unwrap().to_vec();
|
|
r.read(extra_data_len - 4 - mask_len).unwrap(); // skip rest of extra data
|
|
|
|
// read name to find layer
|
|
let mut sub_r = hcie_psd::psd_reader::PsdReader::new(&bytes[start + 4 + mask_len..]);
|
|
let _blending_ranges_len = sub_r.read_u32().unwrap() as usize;
|
|
sub_r.read(_blending_ranges_len).unwrap();
|
|
let name_len = sub_r.read_u8().unwrap() as usize;
|
|
let name_bytes = sub_r.read(name_len).unwrap();
|
|
let name = String::from_utf8_lossy(name_bytes).to_string();
|
|
|
|
layers_meta.push((name, mask_len, mask_bytes));
|
|
}
|
|
|
|
if let Some((name, mask_len, mask_bytes)) = layers_meta.iter().find(|(name, _, _)| name == "D&B with Retouch4me") {
|
|
println!("{}: Layer '{}' mask_len={} bytes={:?}", label, name, mask_len, mask_bytes);
|
|
} else {
|
|
println!("{}: D&B with Retouch4me layer not found", label);
|
|
}
|
|
}
|