#include <KoCompositeOpGreater.h>

Inheritance diagram for KoCompositeOpGreater< CS_Traits, BlendingPolicy >:

Public Member Functions
	KoCompositeOpGreater (const KoColorSpace *cs)

Public Member Functions inherited from KoCompositeOpBase< CS_Traits, KoCompositeOpGreater< CS_Traits, BlendingPolicy > >
void	composite (const KoCompositeOp::ParameterInfo &params) const override

virtual void	composite (const ParameterInfo &params) const

void	composite (quint8 dstRowStart, qint32 dstRowStride, const quint8 srcRowStart, qint32 srcRowStride, const quint8 *maskRowStart, qint32 maskRowStride, qint32 rows, qint32 numColumns, float opacity, const QBitArray &channelFlags=QBitArray()) const

	KoCompositeOpBase (const KoColorSpace *cs, const QString &id, const QString &category)

Public Member Functions inherited from KoCompositeOp
QString	category () const

const KoColorSpace *	colorSpace () const

void	composite (quint8 dstRowStart, qint32 dstRowStride, const quint8 srcRowStart, qint32 srcRowStride, const quint8 *maskRowStart, qint32 maskRowStride, qint32 rows, qint32 numColumns, float opacity, const QBitArray &channelFlags=QBitArray()) const

QString	description () const

QString	id () const

	KoCompositeOp (const KoColorSpace *cs, const QString &id, const QString &category=KoCompositeOp::categoryMisc())

virtual	~KoCompositeOp ()

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Static Public Member Functions
template<bool alphaLocked, bool allChannelFlags>
static channels_type	composeColorChannels (const channels_type src, channels_type srcAlpha, channels_type dst, channels_type dstAlpha, channels_type maskAlpha, channels_type opacity, const QBitArray &channelFlags)

Static Public Member Functions inherited from KoCompositeOp
static QString	categoryArithmetic ()

static QString	categoryBinary ()

static QString	categoryDark ()

static QString	categoryHSI ()

static QString	categoryHSL ()

static QString	categoryHSV ()

static QString	categoryHSY ()

static QString	categoryLight ()

static QString	categoryMisc ()

static QString	categoryMix ()

static QString	categoryModulo ()

static QString	categoryNegative ()

static QString	categoryQuadratic ()

Private Types
typedef KoCompositeOpBase< CS_Traits, KoCompositeOpGreater< CS_Traits, BlendingPolicy > >	base_class

typedef CS_Traits::channels_type	channels_type

typedef KoColorSpaceMathsTraits< typenameCS_Traits::channels_type >::compositetype	composite_type

Static Private Attributes
static const qint8	alpha_pos = CS_Traits::alpha_pos

static const qint8	channels_nb = CS_Traits::channels_nb

Additional Inherited Members
Public Attributes inherited from KoCompositeOp
QString	category

const KoColorSpace *	colorSpace

QBitArray	defaultChannelFlags

QString	description

QString	id

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Detailed Description

template<class CS_Traits, typename BlendingPolicy>
class KoCompositeOpGreater< CS_Traits, BlendingPolicy >

Greater-than compositor - uses the greater of two alpha values to determine the color

Definition at line 29 of file KoCompositeOpGreater.h.

Member Typedef Documentation

◆ base_class

template<class CS_Traits , typename BlendingPolicy >

typedef KoCompositeOpBase<CS_Traits, KoCompositeOpGreater<CS_Traits, BlendingPolicy> > KoCompositeOpGreater< CS_Traits, BlendingPolicy >::base_class

private

Definition at line 31 of file KoCompositeOpGreater.h.

◆ channels_type

template<class CS_Traits , typename BlendingPolicy >

typedef CS_Traits::channels_type KoCompositeOpGreater< CS_Traits, BlendingPolicy >::channels_type

private

Definition at line 32 of file KoCompositeOpGreater.h.

◆ composite_type

template<class CS_Traits , typename BlendingPolicy >

typedef KoColorSpaceMathsTraits<typenameCS_Traits::channels_type>::compositetype KoCompositeOpGreater< CS_Traits, BlendingPolicy >::composite_type

private

Definition at line 33 of file KoCompositeOpGreater.h.

Constructor & Destructor Documentation

◆ KoCompositeOpGreater()

template<class CS_Traits , typename BlendingPolicy >

KoCompositeOpGreater< CS_Traits, BlendingPolicy >::KoCompositeOpGreater ( const KoColorSpace * cs )

inline

Definition at line 39 of file KoCompositeOpGreater.h.

40 : base_class(cs, COMPOSITE_GREATER, KoCompositeOp::categoryMix()) { }

COMPOSITE_GREATER

const QString COMPOSITE_GREATER

Definition KoCompositeOpRegistry.h:73

KoCompositeOpGreater::base_class

KoCompositeOpBase< CS_Traits, KoCompositeOpGreater< CS_Traits, BlendingPolicy > > base_class

Definition KoCompositeOpGreater.h:31

KoCompositeOp::categoryMix

static QString categoryMix()

Definition KoCompositeOp.cpp:41

Member Function Documentation

◆ composeColorChannels()

template<class CS_Traits , typename BlendingPolicy >

template<bool alphaLocked, bool allChannelFlags>

static channels_type KoCompositeOpGreater< CS_Traits, BlendingPolicy >::composeColorChannels	(	const channels_type *	src,
		channels_type	srcAlpha,
		channels_type *	dst,
		channels_type	dstAlpha,
		channels_type	maskAlpha,
		channels_type	opacity,
		const QBitArray &	channelFlags )

inlinestatic

Definition at line 44 of file KoCompositeOpGreater.h.

                                                                                                         {
        using namespace Arithmetic;
                
        if (isUnitValueFuzzy(dstAlpha)) return dstAlpha;
        channels_type appliedAlpha       = mul(maskAlpha, srcAlpha, opacity);
        
        if (isZeroValueFuzzy(appliedAlpha)) return dstAlpha;
        channels_type newDstAlpha;
        
        float dA = scale<float>(dstAlpha);
        
        float w = 1.0/(1.0+exp(-40.0*(dA - scale<float>(appliedAlpha))));
        float a = dA*w + scale<float>(appliedAlpha)*(1.0-w);               
        if (a < 0.0f) {
            a = 0.0f; 
        }
        if (a > 1.0f) {
            a = 1.0f;
        }
        
        // For a standard Over, the resulting alpha is: a = opacity*dstAlpha + (1-opacity)*srcAlpha
        // Let us assume we're blending with a color with srcAlpha = 1 here
        // Therefore, opacity = (1.0 - a)/(1.0 - dstAlpha)
        if (a<dA) a = dA;
        float fakeOpacity = 1.0f - (1.0f - a)/(1.0f - dA + 1e-16f);
        newDstAlpha=scale<channels_type>(a);
 
        if (isZeroValueFuzzy(newDstAlpha)) {
          // just do nothing with color channels and return null opacity
        } else if (!isZeroValueFuzzy(dstAlpha)) {
            for (qint8 channel = 0; channel < channels_nb; ++channel)
                if(channel != alpha_pos && (allChannelFlags || channelFlags.testBit(channel)))
                {
                    typedef typename KoColorSpaceMathsTraits<channels_type>::compositetype composite_type;
 
                    channels_type dstMult = mul(BlendingPolicy::toAdditiveSpace(dst[channel]), dstAlpha);
                    channels_type srcMult = mul(BlendingPolicy::toAdditiveSpace(src[channel]), unitValue<channels_type>());
                    channels_type blendedValue = lerp(dstMult, srcMult, scale<channels_type>(fakeOpacity));
 
                    composite_type normedValue = KoColorSpaceMaths<channels_type>::divide(blendedValue, newDstAlpha);
 
                    dst[channel] = BlendingPolicy::fromAdditiveSpace(KoColorSpaceMaths<channels_type>::clampAfterScale(normedValue));
                }
        }       
        else {
            // don't blend if the color of the destination is undefined (has zero opacity)
            // copy the source channel instead
            for (qint8 channel = 0; channel < channels_nb; ++channel)
                if(channel != alpha_pos && (allChannelFlags || channelFlags.testBit(channel)))
                    dst[channel] = src[channel];
        }
 
        return newDstAlpha;
    }

References KoCompositeOpGreater< CS_Traits, BlendingPolicy >::alpha_pos, KoCompositeOpGreater< CS_Traits, BlendingPolicy >::channels_nb, KoColorSpaceMaths< _T, _Tdst >::divide(), and lerp().

Member Data Documentation

◆ alpha_pos

template<class CS_Traits , typename BlendingPolicy >

const qint8 KoCompositeOpGreater< CS_Traits, BlendingPolicy >::alpha_pos = CS_Traits::alpha_pos

staticprivate

Definition at line 36 of file KoCompositeOpGreater.h.

◆ channels_nb

template<class CS_Traits , typename BlendingPolicy >

const qint8 KoCompositeOpGreater< CS_Traits, BlendingPolicy >::channels_nb = CS_Traits::channels_nb

staticprivate

Definition at line 35 of file KoCompositeOpGreater.h.

The documentation for this class was generated from the following file:

libs/pigment/compositeops/KoCompositeOpGreater.h

Public Member Functions

Static Public Member Functions

Private Types

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ base_class

◆ channels_type

◆ composite_type

Constructor & Destructor Documentation

◆ KoCompositeOpGreater()

Member Function Documentation

◆ composeColorChannels()

Member Data Documentation

◆ alpha_pos

◆ channels_nb