blend.hpp

 
#ifndef UFO_VISION_COLOR_BLEND_HPP
#define UFO_VISION_COLOR_BLEND_HPP
 
// UFO
#include <ufo/vision/color/arithmetic.hpp>
#include <ufo/vision/color/concepts.hpp>
#include <ufo/vision/color/convert.hpp>
#include <ufo/vision/color/type_traits.hpp>
 
// STL
#include <algorithm>
#include <concepts>
#include <iterator>
#include <ranges>
 
namespace ufo
{
template <Color C>
[[nodiscard]] constexpr C blend(C a, C const& b, float t)
{
    using D = typename color_traits<C>::template rebind_value<float>;
 
    if constexpr (std::same_as<C, D>) {
        return a + t * (b - a);
    } else {
        return convert<C>(blend(convert<D>(a), convert<D>(b), t));
    }
}
 
template <std::ranges::input_range R, std::ranges::input_range W>
  requires Color<std::ranges::range_value_t<R>> &&
           std::floating_point<std::ranges::range_value_t<W>>
[[nodiscard]] constexpr std::ranges::range_value_t<R> blend(R&& r, W&& w)
{
    using C = std::ranges::range_value_t<R>;
    using D = typename color_traits<C>::template rebind_value<float>;
 
    if constexpr (std::same_as<C, D>) {
        return std::ranges::fold_left(
            std::views::zip(r, w) | std::views::transform([](auto&& z) {
                auto [c, weight] = z;
                return c * weight;
            }),
            D{}, std::plus{});
    } else {
        return convert<C>(std::ranges::fold_left(
            std::views::zip(r, w) | std::views::transform([](auto&& z) {
                auto [c, weight] = z;
                return convert<D>(c) * weight;
            }),
            D{}, std::plus{}));
    }
}
 
template <std::input_iterator InputIt1, std::sentinel_for<InputIt1> Sentinel,
          std::input_iterator InputIt2>
  requires Color<std::iter_value_t<InputIt1>> &&
           std::floating_point<std::iter_value_t<InputIt2>>
[[nodiscard]] constexpr std::iter_value_t<InputIt1> blend(InputIt1 first, Sentinel last,
                                                          InputIt2 first_weight)
{
    auto r = std::ranges::subrange(std::move(first), std::move(last));
    auto w = std::views::repeat(0.0f) |
             std::views::transform([first_weight, i = 0](auto) mutable {
                 return *std::next(first_weight, i++);
             });
    return blend(r, w);
}
 
template <std::ranges::input_range R, std::floating_point T>
  requires Color<std::ranges::range_value_t<R>>
[[nodiscard]] constexpr std::ranges::range_value_t<R> blend(R&&                      r,
                                                            std::initializer_list<T> w)
{
    return blend(std::forward<R>(r), std::ranges::subrange(w));
}
 
template <Color C, std::floating_point T>
[[nodiscard]] constexpr C blend(std::initializer_list<C> r, std::initializer_list<T> w)
{
    return blend(std::ranges::subrange(r), std::ranges::subrange(w));
}
 
}  // namespace ufo
 
#endif  // UFO_VISION_COLOR_BLEND_HPP