KoColorSpaceMaths.h File Reference

#include <cmath>
#include <limits>
#include "kritapigment_export.h"
#include <KoIntegerMaths.h>
#include "KoChannelInfo.h"
#include "KoLut.h"
#include <kis_global.h>
#include <KoConfig.h>

Go to the source code of this file.

Classes
struct	HSIType
struct	HSLType
struct	HSVType
struct	HSYType
class	KoColorSpaceMaths< _T, _Tdst >
class	KoColorSpaceMathsTraits< _T >
class	KoColorSpaceMathsTraits< double >
class	KoColorSpaceMathsTraits< float >
class	KoColorSpaceMathsTraits< qint16 >
class	KoColorSpaceMathsTraits< quint16 >
class	KoColorSpaceMathsTraits< quint32 >
class	KoColorSpaceMathsTraits< quint8 >
struct	KoIntegerToFloat< _T_ >
struct	KoLuts

Namespaces
namespace	Arithmetic

Functions
template<class HSXType , class TReal >
void	addLightness (TReal &r, TReal &g, TReal &b, TReal light)
template<class T >
KoColorSpaceMathsTraits< T >::compositetype	Arithmetic::and (T a, T b)
template<class T >
T	Arithmetic::blend (T src, T srcAlpha, T dst, T dstAlpha, T cfValue)
template<class T >
T	Arithmetic::clamp (typename KoColorSpaceMathsTraits< T >::compositetype a)
template<class T >
T	Arithmetic::clampChannelToSDR (T a)
template<class T >
T	Arithmetic::clampChannelToSDRBottom (T a)
template<class T >
T	Arithmetic::clampToSDR (typename KoColorSpaceMathsTraits< T >::compositetype a)
template<class T >
T	Arithmetic::clampToSDRBottom (typename KoColorSpaceMathsTraits< T >::compositetype a)
template<class T >
T	Arithmetic::clampToSDRTop (typename KoColorSpaceMathsTraits< T >::compositetype a)
template<class T >
KoColorSpaceMathsTraits< T >::compositetype	Arithmetic::div (T a, T b)
template<class T , typename composite_type = typename KoColorSpaceMathsTraits<T>::compositetype>
composite_type	Arithmetic::divideInCompositeSpace (composite_type a, composite_type b)
template<class T >
T	Arithmetic::epsilon ()
int	float2int (double x)
int	float2int (float x)
template<class TReal >
TReal	getHue (TReal r, TReal g, TReal b)
template<class HSXType , class TReal >
static TReal	getLightness (TReal r, TReal g, TReal b)
template<class TReal >
void	getRGB (TReal &r, TReal &g, TReal &b, TReal hue)
template<class HSXType , class TReal >
static TReal	getSaturation (TReal r, TReal g, TReal b)
template<class T >
T	Arithmetic::halfValue ()
template<class T >
T	Arithmetic::inv (T a)
template<typename T >
static bool	Arithmetic::isHalfValueFuzzy (T v)
template<typename T >
static bool	Arithmetic::isUnitValueClampedFuzzy (T v)
template<typename T >
bool	Arithmetic::isUnitValueClampedStrict (T value)
template<typename T >
static bool	Arithmetic::isUnitValueFuzzy (T v)
template<typename T >
bool	Arithmetic::isUnitValueStrict (T value)
template<typename T >
T	Arithmetic::isUnsafeAsDivisor (T value)
template<typename T >
static bool	Arithmetic::isZeroValueClampedFuzzy (T v)
template<typename T >
bool	Arithmetic::isZeroValueClampedStrict (T value)
template<typename T >
static bool	Arithmetic::isZeroValueFuzzy (T v)
template<typename T >
bool	Arithmetic::isZeroValueStrict (T value)
template<class T >
T	Arithmetic::lerp (T a, T b, T alpha)
template<class T >
T	Arithmetic::max (T a, T b, T c)
template<class T >
T	Arithmetic::min (T a, T b, T c)
template<class T >
KoColorSpaceMathsTraits< T >::compositetype	Arithmetic::mod (T a, T b)
template<class T >
T	Arithmetic::mul (T a, T b)
template<class T >
T	Arithmetic::mul (T a, T b, T c)
template<class T , typename composite_type = typename KoColorSpaceMathsTraits<T>::compositetype>
composite_type	Arithmetic::multiplyInCompositeSpace (composite_type a, composite_type b)
template<class T >
KoColorSpaceMathsTraits< T >::compositetype	Arithmetic::or (T a, T b)
template<class TRet , class T >
TRet	Arithmetic::scale (T a)
template<class HSXType , class TReal >
void	setLightness (TReal &r, TReal &g, TReal &b, TReal light)
template<class HSXType , class TReal >
void	setSaturation (TReal &r, TReal &g, TReal &b, TReal sat)
template<class HSXType , class TReal >
void	ToneMapping (TReal &r, TReal &g, TReal &b)
template<class T >
T	Arithmetic::unionShapeOpacity (T a, T b)
template<class T >
T	Arithmetic::unitValue ()
template<class T >
KoColorSpaceMathsTraits< T >::compositetype	Arithmetic::xor (T a, T b)
template<class T >
T	Arithmetic::zeroValue ()

Variables
static const qreal	Arithmetic::pi = 3.14159265358979323846

Function Documentation

addLightness()

template<class HSXType , class TReal >

void addLightness ( TReal & r, TReal & g, TReal & b, TReal light )

inline

Definition at line 1123 of file KoColorSpaceMaths.h.

{
    using namespace Arithmetic;
 
    r += light;
    g += light;
    b += light;
 
    ToneMapping<HSXType, TReal>(r, g, b);
}

float2int() [1/2]

int float2int ( double x )

inline

Definition at line 173 of file KoColorSpaceMaths.h.

{
    // NOTE: we don't use rint() here, because on Windows
    //       it falls back to x87 instructions on Intel CPUs,
    //       which are executed extremely slowly
    // NOTE2: we do always clamp value to 0...0xff range
    //        before calling this function, so `x` cannot be
    //        negative.
    return int(x + 0.5);
}

float2int() [2/2]

int float2int ( float x )

inline

Definition at line 162 of file KoColorSpaceMaths.h.

{
    // NOTE: we don't use rint() here, because on Windows
    //       it falls back to x87 instructions on Intel CPUs,
    //       which are executed extremely slowly
    // NOTE2: we do always clamp value to 0...0xff range
    //        before calling this function, so `x` cannot be
    //        negative.
    return int(x + 0.5f);
}

getHue()

template<class TReal >

TReal getHue	(	TReal	r,
		TReal	g,
		TReal	b )

Definition at line 988 of file KoColorSpaceMaths.h.

                                        {
    TReal min    = Arithmetic::min(r, g, b);
    TReal max    = Arithmetic::max(r, g, b);
    TReal chroma = max - min;
    
    TReal hue = TReal(-1.0);
    
    if(chroma > std::numeric_limits<TReal>::epsilon()) {
        
//         return atan2(TReal(2.0)*r - g - b, TReal(1.73205080756887729353)*(g - b));
        
        if(max == r) // between yellow and magenta
            hue = (g - b) / chroma;
        else if(max == g) // between cyan and yellow
            hue = TReal(2.0) + (b - r) / chroma;
        else if(max == b) // between magenta and cyan
            hue = TReal(4.0) + (r - g) / chroma;
        
        if(hue < -std::numeric_limits<TReal>::epsilon())
            hue += TReal(6.0);
        
        hue /= TReal(6.0);
    }
    
//     hue = (r == max) ? (b-g) : (g == max) ? TReal(2.0)+(r-b) : TReal(4.0)+(g-r);
    
    return hue;
}

References Arithmetic::max(), and Arithmetic::min().

getLightness()

template<class HSXType , class TReal >

static TReal getLightness ( TReal r, TReal g, TReal b )

inlinestatic

Definition at line 1047 of file KoColorSpaceMaths.h.

                                                            {
    return HSXType::getLightness(r, g, b);
}

getRGB()

template<class TReal >

void getRGB	(	TReal &	r,
		TReal &	g,
		TReal &	b,
		TReal	hue )

Definition at line 1018 of file KoColorSpaceMaths.h.

                                                     {
    // 0 red    -> (1,0,0)
    // 1 yellow -> (1,1,0)
    // 2 green  -> (0,1,0)
    // 3 cyan   -> (0,1,1)
    // 4 blue   -> (0,0,1)
    // 5 magenta -> (1,0,1)
    // 6 red    -> (1,0,0)
    
    if(hue < -std::numeric_limits<TReal>::epsilon()) {
        r = g = b = TReal(0.0);
        return;
    }
    
    int   i = int(hue * TReal(6.0));
    TReal x = hue * TReal(6.0) - i;
    TReal y = TReal(1.0) - x;
    
    switch(i % 6){
        case 0: { r=TReal(1.0), g=x         , b=TReal(0.0); } break;
        case 1: { r=y         , g=TReal(1.0), b=TReal(0.0); } break;
        case 2: { r=TReal(0.0), g=TReal(1.0), b=x         ; } break;
        case 3: { r=TReal(0.0), g=y         , b=TReal(1.0); } break;
        case 4: { r=x         , g=TReal(0.0), b=TReal(1.0); } break;
        case 5: { r=TReal(1.0), g=TReal(0.0), b=y         ; } break;
    }
}

getSaturation()

template<class HSXType , class TReal >

static TReal getSaturation ( TReal r, TReal g, TReal b )

inlinestatic

Definition at line 1141 of file KoColorSpaceMaths.h.

                                                             {
    return HSXType::getSaturation(r, g, b);
}

setLightness()

template<class HSXType , class TReal >

void setLightness ( TReal & r, TReal & g, TReal & b, TReal light )

inline

Definition at line 1135 of file KoColorSpaceMaths.h.

{
    addLightness<HSXType>(r,g,b, light - HSXType::getLightness(r,g,b));
}

setSaturation()

template<class HSXType , class TReal >

void setSaturation ( TReal & r, TReal & g, TReal & b, TReal sat )

inline

Definition at line 1146 of file KoColorSpaceMaths.h.

{
    int   min    = 0;
    int   mid    = 1;
    int   max    = 2;
    TReal rgb[3] = {r, g, b};
    
    if(rgb[mid] < rgb[min]) {
        int tmp = min;
        min = mid;
        mid = tmp;
    }
    
    if(rgb[max] < rgb[mid]) {
        int tmp = mid;
        mid = max;
        max = tmp;
    }
    
    if(rgb[mid] < rgb[min]) {
        int tmp = min;
        min = mid;
        mid = tmp;
    }
    
    if((rgb[max] - rgb[min]) > std::numeric_limits<TReal>::epsilon()) {
        rgb[mid] = ((rgb[mid]-rgb[min]) * sat) / (rgb[max]-rgb[min]);
        rgb[max] = sat;
        rgb[min] = TReal(0.0);
        
        r = rgb[0];
        g = rgb[1];
        b = rgb[2];
    }
    else r = g = b = TReal(0.0);
}

ToneMapping()

template<class HSXType , class TReal >

void ToneMapping ( TReal & r, TReal & g, TReal & b )

inline

The tonemapping method we use does not support lightness values below 0.0, so we just clamp the value.

TODO: use proper HSV/HSI shape-tracking clamping methods we use in kis_hsv_adjustment.cpp

The tonemapping method we use does not support lightness values above 1.0, so we just clamp the value.

TODO: use proper HSV/HSI shape-tracking clamping methods we use in kis_hsv_adjustment.cpp

Definition at line 1052 of file KoColorSpaceMaths.h.

{
    using namespace Arithmetic;
 
 
    TReal l = HSXType::getLightness(r, g, b);
    TReal n = min(r, g, b);
    TReal x = max(r, g, b);
 
    if(n < TReal(0.0)) {
        if (isZeroValueClampedFuzzy<float>(l)) {
            r = g = b = TReal(0.0);
        } else {
            const TReal stretch = l - n;
 
            if (stretch < std::numeric_limits<TReal>::epsilon()) {
                r = g = b = TReal(0.0);
            } else {
                TReal iln = TReal(1.0) / stretch;
                r = l + ((r-l) * l) * iln;
                g = l + ((g-l) * l) * iln;
                b = l + ((b-l) * l) * iln;
            }
        }
    }
 
    if(x > TReal(1.0)) {
        auto setFallbackValues = [&] () {
            if constexpr (HSXType::lightnessIsAverage) {
                r = g = b = TReal(1.0);
            } else {
                r = qMin(r, TReal(1.0));
                g = qMin(g, TReal(1.0));
                b = qMin(b, TReal(1.0));
            }
        };
 
        if (l > TReal(1.0)) {
            setFallbackValues();
        } else {
            const TReal stretch = x - l;
 
            if (stretch < std::numeric_limits<TReal>::epsilon()) {
                setFallbackValues();
            } else {
                TReal il  = TReal(1.0) - l;
                TReal ixl = TReal(1.0) / stretch;
 
                r = l + ((r-l) * il) * ixl;
                g = l + ((g-l) * il) * ixl;
                b = l + ((b-l) * il) * ixl;
            }
        }
    }
}