chromatic_adaptations.ipp

Go to the documentation of this file.

#pragma once
 
#include "Math/Color/chromatic_adaptations.h"
#include "Utility/IUninstantiable.h"
 
#include <Common/assertion.h>
 
namespace ph::math
{
 
template<EChromaticAdaptation ALGORITHM>
class TChromaticAdaptationDefinitionHelper : private IUninstantiable
{
    static_assert(ALGORITHM != EChromaticAdaptation::Unspecified);
 
public:
    inline static consteval EChromaticAdaptation getAlgorithm() noexcept
    {
        return ALGORITHM;
    }
};
 
template<typename T>
inline TMatrix3<T> create_von_kries_linear_CAT_matrix(
    const TMatrix3<T>&    CIEXYZToConeResponse,
    const TMatrix3<T>&    ConeResponseToCIEXYZ,
    const EReferenceWhite srcRefWhite,
    const EReferenceWhite dstRefWhite)
{
    PH_ASSERT(srcRefWhite != EReferenceWhite::Unspecified);
    PH_ASSERT(dstRefWhite != EReferenceWhite::Unspecified);
    PH_ASSERT(srcRefWhite != dstRefWhite);
    
    return create_von_kries_linear_CAT_matrix<T>(
        CIEXYZToConeResponse,
        ConeResponseToCIEXYZ,
        CIEXYZ_of<T>(srcRefWhite),
        CIEXYZ_of<T>(dstRefWhite));
}
 
template<typename T>
inline TMatrix3<T> create_von_kries_linear_CAT_matrix(
    const TMatrix3<T>&           CIEXYZToConeResponse,
    const TMatrix3<T>&           ConeResponseToCIEXYZ,
    const TTristimulusValues<T>& srcRefWhite,
    const TTristimulusValues<T>& dstRefWhite)
{
    const TTristimulusValues<T> srcConeResponse = CIEXYZToConeResponse.multiplyVector(srcRefWhite);
    const TTristimulusValues<T> dstConeResponse = CIEXYZToConeResponse.multiplyVector(dstRefWhite);
 
    PH_ASSERT_NE(srcConeResponse[0], 0);
    PH_ASSERT_NE(srcConeResponse[1], 0);
    PH_ASSERT_NE(srcConeResponse[2], 0);
 
    const TTristimulusValues<T> coneResponseScale = {
        dstConeResponse[0] / srcConeResponse[0],
        dstConeResponse[1] / srcConeResponse[1],
        dstConeResponse[2] / srcConeResponse[2]
    };
    
    const auto coneResponseScaleMat = TMatrix3<T>().setScale(coneResponseScale);
    return ConeResponseToCIEXYZ.mul(coneResponseScaleMat).mul(CIEXYZToConeResponse);
}
 
template<typename T>
class TChromaticAdaptationDefinition<EChromaticAdaptation::XYZScaling, T> final
    : public TChromaticAdaptationDefinitionHelper<EChromaticAdaptation::XYZScaling>
{
public:
    inline static TMatrix3<T> getCIEXYZToConeResponse()
    {
        return TMatrix3<T>().setIdentity();
    }
 
    inline static TMatrix3<T> getConeResponseToCIEXYZ()
    {
        return TMatrix3<T>().setIdentity();
    }
 
    inline static TTristimulusValues<T> adapt(
        const TTristimulusValues<T>& CIEXYZColor,
        const EReferenceWhite        srcRefWhite,
        const EReferenceWhite        dstRefWhite)
    {
        const auto CATMatrix = create_von_kries_linear_CAT_matrix<T>(
            getCIEXYZToConeResponse(),
            getConeResponseToCIEXYZ(),
            srcRefWhite,
            dstRefWhite);
 
        return CATMatrix.multiplyVector(CIEXYZColor);
    }
};
 
template<typename T>
class TChromaticAdaptationDefinition<EChromaticAdaptation::Bradford, T> final
    : public TChromaticAdaptationDefinitionHelper<EChromaticAdaptation::Bradford>
{
public:
    inline static TMatrix3<T> getCIEXYZToConeResponse()
    {
        return TMatrix3<T>(Matrix3D(
             0.8951000,  0.2664000, -0.1614000,
            -0.7502000,  1.7135000,  0.0367000,
             0.0389000, -0.0685000,  1.0296000));
    }
 
    inline static TMatrix3<T> getConeResponseToCIEXYZ()
    {
        return TMatrix3<T>(Matrix3D(
             0.9869929054667121899,   -0.14705425642099010066,  0.15996265166373123948,
             0.43230526972339451002,   0.51836027153677753834,  0.049291228212855612148,
            -0.0085286645751773312464, 0.040042821654084864313, 0.96848669578754998478));
    }
 
    inline static TTristimulusValues<T> adapt(
        const TTristimulusValues<T>& CIEXYZColor,
        const EReferenceWhite        srcRefWhite,
        const EReferenceWhite        dstRefWhite)
    {
        const auto CATMatrix = create_von_kries_linear_CAT_matrix<T>(
            getCIEXYZToConeResponse(),
            getConeResponseToCIEXYZ(),
            srcRefWhite,
            dstRefWhite);
 
        return CATMatrix.multiplyVector(CIEXYZColor);
    }
};
 
template<typename T>
class TChromaticAdaptationDefinition<EChromaticAdaptation::VonKries, T> final
    : public TChromaticAdaptationDefinitionHelper<EChromaticAdaptation::VonKries>
{
public:
    inline static TMatrix3<T> getCIEXYZToConeResponse()
    {
        return TMatrix3<T>(Matrix3D(
             0.4002400, 0.7076000, -0.0808100,
            -0.2263000, 1.1653200,  0.0457000,
             0.0000000, 0.0000000,  0.9182200));
    }
 
    inline static TMatrix3<T> getConeResponseToCIEXYZ()
    {
        return TMatrix3<T>(Matrix3D(
            1.8599363874558397422, -1.1293816185800914784,   0.21989740959619327624,
            0.36119143624176752624, 0.63881246328504213303, -0.0000063705968386570599758,
            0,                      0,                       1.0890636230968613186));
    }
 
    inline static TTristimulusValues<T> adapt(
        const TTristimulusValues<T>& CIEXYZColor,
        const EReferenceWhite        srcRefWhite,
        const EReferenceWhite        dstRefWhite)
    {
        const auto CATMatrix = create_von_kries_linear_CAT_matrix<T>(
            getCIEXYZToConeResponse(),
            getConeResponseToCIEXYZ(),
            srcRefWhite,
            dstRefWhite);
 
        return CATMatrix.multiplyVector(CIEXYZColor);
    }
};
 
// End Chromatic Adaptation Definitions
 
// Unspecified adaption configuration must not be a valid definition.
static_assert(!CChromaticAdaptationDefinition<
    TChromaticAdaptationDefinition<EChromaticAdaptation::Unspecified, ColorValue>, ColorValue>);
 
template<EChromaticAdaptation ALGORITHM, typename T>
inline TTristimulusValues<T> chromatic_adapt(
    const TTristimulusValues<T>& srcCIEXYZColor,
    const EReferenceWhite        srcRefWhite,
    const EReferenceWhite        dstRefWhite)
{
    using ChromaticAdapter = TChromaticAdaptationDefinition<ALGORITHM, T>;
 
    static_assert(CChromaticAdaptationDefinition<ChromaticAdapter, T>,
        "No definition for the specified chromatic adaptation ALGORITHM.");
 
    return ChromaticAdapter::adapt(srcCIEXYZColor, srcRefWhite, dstRefWhite);
}
 
}// end namespace ph::math