#include <kis_convolution_worker_spatial.h>

Inheritance diagram for KisConvolutionWorkerSpatial< _IteratorFactory_ >:

Public Member Functions
void	cleanUp ()

void	convolveCache (quint8 *dstPtr)

template<bool additionalMultiplierActive>
qreal	convolveOneChannelFromCache (quint8 *dstPtr, quint32 channel, qreal additionalMultiplier=0.0)

void	execute (const KisConvolutionKernelSP kernel, const KisPaintDeviceSP src, QPoint srcPos, QPoint dstPos, QSize areaSize, const QRect &dataRect) override

	KisConvolutionWorkerSpatial (KisPainter painter, KoUpdater progress)

void	limitValue (qreal *value, qreal lowBound, qreal highBound)

void	loadPixelToCache (qreal *cache, const quint8 data, int index)

void	moveKernelDown (typename _IteratorFactory_::HLineConstIterator &kitSrc, qreal **pixelPtrCache)

void	moveKernelRight (typename _IteratorFactory_::VLineConstIterator &kitSrc, qreal **pixelPtrCache)

	~KisConvolutionWorkerSpatial () override

Public Member Functions inherited from KisConvolutionWorker< _IteratorFactory_ >
	KisConvolutionWorker (KisPainter painter, KoUpdater progress)

virtual	~KisConvolutionWorker ()

Private Attributes
qreal *	m_absoluteOffset

int	m_alphaCachePos

int	m_alphaRealPos

quint32	m_cacheSize

QList< KoChannelInfo * >	m_convChannelList

quint32	m_convolveChannelsNo

QVector< PtrFromDouble >	m_fromDoubleFuncPtr

qreal *	m_kernelData

qreal	m_kernelFactor

quint32	m_kh

quint32	m_khalfHeight

quint32	m_khalfWidth

quint32	m_kw

qreal *	m_maxClamp

qreal *	m_minClamp

qreal **	m_pixelPtrCache

qreal **	m_pixelPtrCacheCopy

quint32	m_pixelSize

QVector< PtrToDouble >	m_toDoubleFuncPtr

Additional Inherited Members
Protected Member Functions inherited from KisConvolutionWorker< _IteratorFactory_ >
QList< KoChannelInfo * >	convolvableChannelList (const KisPaintDeviceSP src)

Protected Attributes inherited from KisConvolutionWorker< _IteratorFactory_ >
KisPainter *	m_painter

KoUpdater *	m_progress

Detailed Description

template<class _IteratorFactory_>
class KisConvolutionWorkerSpatial< _IteratorFactory_ >

Definition at line 15 of file kis_convolution_worker_spatial.h.

Constructor & Destructor Documentation

◆ KisConvolutionWorkerSpatial()

template<class _IteratorFactory_ >

KisConvolutionWorkerSpatial< _IteratorFactory_ >::KisConvolutionWorkerSpatial	(	KisPainter *	painter,
		KoUpdater *	progress )

inline

Definition at line 18 of file kis_convolution_worker_spatial.h.

        : KisConvolutionWorker<_IteratorFactory_>(painter, progress)
        ,  m_alphaCachePos(-1)
        ,  m_alphaRealPos(-1)
        ,  m_pixelPtrCache(0)
        ,  m_pixelPtrCacheCopy(0)
        ,  m_minClamp(0)
        ,  m_maxClamp(0)
        ,  m_absoluteOffset(0)
    {
    }

◆ ~KisConvolutionWorkerSpatial()

template<class _IteratorFactory_ >

KisConvolutionWorkerSpatial< _IteratorFactory_ >::~KisConvolutionWorkerSpatial ( )

inlineoverride

Definition at line 30 of file kis_convolution_worker_spatial.h.

30 {

31 }

Member Function Documentation

◆ cleanUp()

template<class _IteratorFactory_ >

void KisConvolutionWorkerSpatial< _IteratorFactory_ >::cleanUp ( )

inline

Definition at line 339 of file kis_convolution_worker_spatial.h.

                   {
        for (quint32 c = 0; c < m_cacheSize; ++c) {
            delete[] m_pixelPtrCache[c];
            delete[] m_pixelPtrCacheCopy[c];
        }
 
        delete[] m_kernelData;
        delete[] m_pixelPtrCache;
        delete[] m_pixelPtrCacheCopy;
 
        delete[] m_minClamp;
        delete[] m_maxClamp;
        delete[] m_absoluteOffset;
    }

References KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_absoluteOffset, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_cacheSize, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_kernelData, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_maxClamp, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_minClamp, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_pixelPtrCache, and KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_pixelPtrCacheCopy.

◆ convolveCache()

template<class _IteratorFactory_ >

void KisConvolutionWorkerSpatial< _IteratorFactory_ >::convolveCache ( quint8 * dstPtr )

inline

Definition at line 274 of file kis_convolution_worker_spatial.h.

                                              {
        if (m_alphaCachePos >= 0) {
            qreal alphaValue = convolveOneChannelFromCache<false>(dstPtr, m_alphaCachePos);
 
            // TODO: we need a special case for applying LoG filter,
            // when the alpha i suniform and therefore should not be
            // filtered!
            //alphaValue = 255.0;
 
            if (alphaValue != 0.0) {
                qreal alphaValueInv = 1.0 / alphaValue;
 
                for (quint32 k = 0; k < m_convolveChannelsNo; ++k) {
                    if (k == (quint32)m_alphaCachePos) continue;
                    convolveOneChannelFromCache<true>(dstPtr, k, alphaValueInv);
                }
            } else {
                for (quint32 k = 0; k < m_convolveChannelsNo; ++k) {
                    if (k == (quint32)m_alphaCachePos) continue;
 
                    const qreal zeroValue = 0.0;
                    const quint32 channelPos = m_convChannelList[k]->pos();
                    m_fromDoubleFuncPtr[k](dstPtr, channelPos, zeroValue);
                }
            }
        } else {
            for (quint32 k = 0; k < m_convolveChannelsNo; ++k) {
                convolveOneChannelFromCache<false>(dstPtr, k);
            }
        }
    }

References KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_alphaCachePos, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_convChannelList, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_convolveChannelsNo, and KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_fromDoubleFuncPtr.

◆ convolveOneChannelFromCache()

template<class _IteratorFactory_ >

template<bool additionalMultiplierActive>

qreal KisConvolutionWorkerSpatial< _IteratorFactory_ >::convolveOneChannelFromCache	(	quint8 *	dstPtr,
		quint32	channel,
		qreal	additionalMultiplier = 0.0 )

inline

Definition at line 251 of file kis_convolution_worker_spatial.h.

                                                                                                                {
        qreal interimConvoResult = 0;
 
        for (quint32 pIndex = 0; pIndex < m_cacheSize; ++pIndex) {
            qreal cacheValue = m_pixelPtrCache[pIndex][channel];
            interimConvoResult += m_kernelData[m_cacheSize - pIndex - 1] * cacheValue;
        }
 
        qreal channelPixelValue;
        if (additionalMultiplierActive) {
            channelPixelValue = interimConvoResult * m_kernelFactor * additionalMultiplier + m_absoluteOffset[channel];
        } else {
            channelPixelValue = interimConvoResult * m_kernelFactor + m_absoluteOffset[channel];
        }
 
        limitValue(&channelPixelValue, m_minClamp[channel], m_maxClamp[channel]);
 
        const quint32 channelPos = m_convChannelList[channel]->pos();
        m_fromDoubleFuncPtr[channel](dstPtr, channelPos, channelPixelValue);
 
        return channelPixelValue;
    }

◆ execute()

template<class _IteratorFactory_ >

void KisConvolutionWorkerSpatial< _IteratorFactory_ >::execute	(	const KisConvolutionKernelSP	kernel,
		const KisPaintDeviceSP	src,
		QPoint	srcPos,
		QPoint	dstPos,
		QSize	areaSize,
		const QRect &	dataRect )

inlineoverridevirtual

Implements KisConvolutionWorker< _IteratorFactory_ >.

Definition at line 49 of file kis_convolution_worker_spatial.h.

                                                                                                                                                                {
        // store some kernel characteristics
        m_kw = kernel->width();
        m_kh = kernel->height();
        m_khalfWidth = (m_kw > 0) ? (m_kw - 1) / 2 : m_kw;
        m_khalfHeight = (m_kh > 0) ? (m_kh - 1) / 2 : m_kh;
        m_cacheSize = m_kw * m_kh;
        m_pixelSize = src->colorSpace()->pixelSize();
        quint32 channelCount = src->colorSpace()->channelCount();
 
        m_kernelData = new qreal[m_cacheSize];
        qreal *kernelDataPtr = m_kernelData;
 
        // fill in data
        for (quint32 r = 0; r < kernel->height(); r++) {
            for (quint32 c = 0; c < kernel->width(); c++) {
                *kernelDataPtr = (*(kernel->data()))(r, c);
                kernelDataPtr++;
            }
        }
 
        // Make the area we cover as small as possible
        if (this->m_painter->selection()) {
            QRect r = this->m_painter->selection()->selectedRect().intersected(QRect(srcPos, areaSize));
            dstPos += r.topLeft() - srcPos;
            srcPos = r.topLeft();
            areaSize = r.size();
        }
 
        if (areaSize.width() == 0 || areaSize.height() == 0)
            return;
 
        // Don't convolve with an even sized kernel
        Q_ASSERT((m_kw & 0x01) == 1 || (m_kh & 0x01) == 1 || kernel->factor() != 0);
 
        // find out which channels need be convolved
        m_convChannelList = this->convolvableChannelList(src);
        m_convolveChannelsNo = m_convChannelList.count();
 
        for (int i = 0; i < m_convChannelList.size(); i++) {
            if (m_convChannelList[i]->channelType() == KoChannelInfo::ALPHA) {
                m_alphaCachePos = i;
                m_alphaRealPos = m_convChannelList[i]->pos();
            }
        }
 
        bool hasProgressUpdater = this->m_progress;
        if (hasProgressUpdater)
            this->m_progress->setProgress(0);
 
        // Iterate over all pixels in our rect, create a cache of pixels around the current pixel and convolve them.
        m_pixelPtrCache = new qreal*[m_cacheSize];
        m_pixelPtrCacheCopy = new qreal*[m_cacheSize];
        for (quint32 c = 0; c < m_cacheSize; ++c) {
            m_pixelPtrCache[c] = new qreal[channelCount];
            m_pixelPtrCacheCopy[c] = new qreal[channelCount];
        }
 
        // decide caching strategy
        enum TraversingDirection { Horizontal, Vertical };
        TraversingDirection traversingDirection = Vertical;
        if (m_kw > m_kh) {
            traversingDirection = Horizontal;
        }
 
        KisMathToolbox mathToolbox;
        m_toDoubleFuncPtr = QVector<PtrToDouble>(m_convolveChannelsNo);
        if (!mathToolbox.getToDoubleChannelPtr(m_convChannelList, m_toDoubleFuncPtr))
            return;
 
        m_fromDoubleFuncPtr = QVector<PtrFromDouble>(m_convolveChannelsNo);
        if (!mathToolbox.getFromDoubleChannelPtr(m_convChannelList, m_fromDoubleFuncPtr))
            return;
 
        m_kernelFactor = kernel->factor() ? 1.0 / kernel->factor() : 1;
        m_maxClamp = new qreal[m_convChannelList.count()];
        m_minClamp = new qreal[m_convChannelList.count()];
        m_absoluteOffset = new qreal[m_convChannelList.count()];
        for (quint16 i = 0; i < m_convChannelList.count(); ++i) {
            m_minClamp[i] = mathToolbox.minChannelValue(m_convChannelList[i]);
            m_maxClamp[i] = mathToolbox.maxChannelValue(m_convChannelList[i]);
            m_absoluteOffset[i] = (m_maxClamp[i] - m_minClamp[i]) * kernel->offset();
        }
 
        qint32 row = srcPos.y();
        qint32 col = srcPos.x();
 
        // populate pixelPtrCacheCopy for starting position (0, 0)
        qint32 i = 0;
        typename _IteratorFactory_::HLineConstIterator hitInitSrc = _IteratorFactory_::createHLineConstIterator(src, col - m_khalfWidth, row - m_khalfHeight, m_kw, dataRect);
 
        for (quint32 krow = 0; krow < m_kh; ++krow) {
            do {
                const quint8* data = hitInitSrc->oldRawData();
                loadPixelToCache(m_pixelPtrCacheCopy, data, i);
                ++i;
            } while (hitInitSrc->nextPixel());
            hitInitSrc->nextRow();
        }
 
 
        if (traversingDirection == Horizontal) {
            if(hasProgressUpdater) {
                this->m_progress->setRange(0, areaSize.height());
            }
            typename _IteratorFactory_::HLineIterator hitDst = _IteratorFactory_::createHLineIterator(this->m_painter->device(), dstPos.x(), dstPos.y(), areaSize.width(), dataRect);
            typename _IteratorFactory_::HLineConstIterator hitSrc = _IteratorFactory_::createHLineConstIterator(src, srcPos.x(), srcPos.y(), areaSize.width(), dataRect);
 
            typename _IteratorFactory_::HLineConstIterator khitSrc = _IteratorFactory_::createHLineConstIterator(src, col - m_khalfWidth, row + m_khalfHeight, m_kw, dataRect);
            for (int prow = 0; prow < areaSize.height(); ++prow) {
                // reload cache from copy
                for (quint32 i = 0; i < m_cacheSize; ++i)
                    memcpy(m_pixelPtrCache[i], m_pixelPtrCacheCopy[i], channelCount * sizeof(qreal));
 
                typename _IteratorFactory_::VLineConstIterator kitSrc = _IteratorFactory_::createVLineConstIterator(src, col + m_khalfWidth, row - m_khalfHeight, m_kh, dataRect);
                for (int pcol = 0; pcol < areaSize.width(); ++pcol) {
                    // write original channel values
                    memcpy(hitDst->rawData(), hitSrc->oldRawData(), m_pixelSize);
                    convolveCache(hitDst->rawData());
 
                    ++col;
                    kitSrc->nextColumn();
                    hitDst->nextPixel();
                    hitSrc->nextPixel();
                    moveKernelRight(kitSrc, m_pixelPtrCache);
                }
 
                row++;
                khitSrc->nextRow();
                hitDst->nextRow();
                hitSrc->nextRow();
                col = srcPos.x();
 
                moveKernelDown(khitSrc, m_pixelPtrCacheCopy);
 
                if (hasProgressUpdater) {
                    this->m_progress->setValue(prow);
 
                    if (this->m_progress->interrupted()) {
                        cleanUp();
                        return;
                    }
                }
 
            }
        } else /* if (traversingDirection == Vertical) */ {
            if(hasProgressUpdater) {
                this->m_progress->setRange(0, areaSize.width());
            }
            typename _IteratorFactory_::VLineIterator vitDst = _IteratorFactory_::createVLineIterator(this->m_painter->device(), dstPos.x(), dstPos.y(), areaSize.height(), dataRect);
            typename _IteratorFactory_::VLineConstIterator vitSrc = _IteratorFactory_::createVLineConstIterator(src, srcPos.x(), srcPos.y(), areaSize.height(), dataRect);
 
            typename _IteratorFactory_::VLineConstIterator kitSrc = _IteratorFactory_::createVLineConstIterator(src, col + m_khalfWidth, row - m_khalfHeight, m_kh, dataRect);
            for (int pcol = 0; pcol < areaSize.width(); pcol++) {
                // reload cache from copy
                for (quint32 i = 0; i < m_cacheSize; ++i)
                    memcpy(m_pixelPtrCache[i], m_pixelPtrCacheCopy[i], channelCount * sizeof(qreal));
 
                typename _IteratorFactory_::HLineConstIterator khitSrc = _IteratorFactory_::createHLineConstIterator(src, col - m_khalfWidth, row + m_khalfHeight, m_kw, dataRect);
                for (int prow = 0; prow < areaSize.height(); prow++) {
                    // write original channel values
                    memcpy(vitDst->rawData(), vitSrc->oldRawData(), m_pixelSize);
                    convolveCache(vitDst->rawData());
 
                    ++row;
                    khitSrc->nextRow();
                    vitDst->nextPixel();
                    vitSrc->nextPixel();
                    moveKernelDown(khitSrc, m_pixelPtrCache);
                }
 
                ++col;
                kitSrc->nextColumn();
                vitDst->nextColumn();
                vitSrc->nextColumn();
                row = srcPos.y();
 
                moveKernelRight(kitSrc, m_pixelPtrCacheCopy);
 
                if (hasProgressUpdater) {
                    this->m_progress->setValue(pcol);
 
                    if (this->m_progress->interrupted()) {
                        cleanUp();
                        return;
                    }
                }
            }
        }
        cleanUp();
    }

◆ limitValue()

template<class _IteratorFactory_ >

void KisConvolutionWorkerSpatial< _IteratorFactory_ >::limitValue	(	qreal *	value,
		qreal	lowBound,
		qreal	highBound )

inline

Definition at line 241 of file kis_convolution_worker_spatial.h.

                                                                          {
        if (*value > highBound) {
            *value = highBound;
        } else if (!(*value >= lowBound)) {  // value < lowBound or value == NaN
            // IEEE compliant comparisons with NaN are always false
            *value = lowBound;
        }
    }

References value().

◆ loadPixelToCache()

template<class _IteratorFactory_ >

void KisConvolutionWorkerSpatial< _IteratorFactory_ >::loadPixelToCache	(	qreal **	cache,
		const quint8 *	data,
		int	index )

inline

Definition at line 33 of file kis_convolution_worker_spatial.h.

                                                                               {
        // no alpha is rare case, so just multiply by 1.0 in that case
        qreal alphaValue = m_alphaRealPos >= 0 ?
            m_toDoubleFuncPtr[m_alphaCachePos](data, m_alphaRealPos) : 1.0;
 
        for (quint32 k = 0; k < m_convolveChannelsNo; ++k) {
            if (k != (quint32)m_alphaCachePos) {
                const quint32 channelPos = m_convChannelList[k]->pos();
                cache[index][k] = m_toDoubleFuncPtr[k](data, channelPos) * alphaValue;
            } else {
                cache[index][k] = alphaValue;
            }
        }
 
    }

References KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_alphaCachePos, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_alphaRealPos, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_convChannelList, KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_convolveChannelsNo, and KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_toDoubleFuncPtr.

◆ moveKernelDown()

template<class _IteratorFactory_ >

void KisConvolutionWorkerSpatial< _IteratorFactory_ >::moveKernelDown	(	typename _IteratorFactory_::HLineConstIterator &	kitSrc,
		qreal **	pixelPtrCache )

inline

Definition at line 324 of file kis_convolution_worker_spatial.h.

                                                                                                            {
        quint8 **tmp = new quint8*[m_kw];
        memcpy(tmp, pixelPtrCache, m_kw * sizeof(qreal *));
        memmove(pixelPtrCache, pixelPtrCache + m_kw, (m_kw * m_kh - m_kw) * sizeof(quint8 *));
        memcpy(pixelPtrCache + m_kw *(m_kh - 1), tmp, m_kw * sizeof(quint8 *));
        delete[] tmp;
 
        qint32 i = m_kw * (m_kh - 1);
        do {
            const quint8* data = kitSrc->oldRawData();
            loadPixelToCache(pixelPtrCache, data, i);
            i++;
        } while (kitSrc->nextPixel());
    }

References KisConvolutionWorkerSpatial< _IteratorFactory_ >::loadPixelToCache(), KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_kh, and KisConvolutionWorkerSpatial< _IteratorFactory_ >::m_kw.

◆ moveKernelRight()

template<class _IteratorFactory_ >

void KisConvolutionWorkerSpatial< _IteratorFactory_ >::moveKernelRight	(	typename _IteratorFactory_::VLineConstIterator &	kitSrc,
		qreal **	pixelPtrCache )

inline

Definition at line 306 of file kis_convolution_worker_spatial.h.

                                                                                                             {
        qreal** d = pixelPtrCache;
 
        for (quint32 krow = 0; krow < m_kh; ++krow) {
            qreal* first = *d;
            memmove(d, d + 1, (m_kw - 1) * sizeof(qreal *));
            *(d + m_kw - 1) = first;
            d += m_kw;
        }
 
        qint32 i = m_kw - 1;
        do {
            const quint8* data = kitSrc->oldRawData();
            loadPixelToCache(pixelPtrCache, data, i);
            i += m_kw;
        } while (kitSrc->nextPixel());
    }