lab.hpp

 
#ifndef UFO_VISION_COLOR_LAB_HPP
#define UFO_VISION_COLOR_LAB_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 Lab;
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lab<T, ColorFlags::None> {
    T lightness;
 
    T a;
 
    T b;
 
    [[nodiscard]] friend constexpr bool operator==(Lab const& a,
                                                   Lab const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lab<T, ColorFlags::Alpha> {
    T lightness;
 
    T a;
 
    T b;
 
    T alpha;
 
    [[nodiscard]] friend constexpr bool operator==(Lab const& a,
                                                   Lab const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lab<T, ColorFlags::Weight> {
    T lightness;
 
    T a;
 
    T b;
 
    float weight;
 
    [[nodiscard]] friend constexpr bool operator==(Lab const& a,
                                                   Lab const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lab<T, ColorFlags::Alpha | ColorFlags::Weight> {
    T lightness;
 
    T a;
 
    T b;
 
    T alpha;
 
    float weight;
 
    [[nodiscard]] friend constexpr bool operator==(Lab const& a,
                                                   Lab const& b) noexcept = default;
};
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T lightness(Lab<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 a(Lab<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.a / static_cast<T>(color.weight);
    } else {
        return color.a;
    }
}
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T b(Lab<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.b / static_cast<T>(color.weight);
    } else {
        return color.b;
    }
}
 
using SmallLab = Lab<std::uint8_t>;
 
using SmallLabA = Lab<std::uint8_t, ColorFlags::Alpha>;
 
using SmallLabW = Lab<std::uint8_t, ColorFlags::Weight>;
 
using SmallLabAW = Lab<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>;
 
using FineLab = Lab<float>;
 
using FineLabA = Lab<float, ColorFlags::Alpha>;
 
using FineLabW = Lab<float, ColorFlags::Weight>;
 
using FineLabAW = Lab<float, ColorFlags::Alpha | ColorFlags::Weight>;
 
template <class T, ColorFlags Flags>
inline std::ostream& operator<<(std::ostream& out, Lab<T, Flags> const& c)
{
    out << "Lightness: " << c.lightness << " a: " << c.a << " b: " << c.b;
    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::Lab<T, Flags>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::Lab<T, Flags> const& c, std::format_context& ctx) const
    {
        auto out =
            std::format_to(ctx.out(), "Lightness: {} a: {} b: {}", c.lightness, c.a, c.b);
        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_LAB_HPP