File indexing completed on 2024-05-12 15:58:13

 /*
  *  SPDX-FileCopyrightText: 2005, 2008, 2010 Cyrille Berger <cberger@cberger.net>
  *  SPDX-FileCopyrightText: 2009, 2010 Edward Apap <schumifer@hotmail.com>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #ifndef KIS_CONVOLUTION_WORKER_SPATIAL_H
 #define KIS_CONVOLUTION_WORKER_SPATIAL_H
 
 #include "kis_convolution_worker.h"
 #include "kis_math_toolbox.h"
 
 template <class _IteratorFactory_>
 class KisConvolutionWorkerSpatial : public KisConvolutionWorker<_IteratorFactory_>
 {
 public:
     KisConvolutionWorkerSpatial(KisPainter *painter, KoUpdater *progress)
         : 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() override {
     }
 
     inline void loadPixelToCache(qreal **cache, const quint8 *data, int index) {
         // 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;
             }
         }
 
     }
 
     void execute(const KisConvolutionKernelSP kernel, const KisPaintDeviceSP src, QPoint srcPos, QPoint dstPos, QSize areaSize, const QRect& dataRect) override {
         // 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();
     }
 
     inline void limitValue(qreal *value, qreal lowBound, qreal highBound) {
         if (*value > highBound) {
             *value = highBound;
         } else if (!(*value >= lowBound)) {  // value < lowBound or value == NaN
             // IEEE compliant comparisons with NaN are always false
             *value = lowBound;
         }
     }
 
     template <bool additionalMultiplierActive>
     inline qreal convolveOneChannelFromCache(quint8* dstPtr, quint32 channel, qreal additionalMultiplier = 0.0) {
         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;
     }
 
     inline void convolveCache(quint8* dstPtr) {
         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);
             }
         }
     }
 
     inline void moveKernelRight(typename _IteratorFactory_::VLineConstIterator& kitSrc, qreal **pixelPtrCache) {
         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());
     }
 
     inline void moveKernelDown(typename _IteratorFactory_::HLineConstIterator& kitSrc, qreal **pixelPtrCache) {
         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());
     }
 
     void cleanUp() {
         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;
     }
 
 private:
     quint32 m_kw, m_kh;
     quint32 m_khalfWidth, m_khalfHeight;
     quint32 m_convolveChannelsNo;
     quint32 m_cacheSize, m_pixelSize;
 
     int m_alphaCachePos;
     int m_alphaRealPos;
 
     qreal *m_kernelData;
     qreal** m_pixelPtrCache, ** m_pixelPtrCacheCopy;
     qreal* m_minClamp, *m_maxClamp, *m_absoluteOffset;
 
     qreal m_kernelFactor;
     QList<KoChannelInfo *> m_convChannelList;
     QVector<PtrToDouble> m_toDoubleFuncPtr;
     QVector<PtrFromDouble> m_fromDoubleFuncPtr;
 };
 
 
 #endif