this was the input and output i was getting:
cargo run compile /Users/nicojaffer/Downloads/102607-funny-kolobanga-png-image-high-quality.png
Finished dev [unoptimized + debuginfo] target(s) in 1.46s
Running target/debug/bruh compile /Users/nicojaffer/Downloads/102607-funny-kolobanga-png-image-high-quality.png
thread 'main' panicked at 'File delete failed: Os { code: 2, kind: NotFound, message: "No such file or directory" }', main.rs:65:40
note: run with RUST_BACKTRACE=1
environment variable to display a backtrace
but i fixed it: heres the updated code (sorry i couldnt upload as file, app github doesnt allow that filetype.) (also this was for the main.rs file)
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
use eframe::egui;
use egui_extras::RetainedImage;
extern crate css_color_parser;
use colors_transform::Rgb;
use image;
use image::GenericImageView;
use std::{
env,
fs::{self, OpenOptions},
io::Write,
path::PathBuf,
};
use skia_safe::{
AlphaType, Color4f, ColorType, EncodedImageFormat, ImageInfo, Paint, Rect, Surface,
};
use css_color_parser::Color as CssColor;
static TEMP_RESULT_PATH: &str = "temp.png";
fn vec_to_u32_ne(bytes: &[u8]) -> u32 {
let mut result = [0u8; 4];
result.copy_from_slice(bytes);
u32::from_ne_bytes(result)
}
fn png_to_bruh(path: PathBuf) -> Result<(), std::io::Error> {
let img = image::open(&path).expect("File not found!");
let mut str = String::new();
let mut last_line = 0;
for pixel in img.pixels() {
let hex_color = Rgb::from(
pixel.2 .0[0] as f32,
pixel.2 .0[1] as f32,
pixel.2 .0[2] as f32,
)
.to_css_hex_string();
if last_line != pixel.1 {
str.push_str("\n");
last_line = pixel.1;
}
str.push_str(&hex_color.replace("#", ""));
}
if let Some(path_str) = &path.to_str() {
let height: u32 = img.height();
let width: u32 = img.width();
let height_bytes: [u8; 4] = height.to_ne_bytes();
let width_bytes: [u8; 4] = width.to_ne_bytes();
let path_to_bruh = path_str.replace(".png", ".bruh");
// let mut file = fs::File::create(path_str.replace(".png", ".bruh")).expect("Couldn't write to image.bruh");
// file.write_all(&height_bytes);
// file.write_all(&width_bytes);
// file.write_all(str.as_bytes());
use std::env;
use std::process::Command;
fn main() {
let path_to_bruh = env::args().nth(1).expect("Missing file path argument");
let output = Command::new("rm")
.arg(&path_to_bruh)
.output()
.expect("Failed to execute command");
if output.status.success() {
println!("File deleted successfully");
} else {
let error_message = String::from_utf8_lossy(&output.stderr);
println!("File delete failed: {}", error_message);
}
}
let mut file = OpenOptions::new()
.write(true)
.create(true)
.open(path_to_bruh)
.expect("Couldnt write");
let string_bytes: Vec<u8> = Vec::from(str.as_bytes());
file.write_all(&width_bytes).unwrap();
file.write_all(&height_bytes).unwrap();
file.write_all(&string_bytes).unwrap();
file.flush().unwrap();
} else {
println!("{}", "couldn't find")
}
Ok(())
}
fn bruh_to_png(path: PathBuf) -> (u32, u32) {
let mut contents: Vec = fs::read(&path).expect("Couldn't read file.");
let binding: Vec<_> = contents.drain(0..8).collect();
let width = vec_to_u32_ne(&binding[0..4]);
let height = vec_to_u32_ne(&binding[4..8]);
let sanitized_content = String::from_utf8_lossy(&contents).replace("\n", "");
let result: Vec<&str> = sanitized_content
.as_bytes()
.chunks(6)
.map(std::str::from_utf8)
.collect::<Result<_, _>>()
.expect("Invalid UTF-8 sequence in the input string");
let info = ImageInfo::new(
(width as i32, height as i32),
ColorType::RGBA8888,
AlphaType::Opaque,
None,
);
let mut surface = Surface::new_raster(&info, None, None).unwrap();
let canvas = surface.canvas();
for (i, color) in result.iter().enumerate() {
let hex = "#".to_owned() + color;
let parsed_color = hex
.parse::<CssColor>()
.expect("Failed to convert Hex to RGB");
let color4f = Color4f::new(
parsed_color.r as f32,
parsed_color.g as f32,
parsed_color.b as f32,
0.004 as f32,
);
let paint = Paint::new(color4f, None);
if i == 0 {
println!("{:?}", paint)
}
let x = i % width as usize;
let y = i / width as usize;
let rect = Rect::from_point_and_size((x as f32, y as f32), (1.0, 1.0));
canvas.draw_rect(rect, &paint);
}
let image = surface.image_snapshot();
if let Some(data) = image.encode(None, EncodedImageFormat::PNG, 100) {
fs::write(TEMP_RESULT_PATH, &*data).expect("Failed to write image data to file");
}
return (width, height);
}
fn main() -> Result<(), eframe::Error> {
let args: Vec = env::args().collect();
let file_path: PathBuf = (&args[1]).into();
if &args[1] == "compile" {
if args.len() < 3 {
panic!("Secondary argument ('path') not provided. Example: `cargo run compile ~/image.png`")
}
let path: PathBuf = (&args[2]).into();
match png_to_bruh(path) {
Ok(()) => println!("{}", "Successfully converted PNG to BRUH"),
Err(_) => println!("{}", "Failed to convert PNG to BRUH"),
}
Ok(())
} else {
let (width, height) = bruh_to_png(file_path);
println!("{} {}", width, height);
let options = eframe::NativeOptions {
initial_window_size: Some(egui::vec2(width as f32, height as f32)),
..Default::default()
};
eframe::run_native(
"Image preview",
options,
Box::new(|_cc| Box::<ImagePreview>::default()),
)
}
}
struct ImagePreview {
image: RetainedImage,
}
impl Default for ImagePreview {
fn default() -> Self {
let image_data = std::fs::read(TEMP_RESULT_PATH).expect("Failed to read image file");
fs::remove_file(TEMP_RESULT_PATH).expect("File delete failed on TEMP_RESULT_PATH");
Self {
image: RetainedImage::from_image_bytes(TEMP_RESULT_PATH, &image_data).unwrap(),
}
}
}
impl eframe::App for ImagePreview {
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
egui::CentralPanel::default().show(ctx, |ui| {
self.image.show(ui);
});
}
}