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");
