KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy > Class Template Reference

#include <KoCompositeOpGeneric.h>

Inheritance diagram for KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >:

Public Member Functions
	KoCompositeOpGenericSCFunctor (const KoColorSpace *cs, const QString &id, const QString &category)
Public Member Functions inherited from KoCompositeOpBase< Traits, KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, 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< Traits, KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy > >	base_class
typedef Traits::channels_type	channels_type

Static Private Attributes
static const qint32	alpha_pos = Traits::alpha_pos
static const qint32	channels_nb = 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 Traits, typename CompositeOpFunctor, typename BlendingPolicy>
class KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >

Generic CompositeOp for separable channel compositing functions

A template to generate a KoCompositeOp class by just specifying a blending/compositing function. This template works with compositing functions for separable channels (means each channel of a pixel can be processed separately)

Definition at line 55 of file KoCompositeOpGeneric.h.

Member Typedef Documentation

base_class

template<class Traits , typename CompositeOpFunctor , typename BlendingPolicy >

typedef KoCompositeOpBase< Traits, KoCompositeOpGenericSCFunctor<Traits,CompositeOpFunctor,BlendingPolicy> > KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >::base_class

private

Definition at line 57 of file KoCompositeOpGeneric.h.

channels_type

template<class Traits , typename CompositeOpFunctor , typename BlendingPolicy >

typedef Traits::channels_type KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >::channels_type

private

Definition at line 58 of file KoCompositeOpGeneric.h.

Constructor & Destructor Documentation

KoCompositeOpGenericSCFunctor()

template<class Traits , typename CompositeOpFunctor , typename BlendingPolicy >

KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >::KoCompositeOpGenericSCFunctor ( const KoColorSpace * cs, const QString & id, const QString & category )

inline

Definition at line 64 of file KoCompositeOpGeneric.h.

        : base_class(cs, id, category) { }

Member Function Documentation

composeColorChannels()

template<class Traits , typename CompositeOpFunctor , typename BlendingPolicy >

template<bool alphaLocked, bool allChannelFlags>

static channels_type KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, 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 69 of file KoCompositeOpGeneric.h.

                                                                                                           {
        using namespace Arithmetic;
        
        srcAlpha = mul(srcAlpha, maskAlpha, opacity);
 
        if (isZeroValueFuzzy(srcAlpha)) {
            return dstAlpha;
        }
 
        if(alphaLocked) {
            if(!isZeroValueFuzzy(dstAlpha)) {
                for(qint32 i=0; i <channels_nb; i++) {
                    if(i != alpha_pos && (allChannelFlags || channelFlags.testBit(i))) {
                        const channels_type srcInBlendSpace =
                                CompositeOpFunctor::clampSourceChannelValue(
                                    BlendingPolicy::toAdditiveSpace(
                                        src[i]));
                        const channels_type dstInBlendSpace =
                                CompositeOpFunctor::clampDestinationChannelValue(
                                    BlendingPolicy::toAdditiveSpace(
                                        dst[i]));
 
                        dst[i] = BlendingPolicy::fromAdditiveSpace(
                            lerp(dstInBlendSpace,
                                 CompositeOpFunctor::composeChannel(srcInBlendSpace, dstInBlendSpace),
                                 srcAlpha));
                    }
                }
            }
            
            return dstAlpha;
        } else if (isZeroValueFuzzy(dstAlpha)) {
            for(qint32 i=0; i <channels_nb; i++) {
                if(i != alpha_pos && (allChannelFlags || channelFlags.testBit(i))) {
                    dst[i] = BlendingPolicy::fromAdditiveSpace(
                                CompositeOpFunctor::clampSourceChannelValue(
                                    BlendingPolicy::toAdditiveSpace(src[i])));
                }
            }
            return srcAlpha;
        } else if (isUnitValueFuzzy(dstAlpha)) {
            for(qint32 i=0; i <channels_nb; i++) {
                if(i != alpha_pos && (allChannelFlags || channelFlags.testBit(i))) {
                    const channels_type srcInBlendSpace =
                            CompositeOpFunctor::clampSourceChannelValue(
                                BlendingPolicy::toAdditiveSpace(
                                    src[i]));
                    const channels_type dstInBlendSpace =
                            CompositeOpFunctor::clampDestinationChannelValue(
                                BlendingPolicy::toAdditiveSpace(
                                    dst[i]));
 
                    dst[i] = BlendingPolicy::fromAdditiveSpace(
                        lerp(dstInBlendSpace,
                             CompositeOpFunctor::composeChannel(srcInBlendSpace, dstInBlendSpace),
                             srcAlpha));
                }
            }
            return unitValue<channels_type>();
        }  else if (isUnitValueFuzzy(srcAlpha)) {
            for(qint32 i=0; i <channels_nb; i++) {
                if(i != alpha_pos && (allChannelFlags || channelFlags.testBit(i))) {
                    const channels_type srcInBlendSpace =
                            CompositeOpFunctor::clampSourceChannelValue(
                                BlendingPolicy::toAdditiveSpace(
                                    src[i]));
                    const channels_type dstInBlendSpace =
                            CompositeOpFunctor::clampDestinationChannelValue(
                                BlendingPolicy::toAdditiveSpace(
                                    dst[i]));
 
                    dst[i] = BlendingPolicy::fromAdditiveSpace(
                        lerp(srcInBlendSpace,
                             CompositeOpFunctor::composeChannel(srcInBlendSpace, dstInBlendSpace),
                             dstAlpha));
                }
            }
            return unitValue<channels_type>();
        } else {
            channels_type newDstAlpha = unionShapeOpacity(srcAlpha, dstAlpha);
 
            if (!isZeroValueFuzzy(newDstAlpha)) {
 
                for(qint32 i=0; i <channels_nb; i++) {
                    if(i != alpha_pos && (allChannelFlags || channelFlags.testBit(i))) {
                        const channels_type srcInBlendSpace =
                                CompositeOpFunctor::clampSourceChannelValue(
                                    BlendingPolicy::toAdditiveSpace(
                                        src[i]));
                        const channels_type dstInBlendSpace =
                                CompositeOpFunctor::clampDestinationChannelValue(
                                    BlendingPolicy::toAdditiveSpace(
                                        dst[i]));
 
                        channels_type result =
                            blend(srcInBlendSpace, srcAlpha,
                                  dstInBlendSpace, dstAlpha,
                                  CompositeOpFunctor::composeChannel(srcInBlendSpace, dstInBlendSpace));
 
                        dst[i] = BlendingPolicy::fromAdditiveSpace(div(result, newDstAlpha));
                    }
                }
            }
            
            return newDstAlpha;
        }
    }

References KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >::alpha_pos, KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >::channels_nb, and lerp().

Member Data Documentation

alpha_pos

template<class Traits , typename CompositeOpFunctor , typename BlendingPolicy >

const qint32 KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >::alpha_pos = Traits::alpha_pos

staticprivate

Definition at line 61 of file KoCompositeOpGeneric.h.

channels_nb

template<class Traits , typename CompositeOpFunctor , typename BlendingPolicy >

const qint32 KoCompositeOpGenericSCFunctor< Traits, CompositeOpFunctor, BlendingPolicy >::channels_nb = Traits::channels_nb

staticprivate

Definition at line 60 of file KoCompositeOpGeneric.h.

---

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

• libs/pigment/compositeops/KoCompositeOpGeneric.h