gray.hpp

 
#ifndef UFO_VISION_COLOR_GRAY_HPP
#define UFO_VISION_COLOR_GRAY_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 Gray;
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Gray<T, ColorFlags::None> {
    T gray;
 
    [[nodiscard]] friend constexpr bool operator==(Gray const& a,
                                                   Gray const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Gray<T, ColorFlags::Alpha> {
    T gray;
 
    T alpha;
 
    [[nodiscard]] friend constexpr bool operator==(Gray const& a,
                                                   Gray const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Gray<T, ColorFlags::Weight> {
    T gray;
 
    float weight;
 
    [[nodiscard]] friend constexpr bool operator==(Gray const& a,
                                                   Gray const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Gray<T, ColorFlags::Alpha | ColorFlags::Weight> {
    T gray;
 
    T alpha;
 
    float weight;
 
    [[nodiscard]] friend constexpr bool operator==(Gray const& a,
                                                   Gray const& b) noexcept = default;
};
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T gray(Gray<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.gray / static_cast<T>(color.weight);
    } else {
        return color.gray;
    }
}
 
using SmallGray = Gray<std::uint8_t>;
 
using SmallGrayA = Gray<std::uint8_t, ColorFlags::Alpha>;
 
using SmallGrayW = Gray<std::uint8_t, ColorFlags::Weight>;
 
using SmallGrayAW = Gray<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>;
 
using FineGray = Gray<float>;
 
using FineGrayA = Gray<float, ColorFlags::Alpha>;
 
using FineGrayW = Gray<float, ColorFlags::Weight>;
 
using FineGrayAW = Gray<float, ColorFlags::Alpha | ColorFlags::Weight>;
 
template <class T, ColorFlags Flags>
inline std::ostream& operator<<(std::ostream& out, Gray<T, Flags> const& c)
{
    out << "Gray: " << +c.gray;
    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::Gray<T, Flags>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::Gray<T, Flags> const& c, std::format_context& ctx) const
    {
        auto out = std::format_to(ctx.out(), "Gray: {}", +c.gray);
        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_GRAY_HPP