Classes
struct	HandlePoints

Public Member Functions
QCursor	getScaleCursor (const QPointF &handlePt)

QCursor	getShearCursor (const QPointF &start, const QPointF &end)

	Private (KisPerspectiveTransformStrategy _q, const KisCoordinatesConverter _converter, ToolTransformArgs &_currentArgs, TransformTransactionProperties &_transaction)

void	recalculateTransformations ()

void	recalculateTransformedHandles ()

QTransform	transformFromArgs ()

void	transformIntoArgs (const Eigen::Matrix3f &t)

Public Attributes
ToolTransformArgs	clickArgs

QPointF	clickPos

const KisCoordinatesConverter *	converter
	standard members ///

ToolTransformArgs &	currentArgs

int	currentDraggingHandlePoint {0}

QVector< QPointF >	dstHandlePoints

StrokeFunction	function {NONE}
	custom members ///

QTransform	handlesTransform

bool	imageTooBig {false}

bool	isTransforming {false}

QImage	originalImage

QPointF	paintingOffset

QTransform	paintingTransform

KisPerspectiveTransformStrategy *	q

QVector< QPointF >	srcHandlePoints

QTransform	thumbToImageTransform

TransformTransactionProperties &	transaction

QTransform	transform

HandlePoints	transformedHandles

Detailed Description

Definition at line 48 of file kis_perspective_transform_strategy.cpp.

Constructor & Destructor Documentation

◆ Private()

KisPerspectiveTransformStrategy::Private::Private	(	KisPerspectiveTransformStrategy *	_q,
		const KisCoordinatesConverter *	_converter,
		ToolTransformArgs &	_currentArgs,
		TransformTransactionProperties &	_transaction )

inline

Definition at line 50 of file kis_perspective_transform_strategy.cpp.

        : q(_q),
          converter(_converter),
          currentArgs(_currentArgs),
          transaction(_transaction),
          imageTooBig(false),
          isTransforming(false)
    {
    }

Member Function Documentation

◆ getScaleCursor()

QCursor KisPerspectiveTransformStrategy::Private::getScaleCursor ( const QPointF & handlePt )

◆ getShearCursor()

QCursor KisPerspectiveTransformStrategy::Private::getShearCursor	(	const QPointF &	start,
		const QPointF &	end )

◆ recalculateTransformations()

void KisPerspectiveTransformStrategy::Private::recalculateTransformations ( )

Definition at line 667 of file kis_perspective_transform_strategy.cpp.

{
    transform = transformFromArgs();
 
    QTransform viewScaleTransform = converter->imageToDocumentTransform() * converter->documentToFlakeTransform();
    handlesTransform = transform * viewScaleTransform;
 
    QTransform tl = QTransform::fromTranslate(transaction.originalTopLeft().x(), transaction.originalTopLeft().y());
    paintingTransform = tl.inverted() * q->thumbToImageTransform() * tl * transform * viewScaleTransform;
    paintingOffset = transaction.originalTopLeft();
 
    // check whether image is too big to be displayed or not
    const qreal maxScale = 20.0;
 
    imageTooBig = false;
 
    if (qAbs(currentArgs.scaleX()) > maxScale ||
        qAbs(currentArgs.scaleY()) > maxScale) {
 
        imageTooBig = true;
 
    } else {
        QVector<QPointF> points;
        points << transaction.originalRect().topLeft();
        points << transaction.originalRect().topRight();
        points << transaction.originalRect().bottomRight();
        points << transaction.originalRect().bottomLeft();
 
        for (int i = 0; i < points.size(); i++) {
            points[i] = transform.map(points[i]);
        }
 
        for (int i = 0; i < points.size(); i++) {
            const QPointF &pt = points[i];
            const QPointF &prev = points[(i - 1 + 4) % 4];
            const QPointF &next = points[(i + 1) % 4];
            const QPointF &other = points[(i + 2) % 4];
 
            QLineF l1(pt, other);
            QLineF l2(prev, next);
 
            QPointF intersection;
            l1.intersects(l2, &intersection);
 
            qreal maxDistance = kisSquareDistance(pt, other);
 
            if (kisSquareDistance(pt, intersection) > maxDistance ||
                kisSquareDistance(other, intersection) > maxDistance) {
 
                imageTooBig = true;
                break;
            }
 
            const qreal thresholdDistance = 0.02 * l2.length();
 
            if (kisDistanceToLine(pt, l2) < thresholdDistance) {
                imageTooBig = true;
                break;
            }
        }
    }
 
    // recalculate cached handles position
    recalculateTransformedHandles();
 
    Q_EMIT q->requestShowImageTooBig(imageTooBig);
    Q_EMIT q->requestImageRecalculation();
}

References kisDistanceToLine(), and kisSquareDistance().

◆ recalculateTransformedHandles()

void KisPerspectiveTransformStrategy::Private::recalculateTransformedHandles ( )

Definition at line 130 of file kis_perspective_transform_strategy.cpp.

{
    srcHandlePoints.resize(HANDLE_COUNT);
    srcHandlePoints[HANDLE_TOP_LEFT] = transaction.originalTopLeft();
    srcHandlePoints[HANDLE_TOP_RIGHT] = transaction.originalTopRight();
    srcHandlePoints[HANDLE_BOTTOM_LEFT] = transaction.originalBottomLeft();
    srcHandlePoints[HANDLE_BOTTOM_RIGHT] = transaction.originalBottomRight();
    srcHandlePoints[HANDLE_MIDDLE_TOP] = transaction.originalMiddleTop();
    srcHandlePoints[HANDLE_MIDDLE_BOTTOM] = transaction.originalMiddleBottom();
    srcHandlePoints[HANDLE_MIDDLE_LEFT] = transaction.originalMiddleLeft();
    srcHandlePoints[HANDLE_MIDDLE_RIGHT] = transaction.originalMiddleRight();
 
    dstHandlePoints.clear();
    Q_FOREACH (const QPointF &pt, srcHandlePoints) {
        dstHandlePoints << transform.map(pt);
    }
 
    QMatrix4x4 realMatrix(transform);
    QVector4D v;
 
    v = QVector4D(1, 0, 0, 0);
    v = realMatrix * v;
    transformedHandles.xVanishingExists = !qFuzzyCompare(v.w(), 0);
    transformedHandles.xVanishing = v.toVector2DAffine().toPointF();
 
    v = QVector4D(0, 1, 0, 0);
    v = realMatrix * v;
    transformedHandles.yVanishingExists = !qFuzzyCompare(v.w(), 0);
    transformedHandles.yVanishing = v.toVector2DAffine().toPointF();
}

◆ transformFromArgs()

QTransform KisPerspectiveTransformStrategy::Private::transformFromArgs ( )

Definition at line 464 of file kis_perspective_transform_strategy.cpp.

{
    KisTransformUtils::MatricesPack m(currentArgs);
    return m.finalTransform();
}

References KisTransformUtils::MatricesPack::finalTransform().

◆ transformIntoArgs()

void KisPerspectiveTransformStrategy::Private::transformIntoArgs ( const Eigen::Matrix3f & t )

We disabled decomposed transformation due to bug https://bugs.kde.org/show_bug.cgi?id=447255

In some cases decomposed preliminary transformation shrinks the image into a very small size, which is later inflated by the perspective transform. It creates a really bad and blurry result.

Even though the usage of preliminary rotation makes the bug much less obvious, but the image is still really blurred.

Definition at line 411 of file kis_perspective_transform_strategy.cpp.

{
    Eigen::Matrix3f TS = fromTranslate(-currentArgs.originalCenter());
 
    Eigen::Matrix3f m = t * TS.inverse();
 
    qreal tX = m(0,2) / m(2,2);
    qreal tY = m(1,2) / m(2,2);
 
    Eigen::Matrix3f T = fromTranslate(QPointF(tX, tY));
 
    m = T.inverse() * m;
 
#if 0
    // Decomposition according to:
    // https://www.w3.org/TR/css-transforms-1/#decomposing-a-3d-matrix
    KisAlgebra2D::DecomposedMatrix dm(toQTransform(m));
 
    currentArgs.setScaleX(dm.scaleX);
    currentArgs.setScaleY(dm.scaleY);
 
    currentArgs.setShearX(dm.shearXY);
    currentArgs.setShearY(0.0);
 
    currentArgs.setAZ(kisDegreesToRadians(dm.angle));
 
    QTransform pre = dm.scaleTransform() * dm.shearTransform() * dm.rotateTransform();
    m = m * fromQTransform(pre.inverted());
#else
    currentArgs.setScaleX(1.0);
    currentArgs.setScaleY(1.0);
    currentArgs.setShearX(0.0);
    currentArgs.setShearY(0.0);
    currentArgs.setAZ(0.0);
#endif
 
    currentArgs.setTransformedCenter(QPointF(tX, tY));
    currentArgs.setFlattenedPerspectiveTransform(toQTransform(m));
}