KisCageTransformWorker Class Reference

#include <kis_cage_transform_worker.h>

Inheritance diagram for KisCageTransformWorker:

Public Member Functions
QRect	approxChangeRect (const QRect &rc)
QRect	approxNeedRect (const QRect &rc, const QRect &fullBounds)
QVector< int >	calculateMappedIndexes (int col, int row, int *numExistingPoints)
QVector< QPointF >	calculateTransformedPoints ()
bool	isGridEmpty () const
	KisCageTransformWorker (const QImage &srcImage, const QPointF &srcImageOffset, const QVector< QPointF > &origCage, KoUpdater *progress, int pixelPrecision=8)
	KisCageTransformWorker (const QRect &deviceNonDefaultRegion, const QVector< QPointF > &origCage, KoUpdater *progress, int pixelPrecision=8)
void	prepareTransform ()
	Private (const QVector< QPointF > &_origCage, KoUpdater *_progress, int _pixelPrecision)
void	run (KisPaintDeviceSP srcDevice, KisPaintDeviceSP dstDevice)
QImage	runOnQImage (QPointF *newOffset)
void	setTransformedCage (const QVector< QPointF > &transformedCage)
int	tryGetValidIndex (const QPoint &cellPt)
	~KisCageTransformWorker ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Attributes
QVector< QPointF >	allSrcPoints
QVector< int >	allToValidPointsMap
KisGreenCoordinatesMath	cage
QSize	gridSize
QVector< QPointF >	origCage
int	pixelPrecision
KoUpdater *	progress
QRect	srcBounds
QImage	srcImage
QPointF	srcImageOffset
QVector< QPointF >	transfCage
QVector< QPointF >	validPoints
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 22 of file kis_cage_transform_worker.cpp.

Constructor & Destructor Documentation

KisCageTransformWorker() [1/2]

KisCageTransformWorker::KisCageTransformWorker	(	const QRect &	deviceNonDefaultRegion,
		const QVector< QPointF > &	origCage,
		KoUpdater *	progress,
		int	pixelPrecision = 8 )

Definition at line 71 of file kis_cage_transform_worker.cpp.

    : m_d(new Private(origCage, progress, pixelPrecision))
{
    m_d->srcBounds = deviceNonDefaultRegion;
}

References m_d.

KisCageTransformWorker() [2/2]

KisCageTransformWorker::KisCageTransformWorker	(	const QImage &	srcImage,
		const QPointF &	srcImageOffset,
		const QVector< QPointF > &	origCage,
		KoUpdater *	progress,
		int	pixelPrecision = 8 )

Definition at line 80 of file kis_cage_transform_worker.cpp.

    : m_d(new Private(origCage, progress, pixelPrecision))
{
    m_d->srcImage = srcImage;
    m_d->srcImageOffset = srcImageOffset;
    m_d->srcBounds = QRectF(m_d->srcImageOffset, m_d->srcImage.size()).toAlignedRect();
}

References m_d, srcImage, and srcImageOffset.

~KisCageTransformWorker()

KisCageTransformWorker::~KisCageTransformWorker

(

)

Definition at line 92 of file kis_cage_transform_worker.cpp.

{
}

Member Function Documentation

approxChangeRect()

QRect KisCageTransformWorker::approxChangeRect

(

const QRect &

rc

)

Definition at line 272 of file kis_cage_transform_worker.cpp.

{
    const qreal margin = 0.30;
 
    QVector<QPointF> cageSamplePoints;
 
    const int minStep = 3;
    const int maxSamples = 200;
 
    const int totalPixels = rc.width() * rc.height();
    const int realStep = qMax(minStep, totalPixels / maxSamples);
    const QPolygonF cagePolygon(m_d->origCage);
 
    for (int i = 0; i < totalPixels; i += realStep) {
        const int x = rc.x() + i % rc.width();
        const int y = rc.y() + i / rc.width();
 
        const QPointF pt(x, y);
        if (cagePolygon.containsPoint(pt, Qt::OddEvenFill)) {
            cageSamplePoints << pt;
        }
    }
 
    if (cageSamplePoints.isEmpty()) {
        return rc;
    }
 
    KisGreenCoordinatesMath cage;
    cage.precalculateGreenCoordinates(m_d->origCage, cageSamplePoints);
    cage.generateTransformedCageNormals(m_d->transfCage);
 
    const int numValidPoints = cageSamplePoints.size();
    QVector<QPointF> transformedPoints(numValidPoints);
 
    int failedPoints = 0;
 
    for (int i = 0; i < numValidPoints; i++) {
        transformedPoints[i] = cage.transformedPoint(i, m_d->transfCage);
 
        if (qIsNaN(transformedPoints[i].x()) ||
            qIsNaN(transformedPoints[i].y())) {
 
            transformedPoints[i] = cageSamplePoints[i];
            failedPoints++;
        }
    }
 
    QRect resultRect =
        KisAlgebra2D::approximateRectFromPoints(transformedPoints).toAlignedRect();
 
    return KisAlgebra2D::blowRect(resultRect | rc, margin);
}

References KisAlgebra2D::approximateRectFromPoints(), KisAlgebra2D::blowRect(), cage, KisGreenCoordinatesMath::generateTransformedCageNormals(), m_d, KisGreenCoordinatesMath::precalculateGreenCoordinates(), and KisGreenCoordinatesMath::transformedPoint().

approxNeedRect()

QRect KisCageTransformWorker::approxNeedRect	(	const QRect &	rc,
		const QRect &	fullBounds )

Definition at line 325 of file kis_cage_transform_worker.cpp.

{
    Q_UNUSED(rc);
    return fullBounds;
}

calculateMappedIndexes()

QVector< int > KisCageTransformWorker::calculateMappedIndexes ( int col, int row, int * numExistingPoints )

inline

calculateTransformedPoints()

QVector< QPointF > KisCageTransformWorker::calculateTransformedPoints

(

)

isGridEmpty()

bool KisCageTransformWorker::isGridEmpty ( ) const

inline

Definition at line 56 of file kis_cage_transform_worker.cpp.

                             {
        return allSrcPoints.isEmpty();
    }

prepareTransform()

void KisCageTransformWorker::prepareTransform

(

)

Definition at line 143 of file kis_cage_transform_worker.cpp.

{
    if (m_d->origCage.size() < 3) return;
 
    const QPolygonF srcPolygon(m_d->origCage);
 
    QRect srcBounds = m_d->srcBounds;
    srcBounds &= srcPolygon.boundingRect().toAlignedRect();
 
    // no need to process empty devices
    if (srcBounds.isEmpty()) return;
    m_d->gridSize =
        GridIterationTools::calcGridSize(srcBounds, m_d->pixelPrecision);
 
    PointsFetcherOp pointsOp(srcPolygon);
    GridIterationTools::processGrid(pointsOp, srcBounds, m_d->pixelPrecision);
 
    const int numPoints = pointsOp.m_points.size();
    KIS_ASSERT_RECOVER_RETURN(numPoints == m_d->gridSize.width() * m_d->gridSize.height());
 
    m_d->allSrcPoints = pointsOp.m_points;
    m_d->allToValidPointsMap.resize(pointsOp.m_points.size());
    m_d->validPoints.resize(pointsOp.m_numValidPoints);
 
    {
        int validIdx = 0;
        for (int i = 0; i < numPoints; i++) {
            const QPointF &pt = pointsOp.m_points[i];
            const bool pointValid = pointsOp.m_pointValid[i];
 
            if (pointValid) {
                m_d->validPoints[validIdx] = pt;
                m_d->allToValidPointsMap[i] = validIdx;
                validIdx++;
            } else {
                m_d->allToValidPointsMap[i] = -1;
            }
        }
        KIS_ASSERT_RECOVER_NOOP(validIdx == m_d->validPoints.size());
    }
 
    m_d->cage.precalculateGreenCoordinates(m_d->origCage, m_d->validPoints);
}

References GridIterationTools::calcGridSize(), KIS_ASSERT_RECOVER_NOOP, KIS_ASSERT_RECOVER_RETURN, m_d, PointsFetcherOp::m_numValidPoints, PointsFetcherOp::m_points, PointsFetcherOp::m_pointValid, GridIterationTools::processGrid(), and srcBounds.

Private()

KisCageTransformWorker::Private ( const QVector< QPointF > & _origCage, KoUpdater * _progress, int _pixelPrecision )

inline

Definition at line 24 of file kis_cage_transform_worker.cpp.

        : origCage(_origCage),
          progress(_progress),
          pixelPrecision(_pixelPrecision)
    {
    }

run()

void KisCageTransformWorker::run	(	KisPaintDeviceSP	srcDevice,
		KisPaintDeviceSP	dstDevice )

Definition at line 331 of file kis_cage_transform_worker.cpp.

{
    if (m_d->isGridEmpty()) return;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->origCage.size() >= 3);
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->origCage.size() == m_d->transfCage.size());
    KIS_SAFE_ASSERT_RECOVER_RETURN(*srcDevice->colorSpace() == *dstDevice->colorSpace());
 
    QVector<QPointF> transformedPoints = m_d->calculateTransformedPoints();
 
    KisPaintDeviceSP tempDevice = new KisPaintDevice(dstDevice->colorSpace());
 
    {
        KisSelectionSP selection = new KisSelection();
 
        KisPainter painter(selection->pixelSelection());
        painter.setPaintColor(KoColor(Qt::black, selection->pixelSelection()->colorSpace()));
        painter.setAntiAliasPolygonFill(true);
        painter.setFillStyle(KisPainter::FillStyleForegroundColor);
        painter.setStrokeStyle(KisPainter::StrokeStyleNone);
 
        painter.paintPolygon(m_d->origCage);
 
        dstDevice->clearSelection(selection);
    }
 
    GridIterationTools::PaintDevicePolygonOp polygonOp(srcDevice, tempDevice);
    Private::MapIndexesOp indexesOp(m_d.data());
    GridIterationTools::iterateThroughGrid
        <GridIterationTools::IncompletePolygonPolicy>(polygonOp, indexesOp,
                                                      m_d->gridSize,
                                                      m_d->validPoints,
                                                      transformedPoints);
 
    QRect rect = tempDevice->extent();
    KisPainter gc(dstDevice);
    gc.bitBlt(rect.topLeft(), tempDevice, rect);
}

References KisPainter::bitBlt(), KisPaintDevice::clearSelection(), KisPaintDevice::colorSpace(), KisPaintDevice::extent(), KisPainter::FillStyleForegroundColor, GridIterationTools::iterateThroughGrid(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisPainter::paintPolygon(), KisSelection::pixelSelection, KisPainter::setAntiAliasPolygonFill(), KisPainter::setFillStyle(), KisPainter::setPaintColor(), KisPainter::setStrokeStyle(), and KisPainter::StrokeStyleNone.

runOnQImage()

QImage KisCageTransformWorker::runOnQImage

(

QPointF *

newOffset

)

Definition at line 370 of file kis_cage_transform_worker.cpp.

{
    if (m_d->isGridEmpty()) return QImage();
 
    KIS_ASSERT_RECOVER(m_d->origCage.size() >= 3 &&
                       m_d->origCage.size() == m_d->transfCage.size()) {
        return QImage();
    }
 
    KIS_ASSERT_RECOVER(!m_d->srcImage.isNull()) {
        return QImage();
    }
 
    KIS_ASSERT_RECOVER(m_d->srcImage.format() == QImage::Format_ARGB32) {
        return QImage();
    }
 
    QVector<QPointF> transformedPoints = m_d->calculateTransformedPoints();
 
    QRectF dstBounds;
    Q_FOREACH (const QPointF &pt, transformedPoints) {
        KisAlgebra2D::accumulateBounds(pt, &dstBounds);
    }
 
    const QRectF srcBounds(m_d->srcImageOffset, m_d->srcImage.size());
    dstBounds |= srcBounds;
 
    QPointF dstQImageOffset = dstBounds.topLeft();
    *newOffset = dstQImageOffset;
 
    QRect dstBoundsI = dstBounds.toAlignedRect();
 
 
    QImage dstImage(dstBoundsI.size(), m_d->srcImage.format());
    dstImage.fill(0);
 
    QImage tempImage(dstImage);
 
    {
        // we shouldn't create too many painters
        QPainter gc(&dstImage);
        gc.drawImage(-dstQImageOffset + m_d->srcImageOffset, m_d->srcImage);
        gc.setBrush(Qt::black);
        gc.setPen(Qt::black);
        gc.setCompositionMode(QPainter::CompositionMode_Clear);
        gc.drawPolygon(QPolygonF(m_d->origCage).translated(-dstQImageOffset));
        gc.end();
    }
 
    GridIterationTools::QImagePolygonOp polygonOp(m_d->srcImage, tempImage, m_d->srcImageOffset, dstQImageOffset);
    Private::MapIndexesOp indexesOp(m_d.data());
    GridIterationTools::iterateThroughGrid
        <GridIterationTools::IncompletePolygonPolicy>(polygonOp, indexesOp,
                                                      m_d->gridSize,
                                                      m_d->validPoints,
                                                      transformedPoints);
 
    {
        QPainter gc(&dstImage);
        gc.drawImage(QPoint(), tempImage);
    }
 
    return dstImage;
}

References KisAlgebra2D::accumulateBounds(), GridIterationTools::iterateThroughGrid(), KIS_ASSERT_RECOVER, m_d, and srcBounds.

setTransformedCage()

void KisCageTransformWorker::setTransformedCage

(

const QVector< QPointF > &

transformedCage

)

Definition at line 96 of file kis_cage_transform_worker.cpp.

{
    m_d->transfCage = transformedCage;
}

References m_d.

tryGetValidIndex()

int KisCageTransformWorker::tryGetValidIndex

(

const QPoint &

cellPt

)

Member Data Documentation

allSrcPoints

QVector<QPointF> KisCageTransformWorker::allSrcPoints

Contains all points of the grid including non-defined points (the ones which are placed outside the cage).

Definition at line 50 of file kis_cage_transform_worker.cpp.

allToValidPointsMap

QVector<int> KisCageTransformWorker::allToValidPointsMap

Definition at line 43 of file kis_cage_transform_worker.cpp.

cage

KisGreenCoordinatesMath KisCageTransformWorker::cage

Definition at line 52 of file kis_cage_transform_worker.cpp.

gridSize

QSize KisCageTransformWorker::gridSize

Definition at line 54 of file kis_cage_transform_worker.cpp.

m_d

const QScopedPointer<Private> KisCageTransformWorker::m_d

private

Definition at line 43 of file kis_cage_transform_worker.h.

origCage

QVector<QPointF> KisCageTransformWorker::origCage

Definition at line 38 of file kis_cage_transform_worker.cpp.

pixelPrecision

int KisCageTransformWorker::pixelPrecision

Definition at line 41 of file kis_cage_transform_worker.cpp.

progress

KoUpdater* KisCageTransformWorker::progress

Definition at line 40 of file kis_cage_transform_worker.cpp.

srcBounds

QRect KisCageTransformWorker::srcBounds

Definition at line 33 of file kis_cage_transform_worker.cpp.

srcImage

QImage KisCageTransformWorker::srcImage

Definition at line 35 of file kis_cage_transform_worker.cpp.

srcImageOffset

QPointF KisCageTransformWorker::srcImageOffset

Definition at line 36 of file kis_cage_transform_worker.cpp.

transfCage

QVector<QPointF> KisCageTransformWorker::transfCage

Definition at line 39 of file kis_cage_transform_worker.cpp.

validPoints

QVector<QPointF> KisCageTransformWorker::validPoints

Definition at line 44 of file kis_cage_transform_worker.cpp.

---

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

• libs/image/kis_cage_transform_worker.cpp
• libs/image/kis_cage_transform_worker.h