KisLiquifyTransformWorker Class Reference

#include <kis_liquify_transform_worker.h>

Inheritance diagram for KisLiquifyTransformWorker:

Public Member Functions
QRectF	accumulatedStrokesBounds () const
QRect	approxChangeRect (const QRect &rc)
QRect	approxNeedRect (const QRect &rc, const QRect &fullBounds)
QSize	gridSize () const
bool	isIdentity () const
	KisLiquifyTransformWorker (const KisLiquifyTransformWorker &rhs)
	KisLiquifyTransformWorker (const QRect &srcBounds, KoUpdater *progress, int pixelPrecision=8)
bool	operator== (const KisLiquifyTransformWorker &other) const
const QVector< QPointF > &	originalPoints () const
int	pointToIndex (const QPoint &cellPt)
void	preparePoints ()
	Private (const QRect &_srcBounds, KoUpdater *_progress, int _pixelPrecision)
template<class ProcessOp >
void	processTransformedPixels (ProcessOp op, const QPointF &base, qreal sigma, bool useWashMode, qreal flow)
template<class ProcessOp >
void	processTransformedPixelsBuildUp (ProcessOp op, const QPointF &base, qreal sigma)
template<class ProcessOp >
void	processTransformedPixelsWash (ProcessOp op, const QPointF &base, qreal sigma, qreal flow)
void	restoreShapePoints (const QPointF &base, qreal amount, qreal sigma, bool preserveRotation, bool preserveScale, bool preserveStretch)
void	rotatePoints (const QPointF &base, qreal angle, qreal sigma, bool useWashMode, qreal flow)
void	run (KisPaintDeviceSP srcDevice, KisPaintDeviceSP dstDevice)
QImage	runOnQImage (const QImage &srcImage, const QPointF &srcImageOffset, const QTransform &imageToThumbTransform, QPointF *newOffset)
void	scalePoints (const QPointF &base, qreal scale, qreal sigma, bool useWashMode, qreal flow)
void	toXML (QDomElement *e) const
QVector< QPointF > &	transformedPoints ()
void	transformSrcAndDst (const QTransform &t)
void	translate (const QPointF &offset)
void	translateDstSpace (const QPointF &offset)
void	translatePoints (const QPointF &base, const QPointF &offset, qreal sigma, bool useWashMode, qreal flow)
void	undoPoints (const QPointF &base, qreal amount, qreal sigma)
	~KisLiquifyTransformWorker ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Static Public Member Functions
static KisLiquifyTransformWorker *	fromXML (const QDomElement &e)

Public Attributes
QRectF	accumulatedBrushStrokes
QSize	gridSize
QVector< QPointF >	originalPoints
KisSpatialContainer	originalPointsContainer
int	pixelPrecision
KoUpdater *	progress
QRect	srcBounds
QVector< QPointF >	transformedPoints
KisSpatialContainer	transformedPointsContainer
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 18 of file kis_liquify_transform_worker.cpp.

Constructor & Destructor Documentation

KisLiquifyTransformWorker() [1/2]

KisLiquifyTransformWorker::KisLiquifyTransformWorker	(	const QRect &	srcBounds,
		KoUpdater *	progress,
		int	pixelPrecision = 8 )

Definition at line 68 of file kis_liquify_transform_worker.cpp.

    : m_d(new Private(srcBounds, progress, pixelPrecision))
{
    KIS_ASSERT_RECOVER_RETURN(!srcBounds.isEmpty());
 
    // TODO: implement 'progress' stuff
    m_d->preparePoints();
}

References KIS_ASSERT_RECOVER_RETURN, m_d, and srcBounds.

KisLiquifyTransformWorker() [2/2]

KisLiquifyTransformWorker::KisLiquifyTransformWorker

(

const KisLiquifyTransformWorker &

rhs

)

Definition at line 79 of file kis_liquify_transform_worker.cpp.

    : m_d(new Private(*rhs.m_d.data()))
{
}

~KisLiquifyTransformWorker()

KisLiquifyTransformWorker::~KisLiquifyTransformWorker

(

)

Definition at line 84 of file kis_liquify_transform_worker.cpp.

{
}

Member Function Documentation

accumulatedStrokesBounds()

QRectF KisLiquifyTransformWorker::accumulatedStrokesBounds

(

)

const

Definition at line 650 of file kis_liquify_transform_worker.cpp.

{
    return m_d->accumulatedBrushStrokes;
}

References m_d.

approxChangeRect()

QRect KisLiquifyTransformWorker::approxChangeRect

(

const QRect &

rc

)

Definition at line 637 of file kis_liquify_transform_worker.cpp.

{
    const qreal margin = 0.05;
    QRect resultRect = m_d->transformedPointsContainer.exactBounds().toRect();
    return KisAlgebra2D::blowRect(resultRect | rc, margin);
}

References KisAlgebra2D::blowRect(), and m_d.

approxNeedRect()

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

Definition at line 644 of file kis_liquify_transform_worker.cpp.

{
    Q_UNUSED(rc);
    return fullBounds;
}

fromXML()

KisLiquifyTransformWorker * KisLiquifyTransformWorker::fromXML ( const QDomElement & e )

static

Definition at line 779 of file kis_liquify_transform_worker.cpp.

{
    QDomElement liquifyEl;
 
    QRect srcBounds;
    QVector<QPointF> originalPoints;
    QVector<QPointF> transformedPoints;
    int pixelPrecision;
    QSize gridSize;
 
    bool result = false;
 
 
    result =
        KisDomUtils::findOnlyElement(e, "liquify_points", &liquifyEl) &&
 
        KisDomUtils::loadValue(liquifyEl, "srcBounds", &srcBounds) &&
        KisDomUtils::loadValue(liquifyEl, "originalPoints", &originalPoints) &&
        KisDomUtils::loadValue(liquifyEl, "transformedPoints", &transformedPoints) &&
        KisDomUtils::loadValue(liquifyEl, "pixelPrecision", &pixelPrecision) &&
        KisDomUtils::loadValue(liquifyEl, "gridSize", &gridSize);
 
    if (!result) {
        warnKrita << "WARNING: Failed to load liquify worker from XML";
        return new KisLiquifyTransformWorker(QRect(0,0,1024, 1024), 0, 8);
    }
 
    KisLiquifyTransformWorker *worker =
        new KisLiquifyTransformWorker(srcBounds, 0, pixelPrecision);
 
    const int numPoints = originalPoints.size();
 
    if (numPoints != transformedPoints.size() ||
        numPoints != worker->m_d->originalPoints.size() ||
        gridSize != worker->m_d->gridSize) {
        warnKrita << "WARNING: Inconsistent number of points!";
        warnKrita << ppVar(originalPoints.size());
        warnKrita << ppVar(transformedPoints.size());
        warnKrita << ppVar(gridSize);
        warnKrita << ppVar(worker->m_d->originalPoints.size());
        warnKrita << ppVar(worker->m_d->transformedPoints.size());
        warnKrita << ppVar(worker->m_d->gridSize);
 
        return worker;
    }
 
    QRectF changedRect = QRectF();
 
    for (int i = 0; i < numPoints; i++) {
        worker->m_d->originalPoints[i] = originalPoints[i];
        worker->m_d->transformedPoints[i] = transformedPoints[i];
        if (!KisAlgebra2D::fuzzyPointCompare(transformedPoints[i], originalPoints[i])) {
            KisAlgebra2D::accumulateBounds(transformedPoints[i], &changedRect);
            KisAlgebra2D::accumulateBounds(originalPoints[i], &changedRect);
        }
    }
    changedRect = kisGrowRect(changedRect, pixelPrecision);
 
    worker->m_d->transformedPointsContainer.initializeWith(worker->m_d->transformedPoints);
    worker->m_d->originalPointsContainer.initializeWith(worker->m_d->originalPoints);
 
    worker->m_d->accumulatedBrushStrokes = changedRect;
 
 
    return worker;
}

References KisAlgebra2D::accumulateBounds(), KisDomUtils::findOnlyElement(), KisAlgebra2D::fuzzyPointCompare(), gridSize, kisGrowRect(), KisLiquifyTransformWorker(), KisDomUtils::loadValue(), m_d, originalPoints, pixelPrecision, ppVar, srcBounds, transformedPoints, and warnKrita.

gridSize()

QSize KisLiquifyTransformWorker::gridSize

(

)

const

isIdentity()

bool KisLiquifyTransformWorker::isIdentity

(

)

const

Definition at line 108 of file kis_liquify_transform_worker.cpp.

{
    const qreal eps = 1e-6;
    return KisAlgebra2D::fuzzyPointCompare(m_d->originalPoints, m_d->transformedPoints, eps);
}

References eps, KisAlgebra2D::fuzzyPointCompare(), and m_d.

operator==()

bool KisLiquifyTransformWorker::operator==

(

const KisLiquifyTransformWorker &

other

)

const

Definition at line 88 of file kis_liquify_transform_worker.cpp.

{
    bool result =
            m_d->srcBounds == other.m_d->srcBounds &&
            m_d->pixelPrecision == other.m_d->pixelPrecision &&
            m_d->gridSize == other.m_d->gridSize &&
            m_d->originalPoints.size() == other.m_d->originalPoints.size() &&
            m_d->transformedPoints.size() == other.m_d->transformedPoints.size();
 
    if (!result) return false;
 
    const qreal eps = 1e-6;
 
    result =
        KisAlgebra2D::fuzzyPointCompare(m_d->originalPoints, other.m_d->originalPoints, eps) &&
        KisAlgebra2D::fuzzyPointCompare(m_d->transformedPoints, other.m_d->transformedPoints, eps);
 
    return result;
}

References eps, KisAlgebra2D::fuzzyPointCompare(), and m_d.

originalPoints()

const QVector< QPointF > & KisLiquifyTransformWorker::originalPoints

(

)

const

pointToIndex()

int KisLiquifyTransformWorker::pointToIndex

(

const QPoint &

cellPt

)

Definition at line 114 of file kis_liquify_transform_worker.cpp.

{
    return GridIterationTools::pointToIndex(cellPt, m_d->gridSize);
}

References m_d, and GridIterationTools::pointToIndex().

preparePoints()

void KisLiquifyTransformWorker::preparePoints

(

)

Private()

KisLiquifyTransformWorker::Private ( const QRect & _srcBounds, KoUpdater * _progress, int _pixelPrecision )

inline

Definition at line 20 of file kis_liquify_transform_worker.cpp.

        : srcBounds(_srcBounds)
        , originalPointsContainer(_srcBounds)
        , transformedPointsContainer(_srcBounds)
        , progress(_progress)
        , pixelPrecision(_pixelPrecision)
    {
    }

processTransformedPixels()

template<class ProcessOp >

void KisLiquifyTransformWorker::processTransformedPixels	(	ProcessOp	op,
		const QPointF &	base,
		qreal	sigma,
		bool	useWashMode,
		qreal	flow )

processTransformedPixelsBuildUp()

template<class ProcessOp >

void KisLiquifyTransformWorker::processTransformedPixelsBuildUp	(	ProcessOp	op,
		const QPointF &	base,
		qreal	sigma )

processTransformedPixelsWash()

template<class ProcessOp >

void KisLiquifyTransformWorker::processTransformedPixelsWash	(	ProcessOp	op,
		const QPointF &	base,
		qreal	sigma,
		qreal	flow )

restoreShapePoints()

void KisLiquifyTransformWorker::restoreShapePoints	(	const QPointF &	base,
		qreal	amount,
		qreal	sigma,
		bool	preserveRotation,
		bool	preserveScale,
		bool	preserveStretch )

Definition at line 272 of file kis_liquify_transform_worker.cpp.

{
    const qreal maxDistCoeff = 3.0;
    const qreal maxDist = maxDistCoeff * sigma;
 
    KIS_ASSERT_RECOVER_RETURN(m_d->originalPoints.size() ==
                              m_d->transformedPoints.size());
 
    QRectF clipRect(base.x() - maxDist, base.y() - maxDist,
                    2 * maxDist, 2 * maxDist);
    m_d->accumulatedBrushStrokes |= kisGrowRect(clipRect, m_d->pixelPrecision);
 
    QVector<int> indexes;
    m_d->transformedPointsContainer.findAllInRange(indexes, base, maxDist);
 
    QVector<RestoreShapeSample> samples;
    samples.reserve(indexes.count());
 
    qreal weightSum = 0.0;
    Eigen::Vector2d originalCentroid(0.0, 0.0);
    Eigen::Vector2d transformedCentroid(0.0, 0.0);
 
    for (int i = 0; i < indexes.count(); i++) {
        const int index = indexes[i];
 
        const QPointF diff = m_d->transformedPoints[index] - base;
        const qreal dist = KisAlgebra2D::norm(diff);
        if (dist > maxDist) continue;
 
        const qreal weight = exp(-0.5 * pow2(dist / sigma));
        const qreal lambda = qBound<qreal>(0.0, weight * amount, 1.0);
        if (lambda <= 0.0) continue;
 
        samples << RestoreShapeSample{index, weight, lambda};
 
        originalCentroid += weight * toEigenPoint(m_d->originalPoints[index]);
        transformedCentroid += weight * toEigenPoint(m_d->transformedPoints[index]);
        weightSum += weight;
    }
 
    if (samples.count() < 3 || weightSum <= 1e-12) return;
 
    originalCentroid /= weightSum;
    transformedCentroid /= weightSum;
 
    Eigen::Matrix2d originalMoment = Eigen::Matrix2d::Zero();
    Eigen::Matrix2d transformedOriginalMoment = Eigen::Matrix2d::Zero();
 
    for (int i = 0; i < samples.count(); i++) {
        const RestoreShapeSample &sample = samples[i];
 
        const Eigen::Vector2d originalOffset =
            toEigenPoint(m_d->originalPoints[sample.index]) - originalCentroid;
        const Eigen::Vector2d transformedOffset =
            toEigenPoint(m_d->transformedPoints[sample.index]) - transformedCentroid;
 
        originalMoment += sample.weight * originalOffset * originalOffset.transpose();
        transformedOriginalMoment += sample.weight * transformedOffset * originalOffset.transpose();
    }
 
    if (qAbs(originalMoment.determinant()) < 1e-12) return;
 
    const Eigen::Matrix2d affine =
        transformedOriginalMoment * originalMoment.inverse();
 
    if (!isFinite(affine)) return;
 
    Eigen::JacobiSVD<Eigen::Matrix2d> svd(affine, Eigen::ComputeFullU | Eigen::ComputeFullV);
    Eigen::Matrix2d rotation = svd.matrixU() * svd.matrixV().transpose();
 
    if (rotation.determinant() < 0.0) {
        Eigen::Matrix2d u = svd.matrixU();
        u.col(1) *= -1.0;
        rotation = u * svd.matrixV().transpose();
    }
 
    if (!isFinite(rotation)) return;
 
    const Eigen::Vector2d singularValues = svd.singularValues();
    const qreal uniformScale =
        preserveScale ? qMax<qreal>(1e-6, 0.5 * (singularValues.x() + singularValues.y())) : 1.0;
 
    Eigen::Matrix2d targetLinear = Eigen::Matrix2d::Identity();
    if (preserveRotation) {
        targetLinear = rotation;
    }
    targetLinear *= uniformScale;
 
    if (preserveStretch) {
        const Eigen::Matrix2d stretchInRotationSpace = rotation.transpose() * affine;
        qreal stretchX = qMax<qreal>(1e-6, qAbs(stretchInRotationSpace(0, 0)));
        qreal stretchY = qMax<qreal>(1e-6, qAbs(stretchInRotationSpace(1, 1)));
        const qreal stretchNormalization =
            preserveScale ? uniformScale : qMax<qreal>(1e-6, std::sqrt(stretchX * stretchY));
 
        Eigen::Matrix2d stretch = Eigen::Matrix2d::Identity();
        stretch(0, 0) = stretchX / stretchNormalization;
        stretch(1, 1) = stretchY / stretchNormalization;
        targetLinear *= stretch;
    }
 
    QVector<PointUpdate> updates;
    updates.reserve(samples.count());
 
    Eigen::Vector2d updatedCentroid(0.0, 0.0);
    qreal updatedWeightSum = 0.0;
 
    for (int i = 0; i < samples.count(); i++) {
        const RestoreShapeSample &sample = samples[i];
        const Eigen::Vector2d oldPosition = toEigenPoint(m_d->transformedPoints[sample.index]);
        const Eigen::Vector2d originalOffset =
            toEigenPoint(m_d->originalPoints[sample.index]) - originalCentroid;
        const Eigen::Vector2d targetPosition =
            transformedCentroid + targetLinear * originalOffset;
        const Eigen::Vector2d newPosition =
            oldPosition * (1.0 - sample.lambda) + targetPosition * sample.lambda;
 
        updates << PointUpdate{sample.index,
                               m_d->transformedPoints[sample.index],
                               fromEigenPoint(newPosition)};
 
        updatedCentroid += sample.weight * newPosition;
        updatedWeightSum += sample.weight;
    }
 
    if (updatedWeightSum <= 1e-12) return;
    updatedCentroid /= updatedWeightSum;
 
    const QPointF centroidCorrection = fromEigenPoint(transformedCentroid - updatedCentroid);
 
    for (int i = 0; i < updates.count(); i++) {
        PointUpdate &update = updates[i];
        update.newPosition += centroidCorrection;
        m_d->transformedPoints[update.index] = update.newPosition;
        m_d->transformedPointsContainer.movePoint(update.index,
                                                 update.oldPosition,
                                                 update.newPosition);
    }
}

References KIS_ASSERT_RECOVER_RETURN, kisGrowRect(), m_d, KisAlgebra2D::norm(), pow2(), and u.

rotatePoints()

void KisLiquifyTransformWorker::rotatePoints	(	const QPointF &	base,
		qreal	angle,
		qreal	sigma,
		bool	useWashMode,
		qreal	flow )

Definition at line 591 of file kis_liquify_transform_worker.cpp.

{
    RotateOp op(angle);
    m_d->processTransformedPixels(op, base, sigma, useWashMode, flow);
}

References m_d.

run()

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

Definition at line 601 of file kis_liquify_transform_worker.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(*srcDevice->colorSpace() == *dstDevice->colorSpace());
 
    dstDevice->clear();
 
    using namespace GridIterationTools;
    QRect correctSubGrid = calculateCorrectSubGrid(m_d->srcBounds, m_d->pixelPrecision, m_d->accumulatedBrushStrokes, m_d->gridSize);
 
    PaintDevicePolygonOp polygonOp(srcDevice, dstDevice);
    RegularGridIndexesOp indexesOp(m_d->gridSize);
 
    bool canMergeRects = GridIterationTools::canProcessRectsInRandomOrder(indexesOp, m_d->transformedPoints, correctSubGrid);
    polygonOp.setCanMergeRects(canMergeRects);
 
#ifdef DEBUG_PAINTING_POLYGONS
    polygonOp.setDebugColor(Qt::red);
#endif
 
    iterateThroughGrid<AlwaysCompletePolygonPolicy>(polygonOp, indexesOp,
                                                    m_d->gridSize,
                                                    m_d->originalPoints,
                                                    m_d->transformedPoints,
                                                    correctSubGrid);
    QList<QRectF> areasToCopy = cutOutSubgridFromBounds(correctSubGrid, m_d->srcBounds, m_d->gridSize, m_d->originalPoints);
#ifdef DEBUG_PAINTING_POLYGONS
    QList<QColor> colors = {Qt::blue, Qt::green, Qt::yellow, Qt::black};
#endif
    for (int i = 0; i < areasToCopy.length(); i++) {
#ifdef DEBUG_PAINTING_POLYGONS
        polygonOp.setDebugColor(colors[i]);
#endif
        polygonOp.fastCopyArea(areasToCopy[i].toRect(), false);
    }
}

References GridIterationTools::canProcessRectsInRandomOrder(), KisPaintDevice::clear(), KisPaintDevice::colorSpace(), GridIterationTools::PaintDevicePolygonOp::fastCopyArea(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and GridIterationTools::PaintDevicePolygonOp::setCanMergeRects().

runOnQImage()

QImage KisLiquifyTransformWorker::runOnQImage	(	const QImage &	srcImage,
		const QPointF &	srcImageOffset,
		const QTransform &	imageToThumbTransform,
		QPointF *	newOffset )

Definition at line 691 of file kis_liquify_transform_worker.cpp.

{
    KIS_ASSERT_RECOVER(m_d->originalPoints.size() == m_d->transformedPoints.size()) {
        return QImage();
    }
 
    KIS_ASSERT_RECOVER(!srcImage.isNull()) {
        return QImage();
    }
 
    KIS_ASSERT_RECOVER(srcImage.format() == QImage::Format_ARGB32) {
        return QImage();
    }
 
    QVector<QPointF> originalPointsLocal(m_d->originalPoints);
    QVector<QPointF> transformedPointsLocal(m_d->transformedPoints);
 
    PointMapFunction mapFunc = bindPointMapTransform(imageToThumbTransform);
 
    std::transform(originalPointsLocal.begin(), originalPointsLocal.end(),
                   originalPointsLocal.begin(), mapFunc);
 
    std::transform(transformedPointsLocal.begin(), transformedPointsLocal.end(),
                   transformedPointsLocal.begin(), mapFunc);
 
    QRectF dstBounds;
    Q_FOREACH (const QPointF &pt, transformedPointsLocal) {
        KisAlgebra2D::accumulateBounds(pt, &dstBounds);
    }
 
    const QRectF srcBounds(srcImageOffset, srcImage.size());
    dstBounds |= srcBounds;
 
    QPointF dstQImageOffset = dstBounds.topLeft();
    *newOffset = dstQImageOffset;
 
    QRect dstBoundsI = dstBounds.toAlignedRect();
 
    QImage dstImage(dstBoundsI.size(), srcImage.format());
    dstImage.fill(0);
 
    GridIterationTools::QImagePolygonOp polygonOp(srcImage, dstImage, srcImageOffset, dstQImageOffset);
    GridIterationTools::RegularGridIndexesOp indexesOp(m_d->gridSize);
 
 
    QRect correctSubGrid = GridIterationTools::calculateCorrectSubGrid(m_d->srcBounds, m_d->pixelPrecision, m_d->accumulatedBrushStrokes, m_d->gridSize);
    bool canMergeRects = GridIterationTools::canProcessRectsInRandomOrder(indexesOp, m_d->transformedPoints, correctSubGrid);
    polygonOp.setCanMergeRects(canMergeRects);
 
 
    GridIterationTools::iterateThroughGrid<GridIterationTools::AlwaysCompletePolygonPolicy>(polygonOp, indexesOp,
                                                    m_d->gridSize,
                                                    originalPointsLocal,
                                                    transformedPointsLocal,
                                                    correctSubGrid);
 
 
    QList<QRectF> areasToCopy = GridIterationTools::cutOutSubgridFromBounds(correctSubGrid, m_d->srcBounds, m_d->gridSize, m_d->originalPoints);
    polygonOp.setCanMergeRects(false);
    const qreal eps = 0.001;
    for (int i = 0; i < areasToCopy.length(); i++) {
        QPolygonF transformed = imageToThumbTransform.map(QPolygonF(areasToCopy[i]));
        if (KisAlgebra2D::isPolygonPixelAlignedRect(transformed, eps)) {
            polygonOp.fastCopyArea(transformed.boundingRect().toRect());
        } else {
            polygonOp.operator()(transformed, transformed);
        }
    }
    return dstImage;
}

References KisAlgebra2D::accumulateBounds(), bindPointMapTransform(), GridIterationTools::calculateCorrectSubGrid(), GridIterationTools::canProcessRectsInRandomOrder(), GridIterationTools::cutOutSubgridFromBounds(), eps, GridIterationTools::QImagePolygonOp::fastCopyArea(), KisAlgebra2D::isPolygonPixelAlignedRect(), KIS_ASSERT_RECOVER, m_d, GridIterationTools::QImagePolygonOp::setCanMergeRects(), and srcBounds.

scalePoints()

void KisLiquifyTransformWorker::scalePoints	(	const QPointF &	base,
		qreal	scale,
		qreal	sigma,
		bool	useWashMode,
		qreal	flow )

Definition at line 581 of file kis_liquify_transform_worker.cpp.

{
    ScaleOp op(scale);
    m_d->processTransformedPixels(op, base, sigma, useWashMode, flow);
}

References m_d.

toXML()

void KisLiquifyTransformWorker::toXML

(

QDomElement *

e

)

const

Definition at line 766 of file kis_liquify_transform_worker.cpp.

{
    QDomDocument doc = e->ownerDocument();
    QDomElement liqEl = doc.createElement("liquify_points");
    e->appendChild(liqEl);
 
    KisDomUtils::saveValue(&liqEl, "srcBounds", m_d->srcBounds);
    KisDomUtils::saveValue(&liqEl, "originalPoints", m_d->originalPoints);
    KisDomUtils::saveValue(&liqEl, "transformedPoints", m_d->transformedPoints);
    KisDomUtils::saveValue(&liqEl, "pixelPrecision", m_d->pixelPrecision);
    KisDomUtils::saveValue(&liqEl, "gridSize", m_d->gridSize);
}

References m_d, and KisDomUtils::saveValue().

transformedPoints()

QVector< QPointF > & KisLiquifyTransformWorker::transformedPoints

(

)

transformSrcAndDst()

void KisLiquifyTransformWorker::transformSrcAndDst

(

const QTransform &

t

)

Definition at line 655 of file kis_liquify_transform_worker.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(t.type() <= QTransform::TxScale);
 
    m_d->srcBounds = t.mapRect(m_d->srcBounds);
 
    // TODO: do it within Spatial Container
    for (int i = 0; i < m_d->transformedPoints.count(); i++) {
        m_d->originalPointsContainer.movePoint(i, m_d->originalPoints[i], t.map(m_d->originalPoints[i]));
        m_d->transformedPointsContainer.movePoint(i, m_d->transformedPoints[i], t.map(m_d->transformedPoints[i]));
 
        m_d->originalPoints[i] = t.map(m_d->originalPoints[i]);
        m_d->transformedPoints[i] = t.map(m_d->transformedPoints[i]);
    }
    m_d->accumulatedBrushStrokes = t.map(m_d->accumulatedBrushStrokes).boundingRect();
    if (t == QTransform::fromScale(t.m11(), t.m22()) && t.m11() == t.m22()) {
        m_d->pixelPrecision *= t.m11();
        KIS_SAFE_ASSERT_RECOVER(m_d->pixelPrecision > 0) { m_d->pixelPrecision = 1; }
        KIS_SAFE_ASSERT_RECOVER(QList<int>({1, 2, 4, 8, 16}).contains(m_d->pixelPrecision) || m_d->pixelPrecision%16 == 0) { m_d->pixelPrecision = 1; }
        // should check if pixelPrecision is a power of 2, but that's more complicated
    }
}

References KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, and m_d.

translate()

void KisLiquifyTransformWorker::translate

(

const QPointF &

offset

)

Definition at line 178 of file kis_liquify_transform_worker.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(m_d->originalPoints.size() ==
                              m_d->transformedPoints.size());
 
    // TODO: make it within Spatial Container, either a hidden offset, or just offsetting all points at once
    // and benchmark
    for (int i = 0; i < m_d->transformedPoints.count(); i++) {
        m_d->originalPointsContainer.movePoint(i, m_d->originalPoints[i], m_d->originalPoints[i] + offset);
        m_d->transformedPointsContainer.movePoint(i, m_d->transformedPoints[i], m_d->transformedPoints[i] + offset);
 
        m_d->originalPoints[i] += offset;
        m_d->transformedPoints[i] += offset;
    }
 
    m_d->accumulatedBrushStrokes.translate(offset);
}

References KIS_ASSERT_RECOVER_RETURN, and m_d.

translateDstSpace()

void KisLiquifyTransformWorker::translateDstSpace

(

const QPointF &

offset

)

Definition at line 196 of file kis_liquify_transform_worker.cpp.

{
    // TODO: make it within Spatial Container, either a hidden offset, or just offsetting all points at once
    // and benchmark
    for (int i = 0; i < m_d->transformedPoints.count(); i++) {
        m_d->transformedPointsContainer.movePoint(i, m_d->transformedPoints[i], m_d->transformedPoints[i] + offset);
        m_d->transformedPoints[i] += offset;
    }
}

References m_d.

translatePoints()

void KisLiquifyTransformWorker::translatePoints	(	const QPointF &	base,
		const QPointF &	offset,
		qreal	sigma,
		bool	useWashMode,
		qreal	flow )

Definition at line 571 of file kis_liquify_transform_worker.cpp.

{
    TranslateOp op(offset);
    m_d->processTransformedPixels(op, base, sigma, useWashMode, flow);
}

References m_d.

undoPoints()

void KisLiquifyTransformWorker::undoPoints	(	const QPointF &	base,
		qreal	amount,
		qreal	sigma )

Definition at line 206 of file kis_liquify_transform_worker.cpp.

{
    const qreal maxDistCoeff = 3.0;
    const qreal maxDist = maxDistCoeff * sigma;
 
    KIS_ASSERT_RECOVER_RETURN(m_d->originalPoints.size() ==
                              m_d->transformedPoints.size());
 
    QVector<int> indexes;
    m_d->transformedPointsContainer.findAllInRange(indexes, base, maxDist);
    for (int i = 0; i < indexes.count(); i++) {
 
        QPointF diff = m_d->transformedPoints[indexes[i]] - base;
        qreal dist = KisAlgebra2D::norm(diff);
        qreal lambda = exp(-0.5 * pow2(dist / sigma));
        lambda *= amount;
 
        QPointF oldPosition = m_d->transformedPoints[indexes[i]];
        m_d->transformedPoints[indexes[i]] = m_d->originalPoints[indexes[i]] * lambda + m_d->transformedPoints[indexes[i]] * (1.0 - lambda);
 
        m_d->transformedPointsContainer.movePoint(indexes[i], oldPosition, m_d->transformedPoints[indexes[i]]);
    }
}

References KIS_ASSERT_RECOVER_RETURN, m_d, KisAlgebra2D::norm(), and pow2().

Member Data Documentation

accumulatedBrushStrokes

QRectF KisLiquifyTransformWorker::accumulatedBrushStrokes

Definition at line 39 of file kis_liquify_transform_worker.cpp.

gridSize

QSize KisLiquifyTransformWorker::gridSize

Definition at line 43 of file kis_liquify_transform_worker.cpp.

m_d

const QScopedPointer<Private> KisLiquifyTransformWorker::m_d

private

Definition at line 93 of file kis_liquify_transform_worker.h.

originalPoints

const QVector< QPointF > & KisLiquifyTransformWorker::originalPoints

Definition at line 33 of file kis_liquify_transform_worker.cpp.

originalPointsContainer

KisSpatialContainer KisLiquifyTransformWorker::originalPointsContainer

Definition at line 36 of file kis_liquify_transform_worker.cpp.

pixelPrecision

int KisLiquifyTransformWorker::pixelPrecision

Definition at line 42 of file kis_liquify_transform_worker.cpp.

progress

KoUpdater* KisLiquifyTransformWorker::progress

Definition at line 41 of file kis_liquify_transform_worker.cpp.

srcBounds

QRect KisLiquifyTransformWorker::srcBounds

Definition at line 31 of file kis_liquify_transform_worker.cpp.

transformedPoints

QVector< QPointF > & KisLiquifyTransformWorker::transformedPoints

Definition at line 34 of file kis_liquify_transform_worker.cpp.

transformedPointsContainer

KisSpatialContainer KisLiquifyTransformWorker::transformedPointsContainer

Definition at line 37 of file kis_liquify_transform_worker.cpp.

---

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

• libs/image/kis_liquify_transform_worker.cpp
• libs/image/kis_liquify_transform_worker.h