KisConvolutionWorkerFFT< _IteratorFactory_ > Class Template Reference

#include <kis_convolution_worker_fft.h>

Inheritance diagram for KisConvolutionWorkerFFT< _IteratorFactory_ >:

Classes
struct	FFTInfo

Public Member Functions
void	execute (const KisConvolutionKernelSP kernel, const KisPaintDeviceSP src, QPoint srcPos, QPoint dstPos, QSize areaSize, const QRect &dataRect) override
void	fillCacheFromDevice (KisPaintDeviceSP src, const QRect &rect, const int cacheRowStride, const FFTInfo &info, const QRect &dataRect)
	KisConvolutionWorkerFFT (KisPainter *painter, KoUpdater *progress)
void	limitValue (qreal *value, qreal lowBound, qreal highBound)
qreal	writeAlphaFromCache (quint8 *dstPtr, const quint32 channel, const FFTInfo &info, double *channelValuePtr, bool *dstValueIsNull)
template<bool additionalMultiplierActive>
qreal	writeOneChannelFromCache (quint8 *dstPtr, const quint32 channel, const FFTInfo &info, double *channelValuePtr, const qreal additionalMultiplier=0.0)
void	writeResultToDevice (const QRect &rect, const int cacheRowStride, const int halfKernelWidth, const int halfKernelHeight, const FFTInfo &info, const QRect &dataRect)
	~KisConvolutionWorkerFFT ()
Public Member Functions inherited from KisConvolutionWorker< _IteratorFactory_ >
	KisConvolutionWorker (KisPainter *painter, KoUpdater *progress)
virtual	~KisConvolutionWorker ()

Private Member Functions
void	addToProgress (float amount)
void	cleanUp ()
void	fftFillKernelMatrix (const KisConvolutionKernelSP kernel, fftw_complex *m_kernelFFT)
void	fftLogMatrix (double *channel, const QString &f)
void	fftMultiply (fftw_complex *channel, fftw_complex *kernel)
bool	isInterrupted ()
void	optimumDimensions (quint32 &w, quint32 &h)

Private Attributes
QVector< fftw_complex * >	m_channelFFT
float	m_currentProgress {0.0}
quint32	m_extraMem {0}
quint32	m_fftHeight {0}
quint32	m_fftLength {0}
quint32	m_fftWidth {0}
fftw_complex *	m_kernelFFT {0}

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 KisConvolutionWorkerFFT< _IteratorFactory_ >

Definition at line 40 of file kis_convolution_worker_fft.h.

Constructor & Destructor Documentation

KisConvolutionWorkerFFT()

template<class _IteratorFactory_ >

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

inline

Definition at line 43 of file kis_convolution_worker_fft.h.

        : KisConvolutionWorker<_IteratorFactory_>(painter, progress)
    {
    }

~KisConvolutionWorkerFFT()

template<class _IteratorFactory_ >

KisConvolutionWorkerFFT< _IteratorFactory_ >::~KisConvolutionWorkerFFT ( )

inline

Definition at line 48 of file kis_convolution_worker_fft.h.

    {
    }

Member Function Documentation

addToProgress()

template<class _IteratorFactory_ >

void KisConvolutionWorkerFFT< _IteratorFactory_ >::addToProgress ( float amount )

inlineprivate

Definition at line 515 of file kis_convolution_worker_fft.h.

    {
        m_currentProgress += amount;
 
        if (this->m_progress) {
            this->m_progress->setProgress((int)m_currentProgress);
        }
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::m_currentProgress, KisConvolutionWorker< _IteratorFactory_ >::m_progress, and KoUpdater::setProgress().

cleanUp()

template<class _IteratorFactory_ >

void KisConvolutionWorkerFFT< _IteratorFactory_ >::cleanUp ( )

inlineprivate

Definition at line 534 of file kis_convolution_worker_fft.h.

    {
        // free kernel fft data
        if (m_kernelFFT) {
            fftw_free(m_kernelFFT);
        }
 
        Q_FOREACH (fftw_complex *channel, m_channelFFT) {
            fftw_free(channel);
        }
        m_channelFFT.clear();
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::m_channelFFT, and KisConvolutionWorkerFFT< _IteratorFactory_ >::m_kernelFFT.

execute()

template<class _IteratorFactory_ >

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

inlineoverridevirtual

FIXME: check whether this "optimization" is needed to be uncommented. My tests showed about 30% better performance when the line is commented out (DK).

Implements KisConvolutionWorker< _IteratorFactory_ >.

Definition at line 52 of file kis_convolution_worker_fft.h.

    {
        // 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;
 
        addToProgress(0);
        if (isInterrupted()) return;
 
        const quint32 halfKernelWidth = (kernel->width() - 1) / 2;
        const quint32 halfKernelHeight = (kernel->height() - 1) / 2;
 
        m_fftWidth = areaSize.width() + 4 * halfKernelWidth;
        m_fftHeight = areaSize.height() + 2 * halfKernelHeight;
 
        //optimumDimensions(m_fftWidth, m_fftHeight);
 
        m_fftLength = m_fftHeight * (m_fftWidth / 2 + 1);
        m_extraMem = (m_fftWidth % 2) ? 1 : 2;
 
        // create and fill kernel
        m_kernelFFT = (fftw_complex *)fftw_malloc(sizeof(fftw_complex) * m_fftLength);
        memset(m_kernelFFT, 0, sizeof(fftw_complex) * m_fftLength);
        fftFillKernelMatrix(kernel, m_kernelFFT);
 
        // find out which channels need convolving
        QList<KoChannelInfo*> convChannelList = this->convolvableChannelList(src);
 
        m_channelFFT.resize(convChannelList.count());
        for (auto i = m_channelFFT.begin(); i != m_channelFFT.end(); ++i) {
            *i = (fftw_complex *)fftw_malloc(sizeof(fftw_complex) * m_fftLength);
        }
 
        const double kernelFactor = kernel->factor() ? kernel->factor() : 1;
        const double fftScale = 1.0 / (m_fftHeight * m_fftWidth) / kernelFactor;
 
        FFTInfo info (fftScale, convChannelList, kernel, this->m_painter->device()->colorSpace());
        int cacheRowStride = m_fftWidth + m_extraMem;
 
        fillCacheFromDevice(src,
                            QRect(srcPos.x() - halfKernelWidth,
                                  srcPos.y() - halfKernelHeight,
                                  m_fftWidth,
                                  m_fftHeight),
                            cacheRowStride,
                            info, dataRect);
 
        addToProgress(10);
        if (isInterrupted()) return;
 
        // calculate number off fft operations required for progress reporting
        const float progressPerFFT = (100 - 30) / (double)(convChannelList.count() * 2 + 1);
 
        // perform FFT
        fftw_plan fftwPlanForward, fftwPlanBackward;
 
        KisConvolutionWorkerFFTLock::fftwMutex.lock();
        fftwPlanForward = fftw_plan_dft_r2c_2d(m_fftHeight, m_fftWidth, (double*)m_kernelFFT, m_kernelFFT, FFTW_ESTIMATE);
        fftwPlanBackward = fftw_plan_dft_c2r_2d(m_fftHeight, m_fftWidth, m_kernelFFT, (double*)m_kernelFFT, FFTW_ESTIMATE);
        KisConvolutionWorkerFFTLock::fftwMutex.unlock();
 
        fftw_execute(fftwPlanForward);
        addToProgress(progressPerFFT);
        if (isInterrupted()) return;
 
        for (auto k = m_channelFFT.begin(); k != m_channelFFT.end(); ++k)
        {
            fftw_execute_dft_r2c(fftwPlanForward, (double*)(*k), *k);
            addToProgress(progressPerFFT);
            if (isInterrupted()) return;
 
            fftMultiply(*k, m_kernelFFT);
 
            fftw_execute_dft_c2r(fftwPlanBackward, *k, (double*)*k);
            addToProgress(progressPerFFT);
            if (isInterrupted()) return;
        }
 
        KisConvolutionWorkerFFTLock::fftwMutex.lock();
        fftw_destroy_plan(fftwPlanForward);
        fftw_destroy_plan(fftwPlanBackward);
        KisConvolutionWorkerFFTLock::fftwMutex.unlock();
 
 
        writeResultToDevice(QRect(dstPos.x(), dstPos.y(), areaSize.width(), areaSize.height()),
                            cacheRowStride, halfKernelWidth, halfKernelHeight,
                            info, dataRect);
 
        addToProgress(20);
        cleanUp();
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::addToProgress(), KisConvolutionWorkerFFT< _IteratorFactory_ >::cleanUp(), KisPaintDevice::colorSpace(), KisConvolutionWorker< _IteratorFactory_ >::convolvableChannelList(), KisPainter::device, KisConvolutionKernel::factor, KisConvolutionWorkerFFT< _IteratorFactory_ >::fftFillKernelMatrix(), KisConvolutionWorkerFFT< _IteratorFactory_ >::fftMultiply(), KisConvolutionWorkerFFTLock::fftwMutex, KisConvolutionWorkerFFT< _IteratorFactory_ >::fillCacheFromDevice(), KisConvolutionKernel::height(), KisConvolutionWorkerFFT< _IteratorFactory_ >::isInterrupted(), KisConvolutionWorkerFFT< _IteratorFactory_ >::m_channelFFT, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_extraMem, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftHeight, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftLength, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftWidth, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_kernelFFT, KisConvolutionWorker< _IteratorFactory_ >::m_painter, KisSelection::selectedRect(), KisPainter::selection, KisConvolutionKernel::width(), and KisConvolutionWorkerFFT< _IteratorFactory_ >::writeResultToDevice().

fftFillKernelMatrix()

template<class _IteratorFactory_ >

void KisConvolutionWorkerFFT< _IteratorFactory_ >::fftFillKernelMatrix ( const KisConvolutionKernelSP kernel, fftw_complex * m_kernelFFT )

inlineprivate

Definition at line 415 of file kis_convolution_worker_fft.h.

    {
        // find central item
        QPoint offset((kernel->width() - 1) / 2, (kernel->height() - 1) / 2);
 
        qint32 xShift = m_fftWidth - offset.x();
        qint32 yShift = m_fftHeight - offset.y();
 
        quint32 absXpos, absYpos;
 
        for (quint32 y = 0; y < kernel->height(); y++)
        {
            absYpos = y + yShift;
            if (absYpos >= m_fftHeight)
                absYpos -= m_fftHeight;
 
            for (quint32 x = 0; x < kernel->width(); x++)
            {
                absXpos = x + xShift;
                if (absXpos >= m_fftWidth)
                    absXpos -= m_fftWidth;
 
                ((double*)m_kernelFFT)[(m_fftWidth + m_extraMem) * absYpos + absXpos] = kernel->data()->coeff(y, x);
            }
        }
    }

References KisConvolutionKernel::data, KisConvolutionKernel::height(), KisConvolutionWorkerFFT< _IteratorFactory_ >::m_extraMem, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftHeight, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftWidth, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_kernelFFT, and KisConvolutionKernel::width().

fftLogMatrix()

template<class _IteratorFactory_ >

void KisConvolutionWorkerFFT< _IteratorFactory_ >::fftLogMatrix ( double * channel, const QString & f )

inlineprivate

Definition at line 485 of file kis_convolution_worker_fft.h.

    {
        KisConvolutionWorkerFFTLock::fftwMutex.lock();
        QString filename(QDir::homePath() + "/log_" + f + ".txt");
        dbgKrita << "Log File Name: " << filename;
        QFile file (filename);
        if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text))
        {
            dbgKrita << "Failed";
            KisConvolutionWorkerFFTLock::fftwMutex.unlock();
            return;
        }
 
        QTextStream in(&file);
        KisPortingUtils::setUtf8OnStream(in);
        for (quint32 y = 0; y < m_fftHeight; y++)
        {
            for (quint32 x = 0; x < m_fftWidth; x++)
            {
                QString num = QString::number(channel[y * m_fftWidth + x]);
                while (num.length() < 15)
                    num += " ";
 
                in << num << " ";
            }
            in << "\n";
        }
        KisConvolutionWorkerFFTLock::fftwMutex.unlock();
    }

References dbgKrita, KisConvolutionWorkerFFTLock::fftwMutex, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftHeight, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftWidth, and KisPortingUtils::setUtf8OnStream().

fftMultiply()

template<class _IteratorFactory_ >

void KisConvolutionWorkerFFT< _IteratorFactory_ >::fftMultiply ( fftw_complex * channel, fftw_complex * kernel )

inlineprivate

Definition at line 442 of file kis_convolution_worker_fft.h.

    {
        // perform complex multiplication
        fftw_complex *channelPtr = channel;
        fftw_complex *kernelPtr = kernel;
 
        fftw_complex tmp;
 
        for (quint32 pixelPos = 0; pixelPos < m_fftLength; ++pixelPos)
        {
            tmp[0] = ((*channelPtr)[0] * (*kernelPtr)[0]) - ((*channelPtr)[1] * (*kernelPtr)[1]);
            tmp[1] = ((*channelPtr)[0] * (*kernelPtr)[1]) + ((*channelPtr)[1] * (*kernelPtr)[0]);
 
            (*channelPtr)[0] = tmp[0];
            (*channelPtr)[1] = tmp[1];
 
            ++channelPtr;
            ++kernelPtr;
        }
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftLength.

fillCacheFromDevice()

template<class _IteratorFactory_ >

void KisConvolutionWorkerFFT< _IteratorFactory_ >::fillCacheFromDevice ( KisPaintDeviceSP src, const QRect & rect, const int cacheRowStride, const FFTInfo & info, const QRect & dataRect )

inline

Definition at line 214 of file kis_convolution_worker_fft.h.

                                                    {
 
        typename _IteratorFactory_::HLineConstIterator hitSrc =
            _IteratorFactory_::createHLineConstIterator(src,
                                                        rect.x(), rect.y(), rect.width(),
                                                        dataRect);
 
        const int channelCount = info.numChannels();
        QVector<double*> channelPtr(channelCount);
        const auto channelPtrBegin = channelPtr.begin();
        const auto channelPtrEnd = channelPtr.end();
 
        auto iFFt = m_channelFFT.constBegin();
        for (auto i = channelPtrBegin; i != channelPtrEnd; ++i, ++iFFt) {
            *i = (double*)*iFFt;
        }
 
        // prepare cache, reused in all loops
        QVector<double*> cacheRowStart(channelCount);
        const auto cacheRowStartBegin = cacheRowStart.begin();
 
        for (int y = 0; y < rect.height(); ++y) {
            // cache current channelPtr in cacheRowStart
            memcpy(cacheRowStart.data(), channelPtr.data(), channelCount * sizeof(double*));
 
            for (int x = 0; x < rect.width(); ++x) {
                const quint8 *data = hitSrc->oldRawData();
 
                // no alpha is a rare case, so just multiply by 1.0 in that case
                double alphaValue = info.alphaRealPos >= 0 ?
                    info.toDoubleFuncPtr[info.alphaCachePos](data, info.alphaRealPos) : 1.0;
                int k = 0;
                for (auto i = channelPtrBegin; i != channelPtrEnd; ++i, ++k) {
                    if (k != info.alphaCachePos) {
                        const quint32 channelPos = info.convChannelList[k]->pos();
                        **i = info.toDoubleFuncPtr[k](data, channelPos) * alphaValue;
                    } else {
                        **i = alphaValue;
                    }
 
                    ++(*i);
                }
 
                hitSrc->nextPixel();
            }
 
            auto iRowStart = cacheRowStartBegin;
            for (auto i = channelPtrBegin; i != channelPtrEnd; ++i, ++iRowStart) {
                *i = *iRowStart + cacheRowStride;
            }
 
            hitSrc->nextRow();
        }
 
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::alphaCachePos, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::alphaRealPos, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::convChannelList, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_channelFFT, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::numChannels(), and KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::toDoubleFuncPtr.

isInterrupted()

template<class _IteratorFactory_ >

bool KisConvolutionWorkerFFT< _IteratorFactory_ >::isInterrupted ( )

inlineprivate

Definition at line 524 of file kis_convolution_worker_fft.h.

    {
        if (this->m_progress && this->m_progress->interrupted()) {
            cleanUp();
            return true;
        }
 
        return false;
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::cleanUp(), KoUpdater::interrupted(), and KisConvolutionWorker< _IteratorFactory_ >::m_progress.

limitValue()

template<class _IteratorFactory_ >

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

inline

Definition at line 274 of file kis_convolution_worker_fft.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().

optimumDimensions()

template<class _IteratorFactory_ >

void KisConvolutionWorkerFFT< _IteratorFactory_ >::optimumDimensions ( quint32 & w, quint32 & h )

inlineprivate

Definition at line 463 of file kis_convolution_worker_fft.h.

    {
        // FFTW is most efficient when array size is a factor of 2, 3, 5 or 7
        quint32 optW = w, optH = h;
 
        while ((optW % 2 != 0) || (optW % 3 != 0) || (optW % 5 != 0) || (optW % 7 != 0))
            ++optW;
 
        while ((optH % 2 != 0) || (optH % 3 != 0) || (optH % 5 != 0) || (optH % 7 != 0))
            ++optH;
 
        quint32 optAreaW = optW * h;
        quint32 optAreaH = optH * w;
 
        if (optAreaW < optAreaH) {
            w = optW;
        }
        else {
            h = optH;
        }
    }

writeAlphaFromCache()

template<class _IteratorFactory_ >

qreal KisConvolutionWorkerFFT< _IteratorFactory_ >::writeAlphaFromCache ( quint8 * dstPtr, const quint32 channel, const FFTInfo & info, double * channelValuePtr, bool * dstValueIsNull )

inline

Definition at line 283 of file kis_convolution_worker_fft.h.

                                                           {
        qreal channelPixelValue;
 
        channelPixelValue = *channelValuePtr * info.fftScale + info.absoluteOffset[channel];
        limitValue(&channelPixelValue, info.minClamp[channel], info.maxClamp[channel]);
        info.fromDoubleCheckNullFuncPtr[channel](dstPtr, info.convChannelList[channel]->pos(), channelPixelValue, dstValueIsNull);
 
        return channelPixelValue;
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::absoluteOffset, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::convChannelList, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::fftScale, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::fromDoubleCheckNullFuncPtr, KisConvolutionWorkerFFT< _IteratorFactory_ >::limitValue(), KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::maxClamp, and KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::minClamp.

writeOneChannelFromCache()

template<class _IteratorFactory_ >

template<bool additionalMultiplierActive>

qreal KisConvolutionWorkerFFT< _IteratorFactory_ >::writeOneChannelFromCache ( quint8 * dstPtr, const quint32 channel, const FFTInfo & info, double * channelValuePtr, const qreal additionalMultiplier = 0.0 )

inline

Definition at line 298 of file kis_convolution_worker_fft.h.

                                                                                  {
        qreal channelPixelValue;
 
        if (additionalMultiplierActive) {
            channelPixelValue = *channelValuePtr * info.fftScale * additionalMultiplier + info.absoluteOffset[channel];
        } else {
            channelPixelValue = *channelValuePtr * info.fftScale + info.absoluteOffset[channel];
        }
 
        limitValue(&channelPixelValue, info.minClamp[channel], info.maxClamp[channel]);
 
        info.fromDoubleFuncPtr[channel](dstPtr, info.convChannelList[channel]->pos(), channelPixelValue);
 
        return channelPixelValue;
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::absoluteOffset, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::convChannelList, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::fftScale, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::fromDoubleFuncPtr, KisConvolutionWorkerFFT< _IteratorFactory_ >::limitValue(), KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::maxClamp, and KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::minClamp.

writeResultToDevice()

template<class _IteratorFactory_ >

void KisConvolutionWorkerFFT< _IteratorFactory_ >::writeResultToDevice ( const QRect & rect, const int cacheRowStride, const int halfKernelWidth, const int halfKernelHeight, const FFTInfo & info, const QRect & dataRect )

inline

Definition at line 318 of file kis_convolution_worker_fft.h.

                                                    {
 
        typename _IteratorFactory_::HLineIterator hitDst =
            _IteratorFactory_::createHLineIterator(this->m_painter->device(),
                                                   rect.x(), rect.y(), rect.width(),
                                                   dataRect);
 
        int initialOffset = cacheRowStride * halfKernelHeight + halfKernelWidth;
 
        const int channelCount = info.numChannels();
        QVector<double*> channelPtr(channelCount);
        const auto channelPtrBegin = channelPtr.begin();
        const auto channelPtrEnd = channelPtr.end();
 
        auto iFFt = m_channelFFT.constBegin();
        for (auto i = channelPtrBegin; i != channelPtrEnd; ++i, ++iFFt) {
            *i = (double*)*iFFt + initialOffset;
        }
 
        // prepare cache, reused in all loops
        QVector<double*> cacheRowStart(channelCount);
        const auto cacheRowStartBegin = cacheRowStart.begin();
 
        for (int y = 0; y < rect.height(); ++y) {
            // cache current channelPtr in cacheRowStart
            memcpy(cacheRowStart.data(), channelPtr.data(), channelCount * sizeof(double*));
 
            for (int x = 0; x < rect.width(); ++x) {
                quint8 *dstPtr = hitDst->rawData();
 
                if (info.alphaCachePos >= 0) {
                    bool alphaIsNullInDstSpace = false;
 
                    qreal alphaValue =
                        writeAlphaFromCache(dstPtr,
                                            info.alphaCachePos,
                                            info,
                                            channelPtr.at(info.alphaCachePos),
                                            &alphaIsNullInDstSpace);
 
                    if (!alphaIsNullInDstSpace &&
                        alphaValue > std::numeric_limits<qreal>::epsilon()) {
 
                        qreal alphaValueInv = 1.0 / alphaValue;
 
                        int k = 0;
                        for (auto i = channelPtrBegin; i != channelPtrEnd; ++i, ++k) {
                            if (k != info.alphaCachePos) {
                                writeOneChannelFromCache<true>(dstPtr,
                                                               k,
                                                               info,
                                                               *i,
                                                               alphaValueInv);
                            }
                            ++(*i);
                        }
                    } else {
                        int k = 0;
                        for (auto i = channelPtrBegin; i != channelPtrEnd; ++i, ++k) {
                            if (k != info.alphaCachePos) {
                                info.fromDoubleFuncPtr[k](dstPtr,
                                        info.convChannelList[k]->pos(),
                                        0.0);
                            }
                            ++(*i);
                        }
                    }
                } else {
                    int k = 0;
                    for (auto i = channelPtrBegin; i != channelPtrEnd; ++i, ++k) {
                        writeOneChannelFromCache<false>(dstPtr,
                                                        k,
                                                        info,
                                                        *i);
                       ++(*i);
                    }
                }
 
                hitDst->nextPixel();
            }
 
            auto iRowStart = cacheRowStartBegin;
            for (auto i = channelPtrBegin; i != channelPtrEnd; ++i, ++iRowStart) {
                *i = *iRowStart + cacheRowStride;
            }
 
            hitDst->nextRow();
        }
 
    }

References KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::alphaCachePos, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::convChannelList, KisPainter::device, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::fromDoubleFuncPtr, KisConvolutionWorkerFFT< _IteratorFactory_ >::m_channelFFT, KisConvolutionWorker< _IteratorFactory_ >::m_painter, KisConvolutionWorkerFFT< _IteratorFactory_ >::FFTInfo::numChannels(), and KisConvolutionWorkerFFT< _IteratorFactory_ >::writeAlphaFromCache().

Member Data Documentation

m_channelFFT

template<class _IteratorFactory_ >

QVector<fftw_complex*> KisConvolutionWorkerFFT< _IteratorFactory_ >::m_channelFFT

private

Definition at line 554 of file kis_convolution_worker_fft.h.

m_currentProgress

template<class _IteratorFactory_ >

float KisConvolutionWorkerFFT< _IteratorFactory_ >::m_currentProgress {0.0}

private

Definition at line 551 of file kis_convolution_worker_fft.h.

{0.0};

m_extraMem

template<class _IteratorFactory_ >

quint32 KisConvolutionWorkerFFT< _IteratorFactory_ >::m_extraMem {0}

private

Definition at line 550 of file kis_convolution_worker_fft.h.

{0};

m_fftHeight

template<class _IteratorFactory_ >

quint32 KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftHeight {0}

private

Definition at line 548 of file kis_convolution_worker_fft.h.

{0};

m_fftLength

template<class _IteratorFactory_ >

quint32 KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftLength {0}

private

Definition at line 549 of file kis_convolution_worker_fft.h.

{0};

m_fftWidth

template<class _IteratorFactory_ >

quint32 KisConvolutionWorkerFFT< _IteratorFactory_ >::m_fftWidth {0}

private

Definition at line 547 of file kis_convolution_worker_fft.h.

{0};

m_kernelFFT

template<class _IteratorFactory_ >

fftw_complex* KisConvolutionWorkerFFT< _IteratorFactory_ >::m_kernelFFT {0}

private

Definition at line 553 of file kis_convolution_worker_fft.h.

{0};

---

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

• libs/image/kis_convolution_worker_fft.h