perf: Introduce ImageView type

Author: alixinne

src/image.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 
 use crate::models::Color;
 
-pub trait Image {
+pub trait Image: Sized {
     /// Get the width of the image, in pixels
     fn width(&self) -> u32;
 
@@ -193,3 +193,72 @@ impl TryFrom<(Vec<u8>, u32, u32)> for RawImage {
         })
     }
 }
+
+pub struct ImageView<'i, T: Image> {
+    inner: &'i T,
+    xmin: u32,
+    xmax: u32,
+    ymin: u32,
+    ymax: u32,
+}
+
+impl<'i, T: Image> Image for ImageView<'i, T> {
+    fn width(&self) -> u32 {
+        self.xmax - self.xmin
+    }
+
+    fn height(&self) -> u32 {
+        self.ymax - self.ymin
+    }
+
+    fn color_at(&self, x: u32, y: u32) -> Option<Color> {
+        self.inner.color_at(x + self.xmin, y + self.ymin)
+    }
+
+    unsafe fn color_at_unchecked(&self, x: u32, y: u32) -> 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);
+
+        unsafe {
+            for y in 0..h {
+                for x in 0..w {
+                    let (r, g, b) = self.color_at_unchecked(x, y).into_components();
+                    data.push(r);
+                    data.push(g);
+                    data.push(b);
+                }
+            }
+        }
+
+        RawImage {
+            data,
+            width: w as _,
+            height: h as _,
+        }
+    }
+}
+
+pub trait ImageViewExt: Image {
+    fn wrap(&self, x: std::ops::Range<u32>, y: std::ops::Range<u32>) -> ImageView<Self>;
+}
+
+impl<T: Image> ImageViewExt for T {
+    fn wrap(&self, x: std::ops::Range<u32>, y: std::ops::Range<u32>) -> ImageView<Self> {
+        ImageView {
+            inner: self,
+            xmin: x.start,
+            xmax: x.end,
+            ymin: y.start,
+            ymax: y.end,
+        }
+    }
+}
+
+pub mod prelude {
+    pub use super::{Image, ImageViewExt};
+}

src/instance/black_border_detector.rs

@@ -192,19 +192,18 @@ impl BlackBorder {
         }
     }
 
-    pub fn get_ranges(&self, width: u32, height: u32) -> ((u32, u32), (u32, u32)) {
+    pub fn get_ranges(
+        &self,
+        width: u32,
+        height: u32,
+    ) -> (std::ops::Range<u32>, std::ops::Range<u32>) {
         if self.unknown {
-            ((0, width), (0, height))
+            (0..width, 0..height)
         } else {
             (
-                (
-                    self.vertical_size.min(width / 2),
-                    (width - self.vertical_size).max(width / 2),
-                ),
-                (
-                    self.horizontal_size.min(height / 2),
-                    (height - self.horizontal_size).max(height / 2),
-                ),
+                self.vertical_size.min(width / 2)..(width - self.vertical_size).max(width / 2),
+                self.horizontal_size.min(height / 2)
+                    ..(height - self.horizontal_size).max(height / 2),
             )
         }
     }

src/instance/core.rs

@@ -1,6 +1,6 @@
 use crate::{
     color::{color_to16, ChannelAdjustments, ChannelAdjustmentsBuilder},
-    image::Image,
+    image::prelude::*,
     models::{Color, Color16, InstanceConfig, Leds},
 };
 
@@ -48,20 +48,24 @@ impl Core {
         let black_border = self.black_border_detector.current_border();
 
         // Update the 16-bit color data from the LED ranges and the image
-        let ((xmin, xmax), (ymin, ymax)) = black_border.get_ranges(image.width(), image.height());
-        let width = (xmax - xmin) as f32;
-        let height = (ymax - ymin) as f32;
+        let image = {
+            let (x, y) = black_border.get_ranges(image.width(), image.height());
+            image.wrap(x, y)
+        };
+
+        let width = image.width() as f32;
+        let height = image.height() as f32;
         for (spec, value) in self.leds.leds.iter().zip(self.color_data.iter_mut()) {
             let mut r_acc = 0u64;
             let mut g_acc = 0u64;
             let mut b_acc = 0u64;
             let mut cnt = 0u64;
 
             // TODO: Fixed point arithmetic
-            let lxmin = spec.hmin * width + xmin as f32;
-            let lxmax = spec.hmax * width + xmin as f32;
-            let lymin = spec.vmin * height + ymin as f32;
-            let lymax = spec.vmax * height + ymin as f32;
+            let lxmin = spec.hmin * width;
+            let lxmax = spec.hmax * width;
+            let lymin = spec.vmin * height;
+            let lymax = spec.vmax * height;
 
             for y in lymin.floor() as u32..=(lymax.ceil() as u32).min(image.height() - 1) {
                 let y_area = if (y as f32) < lymin {