color_converter.hpp

#pragma once
#include "color.hpp"
#include "palette.hpp"
#include <bugui/concepts/color.hpp>
 
#include <cstdint>
#include <limits>
 
namespace bugui
{
template <typename Value_t>
struct base_converter
{
  using color_value_t = Value_t;

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

  bool operator== (const color& other) const
  {
    return other == original;
  }
 
  bool operator!= (const base_converter<Value_t>& other) const
  {
    return other != original;
  }

  Value_t get() const { return value; }
  color::states get_state() const
  { return original.get_state(); }

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

template <typename T, typename Value_t = uint8_t>
  requires (has_color_palette<T> && integral_no_bool<Value_t>)
struct color_converter
    : base_converter<Value_t>
{
  color_converter() = default;
  color_converter(const color& color) { set(color); };
  ~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()};
 
    // adapted from
    // github.com/ArthurSonzogni/FTXUI/blob/main/src/ftxui/screen/color.cpp
    // line 114
    for (const auto& [rgb, val] : palette<T>::value)
    {
      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;
      }
    }
  }
 
  void clear() override
  {
    this->value = clear_value;
    this->original.clear();
  }
 
  bool is_clear() override
  {
    return this->original.is_clear()
           && this->value == clear_value;
  }
 
  static const Value_t clear_value;
};
 
template <typename T, typename Value_t>
  requires (has_color_palette<T> && integral_no_bool<Value_t>)
inline const Value_t color_converter<T, Value_t>::clear_value
    {color_converter<T, Value_t>({0, 0, 0}).get()};

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();
  }
 
  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;
  }
 
  static const color::rgba clear_value;
};
 
template <typename T>
  requires (!has_color_palette<T>)
inline const color::rgba color_converter<T, color::rgba>
    ::clear_value{0, 0, 0};

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;
  }
 
  void clear() override
  {
    value = clear_value;
    original.clear();
  }
 
  bool is_clear() override
  {
    return original.is_clear()
    && value == clear_value;
  }
 
  static const uint8_t clear_value;
};
 
template <typename T>
  requires (!has_color_palette<T>)
inline const uint8_t color_converter<T, uint8_t>::clear_value
    {color_converter<T, uint8_t>({0, 0, 0}).get()};
 
} // namespace bugui