MyStitcher/src/main.rs

use fast_image_resize as fr;
use fr::{PixelType, ResizeAlg, ResizeOptions, Resizer, images::Image};
use futures::future::join_all;
use std::{
    cell::UnsafeCell,
    io::Cursor,
    io::Write,
    ops::{Bound, RangeBounds},
};
use tokio::fs;
// use tokio::net::TcpListener;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    //     let listener = TcpListener::bind("127.0.0.1:8080").await?;
    //     println!("Server listening on port 8080");
    //
    //     loop {
    //         let (socket, _) = listener.accept().await?;
    //         tokio::spawn(async move {
    //             if let Err(e) = handle_client(socket).await {
    //                 eprintln!("Error: {}", e);
    //             }
    //         });
    //     }
    // }
    //
    // async fn handle_client(socket: tokio::net::TcpStream) -> Result<(), Box<dyn std::error::Error>> {
    //     // let file = std::fs::File::create("raw_image_123.png").unwrap();
    //     let offset_x = 0.5;
    //     let size_x = 0.5;
    //     let offset_y = 0.5;
    //     let size_y = 0.5;
    //     let rect = "A1:AE55";
    //     let scale = 0.4;
    //
    //     resize_image(
    //         &mut socket.into_std().unwrap(),
    //         rect,
    //         scale,
    //         offset_x,
    //         offset_y,
    //         size_x,
    //         size_y,
    //     )
    //     .await;
    //
    //     Ok(())
    // }
    let timer_start = std::time::Instant::now();

    let file = std::fs::File::create("raw_image_123.png").unwrap();
    let offset_x = 0.5;
    let size_x = 0.5;
    let offset_y = 0.5;
    let size_y = 0.5;
    let rect = "A1:AE55";
    let scale = 0.4;

    resize_image(file, rect, scale, offset_x, offset_y, size_x, size_y).await;

    let duration = timer_start.elapsed();
    println!("Operation completed in: {:.2?}", duration);
    Ok(())
}
async fn resize_image(
    out: impl Write,
    rect: &str,
    scale: f32,
    offset_x: f32,
    offset_y: f32,
    size_x: f32,
    size_y: f32,
) {
    let mut rect = rect.split(":");
    const SIZE: u32 = 720;
    let actual_size = (SIZE as f32 * scale).trunc() as u32;

    let start = rect.next().unwrap();
    let end = rect.next().unwrap();

    let (start_col_s, start_row) = split_before_number(start);
    let start_col = column_to_number(start_col_s);
    let start_row = start_row.parse::<u32>().unwrap();
    let (end_col_s, end_row) = split_before_number(end);
    let end_col = column_to_number(end_col_s);
    let end_row = end_row.parse::<u32>().unwrap();
    let col_count = end_col - start_col + 1;
    let row_count = end_row - start_row + 1;
    let canvas_width = (row_count * actual_size) as usize;
    let canvas_height = (col_count * actual_size) as usize;
    let canvas = UnsafeVec::new(vec![0u8; canvas_width * canvas_height * 3]);

    let min_row = start_row + (row_count as f32 * offset_x).floor() as u32;
    let max_row = start_row + (row_count as f32 * (offset_x + size_x)).floor() as u32;
    let min_col = start_col + (col_count as f32 * offset_y).floor() as u32;
    let max_col = start_col + (col_count as f32 * (offset_y + size_y)).floor() as u32;

    let mut handles = Vec::new();
    for i in start_col..=end_col {
        for j in start_row..=end_row {
            if i < min_col {
                continue;
            }
            if i > max_col {
                continue;
            }
            if j < min_row {
                continue;
            }
            if j > max_row {
                continue;
            }
            handles.push(add_to_canvas(
                &canvas,
                i,
                start_col,
                j,
                start_row,
                SIZE,
                actual_size,
                canvas_width,
                canvas_height,
            ));
        }
    }
    let results = join_all(handles).await;

    let writer = std::io::BufWriter::new(out);

    let start_x = (offset_x * canvas_width as f32).trunc() as usize;
    let start_y = (offset_y * canvas_height as f32).trunc() as usize;
    let end_x = ((offset_x + size_x) * canvas_width as f32).trunc() as usize;
    let end_y = ((offset_y + size_y) * canvas_height as f32).trunc() as usize;

    let crop_width = end_x - start_x;
    let crop_height = end_y - start_y;

    let mut encoder = png::Encoder::new(
        writer,
        crop_width.try_into().unwrap(),
        crop_height.try_into().unwrap(),
    );
    encoder.set_color(png::ColorType::Rgb);
    encoder.set_depth(png::BitDepth::Eight);

    println!("Writing img");
    let mut png_writer = encoder.write_header().unwrap();
    png_writer
        .write_image_data(&crop_rgb_image(
            &canvas.to_vec(),
            (actual_size * row_count) as usize,
            (actual_size * col_count) as usize,
            start_x,
            start_y,
            crop_width,
            crop_height,
        ))
        .unwrap();
}
fn split_before_number(input: &str) -> (&str, &str) {
    let index = find_first_number_start(input);
    (&input[..index], &input[index..])
}
fn find_first_number_start(s: &str) -> usize {
    for (i, c) in s.char_indices() {
        if c.is_ascii_digit() {
            return i;
        }
    }
    s.len()
}
fn number_to_column(mut num: u32) -> String {
    let mut result = String::new();

    while num > 0 {
        num -= 1;
        let ch = ((num % 26) as u8 + b'A') as char;
        result.insert(0, ch);
        num /= 26;
    }

    result
}
fn column_to_number(s: &str) -> u32 {
    let mut result = 0;

    for ch in s.chars() {
        result = result * 26 + (ch as u32 - 'A' as u32 + 1);
    }

    result
}
async fn add_to_canvas(
    canvas: &UnsafeVec<u8>,
    i: u32,
    start_col: u32,
    j: u32,
    start_row: u32,
    size: u32,
    actual_size: u32,
    canvas_width: usize,
    canvas_height: usize,
) {
    let mut resizer = Resizer::new();
    let base_path = "/mnt/c/Users/Formulatrix/Documents/Explorations/WebApplication1/tiles1705/";
    let filename = format!("{}{}{}.png", base_path, number_to_column(i), j);
    // println!("{filename}");

    let data = Cursor::new(fs::read(filename).await.unwrap()); // .unwrap();
    let decoder = png::Decoder::new(data);
    let mut reader = decoder.read_info().unwrap();
    let mut buf = vec![0; reader.output_buffer_size()];
    let _info = reader.next_frame(&mut buf).unwrap();

    let src_img = Image::from_vec_u8(size, size, buf, PixelType::U8x3).unwrap();
    let mut img = Image::new(actual_size, actual_size, PixelType::U8x3);

    resizer
        .resize(
            &src_img,
            &mut img,
            &ResizeOptions::new()
                .resize_alg(ResizeAlg::Nearest)
                .use_alpha(false),
        )
        .unwrap();
    place_image(
        &canvas,
        canvas_width,
        canvas_height,
        &img.into_vec(),
        (actual_size) as usize,
        (actual_size) as usize,
        ((j - start_row) * actual_size) as usize,
        ((i - start_col) * actual_size) as usize,
    );
}
fn place_image(
    canvas: &UnsafeVec<u8>,
    canvas_width: usize,
    canvas_height: usize,
    image: &[u8],
    image_width: usize,
    image_height: usize,
    x_offset: usize,
    y_offset: usize,
) {
    let channels = 3;

    for row in 0..image_height {
        let canvas_y = y_offset + row;
        if canvas_y >= canvas_height {
            continue;
        }

        let canvas_start = (canvas_y * canvas_width + x_offset) * channels;
        let canvas_end = canvas_start + image_width * channels;

        let image_start = row * image_width * channels;
        let image_end = image_start + image_width * channels;

        if canvas_end <= canvas.len() && image_end <= image.len() {
            unsafe {
                canvas.range_mut(canvas_start..canvas_end, &image[image_start..image_end]);
            }
        }
    }
}

fn crop_rgb_image(
    img: &[u8],
    width: usize,
    height: usize,
    start_x: usize,
    start_y: usize,
    crop_width: usize,
    crop_height: usize,
) -> Vec<u8> {
    let mut cropped = Vec::with_capacity(crop_width * crop_height * 3);

    let end_x = start_x + crop_width;
    let end_y = start_y + crop_height;
    for y in start_y..end_y {
        let row_start = (y * width + start_x) * 3;
        let row_end = (y * width + end_x) * 3;
        cropped.extend_from_slice(&img[row_start..row_end]);
    }

    cropped
}

pub struct UnsafeVec<T> {
    data: UnsafeCell<Vec<T>>,
}

impl<T: Copy> UnsafeVec<T> {
    pub fn new(initial: Vec<T>) -> Self {
        UnsafeVec {
            data: UnsafeCell::new(initial),
        }
    }

    pub fn len(&self) -> usize {
        unsafe { (*self.data.get()).len() }
    }

    pub fn to_vec(self) -> Vec<T> {
        self.data.into_inner()
    }

    pub unsafe fn range_mut<R: RangeBounds<usize>>(&self, range: R, value: &[T]) {
        unsafe {
            let vec = &mut *self.data.get();

            let start = match range.start_bound() {
                Bound::Included(&s) => s,
                Bound::Excluded(&s) => s + 1,
                Bound::Unbounded => 0,
            };

            let end = match range.end_bound() {
                Bound::Included(&e) => e + 1,
                Bound::Excluded(&e) => e,
                Bound::Unbounded => vec.len(),
            };

            &mut vec[start..end].copy_from_slice(value);
        }
    }
}

unsafe impl<T> Sync for UnsafeVec<T> {}
unsafe impl<T> Send for UnsafeVec<T> {}