Simply Patrick Hopes can always go up, tears can only come down.

fn check_and_download_model(model_path: &Path) -> Result<()> {
    if model_path.exists() {
        return Ok(());
    }
    println!("MiDaS model file '{}' not found.", model_path.display());
    println!("Downloading model-small.onnx (approx. 58MB)...");

    let url = "https://github.com/intel-isl/MiDaS/releases/download/v2_1/model-small.onnx";
    let status = std::process::Command::new("curl")
        .arg("-L").arg("-o").arg(model_path).arg(url)
        .status();

    // 支援 Windows 預設環境的 PowerShell 備援機制
    if status.is_err() || !status.unwrap().success() {
        // Invoke-WebRequest 備援...
    }
    Ok(())
}

pub fn estimate_depth_single(
    img: &Mat,
    model_path: &str,
    options: &DepthPostProcessOptions,
) -> Result<Mat> {
    let mut net = dnn::read_net_from_onnx_def(model_path)?;

    // 1. Resize 至 256x256
    let target_size = Size::new(256, 256);
    let mut resized = Mat::default();
    imgproc::resize(img, &mut resized, target_size, 0.0, 0.0, imgproc::INTER_CUBIC)?;

    // 2. BGR 轉 RGB 並進行 ImageNet Normalization
    let mut preprocessed = Mat::new_rows_cols_with_default(
        target_size.height, target_size.width, opencv::core::CV_32FC3, Scalar::default()
    )?;

    for y in 0..target_size.height {
        for x in 0..target_size.width {
            let bgr: opencv::core::Vec3b = *resized.at_2d::<opencv::core::Vec3b>(y, x)?;
            let r = (bgr[2] as f32) / 255.0;
            let g = (bgr[1] as f32) / 255.0;
            let b = (bgr[0] as f32) / 255.0;

            let r_norm = (r - 0.485) / 0.229;
            let g_norm = (g - 0.456) / 0.224;
            let b_norm = (b - 0.406) / 0.225;

            *preprocessed.at_2d_mut::<opencv::core::Vec3f>(y, x)? =
                opencv::core::Vec3f::from([r_norm, g_norm, b_norm]);
        }
    }

    // 3. 轉為 4D Blob 並執行 Forward 推理
    let blob = dnn::blob_from_image(&preprocessed, 1.0, target_size, Scalar::default(), false, false, CV_32F)?;
    net.set_input(&blob, "", 1.0, Scalar::default())?;

    let mut output = Mat::default();
    let out_blob_names = opencv::core::Vector::<String>::new();
    net.forward(&mut output, &out_blob_names)?;

    // 4. 提取原始 Raw Depth 矩陣
    // ...
    
    // 5. 進入深度圖後處理管線
    post_process_depth_map(&raw_depth, Some(img), options)
}

// 1. 收集有效深度值並進行分位數排序
let mut valid_vals: Vec<f32> = Vec::with_capacity(total_pixels);
for y in 0..h {
    for x in 0..w {
        let val = *raw_map.at_2d::<f32>(y, x)?;
        if val.is_finite() && val > -0.5 {
            valid_vals.push(val);
        }
    }
}

valid_vals.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
let num_valid = valid_vals.len();

// 計算分位數對應的陣列索引 (例如 1% - 99%)
let min_idx = ((num_valid - 1) as f32 * options.clip_min_quantile) as usize;
let max_idx = ((num_valid - 1) as f32 * options.clip_max_quantile) as usize;

let v_min = valid_vals[min_idx];
let v_max = valid_vals[max_idx];
let range = if (v_max - v_min).abs() > 1e-6 { v_max - v_min } else { 1.0 };

// 2. 裁切 (Clamp)、歸一化至 [0, 1] 並套用 Gamma 曲線
let mut norm_map = Mat::new_rows_cols_with_default(h, w, CV_32F, Scalar::default())?;
for y in 0..h {
    for x in 0..w {
        let val = *raw_map.at_2d::<f32>(y, x)?;
        if val <= -0.5 {
            *norm_map.at_2d_mut::<f32>(y, x)? = 0.0;
        } else {
            let clamped = val.clamp(v_min, v_max);
            let norm = (clamped - v_min) / range;
            let final_val = norm.powf(options.gamma);
            *norm_map.at_2d_mut::<f32>(y, x)? = final_val;
        }
    }
}

pub fn extract_high_pass_detail(img: &Mat, target_size: Size) -> Result<Mat> {
    let mut gray = Mat::default();
    imgproc::cvt_color(img, &mut gray, imgproc::COLOR_BGR2GRAY, 0, AlgorithmHint::ALGO_HINT_DEFAULT)?;

    let mut resized_gray = Mat::default();
    imgproc::resize(&gray, &mut resized_gray, target_size, 0.0, 0.0, imgproc::INTER_CUBIC)?;

    let mut f32_gray = Mat::default();
    resized_gray.convert_to(&mut f32_gray, CV_32F, 1.0 / 255.0, 0.0)?;

    // 模糊層：取得低頻背景
    let mut blurred = Mat::default();
    imgproc::gaussian_blur(&f32_gray, &mut blurred, Size::new(15, 15), 3.0, 3.0, opencv::core::BORDER_DEFAULT, AlgorithmHint::ALGO_HINT_DEFAULT)?;

    // 高通殘差：原圖 - 低頻模糊 = 高頻細節
    let mut detail_map = Mat::new_rows_cols_with_default(target_size.height, target_size.width, CV_32F, Scalar::default())?;
    for y in 0..target_size.height {
        for x in 0..target_size.width {
            let hp = *f32_gray.at_2d::<f32>(y, x)? - *blurred.at_2d::<f32>(y, x)?;
            *detail_map.at_2d_mut::<f32>(y, x)? = hp;
        }
    }
    Ok(detail_map)
}

fn calculate_normal(v1: Vertex, v2: Vertex, v3: Vertex) -> Vertex {
    let ax = v2.x - v1.x; let ay = v2.y - v1.y; let az = v2.z - v1.z;
    let bx = v3.x - v1.x; let by = v3.y - v1.y; let bz = v3.z - v1.z;

    let nx = ay * bz - az * by;
    let ny = az * bx - ax * bz;
    let nz = ax * by - ay * bx;

    let len = (nx * nx + ny * ny + nz * nz).sqrt();
    if len > 1e-6 {
        Vertex { x: nx / len, y: ny / len, z: nz / len }
    } else {
        Vertex { x: 0.0, y: 0.0, z: 0.0 }
    }
}

cargo run --release -- --mode single --input patrick-22.jpg --output-stl patrick-22.stl --width 100 --detail-weight 0.4 --gamma 0.7

// OpenSCAD 浮雕加框與掛鉤腳本
difference() {
    union() {
        // 1. 外圍相框底座
        cube([110, 110, 3], center = true);
        
        // 2. 匯入 depth-relief 產生的 STL 並置中
        translate([-50, -50, 1.5]) 
            import("patrick-22.stl");
    }

    // 3. 挖出後方壁掛螺絲孔
    translate([0, 50, 0])
        cylinder(h = 20, r = 2.5, center = true, $fn = 32);
}