GridIterationTools::PaintDevicePolygonOp Struct Reference

#include <kis_grid_interpolation_tools.h>

Public Member Functions
void	copyPreviousRects ()
void	fastCopyArea (QRect areaToCopy)
void	fastCopyArea (QRect areaToCopy, bool lazy)
void	finalize ()
void	operator() (const QPolygonF &srcPolygon, const QPolygonF &dstPolygon)
void	operator() (const QPolygonF &srcPolygon, const QPolygonF &dstPolygon, const QPolygonF &clipDstPolygon)
	PaintDevicePolygonOp (KisPaintDeviceSP srcDev, KisPaintDeviceSP dstDev)
void	setCanMergeRects (bool newCanMergeRects)

Public Attributes
KisPaintDeviceSP	m_dstDev
const qreal	m_epsilon {0.001}
KisPaintDeviceSP	m_srcDev

Private Attributes
bool	m_canMergeRects {true}
QVector< QRect >	m_rectsToCopy

Detailed Description

Definition at line 169 of file kis_grid_interpolation_tools.h.

Constructor & Destructor Documentation

PaintDevicePolygonOp()

GridIterationTools::PaintDevicePolygonOp::PaintDevicePolygonOp ( KisPaintDeviceSP srcDev, KisPaintDeviceSP dstDev )

inline

Definition at line 171 of file kis_grid_interpolation_tools.h.

        : m_srcDev(srcDev), m_dstDev(dstDev) {}

Member Function Documentation

copyPreviousRects()

void GridIterationTools::PaintDevicePolygonOp::copyPreviousRects ( )

inline

Definition at line 303 of file kis_grid_interpolation_tools.h.

                             {
        QVector<QRect>::iterator end = KisRegion::mergeSparseRects(m_rectsToCopy.begin(), m_rectsToCopy.end());
 
        for (QVector<QRect>::iterator it = m_rectsToCopy.begin(); it < end; it++) {
            QRect areaToCopy = *it;
            fastCopyArea(areaToCopy.adjusted(0, 0, 1, 1), false);
        }
        m_rectsToCopy = QVector<QRect>();
    }

References fastCopyArea(), m_rectsToCopy, and KisRegion::mergeSparseRects().

fastCopyArea() [1/2]

void GridIterationTools::PaintDevicePolygonOp::fastCopyArea ( QRect areaToCopy )

inline

Definition at line 174 of file kis_grid_interpolation_tools.h.

                                        {
        fastCopyArea(areaToCopy, m_canMergeRects);
    }

References fastCopyArea(), and m_canMergeRects.

fastCopyArea() [2/2]

void GridIterationTools::PaintDevicePolygonOp::fastCopyArea ( QRect areaToCopy, bool lazy )

inline

Definition at line 178 of file kis_grid_interpolation_tools.h.

                                                   {
#ifdef DEBUG_PAINTING_POLYGONS
 
        QRect boundRect = areaToCopy;
        KisSequentialIterator dstIt(m_dstDev, boundRect);
        KisSequentialIterator srcIt(m_srcDev, boundRect);
 
        // this can possibly be optimized with scanlining the polygon
        // (use intersectLineConvexPolygon to get a line at every height)
        // but it doesn't matter much because in the vast majority of cases
        // it should go straight to the rect area copying
 
        while (dstIt.nextPixel()  && srcIt.nextPixel()) {
            memcpy(dstIt.rawData(), srcIt.oldRawData(), m_dstDev->pixelSize());
            QColor color = m_debugColor;
            color.setHsl(KisAlgebra2D::wrapValue(m_debugColor.hslHue() + 20, 0, 360), m_debugColor.hslSaturation(), m_debugColor.lightness());
            m_dstDev->colorSpace()->fromQColor(color, dstIt.rawData());
        }
        return;
#endif
        if (lazy) {
            m_rectsToCopy.append(areaToCopy.adjusted(0, 0, -1, -1));
        } else {
            KisPainter::copyAreaOptimized(areaToCopy.topLeft(), m_srcDev, m_dstDev, areaToCopy);
        }
    }

References KisPaintDevice::colorSpace(), KisPainter::copyAreaOptimized(), KoColorSpace::fromQColor(), m_dstDev, m_rectsToCopy, m_srcDev, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), KisPaintDevice::pixelSize(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisAlgebra2D::wrapValue().

finalize()

void GridIterationTools::PaintDevicePolygonOp::finalize ( )

inline

Definition at line 313 of file kis_grid_interpolation_tools.h.

                    {
        copyPreviousRects();
    }

References copyPreviousRects().

operator()() [1/2]

void GridIterationTools::PaintDevicePolygonOp::operator() ( const QPolygonF & srcPolygon, const QPolygonF & dstPolygon )

inline

Definition at line 205 of file kis_grid_interpolation_tools.h.

                                                                               {
        operator() (srcPolygon, dstPolygon, dstPolygon);
    }

References operator()().

operator()() [2/2]

void GridIterationTools::PaintDevicePolygonOp::operator() ( const QPolygonF & srcPolygon, const QPolygonF & dstPolygon, const QPolygonF & clipDstPolygon )

inline

We need to make sure that the destination polygon is not too small, otherwise even small rounding will send the src-accessor into infinity

Definition at line 209 of file kis_grid_interpolation_tools.h.

                                                                                                                {
#ifdef DEBUG_PAINTING_POLYGONS
        //m_rectId++;
#endif
        QRect boundRect = clipDstPolygon.boundingRect().toAlignedRect();
        if (boundRect.isEmpty()) return;
 
        bool samePolygon = (m_dstDev->colorSpace() == m_srcDev->colorSpace())
                && KisAlgebra2D::fuzzyPointCompare(srcPolygon, dstPolygon, m_epsilon)
                && KisAlgebra2D::fuzzyPointCompare(srcPolygon, clipDstPolygon, m_epsilon);
 
        if (samePolygon && KisAlgebra2D::isPolygonPixelAlignedRect(dstPolygon, m_epsilon)) {
            QRect boundRect = dstPolygon.boundingRect().toAlignedRect();
            fastCopyArea(boundRect);
            return;
        }
 
 
        // provess previous rects so they are all processed
        // in the same order as without any performance improvements
        // (according to the grid processing order)
        copyPreviousRects();
 
 
        KisSequentialIterator dstIt(m_dstDev, boundRect);
        KisRandomSubAccessorSP srcAcc = m_srcDev->createRandomSubAccessor();
 
        KisFourPointInterpolatorBackward interp(srcPolygon, dstPolygon);
#ifdef DEBUG_PAINTING_POLYGONS
        int pixelId = 0;
#endif
 
        if (interp.isValid(0.1)) {
            int y = boundRect.top();
            interp.setY(y);
 
            while (dstIt.nextPixel()) {
                int newY = dstIt.y();
 
                if (y != newY) {
                    y = newY;
                    interp.setY(y);
                }
 
                QPointF srcPoint(dstIt.x(), y);
 
                if (clipDstPolygon.containsPoint(srcPoint, Qt::OddEvenFill)) {
 
                    interp.setX(srcPoint.x());
                    QPointF dstPoint = interp.getValue();
 
                    // brain-blowing part:
                    //
                    // since the interpolator does the inverted
                    // transformation we read data from "dstPoint"
                    // (which is non-transformed) and write it into
                    // "srcPoint" (which is transformed position)
 
                    srcAcc->moveTo(dstPoint);
                    quint8* rawData = dstIt.rawData();
                    srcAcc->sampledOldRawData(rawData);
#ifdef DEBUG_PAINTING_POLYGONS
                    QColor color = m_debugColor;
                    color.setHsl(KisAlgebra2D::wrapValue(m_debugColor.hslHue() + m_rectId, 0, 360), m_debugColor.hslSaturation(), qBound(0, m_debugColor.lightness() - 50 - pixelId, 100));
                    pixelId++;
                    m_dstDev->colorSpace()->fromQColor(color, rawData);
#endif
                }
            }
 
        } else {
            srcAcc->moveTo(interp.fallbackSourcePoint());
 
            while (dstIt.nextPixel()) {
                QPointF srcPoint(dstIt.x(), dstIt.y());
 
                if (clipDstPolygon.containsPoint(srcPoint, Qt::OddEvenFill)) {
                    srcAcc->sampledOldRawData(dstIt.rawData());
#ifdef DEBUG_PAINTING_POLYGONS
                    QColor color = m_debugColor;
                    color.setHsl(KisAlgebra2D::wrapValue(m_debugColor.hslHue() + m_rectId, 0, 360), m_debugColor.hslSaturation(), qBound(0, m_debugColor.lightness() + 50, 100));
                    m_dstDev->colorSpace()->fromQColor(color, dstIt.rawData());
#endif
                }
            }
        }
 
    }

References KisPaintDevice::colorSpace(), copyPreviousRects(), KisPaintDevice::createRandomSubAccessor(), dstPoint, fastCopyArea(), KoColorSpace::fromQColor(), KisAlgebra2D::fuzzyPointCompare(), interp(), KisAlgebra2D::isPolygonPixelAlignedRect(), m_dstDev, m_epsilon, m_srcDev, KisRandomSubAccessor::moveTo(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisRandomSubAccessor::sampledOldRawData(), KisAlgebra2D::wrapValue(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

setCanMergeRects()

void GridIterationTools::PaintDevicePolygonOp::setCanMergeRects ( bool newCanMergeRects )

inline

Definition at line 317 of file kis_grid_interpolation_tools.h.

                                                        {
        m_canMergeRects = newCanMergeRects;
    }

References m_canMergeRects.

Member Data Documentation

m_canMergeRects

bool GridIterationTools::PaintDevicePolygonOp::m_canMergeRects {true}

private

Definition at line 334 of file kis_grid_interpolation_tools.h.

{true};

m_dstDev

KisPaintDeviceSP GridIterationTools::PaintDevicePolygonOp::m_dstDev

Definition at line 322 of file kis_grid_interpolation_tools.h.

m_epsilon

const qreal GridIterationTools::PaintDevicePolygonOp::m_epsilon {0.001}

Definition at line 323 of file kis_grid_interpolation_tools.h.

{0.001};

m_rectsToCopy

QVector<QRect> GridIterationTools::PaintDevicePolygonOp::m_rectsToCopy

private

Definition at line 335 of file kis_grid_interpolation_tools.h.

m_srcDev

KisPaintDeviceSP GridIterationTools::PaintDevicePolygonOp::m_srcDev

Definition at line 321 of file kis_grid_interpolation_tools.h.

---

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

• libs/image/kis_grid_interpolation_tools.h