Edite a opacidade de uma imagem enferrujada

Estou tentando percorrer um diretório de imagens, editar a opacidade para 50% e salvá-las. Eu tenho uma coleção de imagens que são jpg e png. Estou usando a caixa de imagens.

Provavelmente terei que fazer algumas considerações sobre os formatos das imagens, mas não sei quais...

use clap::Parser;
use std::{process, thread};
#[derive(Parser,Debug)]
#[command(author,version,about,long_about=None)]
struct Args {
    #[arg(long,value_hint=clap::ValueHint::DirPath, default_value="./")]
    picture_dir: std::path::PathBuf,
    #[arg(long, default_value="300")]
    draw_time: u64,
    #[arg(long, default_value="3")]
    start_delay: u64,
    #[arg(long)]
    dry_run: bool,
}


fn main() {
    let args = Args::parse();
    println!("{}", args.picture_dir.as_os_str().to_str().unwrap());
    let dir = args.picture_dir.as_os_str().to_str().unwrap();
    let dir = format!("{}/*.*", dir);
    let extensions_supported = vec!("png","jpg","bmp");
    for path in glob::glob(&dir).expect("Failed to list directory") {
        let path = path.unwrap();
        let copy_from_path = path.clone();
        let file_name = path.file_name().unwrap();
        let mut cachepath = std::env::temp_dir();
        cachepath.push(file_name.to_str().unwrap());
        let str_path = cachepath.to_str().unwrap();
        let path_extension = path.extension().unwrap().to_str().unwrap();
        if !extensions_supported.contains(&path_extension) {
            println!("We don't support that file type");
            continue;
        }
        println!("{}", str_path);
        let start = std::time::Instant::now();
        // We should open the program
        let cmd_str = format!("cmd.exe /C clipstudiopaint.exe {}", str_path);
        let mut child: Option<process::Child> = None;
        if args.dry_run {
            println!("{}",cmd_str);
        } else {
            std::fs::copy(copy_from_path,cachepath.clone()).expect("Failed to create temporary file");
            let cache_image_path = cachepath.clone();
            let cache_image_path = cache_image_path.to_str().unwrap();
            let save_image_path = cachepath.clone();
            let mut image = image::open(cache_image_path)
            .expect("Failed to open image for editing").to_rgba32f();
            image.pixels_mut().for_each(|p| p[3] /= 2.0);
            
            image.save(save_image_path.to_str().unwrap()).expect("Failed to save image");
            //let mut image_target = image::ImageBuffer::new(image.width(), image.height());
            child = Some(process::Command::new("cmd")
            .arg("/C")
            .arg("clipstudiopaint.exe")
            .arg(cachepath.to_str().unwrap())
            .spawn()
            .expect("Failed to run clipstudiopaint"));
        }
        // We should wait a couple of seconds for it to load
        loop {
            if start.elapsed().as_secs() > args.start_delay {
                break;
            }
        }
        let start = std::time::Instant::now();
        // we should wait the specified drawing time
        println!("Starting timer");
        loop {
            if start.elapsed().as_secs() > args.draw_time {
                break;
            }
        }   
        // we should kill the process
        if !args.dry_run {
            child.unwrap().kill().expect("Failed to kill childprocess");
            std::fs::remove_file(cachepath).expect("Failed to remove temp file");
        }
        let start = std::time::Instant::now();
        loop {
            if start.elapsed().as_secs() > 2 {
                break;
            }
        }  
    }
}

Isso leva ao erro:Failed to save image: Encoding(EncodingError { format: Exact(Png), underlying: Some(ColorType(Rgba32F)) })

As partes relevantes da resposta final ficaram assim:

std::fs::copy(copy_from_path,cachepath.clone()).expect("Failed to create temporary file");
let image_edit_path = image_edit_path.clone();
let image_edit_path = image_edit_path.to_str().unwrap();
let save_image_path = cachepath.clone();
println!("Opening: {} for editing", image_edit_path);
let mut image = image::open(image_edit_path)
.expect("Failed to open image for editing");
let mut target_image = image::DynamicImage::new_rgba8(image.width(), image.height());
let mut target_image = target_image.to_rgba8();
target_image.pixels_mut().for_each(|p| *p = image::Rgba{0: [246, 244, 237, 255]});
let mut image = image.to_rgba8();
image.pixels_mut().for_each(|p| p[3] = 100);
image::imageops::overlay(&mut target_image, &image, 0, 0);
let target_image = image::DynamicImage::ImageRgba8(target_image);

target_image.save(save_image_path.to_str().unwrap()).expect("Failed to save image");