fix: fix image resizing

src/lib.rs

@@ -1,3 +1,4 @@
+#![feature(try_blocks)]
 #![warn(clippy::pedantic)]
 
 mod strandifier;

src/main.rs

@@ -1,30 +1,28 @@
 #![warn(clippy::pedantic)]
+#![feature(never_type)]
 
 use std::{
     f32::consts::FRAC_PI_2,
-    io::stdout,
+    io::{stdin, stdout, Read},
     net::{Ipv4Addr, SocketAddr, UdpSocket},
-    num::ParseIntError,
     path::PathBuf,
-    str::FromStr,
     thread::sleep,
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use bracket_color::prelude::{HSV, RGB};
-use clap::{Parser, Subcommand};
+use clap::{builder::TypedValueParser, Parser, Subcommand, ValueEnum};
 use image::{imageops::FilterType, io::Reader as ImageReader, Pixel, Rgb, RgbImage};
 use rand::Rng;
 
-use splink_client::{send_frame, Layout};
+use splink_client::{send_frame, Layout, SenderError};
-use thiserror::Error;
 
 /// Blinkenwall v3 prototype client
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]
 struct Args {
     /// Timeout in ms for frame completion responses (0 to disable)
-    #[clap(long, default_value_t = 3)]
+    #[clap(long, default_value_t = 10)]
     response_timeout: u64,
 
     /// Local address and port to bind to
@@ -35,57 +33,68 @@ struct Args {
     remote_addr: SocketAddr,
 
     /// The action to perform
-    #[clap(subcommand, rename_all = "kebab-case")]
+    #[clap(subcommand)]
     action: Action,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy)]
-struct Color {
+struct ColorParser;
-    r: u8,
+impl TypedValueParser for ColorParser {
-    g: u8,
+    type Value = Rgb<u8>;
-    b: u8,
-}
 
-#[derive(Clone, Debug, Error)]
+    fn parse_ref(
-enum ColorError {
+        &self,
-    #[error("Wrong parameter length")]
+        _cmd: &clap::Command,
-    WrongLength,
+        _arg: Option<&clap::Arg>,
-    #[error("Illegal integer")]
+        value: &std::ffi::OsStr,
-    BadNumber(#[from] ParseIntError),
+    ) -> Result<Self::Value, clap::Error> {
-}
+        let s = value
-
+            .to_str()
-impl FromStr for Color {
+            .ok_or(clap::Error::raw(clap::ErrorKind::InvalidUtf8, ""))?;
-    type Err = ColorError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
         let s = s.strip_prefix('#').unwrap_or(s);
 
         if s.len() != 6 {
-            return Err(ColorError::WrongLength);
+            return Err(clap::Error::raw(
+                clap::ErrorKind::InvalidValue,
+                "Must be a 6-digit hexadecimal number",
+            ));
         }
 
-        let r = u8::from_str_radix(&s[0..2], 16)?;
+        let mut channels = [0; 3];
-        let g = u8::from_str_radix(&s[2..4], 16)?;
+        for i in 0..3 {
-        let b = u8::from_str_radix(&s[4..6], 16)?;
+            channels[i] = u8::from_str_radix(&s[i * 2..i * 2 + 2], 16).map_err(|_| {
-
+                clap::Error::raw(clap::ErrorKind::InvalidValue, "Invalid hex literal")
-        Ok(Self { r, g, b })
+            })?;
-    }
         }
 
-impl From<Color> for Rgb<u8> {
+        Ok(Rgb(channels))
-    fn from(c: Color) -> Rgb<u8> {
-        Rgb([c.r, c.g, c.b])
     }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Subcommand)]
 enum Action {
-    Rainbow,
+    Animation {
-    Solid { color: Color },
+        #[clap(value_enum)]
-    Image { path: PathBuf },
+        animation: Animation,
+    },
+    Solid {
+        #[clap(value_parser = ColorParser)]
+        color: Rgb<u8>,
+    },
+    Image {
+        path: PathBuf,
+    },
+    Video,
     Clear,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, ValueEnum)]
+enum Animation {
+    Rainbow,
+    Bling,
+    Strobe,
+}
+
 fn bling(layout: Layout, frame: u32) -> RgbImage {
     #![allow(
         clippy::cast_precision_loss,
@@ -137,13 +146,37 @@ fn rainbow(layout: Layout, frame: u32) -> RgbImage {
     let w = layout.width_px();
     let h = layout.height_px();
 
+    let tightness = 100.0;
+    let slowness = 200;
+    let brightness = 0.1;
+
     RgbImage::from_fn(w, h, |x, y| {
-        let RGB { r, g, b } =
+        let RGB { r, g, b } = HSV::from_f32(
-            HSV::from_f32((x + y + frame) as f32 / 100.0 % 1.0, 1.0, 0.1).to_rgb();
+            (x + y) as f32 / tightness % 1.0 + (frame % slowness) as f32 / slowness as f32,
+            1.0,
+            brightness,
+        )
+        .to_rgb();
         Rgb([(r * 255.0) as u8, (g * 255.0) as u8, (b * 255.0) as u8])
     })
 }
 
+fn strobe(layout: Layout, frame: u32) -> RgbImage {
+    let w = layout.width_px();
+    let h = layout.height_px();
+
+    let brightness = 120;
+    let period = 15;
+
+    RgbImage::from_fn(w, h, |_, _| {
+        if frame % period < period / 2 {
+            Rgb([brightness; 3])
+        } else {
+            Rgb([0, 0, 0])
+        }
+    })
+}
+
 fn print_image(image: &RgbImage) {
     let _hide = termion::cursor::HideCursor::from(stdout());
 
@@ -156,6 +189,30 @@ fn print_image(image: &RgbImage) {
     }
 }
 
+fn animate<F: Fn(Layout, u32) -> RgbImage>(
+    socket: &UdpSocket,
+    layout: Layout,
+    generator: F,
+) -> Result<!, anyhow::Error> {
+    print!("{}", termion::clear::All);
+
+    let mut frame: u32 = rand::thread_rng().gen();
+    loop {
+        let start = Instant::now();
+        let image = generator(layout, frame);
+
+        print_image(&image);
+
+        match send_frame(socket, layout, frame, &image) {
+            Ok(()) | Err(SenderError::ConfirmationTimeout) => {}
+            Err(e) => return Err(e.into()),
+        };
+
+        println!("{:?}", Instant::now().duration_since(start));
+        frame += 1;
+    }
+}
+
 fn main() -> anyhow::Result<()> {
     let args = Args::parse();
 
@@ -181,40 +238,56 @@ fn main() -> anyhow::Result<()> {
         first_strand_index: 8,
     };
 
-    match args.action {
+    let image = match args.action {
         Action::Solid { color } => {
-            let image = RgbImage::from_pixel(layout.width_px(), layout.height_px(), color.into());
+            RgbImage::from_pixel(layout.width_px(), layout.height_px(), color)
-            let frame_num: u32 = rand::thread_rng().gen();
-            send_frame(&socket, layout, frame_num, &image)?;
         }
-        Action::Clear => {
+        Action::Clear => RgbImage::new(layout.width_px(), layout.height_px()),
-            let image = RgbImage::new(layout.width_px(), layout.height_px());
+        Action::Image { path } => ImageReader::open(path)?
-            let frame_num: u32 = rand::thread_rng().gen();
-            send_frame(&socket, layout, frame_num, &image)?;
-        }
-        Action::Image { path } => {
-            let image = ImageReader::open(path)?
             .decode()?
-                .resize_to_fill(layout.width_px(), layout.height_px(), FilterType::Gaussian)
+            .resize(layout.width_px(), layout.height_px(), FilterType::Gaussian)
-                .into_rgb8();
+            .into_rgb8(),
-            let frame_num: u32 = rand::thread_rng().gen();
+        Action::Animation { animation } => {
-            send_frame(&socket, layout, frame_num, &image)?;
+            animate(
+                &socket,
+                layout,
+                match animation {
+                    Animation::Rainbow => rainbow,
+                    Animation::Bling => bling,
+                    Animation::Strobe => strobe,
+                },
+            )?;
         }
-        Action::Rainbow => {
+        Action::Video => {
             print!("{}", termion::clear::All);
 
-            for frame in 0.. {
+            let mut frame_num: u32 = rand::thread_rng().gen();
-                let image = rainbow(layout, frame);
+            loop {
+                let w = layout.width_px();
+                let h = layout.height_px();
+
+                let mut buf = vec![0; w as usize * h as usize * 3];
+                stdin().lock().read_exact(&mut buf)?;
+                for c in &mut buf {
+                    *c /= 6;
+                }
+                let image = RgbImage::from_vec(w, h, buf).unwrap();
 
                 print_image(&image);
 
+                match send_frame(&socket, layout, frame_num, &image) {
+                    Ok(()) | Err(SenderError::ConfirmationTimeout) => {}
+                    Err(e) => return Err(e.into()),
+                };
+                frame_num += 1;
+
+                sleep(Duration::from_millis(30));
+            }
+        }
+    };
+
     let frame_num: u32 = rand::thread_rng().gen();
     send_frame(&socket, layout, frame_num, &image)?;
 
-                sleep(Duration::from_millis(16));
-            }
-        }
-    }
-
     Ok(())
 }

src/strandifier.rs

@@ -8,8 +8,8 @@ use crate::Layout;
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Error)]
 #[allow(clippy::module_name_repetitions)]
 pub enum StrandifierError {
-    #[error("Wrong image dimensions")]
+    #[error("Image too large")]
-    WrongDimensions,
+    ImageTooLarge,
     #[error("Invalid strand number")]
     InvalidStrand,
 }
@@ -23,6 +23,9 @@ pub struct Strandifier<'a> {
     pixels_remaining: u32,
     next_x: u32,
     next_y: u32,
+
+    offset_x: u32,
+    offset_y: u32,
 }
 
 impl<'a> Strandifier<'a> {
@@ -41,8 +44,8 @@ impl<'a> Strandifier<'a> {
         image: &'a RgbImage,
         strand_num: u32,
     ) -> Result<Self, StrandifierError> {
-        if layout.width_px() != image.width() || layout.height_px() != image.height() {
+        if layout.width_px() < image.width() || layout.height_px() < image.height() {
-            return Err(StrandifierError::WrongDimensions);
+            return Err(StrandifierError::ImageTooLarge);
         }
 
         if strand_num > layout.num_strands() {
@@ -55,6 +58,9 @@ impl<'a> Strandifier<'a> {
         let first_x = panel_x * layout.gang_len;
         let first_y = panel_y * layout.num_gangs;
 
+        let offset_x = (layout.width_px() - image.width()) / 2;
+        let offset_y = (layout.height_px() - image.height()) / 2;
+
         Ok(Self {
             layout,
             image,
@@ -62,6 +68,9 @@ impl<'a> Strandifier<'a> {
             pixels_remaining: layout.strand_len(),
             next_x: first_x,
             next_y: first_y,
+
+            offset_x,
+            offset_y,
         })
     }
 }
@@ -98,7 +107,14 @@ impl<'a> Iterator for Strandifier<'a> {
         }
         self.pixels_remaining -= 1;
 
-        Some(*self.image.get_pixel(x, y))
+        let opt_px: Option<_> = try {
+            let x = x.checked_sub(self.offset_x)?;
+            let y = y.checked_sub(self.offset_y)?;
+
+            *self.image.get_pixel_checked(x, y)?
+        };
+
+        Some(opt_px.unwrap_or(Rgb([0, 0, 0])))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -259,12 +275,12 @@ mod tests {
         );
 
         let layout2 = Layout {
-            num_gangs: 6,
+            num_gangs: 3,
             ..layout
         };
         assert_eq!(
             Strandifier::make_strand(layout2, &image, 0).unwrap_err(),
-            StrandifierError::WrongDimensions
+            StrandifierError::ImageTooLarge
         );
     }
 }