color_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include "epaper/color/color.hpp"
#include "epaper/color/device_color.hpp"
#include "epaper/core/types.hpp"
#include "epaper/drivers/driver.hpp"
#include <algorithm>
#include <cstdint>
#include <span>
#include <vector>
 
namespace epaper {
 
class ColorManager {
private:
  [[nodiscard]] static constexpr auto distance_sq(const RGB &c1, const RGB &c2) noexcept -> int {
    int dr = static_cast<int>(c1.r) - static_cast<int>(c2.r);
    int dg = static_cast<int>(c1.g) - static_cast<int>(c2.g);
    int db = static_cast<int>(c1.b) - static_cast<int>(c2.b);
    return (dr * dr) + (dg * dg) + (db * db);
  }
 
public:
  ColorManager() = default;
 
  [[nodiscard]] static constexpr auto to_rgb(Color color) noexcept -> RGB {
    switch (color) {
    case Color::Black:
      return colors::Black;
    case Color::White:
      return colors::White;
    case Color::Red:
      return colors::Red;
    case Color::Green:
      return colors::Green;
    case Color::Blue:
      return colors::Blue;
    case Color::Yellow:
      return colors::Yellow;
    case Color::Gray1:
      return colors::LightGray;
    case Color::Gray2:
      return colors::DarkGray;
    default:
      return colors::White;
    }
  }
 
  [[nodiscard]] static constexpr auto convert_to_bw(const RGB &color) noexcept -> DeviceColor<DisplayMode::BlackWhite> {
    const auto gray = color.to_grayscale();
    return DeviceColor<DisplayMode::BlackWhite>{gray >= 128};
  }
 
  [[nodiscard]] static constexpr auto convert_to_gray4(const RGB &color) noexcept
      -> DeviceColor<DisplayMode::Grayscale4> {
    const auto gray = color.to_grayscale();
    // Map 0-255 to 0-3
    // 0-63 -> 0 (black), 64-127 -> 1, 128-191 -> 2, 192-255 -> 3 (white)
    const std::uint8_t level = gray >> 6; // Divide by 64
    return DeviceColor<DisplayMode::Grayscale4>{level};
  }
 
  [[nodiscard]] static constexpr auto convert_to_bwr(const RGB &color) noexcept -> DeviceColor<DisplayMode::BWR> {
    // Current options: Black, White, Red
    const int d_black = distance_sq(color, colors::Black);
    const int d_white = distance_sq(color, colors::White);
    const int d_red = distance_sq(color, colors::Red);
 
    if (d_red < d_black && d_red < d_white) {
      return DeviceColor<DisplayMode::BWR>{TriColor::Third}; // Red
    }
    if (d_black < d_white) {
      return DeviceColor<DisplayMode::BWR>{TriColor::Black};
    }
    return DeviceColor<DisplayMode::BWR>{TriColor::White};
  }
 
  [[nodiscard]] static constexpr auto convert_to_bwy(const RGB &color) noexcept -> DeviceColor<DisplayMode::BWY> {
    // Current options: Black, White, Yellow
    const int d_black = distance_sq(color, colors::Black);
    const int d_white = distance_sq(color, colors::White);
    const int d_yellow = distance_sq(color, colors::Yellow);
 
    if (d_yellow < d_black && d_yellow < d_white) {
      return DeviceColor<DisplayMode::BWY>{TriColor::Third}; // Yellow
    }
    if (d_black < d_white) {
      return DeviceColor<DisplayMode::BWY>{TriColor::Black};
    }
    return DeviceColor<DisplayMode::BWY>{TriColor::White};
  }
 
  [[nodiscard]] static constexpr auto convert_to_spectra6(const RGB &color) noexcept
      -> DeviceColor<DisplayMode::Spectra6> {
    // Colors: Black, White, Red, Green, Blue, Yellow
    const int d_black = distance_sq(color, colors::Black);
    const int d_white = distance_sq(color, colors::White);
    const int d_red = distance_sq(color, colors::Red);
    const int d_green = distance_sq(color, colors::Green);
    const int d_blue = distance_sq(color, colors::Blue);
    const int d_yellow = distance_sq(color, colors::Yellow);
 
    int min_d = d_black;
    auto result = Spectra6Color::Black;
 
    if (d_white < min_d) {
      min_d = d_white;
      result = Spectra6Color::White;
    }
    if (d_red < min_d) {
      min_d = d_red;
      result = Spectra6Color::Red;
    }
    if (d_green < min_d) {
      min_d = d_green;
      result = Spectra6Color::Green;
    }
    if (d_blue < min_d) {
      min_d = d_blue;
      result = Spectra6Color::Blue;
    }
    if (d_yellow < min_d) {
      min_d = d_yellow;
      result = Spectra6Color::Yellow;
    }
    return DeviceColor<DisplayMode::Spectra6>{result};
  }
 
  [[nodiscard]] static constexpr auto convert_to_bw(const RGBA &color, const RGB &background = colors::White) noexcept
      -> DeviceColor<DisplayMode::BlackWhite> {
    const auto blended = blend_alpha(color, background);
    return convert_to_bw(blended);
  }
 
  [[nodiscard]] static constexpr auto convert_to_gray4(const RGBA &color,
                                                       const RGB &background = colors::White) noexcept
      -> DeviceColor<DisplayMode::Grayscale4> {
    const auto blended = blend_alpha(color, background);
    return convert_to_gray4(blended);
  }
 
  template <DisplayMode Mode>
  [[nodiscard]] static constexpr auto convert(const RGB &color) noexcept -> DeviceColor<Mode> {
    if constexpr (Mode == DisplayMode::BlackWhite) {
      return convert_to_bw(color);
    } else if constexpr (Mode == DisplayMode::Grayscale4) {
      return convert_to_gray4(color);
    } else if constexpr (Mode == DisplayMode::BWR) {
      return convert_to_bwr(color);
    } else if constexpr (Mode == DisplayMode::BWY) {
      return convert_to_bwy(color);
    } else if constexpr (Mode == DisplayMode::Spectra6) {
      return convert_to_spectra6(color);
    } else {
      return DeviceColor<Mode>{};
    }
  }
 
  template <DisplayMode Mode>
  [[nodiscard]] static constexpr auto convert(const RGBA &color, const RGB &background = colors::White) noexcept
      -> DeviceColor<Mode> {
    if constexpr (Mode == DisplayMode::BlackWhite) {
      return convert_to_bw(color, background);
    } else if constexpr (Mode == DisplayMode::Grayscale4) {
      return convert_to_gray4(color, background);
    } else {
      // For color modes, blend and default
      const auto blended = blend_alpha(color, background);
      return convert<Mode>(blended);
    }
  }
 
  template <DisplayMode Mode, typename SetPixelFunc>
  static void dither_image(std::span<const std::uint8_t> rgb_data, std::size_t width, std::size_t height,
                           SetPixelFunc set_pixel) {
    if (rgb_data.size() < width * height * 3) {
      return;
    }
 
    // Floyd-Steinberg Error Diffusion Dithering
    // Algorithm: Quantize each pixel and distribute quantization error to
    // neighboring unprocessed pixels using weighted error diffusion kernel.
    //
    // Error diffusion kernel (fractions of quantization error):
    //              X   7/16
    //      3/16  5/16  1/16
    //
    // Where X is current pixel. Error propagates right and down only,
    // allowing single-pass left-to-right, top-to-bottom processing.
 
    struct RGBError {
      int r, g, b;
    };
    std::vector<RGBError> pixels(width * height);
 
    // Initialize working buffer with RGB values as signed integers
    // to allow negative intermediate values during error propagation
    for (std::size_t i = 0; i < width * height; ++i) {
      pixels[i] = {static_cast<int>(rgb_data[i * 3]), static_cast<int>(rgb_data[(i * 3) + 1]),
                   static_cast<int>(rgb_data[(i * 3) + 2])};
    }
 
    // Clamp values to [0, 255] after error accumulation
    auto clamp = [](int v) -> std::uint8_t { return static_cast<std::uint8_t>(std::max(0, std::min(255, v))); };
 
    // Process pixels in raster scan order (left-to-right, top-to-bottom)
    for (std::size_t y = 0; y < height; ++y) {
      for (std::size_t x = 0; x < width; ++x) {
        std::size_t i = (y * width) + x;
        RGB current{clamp(pixels[i].r), clamp(pixels[i].g), clamp(pixels[i].b)};
 
        // Step 1: Quantize current pixel to nearest device color
        auto dev_color = convert<Mode>(current);
        set_pixel(x, y, dev_color);
 
        // Step 2: Calculate quantization error (original - quantized)
        RGB quantized = dev_color.to_rgb();
        int er = static_cast<int>(current.r) - static_cast<int>(quantized.r);
        int eg = static_cast<int>(current.g) - static_cast<int>(quantized.g);
        int eb = static_cast<int>(current.b) - static_cast<int>(quantized.b);
 
        // Step 3: Distribute quantization error to neighboring pixels
        // Floyd-Steinberg error diffusion weights:
        //   Right neighbor (x+1, y):     7/16 of error
        //   Bottom-left (x-1, y+1):      3/16 of error
        //   Bottom (x, y+1):             5/16 of error
        //   Bottom-right (x+1, y+1):     1/16 of error
        auto add_error = [&](std::size_t idx, double factor) {
          pixels[idx].r += static_cast<int>(er * factor);
          pixels[idx].g += static_cast<int>(eg * factor);
          pixels[idx].b += static_cast<int>(eb * factor);
        };
 
        // Diffuse to right neighbor (7/16)
        if (x + 1 < width) {
          add_error((y * width) + (x + 1), 7.0 / 16.0);
        }
 
        // Diffuse to next row (if not at bottom edge)
        if (y + 1 < height) {
          // Bottom-left diagonal (3/16)
          if (x > 0) {
            add_error(((y + 1) * width) + (x - 1), 3.0 / 16.0);
          }
          // Directly below (5/16)
          add_error(((y + 1) * width) + x, 5.0 / 16.0);
          // Bottom-right diagonal (1/16)
          if (x + 1 < width) {
            add_error(((y + 1) * width) + (x + 1), 1.0 / 16.0);
          }
        }
      }
    }
  }
 
private:
  [[nodiscard]] static constexpr auto blend_alpha(const RGBA &color, const RGB &background) noexcept -> RGB {
    const auto alpha = static_cast<double>(color.a) / 255.0;
    const auto inv_alpha = 1.0 - alpha;
 
    const auto r = static_cast<std::uint8_t>((color.r * alpha) + (background.r * inv_alpha));
    const auto g = static_cast<std::uint8_t>((color.g * alpha) + (background.g * inv_alpha));
    const auto b = static_cast<std::uint8_t>((color.b * alpha) + (background.b * inv_alpha));
 
    return RGB{r, g, b};
  }
};
 
} // namespace epaper