KisFilterWeightsBuffer Class Reference

#include <kis_filter_weights_buffer.h>

Classes
struct	FilterWeights

Public Member Functions
	KisFilterWeightsBuffer (KisFilterStrategy *filterStrategy, qreal realScale)
int	maxSpan () const
FilterWeights *	weights (KisFixedPoint pos) const
KisFixedPoint	weightsPositionScale () const
	~KisFilterWeightsBuffer ()

Private Member Functions
int	findMaxIndex (qint16 *buf, int size)

Private Attributes
FilterWeights *	m_filterWeights
int	m_maxSpan
KisFixedPoint	m_weightsPositionScale

Detailed Description

Stores the cached values for the weights of neighbouring pixels that would form the pixel in a result of resampling. The object of this class is created before a pass of the transformation basing on the desired scale factor and the filter strategy used for resampling.

Here is an example of a calculation of the span for a pixel with scale equal to 1.0. The result of the blending will be written into the dst(0) pixel, which is marked with '*' sign. Note that all the coordinates here are related to the center of the pixel, not to its leftmost border as it is common in other systems. The centerSrc coordinate represents the offset between the source and the destination buffers.

dst-coordinates: the coordinates in the resulting image. The values of the filter strategy are calculated in these coordinates.

src-coordinates: the coordinates in the source image/buffer. We pick integer values from there and calculate their dst-position to know their weights.

                  +----+----+----+-- scaledIter (samples, measured in dst pixels,
                  |    |    |    |               correspond to integers in src)

                         +---------+-- supportDst == filterStrategy->intSupport()
                         |         |
               +-- beginDst        +-- endDst
               |         |         |
               |         +-- centerDst (always zero)
               |         |         |

dst: -—|-—|-—|-—|-—*-—|-—|-—|-—|-—|--> -4 -3 -2 -1 0 1 2 3 4 5

src: –|-—|-—|-—|-—|-—|-—|-—|-—|-—|----> -4 -3 -2 -1 0 1 2 3 4 5

         ^         ^         ^
         |         |         |
         |         +-- centerSrc
         |         |         |
         +-- beginSrc        +endSrc
         |         |         |
         |         +---------+-- supportSrc ~= supportDst / realScale
         |                   |
         +-------------------+-- span (number of integers in the region)

Definition at line 133 of file kis_filter_weights_buffer.h.

Constructor & Destructor Documentation

KisFilterWeightsBuffer()

KisFilterWeightsBuffer::KisFilterWeightsBuffer ( KisFilterStrategy * filterStrategy, qreal realScale )

inline

Definition at line 147 of file kis_filter_weights_buffer.h.

                                                                               {
        Q_ASSERT(realScale > 0);
 
        m_filterWeights = new FilterWeights[256];
        m_maxSpan = 0;
        m_weightsPositionScale = 1;
 
        KisFixedPoint supportSrc;
        KisFixedPoint supportDst;
 
        if (realScale < 1.0 && realScale > (1.0 / (1 << 8))) {
            m_weightsPositionScale = KisFixedPoint(realScale);
            supportSrc.from256Frac(filterStrategy->intSupport(m_weightsPositionScale.toFloat()) / realScale);
            supportDst.from256Frac(filterStrategy->intSupport(m_weightsPositionScale.toFloat()));
 
        } else {
            supportSrc.from256Frac(filterStrategy->intSupport(m_weightsPositionScale.toFloat()));
            supportDst.from256Frac(filterStrategy->intSupport(m_weightsPositionScale.toFloat()));
        }
 
        for (int i = 0; i < 256; i++) {
            KisFixedPoint centerSrc;
            centerSrc.from256Frac(i);
 
            KisFixedPoint beginDst = -supportDst;
            KisFixedPoint endDst = supportDst;
 
            KisFixedPoint beginSrc = -supportSrc - centerSrc / m_weightsPositionScale;
            KisFixedPoint endSrc = supportSrc - centerSrc / m_weightsPositionScale;
 
            int span = (2 * supportSrc).toInt() +
                (beginSrc.isInteger() && endSrc.isInteger());
 
            int centerIndex = -beginSrc.toInt();
 
            m_filterWeights[i].centerIndex = centerIndex;
            m_filterWeights[i].span = span;
            m_filterWeights[i].weight = new qint16[span];
            m_maxSpan = qMax(m_maxSpan, span);
 
            // in dst coordinate system:
            KisFixedPoint scaledIter = centerSrc + beginSrc.toInt() * m_weightsPositionScale;
            KisFixedPoint scaledInc = m_weightsPositionScale;
 
            DEBUG_ALL();
 
            int sum = 0;
            for (int j = 0; j < span; j++) {
                int t = filterStrategy->intValueAt(scaledIter.to256Frac(), m_weightsPositionScale.toFloat());
                m_filterWeights[i].weight[j] = t;
                sum += t;
 
                DEBUG_SAMPLE();
                SANITY_CENTER_POSITION();
 
                scaledIter += scaledInc;
            }
 
            SANITY_ZEROS();
 
            if (sum != 255 && sum > 0) {
                qreal fixFactor = 255.0 / sum;
                sum = 0;
 
                for (int j = 0; j < span; j++) {
                    int t = qRound(m_filterWeights[i].weight[j] * fixFactor);
 
                    m_filterWeights[i].weight[j] = t;
                    sum += t;
                }
            }
 
            while (sum != 255) {
                int diff = sum < 255 ? 1 : -1;
                int index = findMaxIndex(m_filterWeights[i].weight, span);
                m_filterWeights[i].weight[index] += diff;
                sum += diff;
            }
 
            SANITY_CHECKSUM();
        }
    }

References KisFilterWeightsBuffer::FilterWeights::centerIndex, DEBUG_ALL, DEBUG_SAMPLE, findMaxIndex(), KisFixedPoint::from256Frac(), KisFilterStrategy::intSupport(), KisFilterStrategy::intValueAt(), KisFixedPoint::isInteger(), m_filterWeights, m_maxSpan, m_weightsPositionScale, SANITY_CENTER_POSITION, SANITY_CHECKSUM, SANITY_ZEROS, KisFilterWeightsBuffer::FilterWeights::span, KisFixedPoint::to256Frac(), KisFixedPoint::toFloat(), KisFixedPoint::toInt(), and KisFilterWeightsBuffer::FilterWeights::weight.

~KisFilterWeightsBuffer()

KisFilterWeightsBuffer::~KisFilterWeightsBuffer ( )

inline

Definition at line 230 of file kis_filter_weights_buffer.h.

                              {
        delete[] m_filterWeights;
    }

References m_filterWeights.

Member Function Documentation

findMaxIndex()

int KisFilterWeightsBuffer::findMaxIndex ( qint16 * buf, int size )

inlineprivate

Definition at line 261 of file kis_filter_weights_buffer.h.

                                            {
        int maxValue = buf[0];
        int maxIndex = 0;
 
        for (int i = 1; i < size; i++) {
            if (buf[i] > maxValue) {
                maxValue = buf[i];
                maxIndex = i;
            }
        }
 
        return maxIndex;
    }

maxSpan()

int KisFilterWeightsBuffer::maxSpan ( ) const

inline

The maximum width of the buffer that would be needed for calculation of a pixel value. In other words, the maximum number of support pixels that are needed for calculation of a single result pixel

Definition at line 247 of file kis_filter_weights_buffer.h.

                        {
        return m_maxSpan;
    }

References m_maxSpan.

weights()

FilterWeights * KisFilterWeightsBuffer::weights ( KisFixedPoint pos ) const

inline

Return a weights buffer for a particular value of offset

Definition at line 237 of file kis_filter_weights_buffer.h.

                                                    {
        return m_filterWeights + pos.to256Frac();
    }

References m_filterWeights, and KisFixedPoint::to256Frac().

weightsPositionScale()

KisFixedPoint KisFilterWeightsBuffer::weightsPositionScale ( ) const

inline

The scale of the support buffer. Note that it is not always equal to the real scale of the transformation due to interpolation/blending difference.

Definition at line 256 of file kis_filter_weights_buffer.h.

                                               {
        return m_weightsPositionScale;
    }

References m_weightsPositionScale.

Member Data Documentation

m_filterWeights

FilterWeights* KisFilterWeightsBuffer::m_filterWeights

private

Definition at line 276 of file kis_filter_weights_buffer.h.

m_maxSpan

int KisFilterWeightsBuffer::m_maxSpan

private

Definition at line 277 of file kis_filter_weights_buffer.h.

m_weightsPositionScale

KisFixedPoint KisFilterWeightsBuffer::m_weightsPositionScale

private

Definition at line 278 of file kis_filter_weights_buffer.h.

---

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

• libs/image/kis_filter_weights_buffer.h