connect to csharp

src/main.rs

@@ -3,67 +3,80 @@ use fr::{PixelType, ResizeAlg, ResizeOptions, Resizer, images::Image};
 use futures::future::join_all;
 use std::{
     cell::UnsafeCell,
+    env,
     io::Cursor,
-    io::Write,
     ops::{Bound, RangeBounds},
+    path::Path,
 };
-use tokio::fs;
-// use tokio::net::TcpListener;
+use tokio::{
+    fs,
+    io::{AsyncReadExt, AsyncWriteExt},
+};
+use tokio::{io::BufReader, 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();
+    dotenv::dotenv().ok();
+    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 {
+            let timer_start = std::time::Instant::now();
+            if let Err(e) = handle_client(socket).await {
+                println!("Error: {}", e);
+            } else {
+                println!("Data sent");
+            }
+            let duration = timer_start.elapsed();
+            println!("Operation completed in: {:.2?}", duration);
+        });
+    }
+}
 
-    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;
+async fn handle_client(
+    mut socket: tokio::net::TcpStream,
+) -> Result<(), Box<dyn std::error::Error>> {
+    println!("Incoming request");
+    let mut reader = BufReader::new(&mut socket);
 
-    resize_image(file, rect, scale, offset_x, offset_y, size_x, size_y).await;
+    let rect_len = reader.read_u16_le().await?;
+    let mut rect_buf = vec![0u8; rect_len as usize];
+    reader.read_exact(&mut rect_buf).await?;
+    let rect = String::from_utf8(rect_buf)?;
+
+    let offset_x = reader.read_f32_le().await?;
+    let size_x = reader.read_f32_le().await?;
+    let offset_y = reader.read_f32_le().await?;
+    let size_y = reader.read_f32_le().await?;
+    let scale = reader.read_f32_le().await?;
+
+    println!("Parsed values:");
+    println!("  rect:     {rect}");
+    println!("  offset_x: {offset_x}");
+    println!("  size_x:   {size_x}");
+    println!("  offset_y: {offset_y}");
+    println!("  size_y:   {size_y}");
+    println!("  scale:    {scale}");
+
+    let mut result_buffer = Vec::new();
+    stitch_and_resize_image(
+        &mut result_buffer,
+        &rect,
+        scale,
+        offset_x,
+        offset_y,
+        size_x,
+        size_y,
+    )
+    .await;
+
+    socket.write_all(&result_buffer).await.unwrap();
 
-    let duration = timer_start.elapsed();
-    println!("Operation completed in: {:.2?}", duration);
     Ok(())
 }
-async fn resize_image(
-    out: impl Write,
+async fn stitch_and_resize_image(
+    out: &mut Vec<u8>,
     rect: &str,
     scale: f32,
     offset_x: f32,
@@ -125,8 +138,6 @@ async fn resize_image(
     }
     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;
@@ -136,16 +147,15 @@ async fn resize_image(
     let crop_height = end_y - start_y;
 
     let mut encoder = png::Encoder::new(
-        writer,
+        Cursor::new(out),
         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
+    encoder
+        .write_header()
+        .unwrap()
         .write_image_data(&crop_rgb_image(
             &canvas.to_vec(),
             (actual_size * row_count) as usize,
@@ -202,11 +212,11 @@ async fn add_to_canvas(
     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 env = &env::var("ASSET_PATH_RO").unwrap();
+    let img_path = Path::new(&env);
+    let filename = format!("{}{}.png", number_to_column(i), j);
 
-    let data = Cursor::new(fs::read(filename).await.unwrap()); // .unwrap();
+    let data = Cursor::new(fs::read(img_path.join(filename)).await.unwrap());
     let decoder = png::Decoder::new(data);
     let mut reader = decoder.read_info().unwrap();
     let mut buf = vec![0; reader.output_buffer_size()];
@@ -225,7 +235,7 @@ async fn add_to_canvas(
         )
         .unwrap();
     place_image(
-        &canvas,
+        canvas,
         canvas_width,
         canvas_height,
         &img.into_vec(),