Public Types
enum	Mode { OVER_POINT = 0 , OVER_POINT_SYMMETRIC , OVER_NODE , OVER_NODE_WHOLE_LINE , OVER_SEGMENT , OVER_SEGMENT_SYMMETRIC , OVER_PATCH , OVER_PATCH_LOCKED , SPLIT_SEGMENT , MULTIPLE_POINT_SELECTION , MOVE_MODE , ROTATE_MODE , SCALE_MODE , NOTHING }

Public Member Functions
QTransform	imageToThumb (bool useFlakeOptimization)

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

void	recalculateTransformations ()

Public Attributes
const KisCoordinatesConverter *	converter

ToolTransformArgs &	currentArgs

boost::optional< KisBezierTransformMesh::ControlPointIndex >	hoveredControl

QPointF	hoveredHandleOffset

boost::optional< KisBezierTransformMesh::PatchIndex >	hoveredPatch

boost::optional< KisBezierTransformMesh::SegmentIndex >	hoveredSegment

KisBezierTransformMesh	initialMeshState

QPointF	initialRotationCenter

qreal	initialSelectionMaxDimension = 0.0

QSize	lastMeshSize

QPointF	lastMousePos

QPointF	localPatchPosition

qreal	localSegmentPosition = 0.0

Mode	mode = NOTHING

QPointF	mouseClickPos

QPointF	paintingOffset

QTransform	paintingTransform

bool	pointWasDragged = false

KisMeshTransformStrategy *const	q

KisSignalCompressor	recalculateSignalCompressor

QSet< KisBezierTransformMesh::NodeIndex >	selectedNodes

TransformTransactionProperties &	transaction

QImage	transformedImage

Detailed Description

Definition at line 27 of file kis_mesh_transform_strategy.cpp.

Member Enumeration Documentation

◆ Mode

enum KisMeshTransformStrategy::Private::Mode

Enumerator
OVER_POINT
OVER_POINT_SYMMETRIC
OVER_NODE
OVER_NODE_WHOLE_LINE
OVER_SEGMENT
OVER_SEGMENT_SYMMETRIC
OVER_PATCH
OVER_PATCH_LOCKED
SPLIT_SEGMENT
MULTIPLE_POINT_SELECTION
MOVE_MODE
ROTATE_MODE
SCALE_MODE
NOTHING

Definition at line 43 of file kis_mesh_transform_strategy.cpp.

              {
        OVER_POINT = 0,
        OVER_POINT_SYMMETRIC,
        OVER_NODE,
        OVER_NODE_WHOLE_LINE,
        OVER_SEGMENT,
        OVER_SEGMENT_SYMMETRIC,
        OVER_PATCH,
        OVER_PATCH_LOCKED,
        SPLIT_SEGMENT,
        MULTIPLE_POINT_SELECTION,
        MOVE_MODE,
        ROTATE_MODE,
        SCALE_MODE,
        NOTHING
    };

Constructor & Destructor Documentation

◆ Private()

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

inline

Definition at line 29 of file kis_mesh_transform_strategy.cpp.

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

Member Function Documentation

◆ imageToThumb()

QTransform KisMeshTransformStrategy::Private::imageToThumb ( bool useFlakeOptimization )

Definition at line 807 of file kis_mesh_transform_strategy.cpp.

{
    return useFlakeOptimization ?
        converter->documentToFlakeTransform() * converter->imageToDocumentTransform() :
        q->thumbToImageTransform().inverted();
}

References converter, KisCoordinatesConverter::documentToFlakeTransform(), KisCoordinatesConverter::imageToDocumentTransform(), q, and KisTransformStrategyBase::thumbToImageTransform().

◆ recalculateTransformations()

void KisMeshTransformStrategy::Private::recalculateTransformations ( )

Definition at line 814 of file kis_mesh_transform_strategy.cpp.

{
    const QTransform scaleTransform = KisTransformUtils::imageToFlakeTransform(converter);
 
    const QTransform resultThumbTransform = q->thumbToImageTransform() * scaleTransform;
    const qreal scale = KisTransformUtils::scaleFromAffineMatrix(resultThumbTransform);
    const bool useFlakeOptimization = scale < 1.0 &&
        !KisTransformUtils::thumbnailTooSmall(resultThumbTransform, q->originalImage().rect());
 
    const QTransform imageToThumb = this->imageToThumb(useFlakeOptimization);
    KIS_SAFE_ASSERT_RECOVER_RETURN(imageToThumb.type() <= QTransform::TxScale);
 
    KisBezierTransformMesh mesh(*currentArgs.meshTransform());
    mesh.transformSrcAndDst(imageToThumb);
 
    paintingOffset = transaction.originalTopLeft();
 
    if (!q->originalImage().isNull()) {
        const QPointF origTLInFlake = imageToThumb.map(transaction.originalTopLeft());
        if (useFlakeOptimization) {
            transformedImage = q->originalImage().transformed(resultThumbTransform);
            paintingTransform = QTransform();
        } else {
            transformedImage = q->originalImage();
            paintingTransform = resultThumbTransform;
 
        }
 
        const QRect dstImageRect = mesh.dstBoundingRect().toAlignedRect();
        QImage dstImage(dstImageRect.size(), transformedImage.format());
        dstImage.fill(0);
 
        mesh.transformMesh(origTLInFlake.toPoint(), transformedImage,
                           dstImageRect.topLeft(), &dstImage);
 
        transformedImage = dstImage;
        paintingOffset = dstImageRect.topLeft();
 
    } else {
        transformedImage = q->originalImage();
        paintingOffset = imageToThumb.map(transaction.originalTopLeft());
        paintingTransform = resultThumbTransform;
    }
 
    Q_EMIT q->requestCanvasUpdate();
    Q_EMIT q->requestImageRecalculation();
}