delta_e.hpp

 
#ifndef UFO_VISION_COLOR_DELTA_E_HPP
#define UFO_VISION_COLOR_DELTA_E_HPP
 
// UFO
#include <ufo/utility/type_traits.hpp>
#include <ufo/vision/color/concepts.hpp>
#include <ufo/vision/color/convert.hpp>
#include <ufo/vision/color/space.hpp>
#include <ufo/vision/color/type_traits.hpp>
 
// STL
#include <cassert>
#include <cmath>
 
namespace ufo
{
enum class ColorDeltaE {
    EUCLIDEAN,
    // CIE76,
    // CMC,
    // CIE94,
    // CIEDE2000
    OK,
};
 
template <Color C>
[[nodiscard]] constexpr float deltaEEuclideanSquared(C const& color, C const& sample)
{
    using F = typename color_traits<C>::template rebind<float, ColorFlags::None>;
 
    auto const c = convert<F>(color);
    auto const s = convert<F>(sample);
 
    if constexpr (GrayColor<C>) {
        float const dg = c.gray - s.gray;
        return dg * dg;
    } else if constexpr (RgbFamilyColor<C>) {
        float const dr = c.red - s.red;
        float const dg = c.green - s.green;
        float const db = c.blue - s.blue;
        return dr * dr + dg * dg + db * db;
    } else if constexpr (LabColor<C>) {
        float const dl = c.lightness - s.lightness;
        float const da = c.a - s.a;
        float const db = c.b - s.b;
        return dl * dl + da * da + db * db;
    } else if constexpr (LchColor<C>) {
        float const dl = c.lightness - s.lightness;
        float const dc = c.chroma - s.chroma;
        float const dh = c.hue - s.hue;
        return dl * dl + dc * dc + dh * dh;
    } else {
        static_assert(dependent_false_v<C>, "Unknown color model");
    }
}
 
template <Color C>
[[nodiscard]] constexpr float deltaEEuclidean(C const& color, C const& sample)
{
    return std::sqrt(deltaEEuclideanSquared(color, sample));
}
 
template <Color C>
[[nodiscard]] constexpr float deltaEOkSquared(C const& color, C const& sample,
                                              float const ab_scale = 2.0f)
{
    auto const c = convert<FineLab>(color);
    auto const s = convert<FineLab>(sample);
 
    float const dl = c.lightness - s.lightness;
    float const da = ab_scale * (c.a - s.a);
    float const db = ab_scale * (c.b - s.b);
    return dl * dl + da * da + db * db;
}
 
template <Color C>
[[nodiscard]] constexpr float deltaEOk(C const& color, C const& sample,
                                       float const ab_scale = 2.0f)
{
    return std::sqrt(deltaEOkSquared(color, sample, ab_scale));
}
 
template <Color C>
[[nodiscard]] constexpr float deltaESquared(C const& color, C const& sample,
                                            ColorDeltaE method = ColorDeltaE::EUCLIDEAN,
                                            ColorSpace  space  = ColorSpace::NATIVE)
{
    if (ColorDeltaE::OK == method || ColorSpace::Oklab2 == space) {
        return deltaEOkSquared(color, sample);
    }
 
    switch (space) {
        case ColorSpace::NATIVE: return deltaEEuclideanSquared(color, sample);
        case ColorSpace::Rgb:
            return deltaEEuclideanSquared(convert<FineRgb>(color), convert<FineRgb>(sample));
        case ColorSpace::Oklab:
            return deltaEEuclideanSquared(convert<FineLab>(color), convert<FineLab>(sample));
        case ColorSpace::Oklch:
            return deltaEEuclideanSquared(convert<FineLch>(color), convert<FineLch>(sample));
        default: break;
    }
 
    assert(false && "Not implemented.");
    return 0.0f;
}
 
template <Color C>
[[nodiscard]] constexpr float deltaE(C const& color, C const& sample,
                                     ColorDeltaE method = ColorDeltaE::EUCLIDEAN,
                                     ColorSpace  space  = ColorSpace::NATIVE)
{
    return std::sqrt(deltaESquared(color, sample, method, space));
}
 
}  // namespace ufo
 
#endif  // UFO_VISION_COLOR_DELTA_E_HPP