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)
	~PaintDevicePolygonOp ()

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

Private Attributes
bool	m_canMergeRects {false}
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) {}

~PaintDevicePolygonOp()

GridIterationTools::PaintDevicePolygonOp::~PaintDevicePolygonOp ( )

inline

When setCanMergeRects() is set to true, the caller should call finalize() to process all the postponed rects, which would clear the vector

Definition at line 174 of file kis_grid_interpolation_tools.h.

    {
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_rectsToCopy.isEmpty());
    }

References KIS_SAFE_ASSERT_RECOVER_NOOP, and m_rectsToCopy.

Member Function Documentation

copyPreviousRects()

void GridIterationTools::PaintDevicePolygonOp::copyPreviousRects ( )

inline

Definition at line 313 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 184 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 188 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 323 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 215 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 219 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

IMPORTANT: When setCanMergeRects() is set to true, the caller should calls finalize() in the end of the processing action to actually copy all the lazily postponed rects.

Definition at line 333 of file kis_grid_interpolation_tools.h.

                                                        {
        m_canMergeRects = newCanMergeRects;
    }

References m_canMergeRects.

Member Data Documentation

m_canMergeRects

bool GridIterationTools::PaintDevicePolygonOp::m_canMergeRects {false}

private

Definition at line 350 of file kis_grid_interpolation_tools.h.

{false};

m_dstDev

KisPaintDeviceSP GridIterationTools::PaintDevicePolygonOp::m_dstDev

Definition at line 338 of file kis_grid_interpolation_tools.h.

m_epsilon

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

Definition at line 339 of file kis_grid_interpolation_tools.h.

{0.001};

m_rectsToCopy

QVector<QRect> GridIterationTools::PaintDevicePolygonOp::m_rectsToCopy

private

Definition at line 351 of file kis_grid_interpolation_tools.h.

m_srcDev

KisPaintDeviceSP GridIterationTools::PaintDevicePolygonOp::m_srcDev

Definition at line 337 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