refactor: Use u16 for image width and height

Author: alixinne

benches/reducer.rs

@@ -8,13 +8,13 @@ use hyperion::{
     models::{ClassicLedConfig, Color16, Leds, ToLeds},
 };
 
-fn random_image(width: u32, height: u32) -> RawImage {
-    let mut data = vec![0u8; (width * height * RawImage::CHANNELS) as usize];
+fn random_image(width: u16, height: u16) -> RawImage {
+    let mut data = vec![0u8; width as usize * height as usize * RawImage::CHANNELS as usize];
 
     let mut rng = rand::thread_rng();
     rng.fill_bytes(&mut data);
 
-    RawImage::try_from((data, width, height)).unwrap()
+    RawImage::try_from((data, width as u32, height as u32)).unwrap()
 }
 
 fn classic_led_config(leds: u32) -> Leds {

src/image.rs

@@ -9,16 +9,16 @@ pub use reducer::*;
 
 pub trait Image: Sized {
     /// Get the width of the image, in pixels
-    fn width(&self) -> u32;
+    fn width(&self) -> u16;
 
     /// Get the height of the image, in pixels
-    fn height(&self) -> u32;
+    fn height(&self) -> u16;
 
     /// Get the color at the given coordinates
-    fn color_at(&self, x: u32, y: u32) -> Option<Color>;
+    fn color_at(&self, x: u16, y: u16) -> Option<Color>;
 
     /// Get the color at the given coordinates skipping bound checks
-    unsafe fn color_at_unchecked(&self, x: u32, y: u32) -> Color;
+    unsafe fn color_at_unchecked(&self, x: u16, y: u16) -> Color;
 
     /// Convert this image trait object to a raw image
     fn to_raw_image(&self) -> RawImage;
@@ -53,12 +53,12 @@ pub enum RawImageError {
 #[derive(Clone)]
 pub struct RawImage {
     data: Vec<u8>,
-    width: u32,
-    height: u32,
+    width: u16,
+    height: u16,
 }
 
 impl RawImage {
-    pub const CHANNELS: u32 = 3;
+    pub const CHANNELS: u16 = 3;
 
     pub fn write_to_kitty(&self, out: &mut dyn std::io::Write) -> Result<(), RawImageError> {
         // Buffer for raw PNG data
@@ -68,8 +68,8 @@ impl RawImage {
         // Write PNG to buffer
         encoder.encode(
             &self.data[..],
-            self.width,
-            self.height,
+            self.width as _,
+            self.height as _,
             image::ColorType::Rgb8,
         )?;
         // Encode to base64
@@ -105,45 +105,28 @@ impl RawImage {
 }
 
 impl Image for RawImage {
-    fn width(&self) -> u32 {
+    fn width(&self) -> u16 {
         self.width
     }
 
-    fn height(&self) -> u32 {
+    fn height(&self) -> u16 {
         self.height
     }
 
-    fn color_at(&self, x: u32, y: u32) -> Option<Color> {
+    fn color_at(&self, x: u16, y: u16) -> Option<Color> {
         if x < self.width && y < self.height {
-            unsafe {
-                Some(Color::new(
-                    *self
-                        .data
-                        .get_unchecked(((y * self.width + x) * Self::CHANNELS) as usize),
-                    *self
-                        .data
-                        .get_unchecked(((y * self.width + x) * Self::CHANNELS + 1) as usize),
-                    *self
-                        .data
-                        .get_unchecked(((y * self.width + x) * Self::CHANNELS + 2) as usize),
-                ))
-            }
+            unsafe { Some(self.color_at_unchecked(x, y)) }
         } else {
             None
         }
     }
 
-    unsafe fn color_at_unchecked(&self, x: u32, y: u32) -> Color {
+    unsafe fn color_at_unchecked(&self, x: u16, y: u16) -> Color {
+        let idx = (y as usize * self.width as usize + x as usize) * Self::CHANNELS as usize;
         Color::new(
-            *self
-                .data
-                .get_unchecked(((y * self.width + x) * Self::CHANNELS) as usize),
-            *self
-                .data
-                .get_unchecked(((y * self.width + x) * Self::CHANNELS + 1) as usize),
-            *self
-                .data
-                .get_unchecked(((y * self.width + x) * Self::CHANNELS + 2) as usize),
+            *self.data.get_unchecked(idx),
+            *self.data.get_unchecked(idx + 1),
+            *self.data.get_unchecked(idx + 2),
         )
     }
 
@@ -173,59 +156,63 @@ impl TryFrom<(Vec<u8>, u32, u32)> for RawImage {
     type Error = RawImageError;
 
     fn try_from((data, width, height): (Vec<u8>, u32, u32)) -> Result<Self, Self::Error> {
-        let expected = (width * height * Self::CHANNELS) as usize;
+        let expected = width as usize * height as usize * Self::CHANNELS as usize;
 
         if data.len() != expected {
             return Err(RawImageError::InvalidData {
                 data: data.len(),
                 width,
                 height,
-                channels: Self::CHANNELS,
+                channels: Self::CHANNELS as _,
                 expected,
             });
         } else if width == 0 {
             return Err(RawImageError::ZeroWidth);
         } else if height == 0 {
             return Err(RawImageError::ZeroHeight);
+        } else if width >= u16::MAX as _ {
+            return Err(RawImageError::InvalidWidth);
+        } else if height >= u16::MAX as _ {
+            return Err(RawImageError::InvalidHeight);
         }
 
         Ok(Self {
             data,
-            width,
-            height,
+            width: width as _,
+            height: height as _,
         })
     }
 }
 
 pub struct ImageView<'i, T: Image> {
     inner: &'i T,
-    xmin: u32,
-    xmax: u32,
-    ymin: u32,
-    ymax: u32,
+    xmin: u16,
+    xmax: u16,
+    ymin: u16,
+    ymax: u16,
 }
 
 impl<'i, T: Image> Image for ImageView<'i, T> {
-    fn width(&self) -> u32 {
+    fn width(&self) -> u16 {
         self.xmax - self.xmin
     }
 
-    fn height(&self) -> u32 {
+    fn height(&self) -> u16 {
         self.ymax - self.ymin
     }
 
-    fn color_at(&self, x: u32, y: u32) -> Option<Color> {
+    fn color_at(&self, x: u16, y: u16) -> Option<Color> {
         self.inner.color_at(x + self.xmin, y + self.ymin)
     }
 
-    unsafe fn color_at_unchecked(&self, x: u32, y: u32) -> Color {
+    unsafe fn color_at_unchecked(&self, x: u16, y: u16) -> Color {
         self.inner.color_at_unchecked(x + self.xmin, y + self.ymin)
     }
 
     fn to_raw_image(&self) -> RawImage {
         let w = self.width();
         let h = self.height();
-        let mut data = Vec::with_capacity((w * h * RawImage::CHANNELS) as usize);
+        let mut data = Vec::with_capacity(w as usize * h as usize * RawImage::CHANNELS as usize);
 
         unsafe {
             for y in 0..h {
@@ -240,18 +227,18 @@ impl<'i, T: Image> Image for ImageView<'i, T> {
 
         RawImage {
             data,
-            width: w as _,
-            height: h as _,
+            width: w,
+            height: h,
         }
     }
 }
 
 pub trait ImageViewExt: Image {
-    fn wrap(&self, x: std::ops::Range<u32>, y: std::ops::Range<u32>) -> ImageView<Self>;
+    fn wrap(&self, x: std::ops::Range<u16>, y: std::ops::Range<u16>) -> ImageView<Self>;
 }
 
 impl<T: Image> ImageViewExt for T {
-    fn wrap(&self, x: std::ops::Range<u32>, y: std::ops::Range<u32>) -> ImageView<Self> {
+    fn wrap(&self, x: std::ops::Range<u16>, y: std::ops::Range<u16>) -> ImageView<Self> {
         ImageView {
             inner: self,
             xmin: x.start,

src/image/reducer.rs

@@ -5,8 +5,8 @@ use super::Image;
 #[derive(Debug, Default)]
 pub struct Reducer {
     spec: Vec<LedSpec>,
-    spec_width: u32,
-    spec_height: u32,
+    spec_width: u16,
+    spec_height: u16,
 }
 
 #[derive(Debug)]
@@ -19,41 +19,40 @@ struct LedSpec {
 }
 
 impl LedSpec {
-    pub fn new(spec: &Led, width: u32, height: u32, fwidth: f32, fheight: f32) -> Self {
+    pub fn new(spec: &Led, width: u16, height: u16, fwidth: f32, fheight: f32) -> Self {
         let lxmin = spec.hmin * fwidth;
         let lxmax = spec.hmax * fwidth;
         let lymin = spec.vmin * fheight;
         let lymax = spec.vmax * fheight;
 
         let x_area = if lxmin.floor() < lxmin {
-            (255. * (1. - lxmin.fract())) as u32
+            (255. * (1. - lxmin.fract())) as u16
         } else if (lxmax.ceil() + 1.) > lxmax {
-            (255. * lxmax.fract()) as u32
+            (255. * lxmax.fract()) as u16
         } else {
             255
         };
 
         let y_area = if lxmin.floor() < lxmin {
-            (255. * (1. - lymin.fract())) as u32
+            (255. * (1. - lymin.fract())) as u16
         } else if (lymax.ceil() + 1.) > lxmax {
-            (255. * lymax.fract()) as u32
+            (255. * lymax.fract()) as u16
         } else {
             255
         };
 
-        // TODO: Add width/height limit to RawImage
         Self {
             lxmin: lxmin.floor() as u16,
-            lxmax: (lxmax.ceil() as u16).min((width - 1) as u16),
+            lxmax: (lxmax.ceil() as u16).min(width - 1),
             lymin: lymin.floor() as u16,
-            lymax: (lymax.ceil() as u16).min((height - 1) as u16),
+            lymax: (lymax.ceil() as u16).min(height - 1),
             area: (x_area * y_area / 255) as u8,
         }
     }
 }
 
 impl Reducer {
-    pub fn reset(&mut self, width: u32, height: u32, leds: &[Led]) {
+    pub fn reset(&mut self, width: u16, height: u16, leds: &[Led]) {
         self.spec_width = width;
         self.spec_height = height;
 

src/instance/black_border_detector.rs

@@ -3,8 +3,8 @@ use crate::{image::Image, models};
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct BlackBorder {
     pub unknown: bool,
-    pub horizontal_size: u32,
-    pub vertical_size: u32,
+    pub horizontal_size: u16,
+    pub vertical_size: u16,
     threshold: u8,
 }
 
@@ -22,7 +22,7 @@ impl BlackBorder {
         color.red < self.threshold && color.green < self.threshold && color.blue < self.threshold
     }
 
-    fn update(&mut self, xy: (Option<u32>, Option<u32>)) {
+    fn update(&mut self, xy: (Option<u16>, Option<u16>)) {
         if let (Some(x), Some(y)) = xy {
             self.unknown = false;
             self.horizontal_size = y;
@@ -121,12 +121,12 @@ impl BlackBorder {
             if first_non_black_x < 0 {
                 None
             } else {
-                Some(first_non_black_x as u32)
+                Some(first_non_black_x as _)
             },
             if first_non_black_y < 0 {
                 None
             } else {
-                Some(first_non_black_y as u32)
+                Some(first_non_black_y as _)
             },
         ));
     }
@@ -203,7 +203,7 @@ impl BlackBorder {
         }
     }
 
-    pub fn blur(&mut self, blur: u32) {
+    pub fn blur(&mut self, blur: u16) {
         if self.horizontal_size > 0 {
             self.horizontal_size += blur;
         }
@@ -215,9 +215,9 @@ impl BlackBorder {
 
     pub fn get_ranges(
         &self,
-        width: u32,
-        height: u32,
-    ) -> (std::ops::Range<u32>, std::ops::Range<u32>) {
+        width: u16,
+        height: u16,
+    ) -> (std::ops::Range<u16>, std::ops::Range<u16>) {
         if self.unknown {
             (0..width, 0..height)
         } else {

src/models.rs

@@ -114,7 +114,7 @@ pub struct BlackBorderDetector {
     pub unknown_frame_cnt: u32,
     pub border_frame_cnt: u32,
     pub max_inconsistent_cnt: u32,
-    pub blur_remove_cnt: u32,
+    pub blur_remove_cnt: u16,
     pub mode: BlackBorderDetectorMode,
 }