GridIterationTools::PaintDevicePolygonOp Struct Reference

#include <kis_grid_interpolation_tools.h>

Public Member Functions
void	fastCopyArea (QPolygonF areaToCopy)
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.1}
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

fastCopyArea() [1/3]

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

inline

Definition at line 175 of file kis_grid_interpolation_tools.h.

                                            {
        QRect boundRect = areaToCopy.boundingRect().toAlignedRect();
        if (boundRect.isEmpty()) return;
 
        bool isItRect = KisAlgebra2D::isPolygonRect(areaToCopy, m_epsilon); // no need for lower tolerance
        if (isItRect) {
            fastCopyArea(boundRect);
            return;
        }
 
        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()) {
            if (areaToCopy.containsPoint(QPoint(dstIt.x(), dstIt.y()), Qt::OddEvenFill)) {
                memcpy(dstIt.rawData(), srcIt.oldRawData(), m_dstDev->pixelSize());
            }
        }
    }

References fastCopyArea(), KisAlgebra2D::isPolygonRect(), m_dstDev, m_epsilon, m_srcDev, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), KisPaintDevice::pixelSize(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

fastCopyArea() [2/3]

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

inline

Definition at line 200 of file kis_grid_interpolation_tools.h.

                                        {
        fastCopyArea(areaToCopy, m_canMergeRects);
    }

References fastCopyArea(), and m_canMergeRects.

fastCopyArea() [3/3]

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

inline

Definition at line 204 of file kis_grid_interpolation_tools.h.

                                                   {
        if (lazy) {
            m_rectsToCopy.append(areaToCopy.adjusted(0, 0, -1, -1));
        } else {
            KisPainter::copyAreaOptimized(areaToCopy.topLeft(), m_srcDev, m_dstDev, areaToCopy);
        }
    }

References KisPainter::copyAreaOptimized(), m_dstDev, m_rectsToCopy, and m_srcDev.

finalize()

void GridIterationTools::PaintDevicePolygonOp::finalize ( )

inline

Definition at line 286 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().

operator()() [1/2]

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

inline

Definition at line 212 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 216 of file kis_grid_interpolation_tools.h.

                                                                                                                {
        QRect boundRect = clipDstPolygon.boundingRect().toAlignedRect();
        if (boundRect.isEmpty()) return;
 
        bool samePolygon = (m_dstDev->colorSpace() == m_srcDev->colorSpace()) && KisAlgebra2D::fuzzyPointCompare(srcPolygon, dstPolygon, m_epsilon);
 
        if (samePolygon) {
            // we can use clipDstPolygon here, because it will be smaller than dstPolygon and srcPolygon, because of how IncompletePolicy works
            // we could also calculate intersection here if we're worried whether that fact is always true
            fastCopyArea(clipDstPolygon);
            return;
        }
 
 
        KisSequentialIterator dstIt(m_dstDev, boundRect);
        KisRandomSubAccessorSP srcAcc = m_srcDev->createRandomSubAccessor();
 
        KisFourPointInterpolatorBackward interp(srcPolygon, dstPolygon);
 
        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);
                }
            }
 
        } else {
            srcAcc->moveTo(interp.fallbackSourcePoint());
 
            while (dstIt.nextPixel()) {
                QPointF srcPoint(dstIt.x(), dstIt.y());
 
                if (clipDstPolygon.containsPoint(srcPoint, Qt::OddEvenFill)) {
                    srcAcc->sampledOldRawData(dstIt.rawData());
                }
            }
        }
 
    }

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

setCanMergeRects()

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

inline

Definition at line 297 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 306 of file kis_grid_interpolation_tools.h.

{true};

m_dstDev

KisPaintDeviceSP GridIterationTools::PaintDevicePolygonOp::m_dstDev

Definition at line 302 of file kis_grid_interpolation_tools.h.

m_epsilon

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

Definition at line 303 of file kis_grid_interpolation_tools.h.

{0.1};

m_rectsToCopy

QVector<QRect> GridIterationTools::PaintDevicePolygonOp::m_rectsToCopy

private

Definition at line 307 of file kis_grid_interpolation_tools.h.

m_srcDev

KisPaintDeviceSP GridIterationTools::PaintDevicePolygonOp::m_srcDev

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