color_converter.hpp

#pragma once
#include "color.hpp"
#include <concepts/device.hpp>
 
#include <cstdint>
#include <limits>
#include <ranges>
 
namespace bugui
{
template <typename Value_t>
struct base_converter
{
  using color_value_t = Value_t;
 
  ~base_converter() = default;

  virtual void set(const color& color) = 0;

  bool operator== (const color& other) const
  {
    return other == original;
  }

  Value_t get() const { return value; }
  Value_t get_secondary() const { return secondary; }
  Value_t get_state() const { return original.get_state(); }

  virtual void clear() = 0;
  virtual bool is_clear() = 0;
 
protected:
  base_converter() = default;
 
  Value_t value{};
  Value_t secondary{};
  color original{};
};

template <typename T>
class base_palette
{
protected:
  static constexpr auto palette{T::palette()};
};

template <hex_color_palette T>
class base_palette<T>
{
  static consteval auto make_rgb()
  {
    using namespace std;
 
    auto arr{array<pair<std::array<uint8_t, 3>, uint8_t>
                   , T::palette().size()>{}};
 
    for (const auto& [hex, rgb]
        : std::views::zip(T::palette(), arr))
    {
      rgb.first[0]  = hex.first >> 16; // R
      auto remain{hex.first - ((rgb.first[0] & 0xff) << 16)};
      rgb.first[1] = remain >> 8; // G
      rgb.first[2] = remain - ((rgb.first[1] & 0xff) << 8); // B
      rgb.second = hex.second; // Value
    }
 
    return arr;
  }
 
protected:
  static constexpr auto palette{make_rgb()};
};

template <has_color_palette T, typename Value_t = uint8_t>
struct color_converter
    : base_converter<Value_t>
    , base_palette<T>
{
  color_converter() = default;
 
  void set(const color& color) override
  {
    if (this->original == color) return;
 
    this->original = color;
    auto c{this->original.get()};
 
    float factor{static_cast<float>(c[3] / 255)};
    uint8_t r = c[0] * factor;
    uint8_t g = c[1] * factor;
    uint8_t b = c[2] * factor;
    int min_d{std::numeric_limits<int>::max()};
 
    if (this->original.get_state() == color::constant)
    {
      // adapted from
      // github.com/ArthurSonzogni/FTXUI/blob/main/src/ftxui/screen/color.cpp
      // line 114
      for (const auto& [rgb, val] : this->palette)
      {
        auto dr{r - rgb[0]};
        auto dg{g - rgb[1]};
        auto db{b - rgb[2]};
        auto d = dr*dr + dg*dg + db*db;
        if (d < min_d)
        {
          min_d = d;
          this->value = val;
        }
      }
    }
    else
    {
      auto sc{this->original.get_secondary()};
 
      float factor{static_cast<float>(sc[3] / 255)};
      uint8_t sr = sc[0] * factor;
      uint8_t sg = sc[1] * factor;
      uint8_t sb = sc[2] * factor;
      int s_min_d{std::numeric_limits<int>::max()};
 
      for (const auto& [rgb, val] : this->palette)
      {
        auto dr{r - rgb[0]};
        auto sdr{sr - rgb[0]};
        auto dg{g - rgb[1]};
        auto sdg{sg - rgb[1]};
        auto db{b - rgb[2]};
        auto sdb{sb - rgb[2]};
        auto d = dr*dr + dg*dg + db*db;
        auto sd = sdr*sdr + sdg*sdg + sdb*sdb;
        if (d < min_d)
        {
          min_d = d;
          this->value = val;
        }
        if (sd < s_min_d)
        {
          s_min_d = sd;
          this->secondary = val;
        }
      }
    }
  }
 
  void clear() override
  {
    this->value = 0;
    this->original.clear();
  }
 
  bool is_clear() override
  {
    return this->original.is_clear()
           && this->value == 0;
  }
};

template <typename T>
  requires (!has_color_palette<T>)
struct color_converter<T, color::rgba>
    : base_converter<color::rgba>
{
  void set(const color& color) override
  {
    original = color;
    value = original.get();
    secondary = original.get_secondary();
  }
 
  void clear() override
  {
    value[0] = 0;
    value[1] = 0;
    value[2] = 0;
    value[3] = 255;
    original.clear();
  }
 
  bool is_clear() override
  {
    return original.is_clear()
           && value[0] == 0
           && value[1] == 0
           && value[2] == 0
           && value[3] == 255;
  }
};

template <typename T>
  requires (!has_color_palette<T>)
struct color_converter<T, uint8_t>
    : base_converter<uint8_t>
{
  void set(const color& color) override
  {
    if (original == color) return;
 
    original = color;
    auto c{original.get()};
 
    float factor{static_cast<float>(c[3] / 255)};
    uint8_t r = c[0] * factor;
    uint8_t g = c[1] * factor;
    uint8_t b = c[2] * factor;
 
    // according to
    // goodcalculators.com/rgb-to-grayscale-conversion-calculator
    value = 0.299 * r + 0.587 * g + 0.114 * b;
 
    if (original.get_state() == color::constant) return;
 
    c = original.get_secondary();
    factor = static_cast<float>(c[3] / 255);
    r = c[0] * factor;
    g = c[1] * factor;
    b = c[2] * factor;
 
    secondary = 0.299 * r + 0.587 * g + 0.114 * b;
  }
 
  void clear() override
  {
    value = 0;
    original.clear();
  }
 
  bool is_clear() override
  {
    return original.is_clear()
    && value == 0;
  }
};
 
} // namespace bugui