Public Types
enum	Mode { OVER_POINT = 0 , MULTIPLE_POINT_SELECTION , MOVE_MODE , ROTATE_MODE , SCALE_MODE , NOTHING }

Public Member Functions
QVector< QPointF * >	getSelectedPoints (QPointF *center, bool limitToSelectedOnly=false) const

QPointF	imageToThumb (const QPointF &pt, bool useFlakeOptimization)

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

void	recalculateTransformations ()

bool	shouldCloseTheCage () const

Public Attributes
bool	clipOriginalPointsPosition {true}

bool	closeOnStartPointClick {false}

const KisCoordinatesConverter *	converter {0}
	standard members ///

ToolTransformArgs &	currentArgs

bool	drawConnectionLines {false}

bool	drawOrigPoints {false}

bool	drawTransfPoints {true}

QTransform	handlesTransform

QPointF	lastMousePos

int	lastNumPoints {0}

Mode	mode {NOTHING}

QPointF	paintingOffset

QTransform	paintingTransform

int	pointIndexUnderCursor {0}

QPointF	pointPosOnClick

QVector< int >	pointsInAction

bool	pointWasDragged {false}

KisWarpTransformStrategy *const	q

KisSignalCompressor	recalculateSignalCompressor

TransformTransactionProperties &	transaction

QImage	transformedImage
	custom members ///

TransformType	transformType = TransformType::WARP_TRANSFORM

Detailed Description

Definition at line 27 of file kis_warp_transform_strategy.cpp.

Member Enumeration Documentation

◆ Mode

enum KisWarpTransformStrategy::Private::Mode

Enumerator
OVER_POINT
MULTIPLE_POINT_SELECTION
MOVE_MODE
ROTATE_MODE
SCALE_MODE
NOTHING

Definition at line 63 of file kis_warp_transform_strategy.cpp.

              {
        OVER_POINT = 0,
        MULTIPLE_POINT_SELECTION,
        MOVE_MODE,
        ROTATE_MODE,
        SCALE_MODE,
        NOTHING
    };

Constructor & Destructor Documentation

◆ Private()

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

inline

Definition at line 29 of file kis_warp_transform_strategy.cpp.

        : q(_q),
          converter(_converter),
          currentArgs(_currentArgs),
          transaction(_transaction),
          recalculateSignalCompressor(40, KisSignalCompressor::FIRST_ACTIVE)
    {
    }

Member Function Documentation

◆ getSelectedPoints()

QVector< QPointF * > KisWarpTransformStrategy::Private::getSelectedPoints	(	QPointF *	center,
		bool	limitToSelectedOnly = false ) const

Definition at line 429 of file kis_warp_transform_strategy.cpp.

{
    QVector<QPointF> &points = currentArgs.refTransformedPoints();
 
    QRectF boundingRect;
    QVector<QPointF*> selectedPoints;
    if (limitToSelectedOnly || pointsInAction.size() > 1) {
        Q_FOREACH (int index, pointsInAction) {
            selectedPoints << &points[index];
            KisAlgebra2D::accumulateBounds(points[index], &boundingRect);
        }
    } else {
        QVector<QPointF>::iterator it = points.begin();
        QVector<QPointF>::iterator end = points.end();
        for (; it != end; ++it) {
            selectedPoints << &(*it);
            KisAlgebra2D::accumulateBounds(*it, &boundingRect);
        }
    }
 
    *center = boundingRect.center();
    return selectedPoints;
}

References KisAlgebra2D::accumulateBounds(), currentArgs, pointsInAction, and ToolTransformArgs::refTransformedPoints().

◆ imageToThumb()

QPointF KisWarpTransformStrategy::Private::imageToThumb	(	const QPointF &	pt,
		bool	useFlakeOptimization )

inline

Definition at line 572 of file kis_warp_transform_strategy.cpp.

{
    return useFlakeOptimization ? converter->imageToDocument(converter->documentToFlake((pt))) : q->thumbToImageTransform().inverted().map(pt);
}

◆ recalculateTransformations()

void KisWarpTransformStrategy::Private::recalculateTransformations ( )

Definition at line 577 of file kis_warp_transform_strategy.cpp.

{
    QTransform scaleTransform = KisTransformUtils::imageToFlakeTransform(converter);
 
    QTransform resultThumbTransform = q->thumbToImageTransform() * scaleTransform;
    qreal scale = KisTransformUtils::scaleFromAffineMatrix(resultThumbTransform);
    bool useFlakeOptimization = scale < 1.0 &&
        !KisTransformUtils::thumbnailTooSmall(resultThumbTransform, q->originalImage().rect());
 
    QVector<QPointF> thumbOrigPoints(currentArgs.numPoints());
    QVector<QPointF> thumbTransfPoints(currentArgs.numPoints());
 
    for (int i = 0; i < currentArgs.numPoints(); ++i) {
        thumbOrigPoints[i] = imageToThumb(currentArgs.origPoints()[i], useFlakeOptimization);
        thumbTransfPoints[i] = imageToThumb(currentArgs.transfPoints()[i], useFlakeOptimization);
    }
 
    paintingOffset = transaction.originalTopLeft();
 
    if (!q->originalImage().isNull() && !currentArgs.isEditingTransformPoints()) {
        QPointF origTLInFlake = imageToThumb(transaction.originalTopLeft(), useFlakeOptimization);
 
        if (useFlakeOptimization) {
            transformedImage = q->originalImage().transformed(resultThumbTransform);
            paintingTransform = QTransform();
        } else {
            transformedImage = q->originalImage();
            paintingTransform = resultThumbTransform;
 
        }
 
        transformedImage = q->calculateTransformedImage(currentArgs,
                                                        transformedImage,
                                                        thumbOrigPoints,
                                                        thumbTransfPoints,
                                                        origTLInFlake,
                                                        &paintingOffset);
    } else {
        transformedImage = q->originalImage();
        paintingOffset = imageToThumb(transaction.originalTopLeft(), false);
        paintingTransform = resultThumbTransform;
    }
 
    handlesTransform = scaleTransform;
    Q_EMIT q->requestCanvasUpdate();
    Q_EMIT q->requestImageRecalculation();
}

References KisTransformUtils::imageToFlakeTransform(), KisTransformUtils::scaleFromAffineMatrix(), and KisTransformUtils::thumbnailTooSmall().

◆ shouldCloseTheCage()

bool KisWarpTransformStrategy::Private::shouldCloseTheCage ( ) const

Definition at line 548 of file kis_warp_transform_strategy.cpp.

{
    return currentArgs.isEditingTransformPoints() &&
        closeOnStartPointClick &&
        pointIndexUnderCursor == 0 &&
        currentArgs.origPoints().size() > 2 &&
        !pointWasDragged;
}