lch.hpp

 
#ifndef UFO_VISION_COLOR_LCH_HPP
#define UFO_VISION_COLOR_LCH_HPP
 
// UFO
#include <ufo/vision/color/flags.hpp>
 
// STL
#include <concepts>
#include <cstdint>
#include <format>
#include <ostream>
 
namespace ufo
{
template <class T = float, ColorFlags Flags = ColorFlags::None>
  requires(std::integral<T> || std::floating_point<T>)
struct Lch;
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lch<T, ColorFlags::None> {
    T lightness;
 
    T chroma;
 
    T hue;
 
    [[nodiscard]] friend constexpr bool operator==(Lch const& a,
                                                   Lch const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lch<T, ColorFlags::Alpha> {
    T lightness;
 
    T chroma;
 
    T hue;
 
    T alpha;
 
    [[nodiscard]] friend constexpr bool operator==(Lch const& a,
                                                   Lch const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lch<T, ColorFlags::Weight> {
    T lightness;
 
    T chroma;
 
    T hue;
 
    float weight;
 
    [[nodiscard]] friend constexpr bool operator==(Lch const& a,
                                                   Lch const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lch<T, ColorFlags::Alpha | ColorFlags::Weight> {
    T lightness;
 
    T chroma;
 
    T hue;
 
    T alpha;
 
    float weight;
 
    [[nodiscard]] friend constexpr bool operator==(Lch const& a,
                                                   Lch const& b) noexcept = default;
};
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T lightness(Lch<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.lightness / static_cast<T>(color.weight);
    } else {
        return color.lightness;
    }
}
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T chroma(Lch<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.chroma / static_cast<T>(color.weight);
    } else {
        return color.chroma;
    }
}
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T hue(Lch<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.hue / static_cast<T>(color.weight);
    } else {
        return color.hue;
    }
}
 
using SmallLch = Lch<std::uint8_t>;
 
using SmallLchA = Lch<std::uint8_t, ColorFlags::Alpha>;
 
using SmallLchW = Lch<std::uint8_t, ColorFlags::Weight>;
 
using SmallLchAW = Lch<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>;
 
using FineLch = Lch<float>;
 
using FineLchA = Lch<float, ColorFlags::Alpha>;
 
using FineLchW = Lch<float, ColorFlags::Weight>;
 
using FineLchAW = Lch<float, ColorFlags::Alpha | ColorFlags::Weight>;
 
template <class T, ColorFlags Flags>
inline std::ostream& operator<<(std::ostream& out, Lch<T, Flags> const& c)
{
    out << "Lightness: " << c.lightness << " Chroma: " << c.chroma << " Hue: " << c.hue;
    if constexpr (alphaset(Flags)) {
        out << " Alpha: " << +c.alpha;
    }
    if constexpr (weightset(Flags)) {
        out << " Weight: " << c.weight;
    }
    return out;
}
 
}  // namespace ufo
 
template <class T, ufo::ColorFlags Flags>
struct std::formatter<ufo::Lch<T, Flags>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::Lch<T, Flags> const& c, std::format_context& ctx) const
    {
        auto out = std::format_to(ctx.out(), "Lightness: {} Chroma: {} Hue: {}", c.lightness,
                                  c.chroma, c.hue);
        if constexpr (ufo::alphaset(Flags)) {
            out = std::format_to(out, " Alpha: {}", +c.alpha);
        }
        if constexpr (ufo::weightset(Flags)) {
            out = std::format_to(out, " Weight: {}", c.weight);
        }
        return out;
    }
};
 
#endif  // UFO_VISION_COLOR_LCH_HPP