#include <kis_filter_weights_applicator.h>

Classes
struct	BlendSpan

class	LinePos

Public Member Functions
BlendSpan	calculateBlendSpan (int dst_l, int line, KisFilterWeightsBuffer *buffer) const

	KisFilterWeightsApplicator (KisPaintDeviceSP src, KisPaintDeviceSP dst, qreal realScale, qreal shear, qreal dx, bool clampToEdge)

template<class T >
LinePos	processLine (LinePos srcLine, int line, KisFilterWeightsBuffer *buffer, qreal filterSupport)

Private Member Functions
KisFixedPoint	c_to_l (KisFixedPoint pixel_c) const

qreal	dstToSrc (qreal dst, int line) const

int	findAntialiasedDstEnd (int src_l, qreal support, int line)

int	findAntialiasedDstStart (int src_l, qreal support, int line)

int	getLeftSrcNeedBorder (int dst_l, int line, KisFilterWeightsBuffer *buffer)

int	getRightSrcNeedBorder (int dst_l, int line, KisFilterWeightsBuffer *buffer)

KisFixedPoint	l_to_c (KisFixedPoint pixel_l) const

qreal	srcToDst (qreal src, int line) const

Private Attributes
bool	m_clampToEdge

KisPaintDeviceSP	m_dst

qreal	m_dx

qreal	m_realScale

qreal	m_shear

KisPaintDeviceSP	m_src

Detailed Description

This is a main class for transforming a line of pixel data. It transforms lines from src into dst using scale, shear and offset (dx) parameters.

Notation: <pixel_name>_l – leftmost border of the pixel <pixel_name>_c – center of the pixel

Example calculation of an offset (see calculateBlendSpan()): scale = 0.5; offset = <very small value>

               +------ dst_l
               |
               |   +-- dst_c
               |   |

dst: | * | * | * |

src: | * | * | * | * | * | * | * | * |

                  |||
                  ||+--- next_c_in_src
                  |||
                  |+---- dst_c_in_src
                  |||
                  |++--- offset (near zero, measured in dst coordinates)
                  |
                  +-- _l position of the pixel, which is considered
                      central in the weights buffer

Another example calculation of an offset (see calculateBlendSpan()): scale = 0.5; offset = <high value near 0.5>

                 +------ dst_l
                 |
                 |   +-- dst_c
                 |   |

dst: | * | * | * |

src: | * | * | * | * | * | * | * | * |

                     || |
                     || +--- next_c_in_src
                     || |
                     +------ dst_c_in_src
                     || |
                     +|-+--- offset (near 0.5, measured in dst coordinates)
                      |
                      +-- _l position of the pixel, which is considered
                          central in the weights buffer

Definition at line 94 of file kis_filter_weights_applicator.h.

Constructor & Destructor Documentation

◆ KisFilterWeightsApplicator()

KisFilterWeightsApplicator::KisFilterWeightsApplicator	(	KisPaintDeviceSP	src,
		KisPaintDeviceSP	dst,
		qreal	realScale,
		qreal	shear,
		qreal	dx,
		bool	clampToEdge )

inline

Definition at line 97 of file kis_filter_weights_applicator.h.

        : m_src(src),
          m_dst(dst),
          m_realScale(realScale),
          m_shear(shear),
          m_dx(dx),
          m_clampToEdge(clampToEdge)
    {
    }

Member Function Documentation

◆ c_to_l()

KisFixedPoint KisFilterWeightsApplicator::c_to_l ( KisFixedPoint pixel_c ) const

inlineprivate

Definition at line 317 of file kis_filter_weights_applicator.h.

                                                             {
        return pixel_c - KisFixedPoint(qreal(0.5));
    }

◆ calculateBlendSpan()

BlendSpan KisFilterWeightsApplicator::calculateBlendSpan	(	int	dst_l,
		int	line,
		KisFilterWeightsBuffer *	buffer ) const

inline

Definition at line 118 of file kis_filter_weights_applicator.h.

                                                                                                   {
        KisFixedPoint dst_c = l_to_c(dst_l);
        KisFixedPoint dst_c_in_src = dstToSrc(dst_c.toFloat(), line);
 
        // gives the nearest center of the pixel in src ( x e (0, 1> => f(x) = 0.5, x e (1, 2> => f(x) = 1.5 etc. )
        KisFixedPoint next_c_in_src = (dst_c_in_src - qreal(0.5)).toIntCeil() + qreal(0.5);
 
        BlendSpan span;
        span.offset = (next_c_in_src - dst_c_in_src) * buffer->weightsPositionScale();
        span.offsetInc = buffer->weightsPositionScale();
 
        Q_ASSERT(span.offset <= span.offsetInc);
 
        span.weights = buffer->weights(span.offset);
        span.firstBlendPixel = next_c_in_src.toIntFloor() - span.weights->centerIndex;
 
        return span;
    }

References KisFilterWeightsBuffer::FilterWeights::centerIndex, dstToSrc(), KisFilterWeightsApplicator::BlendSpan::firstBlendPixel, l_to_c(), KisFilterWeightsApplicator::BlendSpan::offset, KisFilterWeightsApplicator::BlendSpan::offsetInc, KisFixedPoint::toFloat(), KisFixedPoint::toIntFloor(), KisFilterWeightsApplicator::BlendSpan::weights, KisFilterWeightsBuffer::weights(), and KisFilterWeightsBuffer::weightsPositionScale().

◆ dstToSrc()

qreal KisFilterWeightsApplicator::dstToSrc	(	qreal	dst,
		int	line ) const

inlineprivate

Definition at line 325 of file kis_filter_weights_applicator.h.

                                                     {
        return (dst - m_dx - line * m_shear) / m_realScale;
    }

References m_dx, m_realScale, and m_shear.

◆ findAntialiasedDstEnd()

int KisFilterWeightsApplicator::findAntialiasedDstEnd	(	int	src_l,
		qreal	support,
		int	line )

inlineprivate

Definition at line 298 of file kis_filter_weights_applicator.h.

                                                                  {
        qreal dst = srcToDst(src_l, line);
        return !m_clampToEdge ? qRound(dst + support) : qRound(dst);
    }

References m_clampToEdge, and srcToDst().

◆ findAntialiasedDstStart()

int KisFilterWeightsApplicator::findAntialiasedDstStart	(	int	src_l,
		qreal	support,
		int	line )

inlineprivate

Definition at line 293 of file kis_filter_weights_applicator.h.

                                                                    {
        qreal dst = srcToDst(src_l, line);
        return !m_clampToEdge ? qRound(dst - support) : qRound(dst);
    }

References m_clampToEdge, and srcToDst().

◆ getLeftSrcNeedBorder()

int KisFilterWeightsApplicator::getLeftSrcNeedBorder	(	int	dst_l,
		int	line,
		KisFilterWeightsBuffer *	buffer )

inlineprivate

Definition at line 303 of file kis_filter_weights_applicator.h.

                                                                                  {
        BlendSpan span = calculateBlendSpan(dst_l, line, buffer);
        return span.firstBlendPixel;
    }

References calculateBlendSpan(), and KisFilterWeightsApplicator::BlendSpan::firstBlendPixel.

◆ getRightSrcNeedBorder()

int KisFilterWeightsApplicator::getRightSrcNeedBorder	(	int	dst_l,
		int	line,
		KisFilterWeightsBuffer *	buffer )

inlineprivate

Definition at line 308 of file kis_filter_weights_applicator.h.

                                                                                   {
        BlendSpan span = calculateBlendSpan(dst_l, line, buffer);
        return span.firstBlendPixel + span.weights->span;
    }

References calculateBlendSpan(), KisFilterWeightsApplicator::BlendSpan::firstBlendPixel, KisFilterWeightsBuffer::FilterWeights::span, and KisFilterWeightsApplicator::BlendSpan::weights.

◆ l_to_c()

KisFixedPoint KisFilterWeightsApplicator::l_to_c ( KisFixedPoint pixel_l ) const

inlineprivate

Definition at line 313 of file kis_filter_weights_applicator.h.

                                                             {
        return pixel_l + KisFixedPoint(qreal(0.5));
    }

◆ processLine()

template<class T >

LinePos KisFilterWeightsApplicator::processLine	(	LinePos	srcLine,
		int	line,
		KisFilterWeightsBuffer *	buffer,
		qreal	filterSupport )

inline

Since we are rounding the borders of the line we might end up to squashing our line into a single pixel. In such a case we should correct our line to be exactly one pixel

Definition at line 187 of file kis_filter_weights_applicator.h.

                                                                                                        {
        int dstStart;
        int dstEnd;
 
        int leftSrcBorder;
        int rightSrcBorder;
 
        if (m_realScale >= 0) {
            dstStart = findAntialiasedDstStart(srcLine.start(), filterSupport, line);
            dstEnd = findAntialiasedDstEnd(srcLine.end(), filterSupport, line);
 
            if (dstStart == dstEnd) {
                dstEnd = dstStart + 1;
            }
 
            leftSrcBorder = getLeftSrcNeedBorder(dstStart, line, buffer);
            rightSrcBorder = getRightSrcNeedBorder(dstEnd - 1, line, buffer);
        }
        else {
            dstStart = findAntialiasedDstStart(srcLine.end(), filterSupport, line);
            dstEnd = findAntialiasedDstEnd(srcLine.start(), filterSupport, line);
 
            if (dstStart == dstEnd) {
                dstEnd = dstStart + 1;
            }
 
            leftSrcBorder = getLeftSrcNeedBorder(dstEnd - 1, line, buffer);
            rightSrcBorder = getRightSrcNeedBorder(dstStart, line, buffer);
        }
 
        if (dstStart >= dstEnd)  return LinePos(dstStart, 0);
        if (leftSrcBorder >= rightSrcBorder) return LinePos(dstStart, 0);
        if (leftSrcBorder > srcLine.start()) {
            leftSrcBorder = srcLine.start();
        }
        if (srcLine.end() > rightSrcBorder) {
            rightSrcBorder = srcLine.end();
        }
 
        int pixelSize = m_src->pixelSize();
        KoMixColorsOp *mixOp = m_src->colorSpace()->mixColorsOp();
        const KoColor defaultPixelObject = m_src->defaultPixel();
        const quint8 *defaultPixel = defaultPixelObject.data();
        const quint8 *borderPixel = defaultPixel;
        quint8 *srcLineBuf = new quint8[pixelSize * (rightSrcBorder - leftSrcBorder)];
 
        int i = leftSrcBorder;
        quint8 *bufPtr = srcLineBuf;
 
        T srcIt = tmp::createIterator<T>(m_src, srcLine.start(), line, srcLine.size());
 
        if (m_clampToEdge) {
            borderPixel = srcIt->rawData();
        }
 
        for (; i < srcLine.start(); i++, bufPtr+=pixelSize) {
            memcpy(bufPtr, borderPixel, pixelSize);
        }
 
        for (; i < srcLine.end(); i++, bufPtr+=pixelSize) {
            quint8 *data = srcIt->rawData();
            memcpy(bufPtr, data, pixelSize);
            memcpy(data, defaultPixel, pixelSize);
            srcIt->nextPixel();
        }
 
        if (m_clampToEdge) {
            borderPixel = bufPtr - pixelSize;
        }
 
        for (; i < rightSrcBorder; i++, bufPtr+=pixelSize) {
            memcpy(bufPtr, borderPixel, pixelSize);
        }
 
        const quint8 **colors = new const quint8* [buffer->maxSpan()];
 
        T dstIt = tmp::createIterator<T>(m_dst, dstStart, line, dstEnd - dstStart);
        for (int i = dstStart; i < dstEnd; i++) {
            BlendSpan span = calculateBlendSpan(i, line, buffer);
 
            int bufIndexStart = span.firstBlendPixel - leftSrcBorder;
            int bufIndexEnd = bufIndexStart + span.weights->span;
 
            const quint8 **colorsPtr = colors;
            for (int j = bufIndexStart; j < bufIndexEnd; j++) {
                *(colorsPtr++) = srcLineBuf + j * pixelSize;
            }
 
            mixOp->mixColors(colors, span.weights->weight, span.weights->span, dstIt->rawData());
            dstIt->nextPixel();
        }
 
        delete[] colors;
        delete[] srcLineBuf;
 
        return LinePos(dstStart, qMax(0, dstEnd - dstStart));
    }

References calculateBlendSpan(), KisPaintDevice::colorSpace(), KoColor::data(), KisPaintDevice::defaultPixel(), KisFilterWeightsApplicator::LinePos::end(), findAntialiasedDstEnd(), findAntialiasedDstStart(), KisFilterWeightsApplicator::BlendSpan::firstBlendPixel, getLeftSrcNeedBorder(), getRightSrcNeedBorder(), m_clampToEdge, m_dst, m_realScale, m_src, KisFilterWeightsBuffer::maxSpan(), KoMixColorsOp::mixColors(), KoColorSpace::mixColorsOp, KisPaintDevice::pixelSize(), KisFilterWeightsApplicator::LinePos::size(), KisFilterWeightsBuffer::FilterWeights::span, KisFilterWeightsApplicator::LinePos::start(), KisFilterWeightsBuffer::FilterWeights::weight, and KisFilterWeightsApplicator::BlendSpan::weights.

◆ srcToDst()

qreal KisFilterWeightsApplicator::srcToDst	(	qreal	src,
		int	line ) const

inlineprivate

Definition at line 321 of file kis_filter_weights_applicator.h.

                                                     {
        return src * m_realScale + m_dx + line * m_shear;
    }

References m_dx, m_realScale, and m_shear.

Member Data Documentation

◆ m_clampToEdge

bool KisFilterWeightsApplicator::m_clampToEdge

private

Definition at line 336 of file kis_filter_weights_applicator.h.

◆ m_dst

KisPaintDeviceSP KisFilterWeightsApplicator::m_dst

private

Definition at line 331 of file kis_filter_weights_applicator.h.

◆ m_dx

qreal KisFilterWeightsApplicator::m_dx

private

Definition at line 335 of file kis_filter_weights_applicator.h.

◆ m_realScale

qreal KisFilterWeightsApplicator::m_realScale

private

Definition at line 333 of file kis_filter_weights_applicator.h.

◆ m_shear

qreal KisFilterWeightsApplicator::m_shear

private

Definition at line 334 of file kis_filter_weights_applicator.h.

◆ m_src

KisPaintDeviceSP KisFilterWeightsApplicator::m_src

private

Definition at line 330 of file kis_filter_weights_applicator.h.

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

libs/image/kis_filter_weights_applicator.h

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisFilterWeightsApplicator()

Member Function Documentation

◆ c_to_l()

◆ calculateBlendSpan()

◆ dstToSrc()

◆ findAntialiasedDstEnd()

◆ findAntialiasedDstStart()

◆ getLeftSrcNeedBorder()

◆ getRightSrcNeedBorder()

◆ l_to_c()

◆ processLine()

◆ srcToDst()

Member Data Documentation

◆ m_clampToEdge

◆ m_dst

◆ m_dx

◆ m_realScale

◆ m_shear

◆ m_src