141 lines
6.0 KiB
Rust
141 lines
6.0 KiB
Rust
/// Generate a systematic set of inner shadow PSDs for ground-truth MAE tuning.
|
||
///
|
||
/// Each PSD: 256×256 black rectangle (25% margin) + inner shadow effect.
|
||
/// Output: `_tmp/inner_shadow_psd_set/`
|
||
use hcie_protocol::{Layer, LayerType, LayerData, BlendMode, effects::LayerEffect};
|
||
use std::sync::atomic::{AtomicBool};
|
||
use std::sync::Mutex;
|
||
|
||
fn main() {
|
||
let out_dir = std::path::Path::new("_tmp/inner_shadow_psd_set");
|
||
std::fs::create_dir_all(out_dir).expect("create output dir");
|
||
|
||
let canvas: u32 = 256;
|
||
let margin: u32 = 64;
|
||
|
||
let angles: &[f32] = &[0.0, 90.0, 180.0, 270.0];
|
||
let distances: &[f32] = &[5.0, 15.0, 30.0];
|
||
let sizes: &[f32] = &[10.0, 30.0];
|
||
let chokes: &[f32] = &[0.0, 20.0];
|
||
let fx_opacities: &[f32] = &[0.75, 1.0];
|
||
let noises: &[f32] = &[0.0, 15.0];
|
||
let fx_blend_modes: &[(BlendMode, &str)] = &[
|
||
(BlendMode::Normal, "normal"),
|
||
(BlendMode::Multiply, "multiply"),
|
||
];
|
||
let shadow_colors: &[([u8; 4], &str)] = &[
|
||
([220, 30, 30, 255], "red"),
|
||
([30, 180, 30, 255], "green"),
|
||
([30, 60, 220, 255], "blue"),
|
||
([220, 220, 220, 255], "white"),
|
||
];
|
||
|
||
let total = angles.len() * distances.len() * sizes.len() * chokes.len()
|
||
* fx_opacities.len() * fx_blend_modes.len() * shadow_colors.len() * noises.len();
|
||
println!("Generating {} inner shadow PSDs...", total);
|
||
|
||
let mut count = 0usize;
|
||
let mut errors = 0usize;
|
||
|
||
for &angle in angles {
|
||
for &distance in distances {
|
||
for &size in sizes {
|
||
for &choke in chokes {
|
||
for &opacity in fx_opacities {
|
||
for &(_bm, bm_name) in fx_blend_modes {
|
||
for &(color, color_name) in shadow_colors {
|
||
for &noise in noises {
|
||
count += 1;
|
||
let filename = format!(
|
||
"is_a{}_d{}_s{}_c{}_op{}_n{}_{}_{}.psd",
|
||
angle as u32, distance as u32, size as u32,
|
||
choke as u32, (opacity * 100.0) as u32,
|
||
noise as u32, bm_name, color_name
|
||
);
|
||
let path = out_dir.join(&filename);
|
||
if path.exists() {
|
||
continue;
|
||
}
|
||
|
||
let mut pixels = vec![0u8; (canvas * canvas * 4) as usize];
|
||
for y in 0..canvas {
|
||
for x in 0..canvas {
|
||
let i = (y * canvas + x) as usize * 4;
|
||
if x >= margin && x < canvas - margin
|
||
&& y >= margin && y < canvas - margin
|
||
{
|
||
pixels[i] = 0;
|
||
pixels[i + 1] = 0;
|
||
pixels[i + 2] = 0;
|
||
pixels[i + 3] = 255;
|
||
}
|
||
}
|
||
}
|
||
|
||
let effect = LayerEffect::InnerShadow {
|
||
enabled: true,
|
||
blend_mode: bm_name.to_string(),
|
||
color,
|
||
opacity,
|
||
angle,
|
||
distance,
|
||
choke,
|
||
size,
|
||
noise,
|
||
contour: None,
|
||
};
|
||
|
||
let layer = Layer {
|
||
name: "shape".to_string(),
|
||
layer_type: LayerType::Raster,
|
||
data: LayerData::Raster,
|
||
pixels: pixels.clone(),
|
||
width: canvas,
|
||
height: canvas,
|
||
visible: true,
|
||
opacity: 1.0,
|
||
blend_mode: BlendMode::Normal,
|
||
locked: false,
|
||
dirty: false,
|
||
id: 1,
|
||
parent_id: None,
|
||
styles: vec![],
|
||
clipping_mask: false,
|
||
collapsed: false,
|
||
adjustment: None,
|
||
mask_pixels: None,
|
||
mask_bounds: None,
|
||
mask_default_color: 0,
|
||
curve_points: vec![],
|
||
fill_opacity: 1.0,
|
||
effects: vec![effect],
|
||
effects_dirty: AtomicBool::new(false),
|
||
effects_cache: Mutex::new(None),
|
||
adjustment_raw: None,
|
||
is_section_divider: false,
|
||
image_resources_raw: None,
|
||
};
|
||
|
||
match hcie_psd::save_psd(&[layer], canvas, canvas, &pixels, &path) {
|
||
Ok(()) => {}
|
||
Err(e) => {
|
||
eprintln!(" ERROR {}: {}", filename, e);
|
||
errors += 1;
|
||
}
|
||
}
|
||
|
||
if count % 20 == 0 {
|
||
println!(" [{}/{}] errors={}", count, total, errors);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
println!("Done. {} PSDs generated, {} errors.", count - errors, errors);
|
||
}
|