peak_ipl_color_correction_factors.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_ipl/backend/peak_ipl_attribute_defines.h>
#include <peak_ipl/exception/peak_ipl_exception.hpp>
 
#include <array>
#include <type_traits>
#include <limits>
#include <cmath>

namespace peak
{
namespace ipl
{
struct ColorCorrectionFactors
{
    constexpr ColorCorrectionFactors(float facRR, float facGR, float facBR, float facRG, float facGG, float facBG,
        float facRB, float facGB, float facBB)
        : factorRR(facRR)
        , factorGR(facGR)
        , factorBR(facBR)
        , factorRG(facRG)
        , factorGG(facGG)
        , factorBG(facBG)
        , factorRB(facRB)
        , factorGB(facGB)
        , factorBB(facBB)
    {}

    constexpr explicit ColorCorrectionFactors(const std::array<float, 9>& factors)
        : factorRR(factors[0])
        , factorGR(factors[1])
        , factorBR(factors[2])
        , factorRG(factors[3])
        , factorGG(factors[4])
        , factorBG(factors[5])
        , factorRB(factors[6])
        , factorGB(factors[7])
        , factorBB(factors[8])
    {}

    constexpr ColorCorrectionFactors() = default;

    ~ColorCorrectionFactors() = default;

    ColorCorrectionFactors(ColorCorrectionFactors&& o) = default;

    ColorCorrectionFactors(const ColorCorrectionFactors& o) = default;

    ColorCorrectionFactors& operator=(const ColorCorrectionFactors& o) = default;

    ColorCorrectionFactors& operator=(ColorCorrectionFactors&& o) = default;

    PEAK_IPL_NO_DISCARD constexpr bool operator==(const ColorCorrectionFactors& other) const
    {
        return (isEqual(factorRR, other.factorRR) && isEqual(factorGR, other.factorGR)
            && isEqual(factorBR, other.factorBR) && isEqual(factorRG, other.factorRG)
            && isEqual(factorGG, other.factorGG) && isEqual(factorBG, other.factorBG)
            && isEqual(factorRB, other.factorRB) && isEqual(factorGB, other.factorGB)
            && isEqual(factorBB, other.factorBB));
    }

    PEAK_IPL_NO_DISCARD static constexpr ColorCorrectionFactors Identity()
    {
        return { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
    }

    PEAK_IPL_NO_DISCARD constexpr std::array<float,9> AsArray() const
    {
        return { factorRR, factorGR, factorBR, factorRG, factorGG, factorBG, factorRB, factorGB, factorBB };
    }
 
    float factorRR{}; 
    float factorGR{}; 
    float factorBR{}; 
    float factorRG{}; 
    float factorGG{}; 
    float factorBG{}; 
    float factorRB{}; 
    float factorGB{}; 
    float factorBB{}; 
 
private:
    template <class T>
    static constexpr T Absolute(const T& x) noexcept
    {
        return x < 0 ? -x : x;
    }
 
    template <class T>
    static constexpr typename std::enable_if<std::numeric_limits<T>::is_iec559, bool>::type isEqual(T x, T y)
    {
        return Absolute(x - y) <= std::numeric_limits<T>::epsilon();
    }
 
    template <class T>
    static constexpr typename std::enable_if<std::is_integral<T>::value, bool>::type isEqual(T x, T y)
    {
        return x == y;
    }
};
 
} /* namespace ipl */
} /* namespace peak */