hcie-rust-v3.05/hcie-io/examples/tune_mae_shadow.rs

#![allow(dead_code, unused_imports, unused_variables, unused_macros)]
use std::io::Write;

const SHADOW_RS: &str = "hcie-fx/src/tuned.rs";
const PSD_PATH: &str = "_images/_psd_stil_test/drop_shadow.psd";
const REF_PATH: &str = "_images/_psd_stil_test/drop_shadow.png";
const RESULTS_FILE: &str = "/mnt/extra/00_PROJECTS/hcie-rust-v4/shadow_results.txt";

fn main() {
    let original = std::fs::read_to_string(SHADOW_RS).expect("read tuned.rs");

    let start_tag = "// BEGIN_TUNING_ZONE";
    let end_tag = "// END_TUNING_ZONE";

    let zone_start = original.find(start_tag).unwrap();
    let zone_end = original.find(end_tag).unwrap();
    let _before = &original[..zone_start];
    let _after = &original[zone_end + end_tag.len()..];

    let ref_img = image::open(REF_PATH)
        .expect("open drop_shadow.png")
        .to_rgba8();
    let (w, h) = (ref_img.width(), ref_img.height());
    let px = (w * h) as usize;
    let ref_pixels = ref_img.into_raw();

    let layers = hcie_psd::import_psd(std::path::Path::new(PSD_PATH))
        .expect("import drop_shadow.psd");
    let layer = &layers[0];
    let alpha: Vec<u8> = layer.pixels.iter().skip(3).step_by(4).copied().collect();

    let (angle, distance, spread, size, color, blend_mode_str, opacity) = {
        let mut ang = 0.0f32;
        let mut dist = 0.0f32;
        let mut spr = 0.0f32;
        let mut sz = 0.0f32;
        let mut col = [0u8; 4];
        let mut bm = String::new();
        let mut op = 0.0f32;
        for e in &layer.effects {
            if let hcie_protocol::effects::LayerEffect::DropShadow {
                enabled: true, angle, distance, spread, size, color, blend_mode, opacity, ..
            } = e {
                ang = *angle; dist = *distance; spr = *spread; sz = *size;
                col = *color; bm = blend_mode.clone(); op = *opacity;
            }
        }
        (ang, dist, spr, sz, col, bm, op)
    };

    let bm_parsed = hcie_fx::types::blend_mode_from_string(&blend_mode_str);

    println!("DropShadow: angle={}, distance={}, spread={}, size={}, color={:?}, blend={}, opacity={}",
        angle, distance, spread, size, color, blend_mode_str, opacity);
    println!("Image: {}x{}", w, h);
    std::io::stdout().flush().ok();

    let mut best_mae = f64::MAX;
    let mut best_params = (0.0f32, 0i32, 0.0f32);

    let blur_factors = &[0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0];
    let passes_list = &[1, 2, 3, 4, 5, 6, 8, 10];
    let spread_scales = &[0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 2.0];

    let total = blur_factors.len() * passes_list.len() * spread_scales.len();
    println!("Grid search: {} combos", total);
    std::io::stdout().flush().ok();

    let mut count = 0usize;
    for blur_factor in blur_factors {
        for passes in passes_list {
            for spread_scale in spread_scales {
                count += 1;
                if count % 200 == 0 {
                    println!("  [{}/{}] best={:.3}", count, total, best_mae);
                    std::io::stdout().flush().ok();
                }

                let shadow = hcie_fx::tuned::generate_shadow_tuned(
                    &alpha, w, h, angle, distance, spread, size, color, false,
                    *blur_factor, *passes, *spread_scale,
                );

                let mut out = layer.pixels.clone();
                for i in 0..px {
                    let sa = shadow[i * 4 + 3];
                    if sa == 0 { continue; }
                    let dst = [out[i * 4], out[i * 4 + 1], out[i * 4 + 2], out[i * 4 + 3]];
                    let src = [shadow[i * 4], shadow[i * 4 + 1], shadow[i * 4 + 2], sa];
                    let blended = hcie_blend::blend_pixels(dst, src, bm_parsed, opacity);
                    out[i * 4..i * 4 + 4].copy_from_slice(&blended);
                }

                let mut diff_sum = 0.0f64;
                for i in 0..px {
                    let d = (0..4).map(|c| {
                        (out[i * 4 + c] as i32 - ref_pixels[i * 4 + c] as i32).abs() as f64
                    }).sum::<f64>();
                    diff_sum += d;
                }
                let mae = diff_sum / px as f64 / 4.0;

                if mae < best_mae {
                    best_mae = mae;
                    best_params = (*blur_factor, *passes, *spread_scale);
                    println!("*** NEW BEST: {:.3} (blur_factor={:.1}, passes={}, spread_scale={:.2})",
                        best_mae, blur_factor, passes, spread_scale);
                    std::io::stdout().flush().ok();
                }
            }
        }
    }

    if best_mae < f64::MAX {
        let (bbf, bp, bss) = best_params;
        println!("\nCompleted. Best MAE = {:.3} (blur_factor={:.1}, passes={}, spread_scale={:.2})",
            best_mae, bbf, bp, bss);
        if let Ok(mut file) = std::fs::OpenOptions::new().create(true).write(true).truncate(true).open(RESULTS_FILE) {
            let _ = writeln!(file, "=== Drop Shadow Tuned ===\n  Params: blur_factor={:.1}, passes={}, spread_scale={:.2}\n  MAE: {:.3}",
                bbf, bp, bss, best_mae);
        }
    }
}