#include <KoCompositeOpBase.h>

Inheritance diagram for KoCompositeOpBase< _CSTraits, _compositeOp >:

Public Member Functions
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)

Private Types
typedef _CSTraits::channels_type	channels_type

Private Member Functions
template<bool useMask, bool alphaLocked, bool allChannelFlags>
void	genericComposite (const KoCompositeOp::ParameterInfo &params, const QBitArray &channelFlags) const

Static Private Attributes
static const qint32	alpha_pos = _CSTraits::alpha_pos

static const qint32	channels_nb = _CSTraits::channels_nb

static const qint32	pixel_size = _CSTraits::pixelSize

Additional Inherited Members
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 ()

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 _CSTraits, class _compositeOp>
class KoCompositeOpBase< _CSTraits, _compositeOp >

A template base class that can be used for most composite modes/ops

Parameters

_compositeOp this template parameter is a class that must be derived from KoCompositeOpBase and must define the static member function template<bool alphaLocked, bool allChannelFlags> inline 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 )

where channels_type is _CSTraits::channels_type

Definition at line 32 of file KoCompositeOpBase.h.

Member Typedef Documentation

◆ channels_type

template<class _CSTraits , class _compositeOp >

typedef _CSTraits::channels_type KoCompositeOpBase< _CSTraits, _compositeOp >::channels_type

private

Definition at line 34 of file KoCompositeOpBase.h.

Constructor & Destructor Documentation

◆ KoCompositeOpBase()

template<class _CSTraits , class _compositeOp >

KoCompositeOpBase< _CSTraits, _compositeOp >::KoCompositeOpBase	(	const KoColorSpace *	cs,
		const QString &	id,
		const QString &	category )

inline

Definition at line 40 of file KoCompositeOpBase.h.

41 : KoCompositeOp(cs, id, category) { }

KoCompositeOp::category

QString category

Definition KoCompositeOp.cpp:111

KoCompositeOp::KoCompositeOp

KoCompositeOp()

Definition KoCompositeOp.cpp:115

Member Function Documentation

◆ composite() [1/3]

template<class _CSTraits , class _compositeOp >

void KoCompositeOpBase< _CSTraits, _compositeOp >::composite ( const KoCompositeOp::ParameterInfo & params ) const

inlineoverridevirtual

Same as previous, but uses a parameter structure

Reimplemented from KoCompositeOp.

Definition at line 45 of file KoCompositeOpBase.h.

                                                                            {
 
        const QBitArray& flags           = params.channelFlags.isEmpty() ? QBitArray(channels_nb,true) : params.channelFlags;
        bool             allChannelFlags = params.channelFlags.isEmpty() || params.channelFlags == QBitArray(channels_nb,true);
        bool             alphaLocked     = (alpha_pos != -1) && !flags.testBit(alpha_pos);
        bool             useMask         = params.maskRowStart != 0;
 
        if(useMask) {
            if(alphaLocked) {
                if(allChannelFlags) { genericComposite<true,true,true> (params, flags); }
                else                { genericComposite<true,true,false>(params, flags); }
            }
            else {
                if(allChannelFlags) { genericComposite<true,false,true> (params, flags); }
                else                { genericComposite<true,false,false>(params, flags); }
            }
        }
        else {
            if(alphaLocked) {
                if(allChannelFlags) { genericComposite<false,true,true> (params, flags); }
                else                { genericComposite<false,true,false>(params, flags); }
            }
            else {
                if(allChannelFlags) { genericComposite<false,false,true> (params, flags); }
                else                { genericComposite<false,false,false>(params, flags); }
            }
        }
    }

References KoCompositeOpBase< _CSTraits, _compositeOp >::alpha_pos, KoCompositeOp::ParameterInfo::channelFlags, KoCompositeOpBase< _CSTraits, _compositeOp >::channels_nb, and KoCompositeOp::ParameterInfo::maskRowStart.

◆ composite() [2/3]

template<class _CSTraits , class _compositeOp >

void KoCompositeOp::composite ( const ParameterInfo & params ) const

virtual

Same as previous, but uses a parameter structure

Reimplemented from KoCompositeOp.

Definition at line 123 of file KoCompositeOp.cpp.

{
    composite(params.dstRowStart           , params.dstRowStride ,
              params.srcRowStart           , params.srcRowStride ,
              params.maskRowStart          , params.maskRowStride,
              params.rows                  , params.cols         ,
              params.opacity, params.channelFlags );
}

◆ composite() [3/3]

template<class _CSTraits , class _compositeOp >

void KoCompositeOp::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

Parameters

dstRowStart	pointer to the start of the byte array we will composite the source on
dstRowStride	length of the rows of the block of destination pixels in bytes
srcRowStart	pointer to the start of the byte array we will mix with dest
srcRowStride	length of the rows of the block of src in bytes pixels (may be different from the rowstride of the dst pixels, in which case the smaller value is used). If srcRowStride is null it is assumed that the source is a constant color.
maskRowStart	start of the byte mask that determines whether and if so, then how much of src is used for blending
maskRowStride	length of the mask scanlines in bytes
rows	number of scanlines to blend
numColumns	length of the row of pixels in pixels
opacity	transparency with which to blend
channelFlags	a bit array that determines which channels should be processed (channels are in the order of the channels in the colorspace)

Definition at line 113 of file KoCompositeOp.cpp.

{
    KoCompositeOp::ParameterInfo params;
    params.dstRowStart   = dstRowStart;
    params.dstRowStride  = dstRowStride;
    params.srcRowStart   = srcRowStart;
    params.srcRowStride  = srcRowStride;
    params.maskRowStart  = maskRowStart;
    params.maskRowStride = maskRowStride;
    params.rows          = rows;
    params.cols          = numColumns;
    params.opacity       = opacity;
    params.flow          = 1.0f;
    params.channelFlags  = channelFlags;
    composite(params);
}

◆ genericComposite()

template<class _CSTraits , class _compositeOp >

template<bool useMask, bool alphaLocked, bool allChannelFlags>

void KoCompositeOpBase< _CSTraits, _compositeOp >::genericComposite	(	const KoCompositeOp::ParameterInfo &	params,
		const QBitArray &	channelFlags ) const

inlineprivate

Definition at line 76 of file KoCompositeOpBase.h.

                                                                                                         {
 
        using namespace Arithmetic;
 
        qint32        srcInc       = (params.srcRowStride == 0) ? 0 : channels_nb;
        channels_type opacity      = scale<channels_type>(params.opacity);
        quint8*       dstRowStart  = params.dstRowStart;
        const quint8* srcRowStart  = params.srcRowStart;
        const quint8* maskRowStart = params.maskRowStart;
 
        for (qint32 r=0; r<params.rows; ++r) {
            const channels_type* src  = reinterpret_cast<const channels_type*>(srcRowStart);
            channels_type*       dst  = reinterpret_cast<channels_type*>(dstRowStart);
            const quint8*        mask = maskRowStart;
 
            for (qint32 c=0; c<params.cols; ++c) {
                channels_type srcAlpha = (alpha_pos == -1) ? unitValue<channels_type>() : src[alpha_pos];
                channels_type dstAlpha = (alpha_pos == -1) ? unitValue<channels_type>() : dst[alpha_pos];
                channels_type mskAlpha = useMask ? scale<channels_type>(*mask) : unitValue<channels_type>();
 
                if (!allChannelFlags && dstAlpha == zeroValue<channels_type>()) {
                    memset(reinterpret_cast<quint8*>(dst), 0, pixel_size);
                }
 
                channels_type newDstAlpha = _compositeOp::template composeColorChannels<alphaLocked,allChannelFlags>(
                    src, srcAlpha, dst, dstAlpha, mskAlpha, opacity, channelFlags
                );
 
                if(alpha_pos != -1)
                    dst[alpha_pos] = alphaLocked ? dstAlpha : newDstAlpha;
 
                src += srcInc;
                dst += channels_nb;
 
                if(useMask)
                    ++mask;
            }
 
            srcRowStart  += params.srcRowStride;
            dstRowStart  += params.dstRowStride;
            maskRowStart += params.maskRowStride;
        }
    }

Member Data Documentation

◆ alpha_pos

template<class _CSTraits , class _compositeOp >

const qint32 KoCompositeOpBase< _CSTraits, _compositeOp >::alpha_pos = _CSTraits::alpha_pos

staticprivate

Definition at line 36 of file KoCompositeOpBase.h.

◆ channels_nb

template<class _CSTraits , class _compositeOp >

const qint32 KoCompositeOpBase< _CSTraits, _compositeOp >::channels_nb = _CSTraits::channels_nb

staticprivate

Definition at line 35 of file KoCompositeOpBase.h.

◆ pixel_size

template<class _CSTraits , class _compositeOp >

const qint32 KoCompositeOpBase< _CSTraits, _compositeOp >::pixel_size = _CSTraits::pixelSize

staticprivate

Definition at line 37 of file KoCompositeOpBase.h.

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

libs/pigment/compositeops/KoCompositeOpBase.h

Public Member Functions

Private Types

Private Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ channels_type

Constructor & Destructor Documentation

◆ KoCompositeOpBase()

Member Function Documentation

◆ composite() [1/3]

◆ composite() [2/3]

◆ composite() [3/3]

◆ genericComposite()

Member Data Documentation

◆ alpha_pos

◆ channels_nb

◆ pixel_size