add serde/strum, modify EIinkPanel API

Cargo.lock

@@ -1309,6 +1309,8 @@ dependencies = [
  "linux-embedded-hal",
  "minijinja",
  "palette",
+ "serde",
+ "strum",
  "thiserror",
  "tokio",
  "tower-http",
@@ -1756,6 +1758,28 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
+[[package]]
+name = "strum"
+version = "0.26.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.72"

Cargo.toml

@@ -15,6 +15,8 @@ image = "0.25.1"
 linux-embedded-hal = { version = "0.4.0"}
 minijinja = "2.1.0"
 palette = "0.7.6"
+serde = { version = "1.0.204", features = ["derive"] }
+strum = { version = "0.26.3", features = ["derive"] }
 thiserror = "1.0.63"
 tokio = { version = "1.38.1", features = ["full"] }
 tower-http = { version = "0.5.2", features = ["trace"] }

src/api.rs

@@ -7,6 +7,7 @@ use image::ImageReader;
 use std::io::Cursor;
 use std::time::Duration;
 use tracing::{debug, error, info, instrument};
+use serde::{Serialize, Deserialize};
 
 use crate::display::EInkPanel;
 use std::sync::Arc;
@@ -36,25 +37,6 @@ impl Context {
     }
 }
 
-#[derive(Debug)]
-pub struct DisplaySetCommand {
-    img: Box<EInkImage>,
-}
-#[instrument(skip_all)]
-pub async fn display_task(
-    mut rx: Receiver<DisplaySetCommand>,
-    mut display: Box<dyn EInkPanel + Send>,
-) {
-    while let Some(cmd) = rx.recv().await {
-        info!("Got a display set command");
-        let raw_buf = cmd.img.into_display_buffer();
-        if let Err(e) = display.display(&raw_buf) {
-            error!("Error displaying command {e}");
-        }
-        info!("Done setting display");
-    }
-}
-
 // Make our own error that wraps `anyhow::Error`.
 struct AppError(anyhow::Error);
 
@@ -80,11 +62,38 @@ where
     }
 }
 
+#[derive(Debug)]
+pub struct DisplaySetCommand {
+    img: Box<EInkImage>,
+}
+
+#[instrument(skip_all)]
+pub async fn display_task(
+    mut rx: Receiver<DisplaySetCommand>,
+    mut display: Box<dyn EInkPanel + Send>,
+) {
+    while let Some(cmd) = rx.recv().await {
+        info!("Got a display set command");
+        if let Err(e) = display.display(&cmd.img) {
+            error!("Error displaying command {e}");
+        }
+        info!("Done setting display");
+    }
+}
+
 /// API routes for axum
 /// Start with the basics: Send an image, crop it, dither, and upload.
 /// we defer the upload to a separate task.
 pub fn router() -> Router<Context> {
-    Router::new().route("/setimage", post(set_image))
+    Router::new()
+        .route("/setimage", post(set_image))
+        .route("/process_image", post(process_image))
+}
+
+
+
+#[derive(Serialize, Deserialize)]
+pub struct ImageRequest {
 }
 
 #[instrument(skip(ctx))]
@@ -103,8 +112,8 @@ async fn set_image(
             debug!("Guessed format: {:?}", reader.format());
 
             let image = reader.decode()?;
-            let mut buf = EInkImage::new(800, 480);
-            let dither = ErrorDiffusionDither::new(DiffusionMatrix::Atkinson);
+            let mut buf = EInkImage::default();
+            let mut dither = ErrorDiffusionDither::new(DiffusionMatrix::Atkinson);
             dither.dither(&image.into(), &mut buf);
             let cmd = DisplaySetCommand { img: Box::new(buf) };
             ctx.display_channel
@@ -114,3 +123,7 @@ async fn set_image(
     }
     Ok(())
 }
+
+async fn process_image(mut parts: Multipart) -> Result<impl IntoResponse, AppError> {
+    Ok(StatusCode::OK)
+}

src/display.rs

@@ -8,8 +8,10 @@ use tracing::{debug, warn};
 use anyhow::Result;
 use linux_embedded_hal::gpio_cdev::{Chip, LineRequestFlags};
 
+use crate::imageproc::EInkImage;
+
 pub trait EInkPanel {
-    fn display(&mut self, buf: &[u8]) -> Result<()>;
+    fn display(&mut self, buf: &EInkImage) -> Result<()>;
 }
 
 pub struct Wrapper {
@@ -64,9 +66,10 @@ impl Wrapper {
 
 impl EInkPanel for Wrapper {
     #[instrument(skip_all)]
-    fn display(&mut self, buf: &[u8]) -> Result<()> {
+    fn display(&mut self, img: &EInkImage) -> Result<()> {
+        let buf = img.into_display_buffer();
         self.panel
-            .update_and_display_frame(&mut self.spi, buf, &mut self.delay)?;
+            .update_and_display_frame(&mut self.spi, &buf, &mut self.delay)?;
         debug!("Finished updating frame");
         self.panel.sleep(&mut self.spi, &mut self.delay)?;
         debug!("Display entered sleep mode");
@@ -74,11 +77,16 @@ impl EInkPanel for Wrapper {
     }
 }
 
+
+/// A Fake EInk display for testing purposes.
+/// Saves the output as `display.bmp`
 pub struct FakeEInk();
 impl EInkPanel for FakeEInk {
-    fn display(&mut self, _buf: &[u8]) -> Result<()> {
-        // Do nothing.
-        warn!("Fake display was called");
+    fn display(&mut self, img: &EInkImage) -> Result<()> {
+
+        warn!("Fake display was called: saving to display.bmp");
+        img.into_rgbimage().save("display.bmp");
+
         Ok(())
     }
 }

src/imageproc.rs

@@ -1,4 +1,5 @@
-use image::RgbImage;
+use image::{GrayImage, ImageBuffer, Luma, RgbImage};
+use palette::FromColor;
 use tracing::instrument;
 
 use image::Rgb as imgRgb;
@@ -18,128 +19,88 @@ const DISPLAY_PALETTE: [Srgb; 7] = [
     Srgb::new(0.757, 0.443, 0.165), // Orange
 ];
 
-// TODO: support different color palettes.
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum DisplayColor {
-    Black,
-    White,
-    Green,
-    Blue,
-    Red,
-    Yellow,
-    Orange,
+pub enum ProcessingError {
+    DitherError,
+    PaletteIndexError(usize),
 }
 
-impl From<DisplayColor> for Srgb {
-    fn from(value: DisplayColor) -> Self {
-        DISPLAY_PALETTE[value as usize]
-    }
-}
-
-impl DisplayColor {
-    fn from_u8(value: u8) -> Self {
-        match value {
-            0 => Self::Black,
-            1 => Self::White,
-            2 => Self::Green,
-            3 => Self::Blue,
-            4 => Self::Red,
-            5 => Self::Yellow,
-            6 => Self::Orange,
-            _ => panic!("unexpected DisplayColor {value}"),
-        }
-    }
-
-    fn into_byte(color1: Self, color2: Self) -> u8 {
-        let upper: u8 = color1.into();
-        let lower: u8 = color2.into();
-        upper << 4 | lower
-    }
-}
-impl From<DisplayColor> for u8 {
-    fn from(value: DisplayColor) -> Self {
-        value as Self
-    }
-}
 /// Buffer to be sent to the ``EInk`` display.
 #[derive(Debug)]
 pub struct EInkImage {
-    data: Vec<DisplayColor>,
-    width: u32,
-    height: u32,
+    buf: ImageBuffer<Luma<u8>, Vec<u8>>,
+    palette: Vec<Srgb>,
 }
 
 impl EInkImage {
     #[must_use]
     pub fn into_display_buffer(&self) -> Vec<u8> {
-        let mut buf = Vec::with_capacity(self.data.len() / 2);
-
-        for colors in self.data.chunks_exact(2) {
-            buf.push(DisplayColor::into_byte(colors[0], colors[1]));
+        let mut buf = Vec::with_capacity(self.buf.len() / 2);
+        for pix in self.buf.chunks_exact(2) {
+            buf.push(pix[0] << 4 | pix[1]);
         }
-
         buf
     }
-    #[must_use]
-    pub fn new(width: u32, height: u32) -> Self {
-        let v = vec![DisplayColor::Black; (width * height) as usize];
-        Self {
-            data: v,
-            width,
-            height,
-        }
-    }
 
-    /// Produces a regular RGB image from this image buffer using the given
-    /// color palette.
-    pub fn make_image(&self) -> RgbImage {
-        RgbImage::from_fn(self.width, self.height, |x, y| {
-            let srgb = Srgb::from(self.data[(y * self.width + x) as usize]);
-            let arr: [u8; 3] = srgb.into_format().into();
+    /// Convert the EInk-palette image into an RGB image to be viewed on a regular screen.
+    #[must_use]
+    pub fn into_rgbimage(&self) -> RgbImage {
+        RgbImage::from_fn(self.buf.width(), self.buf.height(), |x, y| {
+            let idx = self.buf.get_pixel(x, y).0[0];
+            let disp_color = self.palette.get(idx as usize).unwrap();
+            let arr: [u8; 3] = disp_color.into_format().into();
             imgRgb(arr)
         })
     }
 
-    /// Returns the dimensions (width, height) of the image buffer.
-    pub const fn dimensions(&self) -> (u32, u32) {
-        (self.width, self.height)
+    /// Constructs a new EInk Image based on the given color palette for
+    /// color indexing.
+    #[must_use]
+    pub fn new(palette: Vec<Srgb>) -> Self {
+        Self {
+            buf: GrayImage::new(800, 480),
+            palette,
+        }
+    }
+}
+
+impl Default for EInkImage {
+    fn default() -> Self {
+        Self::new(DISPLAY_PALETTE.to_vec())
     }
 }
 
 pub trait Ditherer {
-    fn dither(&self, img: &RgbImage, output: &mut EInkImage);
+    fn dither(&mut self, img: &RgbImage, output: &mut EInkImage);
 }
 
 /// Find the closest approximate palette color to the given sRGB value.
 /// This uses euclidian distance in linear space.
-#[must_use]
-pub fn nearest_neighbor(input_color: Lab) -> (DisplayColor, Lab) {
-    let (nearest, _, color_diff) = DISPLAY_PALETTE
+fn nearest_neighbor(input_color: Lab, palette: &[Srgb]) -> (u8, Lab) {
+    let (nearest, _, color_diff) = palette
         .iter()
         .enumerate()
         .map(|(idx, p_color)| {
-            let c: Lab = (*p_color).into_color();
+            let c: Lab = Lab::from_color(*p_color);
             (idx, input_color.difference(c), input_color - c)
         })
         .min_by(|(_, a, _), (_, b, _)| a.total_cmp(b))
-        .expect("could not find a color");
-    (DisplayColor::from_u8(nearest as u8), color_diff)
+        .expect("Should always find a color");
+    (nearest as u8, color_diff)
 }
 
 pub struct NNDither();
 
 impl Ditherer for NNDither {
-    fn dither(&self, img: &RgbImage, output: &mut EInkImage) {
+    fn dither(&mut self, img: &RgbImage, output: &mut EInkImage) {
         assert!(img.width() == 800);
         assert!(img.height() == 480);
 
         // sRGB view into the given image. zero copy!
         let srgb = <&[Srgb<u8>]>::from_components(&**img);
 
-        for (idx, pixel) in srgb.iter().enumerate() {
-            let (n, _) = nearest_neighbor(pixel.into_format().into_color());
-            output.data[idx] = n;
+        for (idx, pix) in output.buf.iter_mut().enumerate() {
+            let (n, _) = nearest_neighbor(srgb[idx].into_format().into_color(), &output.palette);
+            *pix = n;
         }
     }
 }
@@ -152,13 +113,13 @@ const fn coord_to_idx(x: u32, y: u32, xsize: u32) -> usize {
 
 /// Compute the error-adjusted new lab value based on the error value of the currently scanned
 /// pixel multiplied by a scalar factor.
-fn get_error_adjusted(orig: &Lab, err: &Lab, scalar: f32) -> Lab {
-    let (p_l, p_a, p_b) = orig.into_components();
+fn compute_error_adjusted_color(orig: &Lab, err: &Lab, weight: f32) -> Lab {
+    let (orig_l, orig_a, orig_b) = orig.into_components();
     let (err_l, err_a, err_b) = err.into_components();
     Lab::from_components((
-        p_l + err_l * scalar,
-        p_a + err_a * scalar,
-        p_b + err_b * scalar,
+        err_l.mul_add(weight, orig_l), // scalar * err_l + p_l
+        err_a.mul_add(weight, orig_a),
+        err_b.mul_add(weight, orig_b),
     ))
 }
 
@@ -255,10 +216,12 @@ impl ErrorDiffusionDither {
 
 impl Ditherer for ErrorDiffusionDither {
     #[instrument]
-    fn dither(&self, img: &RgbImage, output: &mut EInkImage) {
+    fn dither(&mut self, img: &RgbImage, output: &mut EInkImage) {
         // create a copy of the image in Lab space, mutable.
+        // first, a view into the rgb components
         let srgb = <&[Srgb<u8>]>::from_components(&**img);
         let (xsize, ysize) = img.dimensions();
+        // our destination buffer.
         let mut temp_img: Vec<Lab> = Vec::with_capacity((xsize * ysize) as usize);
         for pix in srgb {
             temp_img.push(pix.into_format().into_color());
@@ -269,9 +232,9 @@ impl Ditherer for ErrorDiffusionDither {
             for x in 0..xsize {
                 let index = coord_to_idx(x, y, xsize);
                 let curr_pix = temp_img[index];
-                let (nearest, err) = nearest_neighbor(curr_pix);
+                let (nearest, err) = nearest_neighbor(curr_pix, &output.palette);
                 // set the color in the output buffer.
-                output.data[index] = nearest;
+                *output.buf.get_mut(index).unwrap() = nearest;
                 // take the error, and propagate it.
                 for point in self.0.value() {
                     let Some(target_x) = x.checked_add_signed(point.xshift) else {
@@ -282,7 +245,7 @@ impl Ditherer for ErrorDiffusionDither {
                     };
                     let target = coord_to_idx(target_x, target_y, xsize);
                     if let Some(pix) = temp_img.get(target) {
-                        temp_img[target] = get_error_adjusted(pix, &err, point.scale);
+                        temp_img[target] = compute_error_adjusted_color(pix, &err, point.scale);
                     }
                 }
             }

src/main.rs

@@ -3,13 +3,13 @@ pub mod display;
 pub mod errors;
 pub mod imageproc;
 
-use crate::display::{EInkPanel, Wrapper};
+use crate::display::{FakeEInk, EInkPanel, Wrapper};
 use crate::imageproc::{DiffusionMatrix, Ditherer, EInkImage, ErrorDiffusionDither};
 use clap::{Parser, Subcommand};
 use image::RgbImage;
-use tracing::info;
+use tracing::{error, info};
 
-/// Display images over
+/// Display images on E-Ink Displays
 #[derive(Debug, Parser)]
 #[command(version, about)]
 struct Cli {
@@ -34,15 +34,15 @@ async fn main() -> anyhow::Result<()> {
     println!("CLI {cli:?}");
 
     if matches!(cli.command, Command::Show) {
-        let img: RgbImage = image::ImageReader::open("myimage.png")?.decode()?.into();
-        let mut display = Wrapper::new()?;
+        let img: RgbImage = image::ImageReader::open("image.png")?.decode()?.into();
+        error!("HI");
+        let mut display = FakeEInk {};
 
-        let mut eink_buf = EInkImage::new(800, 480);
-        let dither = ErrorDiffusionDither::new(DiffusionMatrix::Atkinson);
+        let mut eink_buf = EInkImage::default();
+        let mut dither = ErrorDiffusionDither::new(DiffusionMatrix::Atkinson);
 
         dither.dither(&img, &mut eink_buf);
-        let raw_buf = eink_buf.into_display_buffer();
-        display.display(&raw_buf)?;
+        display.display(&eink_buf)?;
     }
     if matches!(cli.command, Command::Test) {
         let mut display = Wrapper::new()?;