refactor: Move image reduction code to image module

Author: alixinne

src/image.rs

@@ -4,6 +4,9 @@ use thiserror::Error;
 
 use crate::models::Color;
 
+mod reducer;
+pub use reducer::*;
+
 pub trait Image: Sized {
     /// Get the width of the image, in pixels
     fn width(&self) -> u32;

src/image/reducer.rs

@@ -0,0 +1,61 @@
+use crate::models::{Color16, Led};
+
+use super::Image;
+
+#[derive(Debug, Default)]
+pub struct Reducer {}
+
+impl Reducer {
+    pub fn reduce(&mut self, image: &impl Image, leds: &[Led], color_data: &mut [Color16]) {
+        let width = image.width() as f32;
+        let height = image.height() as f32;
+        for (spec, value) in leds.iter().zip(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;
+            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 {
+                    (255. * (1. - lymin.fract())) as u64
+                } else if (y + 1) as f32 > lymax {
+                    (255. * lymax.fract()) as u64
+                } else {
+                    255
+                };
+
+                for x in lxmin.floor() as u32..=(lxmax.ceil() as u32).min(image.width() - 1) {
+                    if let Some(rgb) = image.color_at(x, y) {
+                        let x_area = if (x as f32) < lxmin {
+                            (255. * (1. - lxmin.fract())) as u64
+                        } else if (x + 1) as f32 > lxmax {
+                            (255. * lxmax.fract()) as u64
+                        } else {
+                            255
+                        };
+
+                        let area = x_area * y_area / 255;
+
+                        let (r, g, b) = rgb.into_components();
+                        r_acc += (r as u64 * 255) * area;
+                        g_acc += (g as u64 * 255) * area;
+                        b_acc += (b as u64 * 255) * area;
+                        cnt += area;
+                    }
+                }
+            }
+
+            *value = Color16::new(
+                (r_acc / cnt.max(1)).max(0).min(u16::MAX as _) as u16,
+                (g_acc / cnt.max(1)).max(0).min(u16::MAX as _) as u16,
+                (b_acc / cnt.max(1)).max(0).min(u16::MAX as _) as u16,
+            );
+        }
+    }
+}

src/instance/core.rs

@@ -1,6 +1,6 @@
 use crate::{
     color::{color_to16, ChannelAdjustments, ChannelAdjustmentsBuilder},
-    image::prelude::*,
+    image::{prelude::*, Reducer},
     models::{Color, Color16, InstanceConfig, Leds},
 };
 
@@ -16,6 +16,7 @@ pub struct Core {
     channel_adjustments: ChannelAdjustments,
     smoothing: Smoothing,
     notified_inconsistent_led_data: bool,
+    reducer: Reducer,
 }
 
 impl Core {
@@ -35,6 +36,7 @@ impl Core {
             channel_adjustments,
             smoothing,
             notified_inconsistent_led_data: false,
+            reducer: Default::default(),
         }
     }
 
@@ -47,62 +49,15 @@ impl Core {
         self.black_border_detector.process(image);
         let black_border = self.black_border_detector.current_border();
 
-        // Update the 16-bit color data from the LED ranges and the image
+        // Crop the image using a view
         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;
-            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 {
-                    (255. * (1. - lymin.fract())) as u64
-                } else if (y + 1) as f32 > lymax {
-                    (255. * lymax.fract()) as u64
-                } else {
-                    255
-                };
-
-                for x in lxmin.floor() as u32..=(lxmax.ceil() as u32).min(image.width() - 1) {
-                    if let Some(rgb) = image.color_at(x, y) {
-                        let x_area = if (x as f32) < lxmin {
-                            (255. * (1. - lxmin.fract())) as u64
-                        } else if (x + 1) as f32 > lxmax {
-                            (255. * lxmax.fract()) as u64
-                        } else {
-                            255
-                        };
-
-                        let area = x_area * y_area / 255;
-
-                        let (r, g, b) = rgb.into_components();
-                        r_acc += (r as u64 * 255) * area;
-                        g_acc += (g as u64 * 255) * area;
-                        b_acc += (b as u64 * 255) * area;
-                        cnt += area;
-                    }
-                }
-            }
-
-            *value = Color16::new(
-                (r_acc / cnt.max(1)).max(0).min(u16::MAX as _) as u16,
-                (g_acc / cnt.max(1)).max(0).min(u16::MAX as _) as u16,
-                (b_acc / cnt.max(1)).max(0).min(u16::MAX as _) as u16,
-            );
-        }
+        // Update the 16-bit color data from the LED ranges and the image
+        self.reducer
+            .reduce(&image, &self.leds.leds[..], &mut self.color_data);
     }
 
     fn handle_led_colors(&mut self, led_colors: &[Color]) {