KoCompositeOpAlphaBase< _CSTraits, _compositeOp, _alphaLocked > Class Template Reference

#include <KoCompositeOpAlphaBase.h>

Inheritance diagram for KoCompositeOpAlphaBase< _CSTraits, _compositeOp, _alphaLocked >:

Public Member Functions
template<bool alphaLocked, bool allChannelFlags>
void	composite (const KoCompositeOp::ParameterInfo &params) const
template<bool alphaLocked>
void	composite (const KoCompositeOp::ParameterInfo &params) const
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
	KoCompositeOpAlphaBase (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

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, bool _alphaLocked>
class KoCompositeOpAlphaBase< _CSTraits, _compositeOp, _alphaLocked >

A template base class for all composite op that compose color channels values for colorspaces that have an alpha channel.

Parameters

_compositeOp

this class should define a function with the following signature: inline static void composeColorChannels

Definition at line 30 of file KoCompositeOpAlphaBase.h.

Member Typedef Documentation

channels_type

template<class _CSTraits , class _compositeOp , bool _alphaLocked>

typedef _CSTraits::channels_type KoCompositeOpAlphaBase< _CSTraits, _compositeOp, _alphaLocked >::channels_type

private

Definition at line 32 of file KoCompositeOpAlphaBase.h.

Constructor & Destructor Documentation

KoCompositeOpAlphaBase()

template<class _CSTraits , class _compositeOp , bool _alphaLocked>

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

inline

Definition at line 35 of file KoCompositeOpAlphaBase.h.

            : KoCompositeOp(cs, id, category) {
    }

Member Function Documentation

composite() [1/5]

template<class _CSTraits , class _compositeOp , bool _alphaLocked>

template<bool alphaLocked, bool allChannelFlags>

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

inlinevirtual

Same as previous, but uses a parameter structure

Reimplemented from KoCompositeOp.

Definition at line 43 of file KoCompositeOpAlphaBase.h.

                                                                   {
        qint32 srcInc = (params.srcRowStride == 0) ? 0 : _CSTraits::channels_nb;
 
        channels_type opacity = KoColorSpaceMaths<float, channels_type>::scaleToA(params.opacity);
 
        const quint8 *srcRowStart = params.srcRowStart;
        quint8 *dstRowStart = params.dstRowStart;
        const quint8 *maskRowStart = params.maskRowStart;
 
        qint32 rows = params.rows;
 
        while (rows > 0) {
            const channels_type *srcN = reinterpret_cast<const channels_type *>(srcRowStart);
            channels_type *dstN = reinterpret_cast<channels_type *>(dstRowStart);
            const quint8 *mask = maskRowStart;
 
            qint32 columns = params.cols;
 
            while (columns > 0) {
 
                channels_type srcAlpha = _CSTraits::alpha_pos == -1 ? NATIVE_OPACITY_OPAQUE : _compositeOp::selectAlpha(srcN[_CSTraits::alpha_pos], dstN[_CSTraits::alpha_pos]);
 
                // apply the alphamask
                if (mask != 0) {
                    srcAlpha = KoColorSpaceMaths<quint8, channels_type>::multiply(*mask, srcAlpha, opacity);
                    mask++;
                } else if (opacity != NATIVE_OPACITY_OPAQUE) {
                    srcAlpha = KoColorSpaceMaths<channels_type>::multiply(srcAlpha, opacity);
                }
 
                if (srcAlpha != NATIVE_OPACITY_TRANSPARENT) {
 
 
                    channels_type dstAlpha = _CSTraits::alpha_pos == -1 ? NATIVE_OPACITY_OPAQUE : dstN[_CSTraits::alpha_pos];
 
                    channels_type srcBlend;
 
                    if (alphaLocked || _alphaLocked ||
                        dstAlpha == NATIVE_OPACITY_OPAQUE) {
 
                        srcBlend = srcAlpha;
 
                    } else if (dstAlpha == NATIVE_OPACITY_TRANSPARENT) {
                        if (!allChannelFlags) {
                            for (int i = 0; i < (int)_CSTraits::channels_nb; i++) {
                                if (i != _CSTraits::alpha_pos) {
                                    dstN[i] = NATIVE_ZERO_VALUE;
                                }
                            }
                        }
 
                        if (!alphaLocked && !_alphaLocked) {
                            dstN[_CSTraits::alpha_pos] = srcAlpha;
                        }
                        srcBlend = NATIVE_OPACITY_OPAQUE;
 
                    } else {
                        channels_type newAlpha = dstAlpha + KoColorSpaceMaths<channels_type>::multiply(NATIVE_OPACITY_OPAQUE - dstAlpha, srcAlpha);
                        if (!alphaLocked && !_alphaLocked) { // No need to check for _CSTraits::alpha_pos == -1 since it is contained in alphaLocked
                            dstN[_CSTraits::alpha_pos] = newAlpha;
                        }
                        // newAlpha cannot be zero, because srcAlpha!=zero and dstAlpha!=unit here
                        srcBlend = KoColorSpaceMaths<channels_type>::divide(srcAlpha, newAlpha);
                    }
                    _compositeOp::composeColorChannels(srcBlend, srcN, dstN, allChannelFlags, params.channelFlags);
 
                }
                columns--;
                srcN += srcInc;
                dstN += _CSTraits::channels_nb;
            }
 
            rows--;
            srcRowStart += params.srcRowStride;
            dstRowStart += params.dstRowStride;
            if (maskRowStart) {
                maskRowStart += params.maskRowStride;
            }
        }
    }

References KoCompositeOp::ParameterInfo::channelFlags, KoCompositeOp::ParameterInfo::cols, KoColorSpaceMaths< _T, _Tdst >::divide(), KoCompositeOp::ParameterInfo::dstRowStart, KoCompositeOp::ParameterInfo::dstRowStride, KoCompositeOp::ParameterInfo::maskRowStart, KoCompositeOp::ParameterInfo::maskRowStride, KoColorSpaceMaths< _T, _Tdst >::multiply(), NATIVE_OPACITY_OPAQUE, NATIVE_OPACITY_TRANSPARENT, NATIVE_ZERO_VALUE, KoCompositeOp::ParameterInfo::opacity, KoCompositeOp::ParameterInfo::rows, KoColorSpaceMaths< _T, _Tdst >::scaleToA(), KoCompositeOp::ParameterInfo::srcRowStart, and KoCompositeOp::ParameterInfo::srcRowStride.

composite() [2/5]

template<class _CSTraits , class _compositeOp , bool _alphaLocked>

template<bool alphaLocked>

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

inlinevirtual

Same as previous, but uses a parameter structure

Reimplemented from KoCompositeOp.

Definition at line 124 of file KoCompositeOpAlphaBase.h.

    {
        bool allChannelFlags = params.channelFlags.isEmpty();
        if(allChannelFlags)
        {
            composite<alphaLocked, true>(params);
        } else {
            composite<alphaLocked, false>(params);
        }
    }

References KoCompositeOp::ParameterInfo::channelFlags.

composite() [3/5]

template<class _CSTraits , class _compositeOp , bool _alphaLocked>

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

inlineoverridevirtual

Same as previous, but uses a parameter structure

Reimplemented from KoCompositeOp.

Definition at line 135 of file KoCompositeOpAlphaBase.h.

    {
        bool alphaLocked = false;
        if (!params.channelFlags.isEmpty()) {
            if (_CSTraits::alpha_pos == -1 || !params.channelFlags.testBit(_CSTraits::alpha_pos)) {
                alphaLocked = true;
            }
        }
        if(alphaLocked)
        {
            composite<true>(params);
        } else {
            composite<false>(params);
        }
    }

References KoCompositeOp::ParameterInfo::channelFlags.

composite() [4/5]

template<class _CSTraits , class _compositeOp , bool _alphaLocked>

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() [5/5]

template<class _CSTraits , class _compositeOp , bool _alphaLocked>

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);
}

---

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

• libs/pigment/compositeops/KoCompositeOpAlphaBase.h