KisPerspectiveTransformStrategy Class Reference

#include <kis_perspective_transform_strategy.h>

Inheritance diagram for KisPerspectiveTransformStrategy:

Classes
struct	Private

Signals
void	requestCanvasUpdate ()
void	requestImageRecalculation ()
void	requestShowImageTooBig (bool value)

Public Member Functions
bool	beginPrimaryAction (const QPointF &pt) override
virtual bool	beginPrimaryAction (KoPointerEvent *event)=0
void	continuePrimaryAction (const QPointF &pt, bool shiftModifierActive, bool altModifierActive) override
virtual void	continuePrimaryAction (KoPointerEvent *event)=0
bool	endPrimaryAction () override
virtual bool	endPrimaryAction (KoPointerEvent *event)=0
void	externalConfigChanged () override
QCursor	getCurrentCursor () const override
	KisPerspectiveTransformStrategy (const KisCoordinatesConverter *converter, KoSnapGuide *snapGuide, ToolTransformArgs &currentArgs, TransformTransactionProperties &transaction)
void	paint (QPainter &gc) override
void	setTransformFunction (const QPointF &mousePos, bool perspectiveModifierActive, bool shiftModifierActive, bool altModifierActive) override
	~KisPerspectiveTransformStrategy () override
Public Member Functions inherited from KisSimplifiedActionPolicyStrategy
void	activateAlternateAction (KisTool::AlternateAction action) override
void	activatePrimaryAction () override
bool	beginAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
bool	beginPrimaryAction (KoPointerEvent *event) override
void	continueAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
void	continuePrimaryAction (KoPointerEvent *event) override
void	deactivateAlternateAction (KisTool::AlternateAction action) override
bool	endAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
bool	endPrimaryAction (KoPointerEvent *event) override
virtual QPointF	handleSnapPoint (const QPointF &imagePos)
void	hoverActionCommon (KoPointerEvent *event) override
	KisSimplifiedActionPolicyStrategy (const KisCoordinatesConverter *_converter, KoSnapGuide *snapGuide=0)
	~KisSimplifiedActionPolicyStrategy () override
Public Member Functions inherited from KisTransformStrategyBase
virtual bool	acceptsClicks () const
virtual void	deactivatePrimaryAction ()
virtual int	decorationThickness () const
virtual QPainterPath	getCursorOutline () const
	KisTransformStrategyBase ()
QImage	originalImage () const
virtual void	setDecorationThickness (int thickness)
void	setThumbnailImage (const QImage &image, QTransform thumbToImageTransform)
QTransform	thumbToImageTransform () const
	~KisTransformStrategyBase () override

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
Protected Member Functions inherited from KisSimplifiedActionPolicyStrategy
virtual void	hoverActionCommon (const QPointF &pt)
virtual bool	shiftModifierIsUsed () const

Detailed Description

Definition at line 22 of file kis_perspective_transform_strategy.h.

Constructor & Destructor Documentation

KisPerspectiveTransformStrategy()

KisPerspectiveTransformStrategy::KisPerspectiveTransformStrategy	(	const KisCoordinatesConverter *	converter,
		KoSnapGuide *	snapGuide,
		ToolTransformArgs &	currentArgs,
		TransformTransactionProperties &	transaction )

Definition at line 117 of file kis_perspective_transform_strategy.cpp.

    : KisSimplifiedActionPolicyStrategy(converter, snapGuide),
      m_d(new Private(this, converter, currentArgs, transaction))
{
}

~KisPerspectiveTransformStrategy()

KisPerspectiveTransformStrategy::~KisPerspectiveTransformStrategy ( )

override

Definition at line 126 of file kis_perspective_transform_strategy.cpp.

{
}

Member Function Documentation

beginPrimaryAction() [1/2]

bool KisPerspectiveTransformStrategy::beginPrimaryAction ( const QPointF & pt )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 328 of file kis_perspective_transform_strategy.cpp.

{
    Q_UNUSED(pt);
 
    if (m_d->function == NONE) return false;
 
    m_d->clickPos = pt;
    m_d->clickArgs = m_d->currentArgs;
 
    return true;
}

References m_d, and NONE.

beginPrimaryAction() [2/2]

virtual bool KisTransformStrategyBase::beginPrimaryAction ( KoPointerEvent * event )

virtual

Implements KisTransformStrategyBase.

continuePrimaryAction() [1/2]

void KisPerspectiveTransformStrategy::continuePrimaryAction ( const QPointF & pt, bool shiftModifierActive, bool altModifierActive )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 478 of file kis_perspective_transform_strategy.cpp.

{
    Q_UNUSED(shiftModifierActive);
    Q_UNUSED(altModifierActive);
 
    m_d->isTransforming = true;
 
    switch (m_d->function) {
    case NONE:
        break;
    case MOVE: {
        QPointF diff = mousePos - m_d->clickPos;
        m_d->currentArgs.setTransformedCenter(
            m_d->clickArgs.transformedCenter() + diff);
        break;
    }
    case DRAG_HANDLE: {
        KIS_ASSERT_RECOVER_RETURN(m_d->currentDraggingHandlePoint >= 0);
        KIS_ASSERT_RECOVER_RETURN(m_d->currentDraggingHandlePoint < HANDLE_COUNT);
        if (m_d->currentDraggingHandlePoint < HANDLE_MIDDLE_TOP) {
            // Corner point, transform directly.
            m_d->dstHandlePoints[m_d->currentDraggingHandlePoint] = mousePos;
        } else {
            // Middle point, move adjacent corners.
            QPointF delta = mousePos - m_d->dstHandlePoints[m_d->currentDraggingHandlePoint];
            switch(m_d->currentDraggingHandlePoint) {
            case HANDLE_MIDDLE_TOP:
                m_d->dstHandlePoints[HANDLE_TOP_LEFT] += delta;
                m_d->dstHandlePoints[HANDLE_TOP_RIGHT] += delta;
                break;
            case HANDLE_MIDDLE_BOTTOM:
                m_d->dstHandlePoints[HANDLE_BOTTOM_LEFT] += delta;
                m_d->dstHandlePoints[HANDLE_BOTTOM_RIGHT] += delta;
                break;
            case HANDLE_MIDDLE_LEFT:
                m_d->dstHandlePoints[HANDLE_TOP_LEFT] += delta;
                m_d->dstHandlePoints[HANDLE_BOTTOM_LEFT] += delta;
                break;
            case HANDLE_MIDDLE_RIGHT:
                m_d->dstHandlePoints[HANDLE_TOP_RIGHT] += delta;
                m_d->dstHandlePoints[HANDLE_BOTTOM_RIGHT] += delta;
                break;
            }
        }
 
        Eigen::Matrix3f A = getTransitionMatrix(m_d->srcHandlePoints);
        Eigen::Matrix3f B = getTransitionMatrix(m_d->dstHandlePoints);
        Eigen::Matrix3f result = B * A.inverse();
 
        m_d->transformIntoArgs(result);
 
        break;
    }
    case DRAG_X_VANISHING_POINT:
    case DRAG_Y_VANISHING_POINT: {
 
        QMatrix4x4 m(m_d->transform);
 
        QPointF tl = m_d->transaction.originalTopLeft();
        QPointF tr = m_d->transaction.originalTopRight();
        QPointF bl = m_d->transaction.originalBottomLeft();
        QPointF br = m_d->transaction.originalBottomRight();
 
        QVector4D v(1,0,0,0);
        QVector4D otherV(0,1,0,0);
 
        if (m_d->function == DRAG_X_VANISHING_POINT) {
            v = QVector4D(1,0,0,0);
            otherV = QVector4D(0,1,0,0);
        } else {
            v = QVector4D(0,1,0,0);
            otherV = QVector4D(1,0,0,0);
        }
 
        QPointF tl_dst = toQPointF(m * fromQPointF(tl));
        QPointF tr_dst = toQPointF(m * fromQPointF(tr));
        QPointF bl_dst = toQPointF(m * fromQPointF(bl));
        QPointF br_dst = toQPointF(m * fromQPointF(br));
        QPointF v_dst = toQPointF(m * v);
        QPointF otherV_dst = toQPointF(m * otherV);
 
        QVector<QPointF> srcPoints;
        QVector<QPointF> dstPoints;
 
        QPointF far1_src;
        QPointF far2_src;
        QPointF near1_src;
        QPointF near2_src;
 
        QPointF far1_dst;
        QPointF far2_dst;
        QPointF near1_dst;
        QPointF near2_dst;
 
        if (m_d->function == DRAG_X_VANISHING_POINT) {
 
            // topLeft (far) --- topRight (near) --- vanishing
            if (kisSquareDistance(v_dst, tl_dst) > kisSquareDistance(v_dst, tr_dst)) {
                far1_src = tl;
                far2_src = bl;
                near1_src = tr;
                near2_src = br;
 
                far1_dst = tl_dst;
                far2_dst = bl_dst;
                near1_dst = tr_dst;
                near2_dst = br_dst;
 
                // topRight (far) --- topLeft (near) --- vanishing
            } else {
                far1_src = tr;
                far2_src = br;
                near1_src = tl;
                near2_src = bl;
 
                far1_dst = tr_dst;
                far2_dst = br_dst;
                near1_dst = tl_dst;
                near2_dst = bl_dst;
            }
 
        } else /* if (m_d->function == DRAG_Y_VANISHING_POINT) */{
            // topLeft (far) --- bottomLeft (near) --- vanishing
            if (kisSquareDistance(v_dst, tl_dst) > kisSquareDistance(v_dst, bl_dst)) {
                far1_src = tl;
                far2_src = tr;
                near1_src = bl;
                near2_src = br;
 
                far1_dst = tl_dst;
                far2_dst = tr_dst;
                near1_dst = bl_dst;
                near2_dst = br_dst;
 
                // bottomLeft (far) --- topLeft (near) --- vanishing
            } else {
                far1_src = bl;
                far2_src = br;
                near1_src = tl;
                near2_src = tr;
 
                far1_dst = bl_dst;
                far2_dst = br_dst;
                near1_dst = tl_dst;
                near2_dst = tr_dst;
            }
        }
 
        QLineF l0(far1_dst, mousePos);
        QLineF l1(far2_dst, mousePos);
        QLineF l2(otherV_dst, near1_dst);
        l0.intersects(l2, &near1_dst);
        l1.intersects(l2, &near2_dst);
 
        srcPoints << far1_src;
        srcPoints << far2_src;
        srcPoints << near1_src;
        srcPoints << near2_src;
 
        dstPoints << far1_dst;
        dstPoints << far2_dst;
        dstPoints << near1_dst;
        dstPoints << near2_dst;
 
        Eigen::Matrix3f A = getTransitionMatrix(srcPoints);
        Eigen::Matrix3f B = getTransitionMatrix(dstPoints);
        Eigen::Matrix3f result = B * A.inverse();
 
        m_d->transformIntoArgs(result);
        break;
    }
    }
 
    m_d->recalculateTransformations();
}

References A, B, fromQPointF(), getTransitionMatrix(), KIS_ASSERT_RECOVER_RETURN, kisSquareDistance(), m_d, MOVE, NONE, toQPointF(), and v.

continuePrimaryAction() [2/2]

virtual void KisTransformStrategyBase::continuePrimaryAction ( KoPointerEvent * event )

virtual

Implements KisTransformStrategyBase.

endPrimaryAction() [1/2]

bool KisPerspectiveTransformStrategy::endPrimaryAction ( )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 654 of file kis_perspective_transform_strategy.cpp.

{
    bool shouldSave = !m_d->imageTooBig;
    m_d->isTransforming = false;
 
    if (m_d->imageTooBig) {
        m_d->currentArgs = m_d->clickArgs;
        m_d->recalculateTransformations();
    }
 
    return shouldSave;
}

References m_d.

endPrimaryAction() [2/2]

virtual bool KisTransformStrategyBase::endPrimaryAction ( KoPointerEvent * event )

virtual

Implements KisTransformStrategyBase.

externalConfigChanged()

void KisPerspectiveTransformStrategy::externalConfigChanged ( )

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 323 of file kis_perspective_transform_strategy.cpp.

{
    m_d->recalculateTransformations();
}

References m_d.

getCurrentCursor()

QCursor KisPerspectiveTransformStrategy::getCurrentCursor ( ) const

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 196 of file kis_perspective_transform_strategy.cpp.

{
    QCursor cursor;
 
    switch (m_d->function) {
    case NONE:
        cursor = KisCursor::arrowCursor();
        break;
    case MOVE:
        cursor = KisCursor::moveCursor();
        break;
    case DRAG_HANDLE:
    case DRAG_X_VANISHING_POINT:
    case DRAG_Y_VANISHING_POINT:
        cursor = KisCursor::pointingHandCursor();
        break;
    }
 
    return cursor;
}

References KisCursor::arrowCursor(), m_d, MOVE, KisCursor::moveCursor(), NONE, and KisCursor::pointingHandCursor().

paint()

void KisPerspectiveTransformStrategy::paint ( QPainter & gc )

overridevirtual

WARNING: we cannot install a transform to paint the handles here!

There is a bug in Qt that prevents painting of cosmetic-pen brushes in openGL mode when a TxProject matrix is active on a QPainter. So just convert it manually.

https://bugreports.qt-project.org/browse/QTBUG-42658

Implements KisTransformStrategyBase.

Definition at line 217 of file kis_perspective_transform_strategy.cpp.

{
    gc.save();
 
    gc.setOpacity(m_d->transaction.basePreviewOpacity());
    gc.setTransform(m_d->paintingTransform, true);
    gc.drawImage(m_d->paintingOffset, originalImage());
 
    gc.restore();
 
    // Draw Handles
    QPainterPath handles;
 
    handles.moveTo(m_d->transaction.originalTopLeft());
    handles.lineTo(m_d->transaction.originalTopRight());
    handles.lineTo(m_d->transaction.originalBottomRight());
    handles.lineTo(m_d->transaction.originalBottomLeft());
    handles.lineTo(m_d->transaction.originalTopLeft());
 
 
    auto addHandleRectFunc =
        [&](const QPointF &pt) {
            handles.addRect(
                KisTransformUtils::handleRect(KisTransformUtils::handleVisualRadius,
                                              m_d->handlesTransform,
                                              m_d->transaction.originalRect(), pt)
                .translated(pt));
    };
 
    addHandleRectFunc(m_d->transaction.originalTopLeft());
    addHandleRectFunc(m_d->transaction.originalTopRight());
    addHandleRectFunc(m_d->transaction.originalBottomLeft());
    addHandleRectFunc(m_d->transaction.originalBottomRight());
    addHandleRectFunc(m_d->transaction.originalMiddleTop());
    addHandleRectFunc(m_d->transaction.originalMiddleBottom());
    addHandleRectFunc(m_d->transaction.originalMiddleLeft());
    addHandleRectFunc(m_d->transaction.originalMiddleRight());
 
    gc.save();
 
    if (m_d->isTransforming) {
        gc.setOpacity(0.1);
    }
 
    //gc.setTransform(m_d->handlesTransform, true); <-- don't do like this!
 
    QPainterPath mappedHandles = m_d->handlesTransform.map(handles);
 
    QPen pen[2];
    pen[0].setWidth(decorationThickness());
    pen[0].setCosmetic(true);
    pen[1].setWidth(decorationThickness() * 2);
    pen[1].setCosmetic(true);
    pen[1].setColor(Qt::lightGray);
 
    for (int i = 1; i >= 0; --i) {
        gc.setPen(pen[i]);
        gc.drawPath(mappedHandles);
    }
 
    gc.restore();
 
    { // painting perspective handles
        QPainterPath perspectiveHandles;
 
        QRectF handleRect =
            KisTransformUtils::handleRect(KisTransformUtils::handleVisualRadius,
                                          QTransform(),
                                          m_d->transaction.originalRect(), 0, 0);
 
        if (m_d->transformedHandles.xVanishingExists) {
            QRectF rc = handleRect.translated(m_d->transformedHandles.xVanishing);
            perspectiveHandles.addEllipse(rc);
        }
 
        if (m_d->transformedHandles.yVanishingExists) {
            QRectF rc = handleRect.translated(m_d->transformedHandles.yVanishing);
            perspectiveHandles.addEllipse(rc);
        }
 
        if (!perspectiveHandles.isEmpty()) {
            gc.save();
            gc.setTransform(m_d->converter->imageToWidgetTransform());
 
            gc.setBrush(Qt::red);
 
            for (int i = 1; i >= 0; --i) {
                gc.setPen(pen[i]);
                gc.drawPath(perspectiveHandles);
            }
 
            gc.restore();
        }
    }
}

References KisTransformStrategyBase::decorationThickness(), KisTransformUtils::handleRect(), KisTransformUtils::handleVisualRadius, m_d, and KisTransformStrategyBase::originalImage().

requestCanvasUpdate

void KisPerspectiveTransformStrategy::requestCanvasUpdate ( )

signal

requestImageRecalculation

void KisPerspectiveTransformStrategy::requestImageRecalculation ( )

signal

requestShowImageTooBig

void KisPerspectiveTransformStrategy::requestShowImageTooBig ( bool value )

signal

setTransformFunction()

void KisPerspectiveTransformStrategy::setTransformFunction ( const QPointF & mousePos, bool perspectiveModifierActive, bool shiftModifierActive, bool altModifierActive )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 161 of file kis_perspective_transform_strategy.cpp.

{
    Q_UNUSED(perspectiveModifierActive);
    Q_UNUSED(shiftModifierActive);
    Q_UNUSED(altModifierActive);
 
    QPolygonF transformedPolygon = m_d->transform.map(QPolygonF(m_d->transaction.originalRect()));
    StrokeFunction defaultFunction = transformedPolygon.containsPoint(mousePos, Qt::OddEvenFill) ? MOVE : NONE;
    KisTransformUtils::HandleChooser<StrokeFunction>
        handleChooser(mousePos, defaultFunction);
 
    qreal handleRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
 
    if (!m_d->transformedHandles.xVanishing.isNull()) {
        handleChooser.addFunction(m_d->transformedHandles.xVanishing,
                                  handleRadius, DRAG_X_VANISHING_POINT);
    }
 
    if (!m_d->transformedHandles.yVanishing.isNull()) {
        handleChooser.addFunction(m_d->transformedHandles.yVanishing,
                                  handleRadius, DRAG_Y_VANISHING_POINT);
    }
 
    m_d->currentDraggingHandlePoint = -1;
    for (int i = 0; i < m_d->dstHandlePoints.size(); i++) {
        if (handleChooser.addFunction(m_d->dstHandlePoints[i],
                                      handleRadius, DRAG_HANDLE)) {
 
            m_d->currentDraggingHandlePoint = i;
        }
    }
 
    m_d->function = handleChooser.function();
}

References KisTransformUtils::HandleChooser< Function >::addFunction(), KisTransformUtils::effectiveHandleGrabRadius(), KisTransformUtils::HandleChooser< Function >::function(), m_d, MOVE, and NONE.

Member Data Documentation

m_d

const QScopedPointer<Private> KisPerspectiveTransformStrategy::m_d

private

Definition at line 53 of file kis_perspective_transform_strategy.h.

---

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

• plugins/tools/tool_transform2/kis_perspective_transform_strategy.h
• plugins/tools/tool_transform2/kis_perspective_transform_strategy.cpp