KoCompositeOpFunctions.h File Reference

#include <KoColorSpaceMaths.h>
#include <KoCompositeOpGenericFunctorBase.h>
#include <KoCompositeOpClampPolicy.h>
#include <type_traits>
#include <cmath>

Go to the source code of this file.

Classes
struct	CFAdditiveSubtractive< T >
struct	CFColor< HSXType, channels_type >
struct	CFColorBurn< T >
struct	CFColorDodge< T, ClampPolicy >
struct	CFDarkerColor< HSXType, channels_type >
struct	CFDecreaseLightness< HSXType, channels_type >
struct	CFDecreaseSaturation< HSXType, channels_type >
struct	CFDivide< T >
struct	CFEquivalence< T >
struct	CFExclusion< T >
struct	CFFlatLight< T >
struct	CFFrect< T >
struct	CFGammaDark< T >
struct	CFGammaIllumination< T >
struct	CFGammaLight< T >
struct	CFGeometricMean< T >
struct	CFGleat< T >
struct	CFGrainExtract< T >
struct	CFGrainMerge< T >
struct	CFHardLight< T >
struct	CFHardMix< T, ClampPolicy >
struct	CFHardMixPhotoshop< T >
struct	CFHardMixSofterPhotoshop< T >
struct	CFHardOverlay< T, ClampPolicy >
struct	CFHelow< T >
struct	CFHue< HSXType, channels_type >
struct	CFIncreaseLightness< HSXType, channels_type >
struct	CFIncreaseSaturation< HSXType, channels_type >
struct	CFInverseSubtract< T >
struct	CFLambertLighting< HSXType, channels_type >
struct	CFLambertLightingGamma2_2< HSXType, channels_type >
struct	CFLighterColor< HSXType, channels_type >
struct	CFLightness< HSXType, channels_type >
struct	CFLinearBurn< T, ClampPolicy >
struct	CFNegation< T >
struct	CFOverlay< T >
struct	CFParallel< T >
struct	CFPenumbraA< T >
struct	CFPenumbraB< T >
struct	CFPinLight< T >
struct	CFReeze< T >
struct	CFReorientedNormalMapCombine< channels_type >
struct	CFSaturation< HSXType, channels_type >
struct	CFSoftLight< T >
struct	CFSoftLightSvg< T >
struct	CFTangentNormalmap< channels_type >
struct	CFTint< HSXType, channels_type >
struct	CFVividLight< T, ClampPolicy >

Functions
template<class T >
T	cfAddition (T src, T dst)
template<class HSXType , class TReal >
void	cfAdditionSAI (TReal src, TReal sa, TReal &dst, TReal &da)
template<class T >
T	cfAllanon (T src, T dst)
template<class T >
T	cfAnd (T src, T dst)
template<class T >
T	cfArcTangent (T src, T dst)
template<class T >
T	cfConverse (T src, T dst)
template<class T >
T	cfDarkenOnly (T src, T dst)
template<class T >
T	cfDifference (T src, T dst)
template<class T >
T	cfDivisiveModulo (T src, T dst)
template<class T >
T	cfDivisiveModuloContinuous (T src, T dst)
template<class T >
T	cfEasyBurn (T src, T dst)
template<class T >
T	cfEasyDodge (T src, T dst)
template<class T >
T	cfFhyrd (T src, T dst)
template<class T >
T	cfFogDarkenIFSIllusions (T src, T dst)
template<class T >
T	cfFogLightenIFSIllusions (T src, T dst)
template<class T >
T	cfFreeze (T src, T dst)
template<class T >
T	cfGlow (T src, T dst)
template<class T >
T	cfHeat (T src, T dst)
template<class T >
T	cfImplies (T src, T dst)
template<class T >
T	cfInterpolation (T src, T dst)
template<class T >
T	cfInterpolationB (T src, T dst)
template<class T >
T	cfLightenOnly (T src, T dst)
template<class T >
T	cfLinearLight (T src, T dst)
template<class T >
T	cfModulo (T src, T dst)
template<class T >
T	cfModuloContinuous (T src, T dst)
template<class T >
T	cfModuloShift (T src, T dst)
template<class T >
T	cfModuloShiftContinuous (T src, T dst)
template<class T >
T	cfMultiply (T src, T dst)
template<class T >
T	cfNand (T src, T dst)
template<class T >
T	cfNor (T src, T dst)
template<class T >
T	cfNotConverse (T src, T dst)
template<class T >
T	cfNotImplies (T src, T dst)
template<class T >
T	cfOr (T src, T dst)
template<class T >
T	cfOver (T src, T dst)
template<class T >
T	cfPenumbraC (T src, T dst)
template<class T >
T	cfPenumbraD (T src, T dst)
template<class T >
T	cfPNormA (T src, T dst)
template<class T >
T	cfPNormB (T src, T dst)
template<class T >
T	cfReflect (T src, T dst)
template<class T >
T	cfScreen (T src, T dst)
template<class T >
T	cfShadeIFSIllusions (T src, T dst)
template<class T >
T	cfSoftLightIFSIllusions (T src, T dst)
template<class T >
T	cfSoftLightPegtopDelphi (T src, T dst)
template<class T >
T	cfSubtract (T src, T dst)
template<class T >
T	cfSuperLight (T src, T dst)
template<class T >
T	cfTintIFSIllusions (T src, T dst)
template<class T >
T	cfXnor (T src, T dst)
template<class T >
T	cfXor (T src, T dst)

Function Documentation

cfAddition()

template<class T >

T cfAddition ( T src, T dst )

inline

Definition at line 406 of file KoCompositeOpFunctions.h.

                                  {
    typedef typename KoColorSpaceMathsTraits<T>::compositetype composite_type;
    return Arithmetic::clamp<T>(composite_type(src) + dst);
}

cfAdditionSAI()

template<class HSXType , class TReal >

void cfAdditionSAI ( TReal src, TReal sa, TReal & dst, TReal & da )

inline

Definition at line 1336 of file KoCompositeOpFunctions.h.

{
    using namespace Arithmetic;
    typedef typename KoColorSpaceMathsTraits<TReal>::compositetype composite_type;
 
    Q_UNUSED(da);
    composite_type newsrc;
    newsrc = mul(src, sa);
    dst = clamp<TReal>(newsrc + dst);
}

cfAllanon()

template<class T >

T cfAllanon ( T src, T dst )

inline

Definition at line 597 of file KoCompositeOpFunctions.h.

                                 {
    using namespace Arithmetic;
    typedef typename KoColorSpaceMathsTraits<T>::compositetype composite_type;
    // (dst + src) / 2   [or (dst + src) * 0.5]
    return T((composite_type(src) + dst) * halfValue<T>() / unitValue<T>());
}

cfAnd()

template<class T >

T cfAnd ( T src, T dst )

inline

Definition at line 1092 of file KoCompositeOpFunctions.h.

                             {
    using namespace Arithmetic;
        
    return cfNor(inv(src),inv(dst));
}

References cfNor().

cfArcTangent()

template<class T >

T cfArcTangent ( T src, T dst )

inline

Definition at line 591 of file KoCompositeOpFunctions.h.

                                    {
    using namespace Arithmetic;
    return scale<T>(2.0 * atan2(scale<qreal>(src), scale<qreal>(dst)) / Arithmetic::pi);
}

References Arithmetic::pi.

cfConverse()

template<class T >

T cfConverse ( T src, T dst )

inline

Definition at line 1106 of file KoCompositeOpFunctions.h.

                                  {
    using namespace Arithmetic;
        
    return cfOr(inv(src),dst);
}

References cfOr().

cfDarkenOnly()

template<class T >

T cfDarkenOnly ( T src, T dst )

inline

Definition at line 846 of file KoCompositeOpFunctions.h.

{ return qMin(src, dst); }

cfDifference()

template<class T >

T cfDifference ( T src, T dst )

inline

Definition at line 840 of file KoCompositeOpFunctions.h.

{ return qMax(src,dst) - qMin(src,dst); }

cfDivisiveModulo()

template<class T >

T cfDivisiveModulo ( T src, T dst )

inline

Definition at line 1252 of file KoCompositeOpFunctions.h.

                                        {
    using namespace Arithmetic;
    //I have to use 1.00000 as unitValue failed to work for those area.
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
        if (fsrc == zeroValue<T>()) {
        return scale<T>(mod(((1.0000000000/epsilon<T>()) * fdst),1.0000000000));
    }  
    
    return scale<T>(mod(((1.0000000000/fsrc) * fdst),1.0000000000)); 
}

cfDivisiveModuloContinuous()

template<class T >

T cfDivisiveModuloContinuous ( T src, T dst )

inline

Definition at line 1267 of file KoCompositeOpFunctions.h.

                                                  {
    using namespace Arithmetic;
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    if (fdst == zeroValue<T>()) {
    return zeroValue<T>();
    }  
    
    if (fsrc == zeroValue<T>()) {
    return cfDivisiveModulo(fsrc,fdst);
    }  
 
    
    return scale<T>( int(ceil(fdst/fsrc)) % 2 != 0 ? cfDivisiveModulo(fsrc,fdst) : inv(cfDivisiveModulo(fsrc,fdst))); 
}

References cfDivisiveModulo().

cfEasyBurn()

template<class T >

T cfEasyBurn ( T src, T dst )

inline

Definition at line 1308 of file KoCompositeOpFunctions.h.

                                  {
    using namespace Arithmetic;
    // The 13 divided by 15 can be adjusted to taste. See imgblend.m
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
 
    
    return scale<T>(inv(pow(inv(fsrc != 1.0 ? fsrc : .999999999999),mul(fdst,1.039999999)))); 
}

cfEasyDodge()

template<class T >

T cfEasyDodge ( T src, T dst )

inline

Definition at line 1293 of file KoCompositeOpFunctions.h.

                                   {
    using namespace Arithmetic;
    // The 13 divided by 15 can be adjusted to taste. See imgblend.m
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    if (fsrc == 1.0) {
        return scale<T>(1.0);}
 
    
    return scale<T>(pow(fdst,mul(inv(fsrc != 1.0 ? fsrc : .999999999999),1.039999999))); 
}

cfFhyrd()

template<class T >

T cfFhyrd ( T src, T dst )

inline

Definition at line 955 of file KoCompositeOpFunctions.h.

                               {
    using namespace Arithmetic;
    
    return (cfAllanon(CFFrect<T>::composeChannel(src,dst),
                      CFHelow<T>::composeChannel(src,dst)));
}

References cfAllanon().

cfFogDarkenIFSIllusions()

template<class T >

T cfFogDarkenIFSIllusions ( T src, T dst )

inline

Definition at line 1202 of file KoCompositeOpFunctions.h.

                                               {
    using namespace Arithmetic;
    //Known as Dark Blending mode found in IFS Illusions. Picked this name because the shading reminds me of fog when overlaying with a gradient.
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    if (fsrc < .5) {
        return scale<T>(inv(fsrc)*fsrc+fsrc*fdst);
    }  
    
    return scale<T>(fsrc*fdst+fsrc-pow(fsrc,2)); 
}

cfFogLightenIFSIllusions()

template<class T >

T cfFogLightenIFSIllusions ( T src, T dst )

inline

Definition at line 1187 of file KoCompositeOpFunctions.h.

                                                {
    using namespace Arithmetic;
    //Known as Bright Blending mode found in IFS Illusions. Picked this name because the shading reminds me of fog when overlaying with a gradient.
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    if (fsrc < .5) {
        return scale<T>(inv(inv(fsrc)*fsrc)-inv(fdst)*inv(fsrc));
    }  
    
    return scale<T>(fsrc-inv(fdst)*inv(fsrc)+pow(inv(fsrc),2)); 
}

cfFreeze()

template<class T >

T cfFreeze ( T src, T dst )

inline

Definition at line 887 of file KoCompositeOpFunctions.h.

                                {
    using namespace Arithmetic;
    
    return (cfHeat(dst,src)); 
}

References cfHeat().

cfGlow()

template<class T >

T cfGlow ( T src, T dst )

inline

Definition at line 852 of file KoCompositeOpFunctions.h.

                              {
    using namespace Arithmetic;
        // see http://www.pegtop.net/delphi/articles/blendmodes/quadratic.htm for formulas of Quadratic Blending Modes like Glow, Reflect, Freeze, and Heat
 
    if (dst == unitValue<T>()) {
        return unitValue<T>();
    }
 
    return clamp<T>(div(mul(src, src), inv(dst)));
}

cfHeat()

template<class T >

T cfHeat ( T src, T dst )

inline

Definition at line 872 of file KoCompositeOpFunctions.h.

                              {
    using namespace Arithmetic;
    
    if(src == unitValue<T>()) {
        return unitValue<T>();
    }
 
    if(dst == zeroValue<T>()) {
        return zeroValue<T>();
    }
 
    return inv(clamp<T>(div(mul(inv(src), inv(src)),dst)));
}

cfImplies()

template<class T >

T cfImplies ( T src, T dst )

inline

Definition at line 1120 of file KoCompositeOpFunctions.h.

                                 {
    using namespace Arithmetic;
        
    return cfOr(src,inv(dst));
}

References cfOr().

cfInterpolation()

template<class T >

T cfInterpolation ( T src, T dst )

inline

Definition at line 963 of file KoCompositeOpFunctions.h.

                                       {
    using namespace Arithmetic;
 
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    if(dst == zeroValue<T>() && src == zeroValue<T>()) {
        return zeroValue<T>();
    } 
 
    return scale<T>(.5f-.25f*cos(pi*(fsrc))-.25f*cos(pi*(fdst)));
}

cfInterpolationB()

template<class T >

T cfInterpolationB ( T src, T dst )

inline

Definition at line 977 of file KoCompositeOpFunctions.h.

                                        {
    using namespace Arithmetic;
 
    return cfInterpolation(cfInterpolation(src,dst),cfInterpolation(src,dst));
}

References cfInterpolation().

cfLightenOnly()

template<class T >

T cfLightenOnly ( T src, T dst )

inline

Definition at line 849 of file KoCompositeOpFunctions.h.

{ return qMax(src, dst); }

cfLinearLight()

template<class T >

T cfLinearLight ( T src, T dst )

inline

Definition at line 605 of file KoCompositeOpFunctions.h.

                                     {
    using namespace Arithmetic;
    typedef typename KoColorSpaceMathsTraits<T>::compositetype composite_type;
    
    // min(1,max(0,(dst + 2*src)-1))
    return clamp<T>((composite_type(src) + src + dst) - unitValue<T>());
}

cfModulo()

template<class T >

T cfModulo ( T src, T dst )

inline

Definition at line 1217 of file KoCompositeOpFunctions.h.

                                {
    using namespace Arithmetic;
    
    return mod(dst,src); 
}

cfModuloContinuous()

template<class T >

T cfModuloContinuous ( T src, T dst )

inline

Definition at line 1286 of file KoCompositeOpFunctions.h.

                                          {
    using namespace Arithmetic;
    
    return cfMultiply(cfDivisiveModuloContinuous(src,dst),src); 
}

References cfDivisiveModuloContinuous(), and cfMultiply().

cfModuloShift()

template<class T >

T cfModuloShift ( T src, T dst )

inline

Definition at line 1224 of file KoCompositeOpFunctions.h.

                                     {
    using namespace Arithmetic;
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    if (fsrc == 1.0 && fdst == 0.0) {
    return scale<T>(0.0);
    }  
 
    
    return scale<T>(mod((fdst+fsrc),1.0000000000)); 
}

cfModuloShiftContinuous()

template<class T >

T cfModuloShiftContinuous ( T src, T dst )

inline

Definition at line 1238 of file KoCompositeOpFunctions.h.

                                               {
    using namespace Arithmetic;
    //This blending mode do not behave like difference/equivalent with destination layer inverted if you use group layer on addition while the content of group layer contains several addition-mode layers, it works as expected on float images. So, no need to change this.
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    if (fsrc == 1.0 && fdst == 0.0) {
    return scale<T>(1.0);
    }  
    
    return scale<T>((int(ceil(fdst+fsrc)) % 2 != 0) || (fdst == zeroValue<T>()) ? cfModuloShift(fsrc,fdst) : inv(cfModuloShift(fsrc,fdst))); 
}

References cfModuloShift().

cfMultiply()

template<class T >

T cfMultiply ( T src, T dst )

inline

Definition at line 805 of file KoCompositeOpFunctions.h.

{ return Arithmetic::mul(src, dst); }

References Arithmetic::mul().

cfNand()

template<class T >

T cfNand ( T src, T dst )

inline

Definition at line 1071 of file KoCompositeOpFunctions.h.

                              {
    using namespace Arithmetic;
        
    return or(src,dst);
}

cfNor()

template<class T >

T cfNor ( T src, T dst )

inline

Definition at line 1064 of file KoCompositeOpFunctions.h.

                             {
    using namespace Arithmetic;
        
    return and(src,dst);
}

cfNotConverse()

template<class T >

T cfNotConverse ( T src, T dst )

inline

Definition at line 1113 of file KoCompositeOpFunctions.h.

                                     {
    using namespace Arithmetic;
        
    return cfAnd(src,inv(dst));
}

References cfAnd().

cfNotImplies()

template<class T >

T cfNotImplies ( T src, T dst )

inline

Definition at line 1127 of file KoCompositeOpFunctions.h.

                                    {
    using namespace Arithmetic;
        
    return cfAnd(inv(src),dst);
}

References cfAnd().

cfOr()

template<class T >

T cfOr ( T src, T dst )

inline

Definition at line 1099 of file KoCompositeOpFunctions.h.

                            {
    using namespace Arithmetic;
        
    return cfNand(inv(src),inv(dst));
}

References cfNand().

cfOver()

template<class T >

T cfOver ( T src, T dst )

inline

Definition at line 795 of file KoCompositeOpFunctions.h.

{ Q_UNUSED(dst); return src; }

cfPenumbraC()

template<class T >

T cfPenumbraC ( T src, T dst )

inline

Definition at line 1016 of file KoCompositeOpFunctions.h.

                                   {
    using namespace Arithmetic;
    
    return cfPenumbraD(dst,src);
}

References cfPenumbraD().

cfPenumbraD()

template<class T >

T cfPenumbraD ( T src, T dst )

inline

Definition at line 1005 of file KoCompositeOpFunctions.h.

                                   {
    using namespace Arithmetic;
    
    if (dst == unitValue<T>()) {
        return unitValue<T>();
    }
    
    return cfArcTangent(src,inv(dst));
}

References cfArcTangent().

cfPNormA()

template<class T >

T cfPNormA ( T src, T dst )

inline

Definition at line 1134 of file KoCompositeOpFunctions.h.

                                {
    using namespace Arithmetic;
    //This is also known as P-Norm mode with factor of 2.3333 See IMBLEND image blending mode samples, and please see imblend.m file found on Additional Blending Mode thread at Phabricator. 1/2.3333 is .42875...
    
    return clamp<T>(pow(pow((float)dst, 2.3333333333333333) + pow((float)src, 2.3333333333333333), 0.428571428571434)); 
}

cfPNormB()

template<class T >

T cfPNormB ( T src, T dst )

inline

Definition at line 1142 of file KoCompositeOpFunctions.h.

                                {
    using namespace Arithmetic;
    //This is also known as P-Norm mode with factor of 2.3333 See IMBLEND image blending mode samples, and please see imblend.m file found on Additional Blending Mode thread at Phabricator. 1/2.3333 is .42875...
    
    return clamp<T>(pow(pow(dst,4)+pow(src,4),0.25)); 
}

cfReflect()

template<class T >

T cfReflect ( T src, T dst )

inline

Definition at line 864 of file KoCompositeOpFunctions.h.

                                 {
    using namespace Arithmetic;
    
    
    return clamp<T>(cfGlow(dst,src));
}

References cfGlow().

cfScreen()

template<class T >

T cfScreen ( T src, T dst )

inline

Definition at line 843 of file KoCompositeOpFunctions.h.

{ return Arithmetic::unionShapeOpacity(src, dst); }

References Arithmetic::unionShapeOpacity().

cfShadeIFSIllusions()

template<class T >

T cfShadeIFSIllusions ( T src, T dst )

inline

Definition at line 1176 of file KoCompositeOpFunctions.h.

                                           {
    using namespace Arithmetic;
    //Known as Shadow Blending mode found in IFS Illusions. Picked this name because it is the opposite of Tint (IFS Illusion Blending mode).
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    return scale<T>(inv((inv(fdst)*fsrc)+sqrt(inv(fsrc)))); 
}

cfSoftLightIFSIllusions()

template<class T >

T cfSoftLightIFSIllusions ( T src, T dst )

inline

Definition at line 1031 of file KoCompositeOpFunctions.h.

                                               {
    using namespace Arithmetic;
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    return scale<T>(pow(fdst,pow(2.0,(mul(2.0,.5f-fsrc))))); 
}

cfSoftLightPegtopDelphi()

template<class T >

T cfSoftLightPegtopDelphi ( T src, T dst )

inline

Definition at line 1041 of file KoCompositeOpFunctions.h.

                                               {
    using namespace Arithmetic;
 
    return clamp<T>(cfAddition(mul(dst,cfScreen(src,dst)),mul(mul(src,dst),inv(dst)))); 
}

References cfAddition(), and cfScreen().

cfSubtract()

template<class T >

T cfSubtract ( T src, T dst )

inline

Definition at line 412 of file KoCompositeOpFunctions.h.

                                  {
    using namespace Arithmetic;
    typedef typename KoColorSpaceMathsTraits<T>::compositetype composite_type;
    return clamp<T>(composite_type(dst) - src);
}

cfSuperLight()

template<class T >

T cfSuperLight ( T src, T dst )

inline

Definition at line 1150 of file KoCompositeOpFunctions.h.

                                    {
    using namespace Arithmetic;
    //4.0 can be adjusted to taste. 4.0 is picked for being the best in terms of contrast and details. See imblend.m file.
        
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    if (fsrc < .5) {
        return scale<T>(inv(pow(pow(inv(fdst),2.875)+pow(inv(2.0*fsrc),2.875),1.0/2.875)));
    }   
    
    return scale<T>(pow(pow(fdst,2.875)+pow(2.0*fsrc-1.0,2.875),1.0/2.875)); 
}

cfTintIFSIllusions()

template<class T >

T cfTintIFSIllusions ( T src, T dst )

inline

Definition at line 1165 of file KoCompositeOpFunctions.h.

                                          {
    using namespace Arithmetic;
    //Known as Light Blending mode found in IFS Illusions. Picked this name because it results into a very strong tint, and has better naming convention.
    
    qreal fsrc = scale<qreal>(src);
    qreal fdst = scale<qreal>(dst);
    
    return scale<T>(fsrc*inv(fdst)+sqrt(fdst)); 
}

cfXnor()

template<class T >

T cfXnor ( T src, T dst )

inline

Definition at line 1085 of file KoCompositeOpFunctions.h.

                              {
    using namespace Arithmetic;
    
    return cfXor(src,inv(dst));
}

References cfXor().

cfXor()

template<class T >

T cfXor ( T src, T dst )

inline

Definition at line 1078 of file KoCompositeOpFunctions.h.

                             {
    using namespace Arithmetic;
    
    return xor(src,dst);
}