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, const KoColorDisplayRendererInterface *displayRendererInterface) 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 void	decreaseBrushSize (KoCanvasBase *canvas)
virtual QPainterPath	getCursorOutline () const
virtual void	increaseBrushSize (KoCanvasBase *canvas)
	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	continuePrimaryAction (const QPointF &pt, bool shiftModifierActive, bool altModifierActive, bool hasOriginalModifiersSet)
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 120 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 129 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 331 of file kis_perspective_transform_strategy.cpp.

{
    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 479 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();
 
        // Points in dstHandlePoints are not arranged in an organized way, so if we used it directly as a polygon it
        // will never be considered convex
        QPolygonF poly;
        poly << m_d->dstHandlePoints[HANDLE_TOP_LEFT] << m_d->dstHandlePoints[HANDLE_TOP_RIGHT]
             << m_d->dstHandlePoints[HANDLE_BOTTOM_RIGHT] << m_d->dstHandlePoints[HANDLE_BOTTOM_LEFT];
 
        //Don't apply the handle movement if it makes the transform area not convex
        if (!KisAlgebra2D::isPolygonTrulyConvex(poly, true, Private::MaxPolygonVertexAngle)) {
            break;
        }
 
        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(), KisAlgebra2D::isPolygonTrulyConvex(), KIS_ASSERT_RECOVER_RETURN, kisSquareDistance(), m_d, KisPerspectiveTransformStrategy::Private::MaxPolygonVertexAngle, 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 666 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 326 of file kis_perspective_transform_strategy.cpp.

{
    m_d->recalculateTransformations();
}

References m_d.

getCurrentCursor()

QCursor KisPerspectiveTransformStrategy::getCurrentCursor ( ) const

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 199 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, const KoColorDisplayRendererInterface * displayRendererInterface )

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 220 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(displayRendererInterface->convertColorToDisplayColorSpace(KoColor(Qt::lightGray, KoColorSpaceRegistry::instance()->rgb8())));
 
    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 KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), KisTransformStrategyBase::decorationThickness(), KisTransformUtils::handleRect(), KisTransformUtils::handleVisualRadius, KoColorSpaceRegistry::instance(), 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 164 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