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

Static Public Attributes
static constexpr qreal	MaxPolygonVertexAngle {177.0}

Detailed Description

Definition at line 49 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 51 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 679 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();
 
    imageTooBig = false;
 
    {
        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]);
        }
 
        QPolygonF poly (points);
        if (!KisAlgebra2D::isPolygonTrulyConvex(poly, true, Private::MaxPolygonVertexAngle)) {
            imageTooBig = true;
        }
 
        const QRectF transformedRect = poly.boundingRect();
        const QRectF limitRect = KisAlgebra2D::blowRect(converter->imageRectInImagePixels(), 2.0);
        if (!limitRect.contains(transformedRect)) {
            imageTooBig = true;
        }
    }
 
    // recalculate cached handles position
    recalculateTransformedHandles();
 
    Q_EMIT q->requestShowImageTooBig(imageTooBig);
    Q_EMIT q->requestImageRecalculation();
}

References KisAlgebra2D::blowRect(), KisAlgebra2D::isPolygonTrulyConvex(), and MaxPolygonVertexAngle.

◆ recalculateTransformedHandles()

void KisPerspectiveTransformStrategy::Private::recalculateTransformedHandles ( )

Definition at line 133 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 465 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 412 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));
}