From 97bb431b624099be316ca2389a9dbbc0bc8d8145 Mon Sep 17 00:00:00 2001
From: Patrick Michl <huanzodev@gmail.com>
Date: Tue, 16 Mar 2021 17:16:09 +0100
Subject: [PATCH] some image sequencing

---
 Cargo.lock       |  1 -
 Cargo.toml       |  3 +--
 Dockerfile       | 15 +++++++++++++++
 src/main.rs      | 41 ++++++++++++++++++++++++++---------------
 src/pixelflut.rs |  8 ++++++++
 5 files changed, 50 insertions(+), 18 deletions(-)
 create mode 100644 Dockerfile

diff --git a/Cargo.lock b/Cargo.lock
index d4bc683..0f7a890 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -339,7 +339,6 @@ dependencies = [
  "crossbeam",
  "image",
  "r2d2",
- "rayon",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 41ddb7f..68a3552 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,5 +9,4 @@ edition = "2018"
 [dependencies]
 r2d2 = "*"
 image = "*"
-rayon = "*"
-crossbeam = "*"
\ No newline at end of file
+crossbeam = "*"
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..8247be0
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,15 @@
+FROM ekidd/rust-musl-builder:nightly-2021-02-13 AS rust-build
+USER root
+
+RUN rustup target add x86_64-unknown-linux-musl
+
+COPY . /app
+WORKDIR /app
+RUN cargo build --bins --release --target x86_64-unknown-linux-musl
+
+FROM alpine:latest
+
+WORKDIR /home
+
+# Copy Rust artifacts
+COPY --from=rust-build /app/target/x86_64-unknown-linux-musl/release/pixelrush ./app
diff --git a/src/main.rs b/src/main.rs
index 7316760..b122dbe 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,35 +1,38 @@
 mod pixelflut;
 
-use std::{
-    io::{self, BufReader, Read},
-    thread::JoinHandle,
-};
+use std::thread::JoinHandle;
 
 use crossbeam::channel::*;
 use pixelflut::*;
+use std::fs;
+use std::path::PathBuf;
 
 enum Message {
     Pixel(u32, u32, image::Rgba<u8>),
+    Line(Vec<(u32, u32, image::Rgba<u8>)>),
     Exit,
 }
 
 fn main() -> Result<(), std::io::Error> {
-    let mut stdin_reader = BufReader::new(io::stdin());
-    let mut image_buffer: Vec<u8> = Vec::new();
-    let _ = stdin_reader.read_to_end(&mut image_buffer)?;
-    let mut image = image::load_from_memory(&image_buffer).expect("Unable to read image format");
+    let entries = fs::read_dir("nyancat/").unwrap();
+    let mut entries: Vec<PathBuf> = entries.map(|entry| entry.unwrap().path()).collect();
+    let mut images: Vec<image::DynamicImage> = Vec::new();
+    for entry in entries {
+        images.push(image::open(entry).expect("Unable to read image format"));
+    }
+    //let image = image::open("image.png").expect("Unable to read image format");
 
-    let manager = PixelflutConnectionManager::new("localhost:1234")?;
+    let manager = PixelflutConnectionManager::new("10.3.32.187:1234")?;
     let pool = r2d2::Pool::builder()
-        .max_size(16)
+        .max_size(64)
         .build(manager)
         .expect("Could not initialize connection pool");
 
-    let image = image.as_rgba8().expect("Not a valid Image");
+    //let image = image.as_rgba8().expect("Not a valid Image");
 
     let (sender, receiver) = unbounded::<Message>();
     let mut handles: Vec<JoinHandle<()>> = Vec::new();
-    for _ in 0..16 {
+    for _ in 0..64 {
         let r2 = receiver.clone();
         let p2 = pool.clone();
         let handle = std::thread::spawn(move || {
@@ -41,7 +44,10 @@ fn main() -> Result<(), std::io::Error> {
                 match r2.recv().unwrap() {
                     Message::Pixel(x, y, c) => {
                         let _ = connection.set(x, y, c);
-                    }
+                    },
+                    Message::Line(l) => {
+                        let _ = connection.set_multiple(l);
+                    },
                     Message::Exit => return,
                 }
             }
@@ -49,8 +55,13 @@ fn main() -> Result<(), std::io::Error> {
         handles.push(handle);
     }
 
-    for (x, y, p) in image.enumerate_pixels() {
-        let _ = sender.send(Message::Pixel(x, y, p.clone()));
+    loop{
+        for image in &images {
+        for (y, row) in image.to_rgba8().enumerate_rows() {
+            let row: Vec<(u32,u32,image::Rgba<u8>)> = row.into_iter().map(|(x,y,c)| (x,y,c.clone())).collect();
+            let _ = sender.send(Message::Line(row));
+        }
+        }
     }
 
     (0..16).for_each(|_| {
diff --git a/src/pixelflut.rs b/src/pixelflut.rs
index 9fe2a9d..6b213f5 100644
--- a/src/pixelflut.rs
+++ b/src/pixelflut.rs
@@ -30,6 +30,7 @@ impl PixelflutConnectionManager {
     }
 }
 
+#[derive(Copy, Clone)]
 pub struct Rgba(u8, u8, u8, u8);
 
 impl fmt::Display for Rgba {
@@ -59,6 +60,13 @@ impl PixelflutConnection {
         let msg = format!("PX {} {} {}\n", x, y, c.into());
         self.write_command(&msg)
     }
+    pub fn set_multiple(&mut self, ps: Vec<(u32, u32, impl Into<Rgba>)>) -> Result<(), Error> {
+        let mut msg = String::from("");
+        for (x,y,p) in ps {
+            msg.push_str(&format!("PX {} {} {}\n", x, y, p.into()))
+        }
+        self.write_command(&msg)
+    }
 
     pub fn get(&mut self, x: u32, y: u32) -> Result<Rgba, Error> {
         let msg = format!("PX {} {}\n", x, y);