KoCompositeOpAlphaDarken< Traits, ParamsWrapper > Class Template Reference

#include <KoCompositeOpAlphaDarken.h>

Inheritance diagram for KoCompositeOpAlphaDarken< Traits, ParamsWrapper >:

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
template<bool useMask>
void	genericComposite (const KoCompositeOp::ParameterInfo &params) const
	KoCompositeOpAlphaDarken (const KoColorSpace *cs)
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
static channels_type	calculateAlpha (const KoCompositeOp::ParameterInfo &params, const ParamsWrapper &paramsWrapper, channels_type flow, channels_type opacity, channels_type srcAlpha, channels_type dstAlpha, channels_type mskAlpha)
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 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, class ParamsWrapper>
class KoCompositeOpAlphaDarken< Traits, ParamsWrapper >

A template version of the alphadarken composite operation to use in colorspaces

Definition at line 19 of file KoCompositeOpAlphaDarken.h.

Member Typedef Documentation

channels_type

template<class Traits , class ParamsWrapper >

typedef Traits::channels_type KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::channels_type

private

Definition at line 21 of file KoCompositeOpAlphaDarken.h.

Constructor & Destructor Documentation

KoCompositeOpAlphaDarken()

template<class Traits , class ParamsWrapper >

KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::KoCompositeOpAlphaDarken ( const KoColorSpace * cs )

inline

Definition at line 27 of file KoCompositeOpAlphaDarken.h.

                                                    :
        KoCompositeOp(cs, COMPOSITE_ALPHA_DARKEN, KoCompositeOp::categoryMix()) { }

Member Function Documentation

calculateAlpha()

template<class Traits , class ParamsWrapper >

static channels_type KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::calculateAlpha ( const KoCompositeOp::ParameterInfo & params, const ParamsWrapper & paramsWrapper, channels_type flow, channels_type opacity, channels_type srcAlpha, channels_type dstAlpha, channels_type mskAlpha )

inlinestatic

Here we calculate fullFlowAlpha, which should strive either to averageOpacity or opacity (whichever is the greater) or just keep old dstAlpha value, if both opacity values are not bit enough

This cryptic code is basically an optimized version of the following: fullFlowAlpha = averageOpacity * unionShapeOpacity(srcAlpha / averageOpacity, dstAlpha / averageOpacity);

The main idea is: fullFlowAlpha should be as near to averageOpacity as maximum of srcAlpha and dstAlpha and a bit more. So that in consequent applications of the blending operation alpha channel would aim to averageOpacity.

Definition at line 96 of file KoCompositeOpAlphaDarken.h.

    {
        using namespace Arithmetic;
 
        channels_type fullFlowAlpha;
        channels_type averageOpacity = scale<channels_type>(paramsWrapper.averageOpacity);
 
        if (averageOpacity > opacity) {
            channels_type reverseBlend = KoColorSpaceMaths<channels_type>::divide(dstAlpha, averageOpacity);
            fullFlowAlpha = averageOpacity > dstAlpha ? lerp(srcAlpha, averageOpacity, reverseBlend) : dstAlpha;
        } else {
            fullFlowAlpha = opacity > dstAlpha ? lerp(dstAlpha, opacity, mskAlpha) : dstAlpha;
        }
 
        if (params.flow == 1.0f) {
            return fullFlowAlpha;
        } else {
            channels_type zeroFlowAlpha = ParamsWrapper::calculateZeroFlowAlphaLegacy(srcAlpha, dstAlpha);
            return lerp(zeroFlowAlpha, fullFlowAlpha, flow);
        }
    }

References KoColorSpaceMaths< _T, _Tdst >::divide(), KoCompositeOp::ParameterInfo::flow, and lerp().

composite() [1/3]

template<class Traits , class ParamsWrapper >

void KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::composite ( const KoCompositeOp::ParameterInfo & params ) const

inlineoverridevirtual

Same as previous, but uses a parameter structure

Reimplemented from KoCompositeOp.

Definition at line 32 of file KoCompositeOpAlphaDarken.h.

    {
        if(params.maskRowStart != 0)
            genericComposite<true>(params);
        else
            genericComposite<false>(params);
    }

References KoCompositeOp::ParameterInfo::maskRowStart.

composite() [2/3]

template<class Traits , class ParamsWrapper >

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 Traits , class ParamsWrapper >

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 Traits , class ParamsWrapper >

template<bool useMask>

void KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::genericComposite ( const KoCompositeOp::ParameterInfo & params ) const

inline

Definition at line 41 of file KoCompositeOpAlphaDarken.h.

    {
        using namespace Arithmetic;
 
        ParamsWrapper paramsWrapper(params);
 
        qint32        srcInc       = (params.srcRowStride == 0) ? 0 : channels_nb;
        channels_type flow         = scale<channels_type>(paramsWrapper.flow);
        channels_type opacity      = scale<channels_type>(paramsWrapper.opacity);
        quint8*       dstRowStart  = params.dstRowStart;
        const quint8* srcRowStart  = params.srcRowStart;
        const quint8* maskRowStart = params.maskRowStart;
 
        for (qint32 r = params.rows; r > 0; --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=params.cols; c>0; --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 ? mul(scale<channels_type>(*mask), srcAlpha) : srcAlpha;
 
                srcAlpha = mul(mskAlpha, opacity);
 
                if(dstAlpha != zeroValue<channels_type>()) {
                    for(qint32 i=0; i <channels_nb; i++) {
                        if(i != alpha_pos)
                            dst[i] = lerp(dst[i], src[i], srcAlpha);
                    }
                }
                else {
                    for(qint32 i=0; i <channels_nb; i++) {
                        if(i != alpha_pos)
                            dst[i] = src[i];
                    }
                }
 
                if(alpha_pos != -1) {
                    dst[alpha_pos] = calculateAlpha(params, paramsWrapper, flow, opacity, srcAlpha, dstAlpha, mskAlpha);
                }
 
                src += srcInc;
                dst += channels_nb;
 
                if(useMask)
                    ++mask;
            }
 
            srcRowStart  += params.srcRowStride;
            dstRowStart  += params.dstRowStride;
            maskRowStart += params.maskRowStride;
        }
    }

References KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::alpha_pos, KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::calculateAlpha(), KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::channels_nb, KoCompositeOp::ParameterInfo::cols, KoCompositeOp::ParameterInfo::dstRowStart, KoCompositeOp::ParameterInfo::dstRowStride, lerp(), KoCompositeOp::ParameterInfo::maskRowStart, KoCompositeOp::ParameterInfo::maskRowStride, KoCompositeOp::ParameterInfo::rows, KoCompositeOp::ParameterInfo::srcRowStart, and KoCompositeOp::ParameterInfo::srcRowStride.

Member Data Documentation

alpha_pos

template<class Traits , class ParamsWrapper >

const qint32 KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::alpha_pos = Traits::alpha_pos

staticprivate

Definition at line 24 of file KoCompositeOpAlphaDarken.h.

channels_nb

template<class Traits , class ParamsWrapper >

const qint32 KoCompositeOpAlphaDarken< Traits, ParamsWrapper >::channels_nb = Traits::channels_nb

staticprivate

Definition at line 23 of file KoCompositeOpAlphaDarken.h.

---

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

• libs/pigment/compositeops/KoCompositeOpAlphaDarken.h