#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)

	QImagePolygonOp (const QImage &srcImage, QImage &dstImage, const QPointF &srcImageOffset, const QPointF &dstImageOffset)

void	setCanMergeRects (bool canMergeRects)

	~QImagePolygonOp ()

Public Attributes
QImage &	m_dstImage

QPointF	m_dstImageOffset

QRect	m_dstImageRect

const qreal	m_epsilon {0.001}

const QImage &	m_srcImage

QPointF	m_srcImageOffset

QRect	m_srcImageRect

Private Attributes
bool	m_canMergeRects {false}

QVector< QRect >	m_rectsToCopy

Detailed Description

Definition at line 355 of file kis_grid_interpolation_tools.h.

Constructor & Destructor Documentation

◆ QImagePolygonOp()

GridIterationTools::QImagePolygonOp::QImagePolygonOp	(	const QImage &	srcImage,
		QImage &	dstImage,
		const QPointF &	srcImageOffset,
		const QPointF &	dstImageOffset )

inline

Definition at line 357 of file kis_grid_interpolation_tools.h.

        : m_srcImage(srcImage), m_dstImage(dstImage),
          m_srcImageOffset(srcImageOffset),
          m_dstImageOffset(dstImageOffset),
          m_srcImageRect(m_srcImage.rect()),
          m_dstImageRect(m_dstImage.rect())
    {
    }

◆ ~QImagePolygonOp()

GridIterationTools::QImagePolygonOp::~QImagePolygonOp ( )

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 368 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::QImagePolygonOp::copyPreviousRects ( )

inline

Definition at line 485 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::QImagePolygonOp::fastCopyArea ( QRect areaToCopy )

inline

Definition at line 378 of file kis_grid_interpolation_tools.h.

                                        {
        fastCopyArea(areaToCopy, m_canMergeRects);
    }

References fastCopyArea(), and m_canMergeRects.

◆ fastCopyArea() [2/2]

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

inline

Definition at line 382 of file kis_grid_interpolation_tools.h.

                                                   {
        if (lazy) {
            m_rectsToCopy.append(areaToCopy.adjusted(0, 0, -1, -1));
            return;
        }
 
        // only handling saved offsets
        QRect srcArea = areaToCopy.translated(-m_srcImageOffset.toPoint());
        QRect dstArea = areaToCopy.translated(-m_dstImageOffset.toPoint());
 
        srcArea = srcArea.intersected(m_srcImageRect);
        dstArea = dstArea.intersected(m_dstImageRect);
 
        // it might look pointless but it cuts off unneeded areas on both rects based on where they end up
        // since *I know* they are the same rectangle before translation
        // TODO: I'm pretty sure this logic is correct, but let's check it when I'm less sleepy
        QRect srcAreaUntranslated = srcArea.translated(m_srcImageOffset.toPoint());
        QRect dstAreaUntranslated = dstArea.translated(m_dstImageOffset.toPoint());
 
        QRect actualCopyArea = srcAreaUntranslated.intersected(dstAreaUntranslated);
        srcArea = actualCopyArea.translated(-m_srcImageOffset.toPoint());
        dstArea = actualCopyArea.translated(-m_dstImageOffset.toPoint());
 
        int bytesPerPixel = m_srcImage.sizeInBytes()/m_srcImage.height()/m_srcImage.width();
 
        int srcX = srcArea.left()*bytesPerPixel;
        int dstX = dstArea.left()*bytesPerPixel;
 
        for (int srcY = srcArea.top(); srcY <= srcArea.bottom(); ++srcY) {
 
            int dstY = dstArea.top() + srcY - srcArea.top();
            const uchar *srcLine = m_srcImage.constScanLine(srcY);
            uchar *dstLine = m_dstImage.scanLine(dstY);
            memcpy(dstLine + dstX, srcLine + srcX, srcArea.width()*bytesPerPixel);
 
        }
    }

References m_dstImage, m_dstImageOffset, m_dstImageRect, m_rectsToCopy, m_srcImage, m_srcImageOffset, and m_srcImageRect.

◆ finalize()

void GridIterationTools::QImagePolygonOp::finalize ( )

inline

Definition at line 497 of file kis_grid_interpolation_tools.h.

                    {
        copyPreviousRects();
    }

References copyPreviousRects().

◆ operator()() [1/2]

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

inline

Definition at line 420 of file kis_grid_interpolation_tools.h.

                                                                               {
        this->operator() (srcPolygon, dstPolygon, dstPolygon);
    }

References operator()().

◆ operator()() [2/2]

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

inline

Definition at line 424 of file kis_grid_interpolation_tools.h.

                                                                                                                {
        QRect boundRect = clipDstPolygon.boundingRect().toAlignedRect();
 
        bool samePolygon = (m_dstImage.format() == m_srcImage.format())
                && 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
        copyPreviousRects();
 
        KisFourPointInterpolatorBackward interp(srcPolygon, dstPolygon);
 
        for (int y = boundRect.top(); y <= boundRect.bottom(); y++) {
            interp.setY(y);
            for (int x = boundRect.left(); x <= boundRect.right(); x++) {
 
                QPointF srcPoint(x, y);
                if (clipDstPolygon.containsPoint(srcPoint, Qt::OddEvenFill)) {
 
                    interp.setX(srcPoint.x());
                    QPointF dstPoint = interp.getValue();
 
                    // about srcPoint/dstPoint hell please see a
                    // comment in PaintDevicePolygonOp::operator() ()
 
                    srcPoint -= m_dstImageOffset;
                    dstPoint -= m_srcImageOffset;
 
                    QPoint srcPointI = srcPoint.toPoint();
                    QPoint dstPointI = dstPoint.toPoint();
 
                    if (!m_dstImageRect.contains(srcPointI)) continue;
                    if (!m_srcImageRect.contains(dstPointI)) continue;
 
                    m_dstImage.setPixel(srcPointI, m_srcImage.pixel(dstPointI));
                }
            }
        }
 
#ifdef DEBUG_PAINTING_POLYGONS
        QPainter gc(&m_dstImage);
        gc.setPen(Qt::red);
        gc.setOpacity(0.5);
 
        gc.setBrush(Qt::green);
        gc.drawPolygon(clipDstPolygon.translated(-m_dstImageOffset));
 
        gc.setBrush(Qt::blue);
        //gc.drawPolygon(dstPolygon.translated(-m_dstImageOffset));
 
#endif /* DEBUG_PAINTING_POLYGONS */
 
    }

References copyPreviousRects(), dstPoint, fastCopyArea(), KisAlgebra2D::fuzzyPointCompare(), interp(), KisAlgebra2D::isPolygonPixelAlignedRect(), m_dstImage, m_dstImageOffset, m_dstImageRect, m_epsilon, m_srcImage, m_srcImageOffset, and m_srcImageRect.

◆ setCanMergeRects()

void GridIterationTools::QImagePolygonOp::setCanMergeRects ( bool canMergeRects )

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 507 of file kis_grid_interpolation_tools.h.

                                                     {
        m_canMergeRects = canMergeRects;
    }

References m_canMergeRects.

Member Data Documentation

◆ m_canMergeRects

bool GridIterationTools::QImagePolygonOp::m_canMergeRects {false}

private

Definition at line 522 of file kis_grid_interpolation_tools.h.

522{false};

◆ m_dstImage

QImage& GridIterationTools::QImagePolygonOp::m_dstImage

Definition at line 512 of file kis_grid_interpolation_tools.h.

◆ m_dstImageOffset

QPointF GridIterationTools::QImagePolygonOp::m_dstImageOffset

Definition at line 514 of file kis_grid_interpolation_tools.h.

◆ m_dstImageRect

QRect GridIterationTools::QImagePolygonOp::m_dstImageRect

Definition at line 517 of file kis_grid_interpolation_tools.h.

◆ m_epsilon

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

Definition at line 519 of file kis_grid_interpolation_tools.h.

519{0.001};

◆ m_rectsToCopy

QVector<QRect> GridIterationTools::QImagePolygonOp::m_rectsToCopy

private

Definition at line 523 of file kis_grid_interpolation_tools.h.

◆ m_srcImage

const QImage& GridIterationTools::QImagePolygonOp::m_srcImage

Definition at line 511 of file kis_grid_interpolation_tools.h.

◆ m_srcImageOffset

QPointF GridIterationTools::QImagePolygonOp::m_srcImageOffset

Definition at line 513 of file kis_grid_interpolation_tools.h.

◆ m_srcImageRect

QRect GridIterationTools::QImagePolygonOp::m_srcImageRect

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

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ QImagePolygonOp()

◆ ~QImagePolygonOp()

Member Function Documentation

◆ copyPreviousRects()

◆ fastCopyArea() [1/2]

◆ fastCopyArea() [2/2]

◆ finalize()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ setCanMergeRects()

Member Data Documentation

◆ m_canMergeRects

◆ m_dstImage

◆ m_dstImageOffset

◆ m_dstImageRect

◆ m_epsilon

◆ m_rectsToCopy

◆ m_srcImage

◆ m_srcImageOffset

◆ m_srcImageRect