KoConvolutionOpImpl< _CSTrait > Class Template Reference

#include <KoConvolutionOpImpl.h>

Inheritance diagram for KoConvolutionOpImpl< _CSTrait >:

Public Member Functions
void	convolveColors (const quint8 *const *colors, const qreal *kernelValues, quint8 *dst, qreal factor, qreal offset, qint32 nPixels, const QBitArray &channelFlags) const override
	KoConvolutionOpImpl ()
	~KoConvolutionOpImpl () override
Public Member Functions inherited from KoConvolutionOp
virtual	~KoConvolutionOp ()

Private Types
typedef _CSTrait::channels_type	channels_type
typedef KoColorSpaceMathsTraits< typename_CSTrait::channels_type >::compositetype	compositetype

Detailed Description

template<class _CSTrait>
class KoConvolutionOpImpl< _CSTrait >

Definition at line 17 of file KoConvolutionOpImpl.h.

Member Typedef Documentation

channels_type

template<class _CSTrait >

typedef _CSTrait::channels_type KoConvolutionOpImpl< _CSTrait >::channels_type

private

Definition at line 20 of file KoConvolutionOpImpl.h.

compositetype

template<class _CSTrait >

typedef KoColorSpaceMathsTraits<typename_CSTrait::channels_type>::compositetype KoConvolutionOpImpl< _CSTrait >::compositetype

private

Definition at line 19 of file KoConvolutionOpImpl.h.

Constructor & Destructor Documentation

KoConvolutionOpImpl()

template<class _CSTrait >

KoConvolutionOpImpl< _CSTrait >::KoConvolutionOpImpl ( )

inline

Definition at line 23 of file KoConvolutionOpImpl.h.

{ }

~KoConvolutionOpImpl()

template<class _CSTrait >

KoConvolutionOpImpl< _CSTrait >::~KoConvolutionOpImpl ( )

inlineoverride

Definition at line 25 of file KoConvolutionOpImpl.h.

{ }

Member Function Documentation

convolveColors()

template<class _CSTrait >

void KoConvolutionOpImpl< _CSTrait >::convolveColors ( const quint8 *const * colors, const qreal * kernelValues, quint8 * dst, qreal factor, qreal offset, qint32 nPixels, const QBitArray & channelFlags ) const

inlineoverridevirtual

Calculates a weighted average of the pixels, mentioned in colors using weight values from kernelValues

Note: It behaves in a quite unclear way, when at least one pixel is fully transparent. There are three cases: Case A) None of the pixels is fully transparent.

• Every color channel AND alpha channel of dst stores a sum of the corresponding channels from colors, divided by factor and incremented by offset Case B) At least one pixel of colors is transparent and factor stores a weight of the kernel (sum of it's items).
• Every color channel of dst stores a sum of the corresponding channels from non-transparent pixels, divided by a weight of non-transparent pixels and incremented by offset.
• Alpha channel of dst stores a sum of the corresponding channels from non-transparent pixels, divided by a weight of all the pixels (equals to factor) and incremented by offset. Case C) At least one pixel of colors is transparent and factor is set to an arbitrary value.
• Every color channel of dst stores a sum of the corresponding channels from non-transparent pixels, divided by a "scaled down factor" and incremented by offset. "Scaled down factor" is calculated in the following way:

                           [weight of non-transparent pixels]
  

  scaledDownFactor = factor * -------------------------------— [weight of all the pixels]
• Alpha channel of dst stores a sum of the corresponding channels from non-transparent pixels, divided by unscaled factor and incremented by offset.

Implements KoConvolutionOp.

Definition at line 63 of file KoConvolutionOpImpl.h.

                                                                                                                                                                                        {
 
        // Create and initialize to 0 the array of totals
        qreal totals[_CSTrait::channels_nb];
 
        qreal totalWeight = 0;
        qreal totalWeightTransparent = 0;
 
        memset(totals, 0, sizeof(qreal) * _CSTrait::channels_nb);
 
        for (; nPixels--; colors++, kernelValues++) {
            qreal weight = *kernelValues;
            const channels_type* color = _CSTrait::nativeArray(*colors);
            if (weight != 0) {
                if (_CSTrait::opacityU8(*colors) == 0) {
                    totalWeightTransparent += weight;
                } else {
                    for (uint i = 0; i < _CSTrait::channels_nb; i++) {
                        totals[i] += color[i] * weight;
                    }
                }
                totalWeight += weight;
            }
        }
 
        typename _CSTrait::channels_type* dstColor = _CSTrait::nativeArray(dst);
 
        bool allChannels = channelFlags.isEmpty();
        Q_ASSERT(allChannels || channelFlags.size() == (int)_CSTrait::channels_nb);
        if (totalWeightTransparent == 0) {
            // Case A)
            for (uint i = 0; i < _CSTrait::channels_nb; i++) {
                if (allChannels || channelFlags.testBit(i)) {
                    compositetype v = totals[i] / factor + offset;
                    dstColor[ i ] = CLAMP(v, KoColorSpaceMathsTraits<channels_type>::min,
                                          KoColorSpaceMathsTraits<channels_type>::max);
                }
            }
        } else if (totalWeightTransparent != totalWeight) {
            if (totalWeight == factor) {
                // Case B)
                qint64 a = (totalWeight - totalWeightTransparent);
                for (uint i = 0; i < _CSTrait::channels_nb; i++) {
                    if (allChannels || channelFlags.testBit(i)) {
                        if (i == (uint)_CSTrait::alpha_pos) {
                            compositetype v = totals[i] / totalWeight + offset;
                            dstColor[ i ] = CLAMP(v, KoColorSpaceMathsTraits<channels_type>::min,
                                                  KoColorSpaceMathsTraits<channels_type>::max);
                        } else {
                            compositetype v = totals[i] / a + offset;
                            dstColor[ i ] = CLAMP(v, KoColorSpaceMathsTraits<channels_type>::min,
                                                  KoColorSpaceMathsTraits<channels_type>::max);
                        }
                    }
                }
            } else {
                // Case C)
                qreal a = qreal(totalWeight) / (factor * (totalWeight - totalWeightTransparent));     // use qreal as it easily saturate
                for (uint i = 0; i < _CSTrait::channels_nb; i++) {
                    if (allChannels || channelFlags.testBit(i)) {
                        if (i == (uint)_CSTrait::alpha_pos) {
                            compositetype v = totals[i] / factor + offset;
                            dstColor[ i ] = CLAMP(v, KoColorSpaceMathsTraits<channels_type>::min,
                                                  KoColorSpaceMathsTraits<channels_type>::max);
                        } else {
                            compositetype v = (compositetype)(totals[i] * a + offset);
                            dstColor[ i ] = CLAMP(v, KoColorSpaceMathsTraits<channels_type>::min,
                                                  KoColorSpaceMathsTraits<channels_type>::max);
                        }
                    }
                }
            }
        }
 
    }

References CLAMP, and v.

---

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

• libs/pigment/KoConvolutionOpImpl.h