#include <tool_transform_args.h>

Inheritance diagram for ToolTransformArgs:

Public Types
enum	TransformMode { FREE_TRANSFORM = 0 , WARP , CAGE , LIQUIFY , PERSPECTIVE_4POINT , MESH , N_MODES }

Public Member Functions
double	alpha () const

double	aX () const

double	aY () const

double	aZ () const

double	boundsRotation () const

QVector3D	cameraPos () const

KisToolChangesTrackerData *	clone () const override

const ToolTransformArgs *	continuedTransform () const

bool	defaultPoints () const

KisPaintDeviceSP	externalSource () const

KisFilterStrategy *	filter () const

QString	filterId () const

QTransform	flattenedPerspectiveTransform () const

void	initLiquifyTransformMode (const QRect &srcRect)

bool	isEditingTransformPoints () const

bool	isIdentity () const

bool	isSameMode (const ToolTransformArgs &other) const

bool	isUnchanging () const

bool	keepAspectRatio () const

KisLiquifyProperties *	liquifyProperties ()

const KisLiquifyProperties *	liquifyProperties () const

KisLiquifyTransformWorker *	liquifyWorker () const

bool	meshScaleHandles () const

bool	meshShowHandles () const

bool	meshSymmetricalHandles () const

KisBezierTransformMesh *	meshTransform ()

const KisBezierTransformMesh *	meshTransform () const

TransformMode	mode () const

int	numPoints () const

ToolTransformArgs &	operator= (const ToolTransformArgs &args)

bool	operator== (const ToolTransformArgs &other) const

QPointF	originalCenter () const

QPointF &	origPoint (int i)

const QVector< QPointF > &	origPoints () const

int	pixelPrecision () const

int	previewPixelPrecision () const

QVector< QPointF > &	refOriginalPoints ()

QVector< QPointF > &	refTransformedPoints ()

void	restoreContinuedState ()

QPointF	rotationCenterOffset () const

void	saveContinuedState ()

void	saveLiquifyTransformMode () const

void	scale3dSrcAndDst (qreal scale)

double	scaleX () const

double	scaleY () const

void	setAlpha (double alpha)

void	setAX (double aX)

void	setAY (double aY)

void	setAZ (double aZ)

void	setBoundsRotation (double boundsRotation)

void	setCameraPos (const QVector3D &pos)

void	setDefaultPoints (bool defaultPoints)

void	setEditingTransformPoints (bool value)

void	setExternalSource (KisPaintDeviceSP externalSource)

void	setFilterId (const QString &id)

void	setFlattenedPerspectiveTransform (const QTransform &value)

void	setKeepAspectRatio (bool value)

void	setMeshScaleHandles (bool meshScaleHandles)

void	setMeshShowHandles (bool value)

void	setMeshSymmetricalHandles (bool meshSymmetricalHandles)

void	setMode (TransformMode mode)

void	setOriginalCenter (QPointF originalCenter)

void	setPixelPrecision (int precision)

void	setPoints (QVector< QPointF > origPoints, QVector< QPointF > transfPoints)

void	setPreviewPixelPrecision (int precision)

void	setRotationCenterOffset (QPointF rotationCenterOffset)

void	setScaleX (double scaleX)

void	setScaleY (double scaleY)

void	setShearX (double shearX)

void	setShearY (double shearY)

void	setTransformAroundRotationCenter (bool value)

void	setTransformedCenter (QPointF transformedCenter)

void	setWarpCalculation (KisWarpTransformWorker::WarpCalculation warpCalc)

void	setWarpType (KisWarpTransformWorker::WarpType warpType)

double	shearX () const

double	shearY () const

	ToolTransformArgs ()

	ToolTransformArgs (const ToolTransformArgs &args)

	ToolTransformArgs (TransformMode mode, QPointF transformedCenter, QPointF originalCenter, QPointF rotationCenterOffset, bool transformAroundRotationCenter, double aX, double aY, double aZ, double scaleX, double scaleY, double shearX, double shearY, double boundsRotation, KisWarpTransformWorker::WarpType warpType, double alpha, bool defaultPoints, const QString &filterId, int pixelPrecision, int previewPixelPrecision, KisPaintDeviceSP externalSource)

void	toXML (QDomElement *e) const

bool	transformAroundRotationCenter () const

QPointF	transformedCenter () const

void	transformSrcAndDst (const QTransform &t)

QPointF &	transfPoint (int i)

const QVector< QPointF > &	transfPoints () const

void	translateDstSpace (const QPointF &offset)

void	translateSrcAndDst (const QPointF &offset)

KisWarpTransformWorker::WarpCalculation	warpCalculation ()

KisWarpTransformWorker::WarpType	warpType () const

	~ToolTransformArgs ()

Public Member Functions inherited from KisToolChangesTrackerData
virtual	~KisToolChangesTrackerData ()

Static Public Member Functions
static ToolTransformArgs	fromXML (const QDomElement &e)

Private Member Functions
void	clear ()

void	init (const ToolTransformArgs &args)

Private Attributes
double	m_alpha {1.0}

double	m_aX {0}

double	m_aY {0}

double	m_aZ {0}

double	m_boundsRotation {0.0}

QVector3D	m_cameraPos {QVector3D(0,0,1024)}

QScopedPointer< ToolTransformArgs >	m_continuedTransformation

bool	m_defaultPoints {true}

bool	m_editTransformPoints {false}

KisPaintDeviceSP	m_externalSource

KisFilterStrategy *	m_filter {0}

QTransform	m_flattenedPerspectiveTransform

bool	m_keepAspectRatio {false}

QSharedPointer< KisLiquifyProperties >	m_liquifyProperties

QScopedPointer< KisLiquifyTransformWorker >	m_liquifyWorker

bool	m_meshScaleHandles = false

bool	m_meshShowHandles = true

bool	m_meshSymmetricalHandles = true

KisBezierTransformMesh	m_meshTransform

TransformMode	m_mode {ToolTransformArgs::TransformMode::FREE_TRANSFORM}

QPointF	m_originalCenter

QVector< QPointF >	m_origPoints

int	m_pixelPrecision {8}

int	m_previewPixelPrecision {16}

QPointF	m_rotationCenterOffset

double	m_scaleX {1.0}

double	m_scaleY {1.0}

double	m_shearX {0.0}

double	m_shearY {0.0}

bool	m_transformAroundRotationCenter {false}

QPointF	m_transformedCenter

QVector< QPointF >	m_transfPoints

KisWarpTransformWorker::WarpCalculation	m_warpCalculation {KisWarpTransformWorker::WarpCalculation::DRAW}

KisWarpTransformWorker::WarpType	m_warpType {KisWarpTransformWorker::WarpType_::RIGID_TRANSFORM}

Detailed Description

Class used to store the parameters of a transformation. Some parameters are specific to free transform mode, and others to warp mode : maybe add a union to save a little more memory.

Definition at line 34 of file tool_transform_args.h.

Member Enumeration Documentation

◆ TransformMode

enum ToolTransformArgs::TransformMode

Enumerator
FREE_TRANSFORM
WARP
CAGE
LIQUIFY
PERSPECTIVE_4POINT
MESH
N_MODES

Definition at line 37 of file tool_transform_args.h.

                       {FREE_TRANSFORM = 0,
                        WARP,
                        CAGE,
                        LIQUIFY,
                        PERSPECTIVE_4POINT,
                        MESH,
                        N_MODES};

Constructor & Destructor Documentation

◆ ToolTransformArgs() [1/3]

ToolTransformArgs::ToolTransformArgs ( )

Initializes the parameters for an identity transformation, with mode set to free transform.

Definition at line 22 of file tool_transform_args.cc.

    : m_liquifyProperties(new KisLiquifyProperties())
{
    KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
    QString savedFilterId = configGroup.readEntry("filterId", "Bicubic");
    setFilterId(savedFilterId);
    m_transformAroundRotationCenter = configGroup.readEntry("transformAroundRotationCenter", "0").toInt();
    m_meshShowHandles = configGroup.readEntry("meshShowHandles", true);
    m_meshSymmetricalHandles = configGroup.readEntry("meshSymmetricalHandles", true);
    m_meshScaleHandles = configGroup.readEntry("meshScaleHandles", false);
}

References m_meshScaleHandles, m_meshShowHandles, m_meshSymmetricalHandles, m_transformAroundRotationCenter, and setFilterId().

◆ ToolTransformArgs() [2/3]

ToolTransformArgs::ToolTransformArgs ( const ToolTransformArgs & args )

The object return will be a copy of args.

Definition at line 112 of file tool_transform_args.cc.

    : m_liquifyProperties(new KisLiquifyProperties(*args.m_liquifyProperties.data()))
{
    init(args);
}

References init().

◆ ToolTransformArgs() [3/3]

ToolTransformArgs::ToolTransformArgs	(	TransformMode	mode,
		QPointF	transformedCenter,
		QPointF	originalCenter,
		QPointF	rotationCenterOffset,
		bool	transformAroundRotationCenter,
		double	aX,
		double	aY,
		double	aZ,
		double	scaleX,
		double	scaleY,
		double	shearX,
		double	shearY,
		double	boundsRotation,
		KisWarpTransformWorker::WarpType	warpType,
		double	alpha,
		bool	defaultPoints,
		const QString &	filterId,
		int	pixelPrecision,
		int	previewPixelPrecision,
		KisPaintDeviceSP	externalSource )

If mode is warp, original and transformed vector points will be of size 0. Use setPoints method to set those vectors.

Definition at line 229 of file tool_transform_args.cc.

    : m_mode(mode)
    , m_defaultPoints(defaultPoints)
    , m_origPoints {QVector<QPointF>()}
    , m_transfPoints {QVector<QPointF>()}
    , m_warpType(warpType)
    , m_alpha(alpha)
    , m_transformedCenter(transformedCenter)
    , m_originalCenter(originalCenter)
    , m_rotationCenterOffset(rotationCenterOffset)
    , m_transformAroundRotationCenter(transformAroundRotationCenter)
    , m_aX(aX)
    , m_aY(aY)
    , m_aZ(aZ)
    , m_scaleX(scaleX)
    , m_scaleY(scaleY)
    , m_shearX(shearX)
    , m_shearY(shearY)
    , m_boundsRotation(boundsRotation)
    , m_liquifyProperties(new KisLiquifyProperties())
    , m_pixelPrecision(pixelPrecision)
    , m_previewPixelPrecision(previewPixelPrecision)
    , m_externalSource(externalSource)
{
    setFilterId(filterId);
}

References filterId(), and setFilterId().

◆ ~ToolTransformArgs()

ToolTransformArgs::~ToolTransformArgs ( )

Definition at line 271 of file tool_transform_args.cc.

{
    clear();
}

References clear().

Member Function Documentation

◆ alpha()

double ToolTransformArgs::alpha ( ) const

inline

Definition at line 141 of file tool_transform_args.h.

                                {
        return m_alpha;
    }

◆ aX()

double ToolTransformArgs::aX ( ) const

inline

Definition at line 181 of file tool_transform_args.h.

                             {
        return m_aX;
    }

◆ aY()

double ToolTransformArgs::aY ( ) const

inline

Definition at line 184 of file tool_transform_args.h.

                             {
        return m_aY;
    }

◆ aZ()

double ToolTransformArgs::aZ ( ) const

inline

Definition at line 187 of file tool_transform_args.h.

                             {
        return m_aZ;
    }

◆ boundsRotation()

double ToolTransformArgs::boundsRotation ( ) const

inline

Definition at line 208 of file tool_transform_args.h.

                                         {
        return m_boundsRotation;
    }

◆ cameraPos()

QVector3D ToolTransformArgs::cameraPos ( ) const

inline

Definition at line 190 of file tool_transform_args.h.

                                       {
        return m_cameraPos;
    }

◆ clear()

void ToolTransformArgs::clear ( )

private

Definition at line 105 of file tool_transform_args.cc.

{
    m_origPoints.clear();
    m_transfPoints.clear();
    m_meshTransform = KisBezierTransformMesh();
}

References m_meshTransform, m_origPoints, and m_transfPoints.

◆ clone()

KisToolChangesTrackerData * ToolTransformArgs::clone ( ) const

overridevirtual

Reimplemented from KisToolChangesTrackerData.

Definition at line 118 of file tool_transform_args.cc.

{
    return new ToolTransformArgs(*this);
}

References ToolTransformArgs().

◆ continuedTransform()

const ToolTransformArgs * ToolTransformArgs::continuedTransform ( ) const

Definition at line 575 of file tool_transform_args.cc.

{
    return m_continuedTransformation.data();
}

References m_continuedTransformation.

◆ defaultPoints()

bool ToolTransformArgs::defaultPoints ( ) const

inline

Definition at line 144 of file tool_transform_args.h.

                                      {
        return m_defaultPoints;
    }

◆ externalSource()

KisPaintDeviceSP ToolTransformArgs::externalSource ( ) const

inline

Definition at line 105 of file tool_transform_args.h.

                                                   {
        return m_externalSource;
    }

◆ filter()

KisFilterStrategy * ToolTransformArgs::filter ( ) const

inline

Definition at line 260 of file tool_transform_args.h.

                                             {
        return m_filter;
    }

◆ filterId()

QString ToolTransformArgs::filterId ( ) const

inline

Definition at line 254 of file tool_transform_args.h.

                                    {
        return m_filter->id();
    }

◆ flattenedPerspectiveTransform()

QTransform ToolTransformArgs::flattenedPerspectiveTransform ( ) const

inline

Definition at line 273 of file tool_transform_args.h.

                                                            {
        return m_flattenedPerspectiveTransform;
    }

◆ fromXML()

ToolTransformArgs ToolTransformArgs::fromXML ( const QDomElement & e )

static

Definition at line 443 of file tool_transform_args.cc.

{
    ToolTransformArgs args;
 
    int newMode = e.attribute("mode", "0").toInt();
    if (newMode < 0 || newMode >= N_MODES) return ToolTransformArgs();
 
    args.m_mode = (TransformMode) newMode;
 
    // reset explicitly
    args.m_editTransformPoints = false;
 
    bool result = false;
 
    if (args.m_mode == FREE_TRANSFORM || args.m_mode == PERSPECTIVE_4POINT) {
 
        QDomElement freeEl;
 
        QString filterId;
 
        result =
            KisDomUtils::findOnlyElement(e, "free_transform", &freeEl) &&
 
            KisDomUtils::loadValue(freeEl, "transformedCenter", &args.m_transformedCenter) &&
            KisDomUtils::loadValue(freeEl, "originalCenter", &args.m_originalCenter) &&
            KisDomUtils::loadValue(freeEl, "rotationCenterOffset", &args.m_rotationCenterOffset) &&
 
            KisDomUtils::loadValue(freeEl, "aX", &args.m_aX) &&
            KisDomUtils::loadValue(freeEl, "aY", &args.m_aY) &&
            KisDomUtils::loadValue(freeEl, "aZ", &args.m_aZ) &&
 
            KisDomUtils::loadValue(freeEl, "cameraPos", &args.m_cameraPos) &&
 
            KisDomUtils::loadValue(freeEl, "scaleX", &args.m_scaleX) &&
            KisDomUtils::loadValue(freeEl, "scaleY", &args.m_scaleY) &&
 
            KisDomUtils::loadValue(freeEl, "shearX", &args.m_shearX) &&
            KisDomUtils::loadValue(freeEl, "shearY", &args.m_shearY) &&
 
            KisDomUtils::loadValue(freeEl, "keepAspectRatio", &args.m_keepAspectRatio) &&
            KisDomUtils::loadValue(freeEl, "flattenedPerspectiveTransform", &args.m_flattenedPerspectiveTransform) &&
            KisDomUtils::loadValue(freeEl, "filterId", &filterId);
 
        // transformAroundRotationCenter is a new parameter introduced in Krita 4.0,
        // so it might be not present in older transform masks
        if (!KisDomUtils::loadValue(freeEl, "transformAroundRotationCenter", &args.m_transformAroundRotationCenter)) {
            args.m_transformAroundRotationCenter = false;
        }
 
        // bounds rotation is currently not supported by transform masks, so it should be null for them
        if (!KisDomUtils::loadValue(freeEl, "boundsRotation", &args.m_boundsRotation)) {
            args.m_boundsRotation = 0.0;
        }
 
        if (result) {
            args.m_filter = KisFilterStrategyRegistry::instance()->value(filterId);
            result = (bool) args.m_filter;
        }
 
    } else if (args.m_mode == WARP || args.m_mode == CAGE) {
        QDomElement warpEl;
 
        int warpType = 0;
 
        result =
            KisDomUtils::findOnlyElement(e, "warp_transform", &warpEl) &&
 
            KisDomUtils::loadValue(warpEl, "defaultPoints", &args.m_defaultPoints) &&
 
            KisDomUtils::loadValue(warpEl, "originalPoints", &args.m_origPoints) &&
            KisDomUtils::loadValue(warpEl, "transformedPoints", &args.m_transfPoints) &&
 
            KisDomUtils::loadValue(warpEl, "warpType", &warpType) &&
            KisDomUtils::loadValue(warpEl, "alpha", &args.m_alpha);
 
        if(args.m_mode == CAGE){
            // Pixel precision is a parameter introduced in Krita 4.2, so we should
            // expect it not being present in older files. In case it is not found,
            // just use the default value initialized by c-tor (that is, do nothing).
 
            (void) KisDomUtils::loadValue(warpEl, "pixelPrecision", &args.m_pixelPrecision);
            (void) KisDomUtils::loadValue(warpEl, "previewPixelPrecision", &args.m_previewPixelPrecision);
        }
 
        if (result && warpType >= 0 && warpType < KisWarpTransformWorker::N_MODES) {
            args.m_warpType = (KisWarpTransformWorker::WarpType_) warpType;
        } else {
            result = false;
        }
 
    } else if (args.m_mode == LIQUIFY) {
        QDomElement liquifyEl;
 
        result =
            KisDomUtils::findOnlyElement(e, "liquify_transform", &liquifyEl);
 
        *args.m_liquifyProperties = KisLiquifyProperties::fromXML(e);
        args.m_liquifyWorker.reset(KisLiquifyTransformWorker::fromXML(e));
    } else if (args.m_mode == MESH) {
        QDomElement meshEl;
 
        result =
            KisDomUtils::findOnlyElement(e, "mesh_transform", &meshEl);
 
        result &= KisDomUtils::loadValue(meshEl, "mesh", &args.m_meshTransform);
 
    } else {
        KIS_ASSERT_RECOVER_NOOP(0 && "Unknown transform mode");
    }
 
    KIS_SAFE_ASSERT_RECOVER(result) {
        args = ToolTransformArgs();
    }
 
    return args;
}

References CAGE, filterId(), KisDomUtils::findOnlyElement(), FREE_TRANSFORM, KisLiquifyTransformWorker::fromXML(), KisLiquifyProperties::fromXML(), KisFilterStrategyRegistry::instance(), KIS_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER, LIQUIFY, KisDomUtils::loadValue(), m_alpha, m_aX, m_aY, m_aZ, m_boundsRotation, m_cameraPos, m_defaultPoints, m_editTransformPoints, m_filter, m_flattenedPerspectiveTransform, m_keepAspectRatio, m_liquifyProperties, m_liquifyWorker, m_meshTransform, m_mode, m_originalCenter, m_origPoints, m_pixelPrecision, m_previewPixelPrecision, m_rotationCenterOffset, m_scaleX, m_scaleY, m_shearX, m_shearY, m_transformAroundRotationCenter, m_transformedCenter, m_transfPoints, m_warpType, MESH, KisWarpTransformWorker::N_MODES, N_MODES, PERSPECTIVE_4POINT, ToolTransformArgs(), KoGenericRegistry< T >::value(), void(), WARP, and warpType().

◆ init()

void ToolTransformArgs::init ( const ToolTransformArgs & args )

private

Definition at line 51 of file tool_transform_args.cc.

{
    m_mode = args.mode();
    m_transformedCenter = args.transformedCenter();
    m_originalCenter = args.originalCenter();
    m_rotationCenterOffset = args.rotationCenterOffset();
    m_transformAroundRotationCenter = args.transformAroundRotationCenter();
    m_cameraPos = args.m_cameraPos;
    m_aX = args.aX();
    m_aY = args.aY();
    m_aZ = args.aZ();
    m_scaleX = args.scaleX();
    m_scaleY = args.scaleY();
    m_shearX = args.shearX();
    m_shearY = args.shearY();
    m_boundsRotation = args.boundsRotation();
    m_origPoints = args.origPoints(); //it's a copy
    m_transfPoints = args.transfPoints();
    m_warpType = args.warpType();
    m_alpha = args.alpha();
    m_defaultPoints = args.defaultPoints();
    m_keepAspectRatio = args.keepAspectRatio();
    m_filter = args.m_filter;
    m_flattenedPerspectiveTransform = args.m_flattenedPerspectiveTransform;
    m_editTransformPoints = args.m_editTransformPoints;
    m_pixelPrecision = args.pixelPrecision();
    m_previewPixelPrecision = args.previewPixelPrecision();
    m_externalSource = args.externalSource();
 
    if (args.m_liquifyWorker) {
        m_liquifyWorker.reset(new KisLiquifyTransformWorker(*args.m_liquifyWorker.data()));
    }
 
    m_meshTransform = args.m_meshTransform;
    m_meshShowHandles = args.m_meshShowHandles;
    m_meshSymmetricalHandles = args.m_meshSymmetricalHandles;
    m_meshScaleHandles = args.m_meshScaleHandles;
 
    m_continuedTransformation.reset(args.m_continuedTransformation ? new ToolTransformArgs(*args.m_continuedTransformation) : 0);
}

References alpha(), aX(), aY(), aZ(), boundsRotation(), defaultPoints(), externalSource(), keepAspectRatio(), m_alpha, m_aX, m_aY, m_aZ, m_boundsRotation, m_cameraPos, m_continuedTransformation, m_defaultPoints, m_editTransformPoints, m_externalSource, m_filter, m_flattenedPerspectiveTransform, m_keepAspectRatio, m_liquifyWorker, m_meshScaleHandles, m_meshShowHandles, m_meshSymmetricalHandles, m_meshTransform, m_mode, m_originalCenter, m_origPoints, m_pixelPrecision, m_previewPixelPrecision, m_rotationCenterOffset, m_scaleX, m_scaleY, m_shearX, m_shearY, m_transformAroundRotationCenter, m_transformedCenter, m_transfPoints, m_warpType, mode(), originalCenter(), origPoints(), pixelPrecision(), previewPixelPrecision(), rotationCenterOffset(), scaleX(), scaleY(), shearX(), shearY(), transformAroundRotationCenter(), transformedCenter(), transfPoints(), and warpType().

◆ initLiquifyTransformMode()

void ToolTransformArgs::initLiquifyTransformMode ( const QRect & srcRect )

Definition at line 362 of file tool_transform_args.cc.

{
    m_liquifyWorker.reset(new KisLiquifyTransformWorker(srcRect, 0, 8));
    m_liquifyProperties->loadAndResetMode();
}

References m_liquifyProperties, and m_liquifyWorker.

◆ isEditingTransformPoints()

bool ToolTransformArgs::isEditingTransformPoints ( ) const

inline

Definition at line 281 of file tool_transform_args.h.

                                          {
        return m_editTransformPoints;
    }

◆ isIdentity()

bool ToolTransformArgs::isIdentity ( ) const

Definition at line 331 of file tool_transform_args.cc.

{
    if (m_mode == FREE_TRANSFORM) {
        return (m_transformedCenter == m_originalCenter && m_scaleX == 1
                && m_scaleY == 1 && m_shearX == 0 && m_shearY == 0
                && m_aX == 0 && m_aY == 0 && m_aZ == 0 && m_boundsRotation == 0);
    } else if (m_mode == PERSPECTIVE_4POINT) {
            return (m_transformedCenter == m_originalCenter && m_scaleX == 1
                    && m_scaleY == 1 && m_shearX == 0 && m_shearY == 0
                    && m_flattenedPerspectiveTransform.isIdentity());
    } else if(m_mode == WARP || m_mode == CAGE) {
        for (int i = 0; i < m_origPoints.size(); ++i)
            if (m_origPoints[i] != m_transfPoints[i])
                return false;
 
        return true;
    } else if (m_mode == LIQUIFY) {
        return !m_liquifyWorker || m_liquifyWorker->isIdentity();
    } else if (m_mode == MESH) {
        return m_meshTransform.isIdentity();
    } else {
        KIS_ASSERT_RECOVER_NOOP(0 && "unknown transform mode");
        return true;
    }
}

References CAGE, FREE_TRANSFORM, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::isIdentity(), KIS_ASSERT_RECOVER_NOOP, LIQUIFY, m_aX, m_aY, m_aZ, m_boundsRotation, m_flattenedPerspectiveTransform, m_liquifyWorker, m_meshTransform, m_mode, m_originalCenter, m_origPoints, m_scaleX, m_scaleY, m_shearX, m_shearY, m_transformedCenter, m_transfPoints, MESH, PERSPECTIVE_4POINT, and WARP.

◆ isSameMode()

bool ToolTransformArgs::isSameMode ( const ToolTransformArgs & other ) const

Definition at line 179 of file tool_transform_args.cc.

{
    if (m_mode != other.m_mode) return false;
 
    bool result = true;
 
    if (m_mode == FREE_TRANSFORM) {
        result &= m_transformedCenter == other.m_transformedCenter;
        result &= m_originalCenter == other.m_originalCenter;
        result &= m_scaleX == other.m_scaleX;
        result &= m_scaleY == other.m_scaleY;
        result &= m_shearX == other.m_shearX;
        result &= m_shearY == other.m_shearY;
        result &= m_boundsRotation == other.m_boundsRotation;
        result &= m_aX == other.m_aX;
        result &= m_aY == other.m_aY;
        result &= m_aZ == other.m_aZ;
 
    } else if (m_mode == PERSPECTIVE_4POINT) {
        result &= m_transformedCenter == other.m_transformedCenter;
        result &= m_originalCenter == other.m_originalCenter;
        result &= m_scaleX == other.m_scaleX;
        result &= m_scaleY == other.m_scaleY;
        result &= m_shearX == other.m_shearX;
        result &= m_shearY == other.m_shearY;
        result &= m_flattenedPerspectiveTransform == other.m_flattenedPerspectiveTransform;
 
    } else if(m_mode == WARP || m_mode == CAGE) {
        result &= m_origPoints == other.m_origPoints;
        result &= m_transfPoints == other.m_transfPoints;
 
    } else if (m_mode == LIQUIFY) {
        result &= m_liquifyProperties &&
            (m_liquifyProperties == other.m_liquifyProperties ||
             *m_liquifyProperties == *other.m_liquifyProperties);
 
        result &=
            (m_liquifyWorker && other.m_liquifyWorker &&
             *m_liquifyWorker == *other.m_liquifyWorker)
            || m_liquifyWorker == other.m_liquifyWorker;
 
    } else if (m_mode == MESH) {
        result &= m_meshTransform == other.m_meshTransform;
    } else {
        KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "unknown transform mode");
    }
 
    return result;
}

References CAGE, FREE_TRANSFORM, KIS_SAFE_ASSERT_RECOVER_NOOP, LIQUIFY, m_aX, m_aY, m_aZ, m_boundsRotation, m_flattenedPerspectiveTransform, m_liquifyProperties, m_liquifyWorker, m_meshTransform, m_mode, m_originalCenter, m_origPoints, m_scaleX, m_scaleY, m_shearX, m_shearY, m_transformedCenter, m_transfPoints, MESH, PERSPECTIVE_4POINT, and WARP.

◆ isUnchanging()

bool ToolTransformArgs::isUnchanging ( ) const

Definition at line 357 of file tool_transform_args.cc.

{
    return !m_externalSource && isIdentity();
}

References isIdentity(), and m_externalSource.

◆ keepAspectRatio()

bool ToolTransformArgs::keepAspectRatio ( ) const

inline

Definition at line 199 of file tool_transform_args.h.

                                        {
        return m_keepAspectRatio;
    }

◆ liquifyProperties() [1/2]

KisLiquifyProperties * ToolTransformArgs::liquifyProperties ( )

inline

Definition at line 293 of file tool_transform_args.h.

                                              {
        return m_liquifyProperties.data();
    }

◆ liquifyProperties() [2/2]

const KisLiquifyProperties * ToolTransformArgs::liquifyProperties ( ) const

inline

Definition at line 289 of file tool_transform_args.h.

                                                          {
        return m_liquifyProperties.data();
    }

◆ liquifyWorker()

KisLiquifyTransformWorker * ToolTransformArgs::liquifyWorker ( ) const

inline

Definition at line 300 of file tool_transform_args.h.

                                                     {
        return m_liquifyWorker.data();
    }

◆ meshScaleHandles()

bool ToolTransformArgs::meshScaleHandles ( ) const

Definition at line 92 of file tool_transform_args.cc.

{
    return m_meshScaleHandles;
}

References m_meshScaleHandles.

◆ meshShowHandles()

bool ToolTransformArgs::meshShowHandles ( ) const

Definition at line 590 of file tool_transform_args.cc.

{
    return m_meshShowHandles;
}

References m_meshShowHandles.

◆ meshSymmetricalHandles()

bool ToolTransformArgs::meshSymmetricalHandles ( ) const

Definition at line 603 of file tool_transform_args.cc.

{
    return m_meshSymmetricalHandles;
}

References m_meshSymmetricalHandles.

◆ meshTransform() [1/2]

KisBezierTransformMesh * ToolTransformArgs::meshTransform ( )

Definition at line 585 of file tool_transform_args.cc.

{
    return &m_meshTransform;
}

References m_meshTransform.

◆ meshTransform() [2/2]

const KisBezierTransformMesh * ToolTransformArgs::meshTransform ( ) const

Definition at line 580 of file tool_transform_args.cc.

{
    return &m_meshTransform;
}

References m_meshTransform.

◆ mode()

TransformMode ToolTransformArgs::mode ( ) const

inline

Definition at line 82 of file tool_transform_args.h.

                                      {
        return m_mode;
    }

◆ numPoints()

int ToolTransformArgs::numPoints ( ) const

inline

Definition at line 114 of file tool_transform_args.h.

                                 {
        KIS_ASSERT_RECOVER_NOOP(m_origPoints.size() == m_transfPoints.size());
        return m_origPoints.size();
    }

References KIS_ASSERT_RECOVER_NOOP.

◆ operator=()

ToolTransformArgs & ToolTransformArgs::operator= ( const ToolTransformArgs & args )

Definition at line 123 of file tool_transform_args.cc.

{
    if (this == &args) return *this;
 
    clear();
 
    m_liquifyProperties.reset(new KisLiquifyProperties(*args.m_liquifyProperties.data()));
    init(args);
 
    return *this;
}

References clear(), init(), and m_liquifyProperties.

◆ operator==()

bool ToolTransformArgs::operator== ( const ToolTransformArgs & other ) const

Definition at line 135 of file tool_transform_args.cc.

{
    return
        m_mode == other.m_mode &&
        m_defaultPoints == other.m_defaultPoints &&
        m_origPoints == other.m_origPoints &&
        m_transfPoints == other.m_transfPoints &&
        m_warpType == other.m_warpType &&
        m_alpha == other.m_alpha &&
        m_transformedCenter == other.m_transformedCenter &&
        m_originalCenter == other.m_originalCenter &&
        m_rotationCenterOffset == other.m_rotationCenterOffset &&
        m_transformAroundRotationCenter == other.m_transformAroundRotationCenter &&
        m_aX == other.m_aX &&
        m_aY == other.m_aY &&
        m_aZ == other.m_aZ &&
        m_cameraPos == other.m_cameraPos &&
        m_scaleX == other.m_scaleX &&
        m_scaleY == other.m_scaleY &&
        m_shearX == other.m_shearX &&
        m_shearY == other.m_shearY &&
        m_boundsRotation == other.m_boundsRotation &&
        m_keepAspectRatio == other.m_keepAspectRatio &&
        m_flattenedPerspectiveTransform == other.m_flattenedPerspectiveTransform &&
        m_editTransformPoints == other.m_editTransformPoints &&
        (m_liquifyProperties == other.m_liquifyProperties ||
         *m_liquifyProperties == *other.m_liquifyProperties) &&
        m_meshTransform == other.m_meshTransform &&
 
        // pointer types
 
        m_externalSource == other.m_externalSource &&
 
        ((m_filter && other.m_filter &&
          m_filter->id() == other.m_filter->id())
         || m_filter == other.m_filter) &&
 
        ((m_liquifyWorker && other.m_liquifyWorker &&
          *m_liquifyWorker == *other.m_liquifyWorker)
         || m_liquifyWorker == other.m_liquifyWorker) &&
            m_pixelPrecision == other.m_pixelPrecision &&
            m_previewPixelPrecision == other.m_previewPixelPrecision;
}

References KisFilterStrategy::id(), m_alpha, m_aX, m_aY, m_aZ, m_boundsRotation, m_cameraPos, m_defaultPoints, m_editTransformPoints, m_externalSource, m_filter, m_flattenedPerspectiveTransform, m_keepAspectRatio, m_liquifyProperties, m_liquifyWorker, m_meshTransform, m_mode, m_originalCenter, m_origPoints, m_pixelPrecision, m_previewPixelPrecision, m_rotationCenterOffset, m_scaleX, m_scaleY, m_shearX, m_shearY, m_transformAroundRotationCenter, m_transformedCenter, m_transfPoints, and m_warpType.

◆ originalCenter()

QPointF ToolTransformArgs::originalCenter ( ) const

inline

Definition at line 172 of file tool_transform_args.h.

                                          {
        return m_originalCenter;
    }

◆ origPoint()

QPointF & ToolTransformArgs::origPoint ( int i )

inline

Definition at line 118 of file tool_transform_args.h.

                                     {
        return m_origPoints[i];
    }

◆ origPoints()

const QVector< QPointF > & ToolTransformArgs::origPoints ( ) const

inline

Definition at line 124 of file tool_transform_args.h.

                                                      {
        return m_origPoints;
    }

◆ pixelPrecision()

int ToolTransformArgs::pixelPrecision ( ) const

inline

Definition at line 89 of file tool_transform_args.h.

                                      {
        return m_pixelPrecision;
    }

◆ previewPixelPrecision()

int ToolTransformArgs::previewPixelPrecision ( ) const

inline

Definition at line 97 of file tool_transform_args.h.

                                             {
        return m_previewPixelPrecision;
    }

◆ refOriginalPoints()

QVector< QPointF > & ToolTransformArgs::refOriginalPoints ( )

inline

Definition at line 131 of file tool_transform_args.h.

                                                 {
        return m_origPoints;
    }

◆ refTransformedPoints()

QVector< QPointF > & ToolTransformArgs::refTransformedPoints ( )

inline

Definition at line 134 of file tool_transform_args.h.

                                                    {
        return m_transfPoints;
    }

◆ restoreContinuedState()

void ToolTransformArgs::restoreContinuedState ( )

Definition at line 566 of file tool_transform_args.cc.

{
    QScopedPointer<ToolTransformArgs> tempTransformation(
        new ToolTransformArgs(*m_continuedTransformation));
 
    *this = *tempTransformation;
    m_continuedTransformation.swap(tempTransformation);
}

References m_continuedTransformation, and ToolTransformArgs().

◆ rotationCenterOffset()

QPointF ToolTransformArgs::rotationCenterOffset ( ) const

inline

Definition at line 175 of file tool_transform_args.h.

                                                {
        return m_rotationCenterOffset;
    }

◆ saveContinuedState()

void ToolTransformArgs::saveContinuedState ( )

Definition at line 560 of file tool_transform_args.cc.

{
    m_continuedTransformation.reset();
    m_continuedTransformation.reset(new ToolTransformArgs(*this));
}

References m_continuedTransformation, and ToolTransformArgs().

◆ saveLiquifyTransformMode()

void ToolTransformArgs::saveLiquifyTransformMode ( ) const

Definition at line 368 of file tool_transform_args.cc.

{
    m_liquifyProperties->saveMode();
}

References m_liquifyProperties.

◆ scale3dSrcAndDst()

void ToolTransformArgs::scale3dSrcAndDst ( qreal scale )

Definition at line 616 of file tool_transform_args.cc.

{
    const QTransform t = QTransform::fromScale(scale, scale);
 
    if (m_mode == FREE_TRANSFORM ) {
        m_originalCenter = t.map(m_originalCenter);
        m_transformedCenter = t.map(m_transformedCenter);
 
        // we need to scale Z-coordinate of the camera pos as well,
        // so we cannot just do `QMatrix4x4 m(t)`.
        QMatrix4x4 m;
        m.scale(scale);
        m_cameraPos = m * m_cameraPos;
    } else {
        transformSrcAndDst(t);
    }
}

References FREE_TRANSFORM, m_cameraPos, m_mode, m_originalCenter, m_transformedCenter, and transformSrcAndDst().

◆ scaleX()

double ToolTransformArgs::scaleX ( ) const

inline

Definition at line 193 of file tool_transform_args.h.

                                 {
        return m_scaleX;
    }

◆ scaleY()

double ToolTransformArgs::scaleY ( ) const

inline

Definition at line 196 of file tool_transform_args.h.

                                 {
        return m_scaleY;
    }

◆ setAlpha()

void ToolTransformArgs::setAlpha ( double alpha )

inline

Definition at line 161 of file tool_transform_args.h.

                                       {
        m_alpha = alpha;
    }

◆ setAX()

void ToolTransformArgs::setAX ( double aX )

inline

Definition at line 223 of file tool_transform_args.h.

                                 {
        m_aX = aX;
    }

◆ setAY()

void ToolTransformArgs::setAY ( double aY )

inline

Definition at line 226 of file tool_transform_args.h.

                                 {
        m_aY = aY;
    }

◆ setAZ()

void ToolTransformArgs::setAZ ( double aZ )

inline

Definition at line 229 of file tool_transform_args.h.

                                 {
        m_aZ = aZ;
    }

◆ setBoundsRotation()

void ToolTransformArgs::setBoundsRotation ( double boundsRotation )

inline

Definition at line 250 of file tool_transform_args.h.

                                                         {
        m_boundsRotation = boundsRotation;
    }

◆ setCameraPos()

void ToolTransformArgs::setCameraPos ( const QVector3D & pos )

inline

Definition at line 232 of file tool_transform_args.h.

                                                   {
        m_cameraPos = pos;
    }

◆ setDefaultPoints()

void ToolTransformArgs::setDefaultPoints ( bool defaultPoints )

inline

Definition at line 164 of file tool_transform_args.h.

                                                     {
        m_defaultPoints = defaultPoints;
    }

◆ setEditingTransformPoints()

void ToolTransformArgs::setEditingTransformPoints ( bool value )

inline

Definition at line 285 of file tool_transform_args.h.

                                               {
        m_editTransformPoints = value;
    }

References value().

◆ setExternalSource()

void ToolTransformArgs::setExternalSource ( KisPaintDeviceSP externalSource )

inline

Definition at line 109 of file tool_transform_args.h.

                                                                   {
        m_externalSource = externalSource;
    }

◆ setFilterId()

void ToolTransformArgs::setFilterId ( const QString & id )

Definition at line 34 of file tool_transform_args.cc.

                                                     {
    m_filter = KisFilterStrategyRegistry::instance()->value(id);
 
    if (m_filter) {
        KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
        configGroup.writeEntry("filterId", id);
    }
}

References KisFilterStrategyRegistry::instance(), m_filter, and KoGenericRegistry< T >::value().

◆ setFlattenedPerspectiveTransform()

void ToolTransformArgs::setFlattenedPerspectiveTransform ( const QTransform & value )

inline

Definition at line 277 of file tool_transform_args.h.

                                                                          {
        m_flattenedPerspectiveTransform = value;
    }

References value().

◆ setKeepAspectRatio()

void ToolTransformArgs::setKeepAspectRatio ( bool value )

inline

Definition at line 241 of file tool_transform_args.h.

                                               {
        m_keepAspectRatio = value;
    }

References value().

◆ setMeshScaleHandles()

void ToolTransformArgs::setMeshScaleHandles ( bool meshScaleHandles )

Definition at line 97 of file tool_transform_args.cc.

{
    m_meshScaleHandles = meshScaleHandles;
 
    KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
    configGroup.writeEntry("meshScaleHandles", meshScaleHandles);
}

References m_meshScaleHandles, and meshScaleHandles().

◆ setMeshShowHandles()

void ToolTransformArgs::setMeshShowHandles ( bool value )

Definition at line 595 of file tool_transform_args.cc.

{
    m_meshShowHandles = value;
 
    KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
    configGroup.writeEntry("meshShowHandles", value);
}

References m_meshShowHandles, and value().

◆ setMeshSymmetricalHandles()

void ToolTransformArgs::setMeshSymmetricalHandles ( bool meshSymmetricalHandles )

Definition at line 608 of file tool_transform_args.cc.

{
    m_meshSymmetricalHandles = value;
 
    KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
    configGroup.writeEntry("meshSymmetricalHandles", value);
}

References m_meshSymmetricalHandles, and value().

◆ setMode()

void ToolTransformArgs::setMode ( TransformMode mode )

inline

Definition at line 85 of file tool_transform_args.h.

                                            {
        m_mode = mode;
    }

◆ setOriginalCenter()

void ToolTransformArgs::setOriginalCenter ( QPointF originalCenter )

inline

Definition at line 215 of file tool_transform_args.h.

                                                          {
        m_originalCenter = originalCenter;
    }

◆ setPixelPrecision()

void ToolTransformArgs::setPixelPrecision ( int precision )

inline

Definition at line 93 of file tool_transform_args.h.

                                                 {
        m_pixelPrecision = precision;
    }

◆ setPoints()

void ToolTransformArgs::setPoints	(	QVector< QPointF >	origPoints,
		QVector< QPointF >	transfPoints )

inline

Definition at line 147 of file tool_transform_args.h.

                                                                                      {
        m_origPoints = QVector<QPointF>(origPoints);
        m_transfPoints = QVector<QPointF>(transfPoints);
    }

◆ setPreviewPixelPrecision()

void ToolTransformArgs::setPreviewPixelPrecision ( int precision )

inline

Definition at line 101 of file tool_transform_args.h.

                                                        {
        m_previewPixelPrecision = precision;
    }

◆ setRotationCenterOffset()

void ToolTransformArgs::setRotationCenterOffset ( QPointF rotationCenterOffset )

inline

Definition at line 218 of file tool_transform_args.h.

                                                                      {
        m_rotationCenterOffset = rotationCenterOffset;
    }

◆ setScaleX()

void ToolTransformArgs::setScaleX ( double scaleX )

inline

Definition at line 235 of file tool_transform_args.h.

                                         {
        m_scaleX = scaleX;
    }

◆ setScaleY()

void ToolTransformArgs::setScaleY ( double scaleY )

inline

Definition at line 238 of file tool_transform_args.h.

                                         {
        m_scaleY = scaleY;
    }

◆ setShearX()

void ToolTransformArgs::setShearX ( double shearX )

inline

Definition at line 244 of file tool_transform_args.h.

                                         {
        m_shearX = shearX;
    }

◆ setShearY()

void ToolTransformArgs::setShearY ( double shearY )

inline

Definition at line 247 of file tool_transform_args.h.

                                         {
        m_shearY = shearY;
    }

◆ setTransformAroundRotationCenter()

void ToolTransformArgs::setTransformAroundRotationCenter ( bool value )

Definition at line 43 of file tool_transform_args.cc.

{
    m_transformAroundRotationCenter = value;
 
    KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
    configGroup.writeEntry("transformAroundRotationCenter", int(value));
}

References m_transformAroundRotationCenter, and value().

◆ setTransformedCenter()

void ToolTransformArgs::setTransformedCenter ( QPointF transformedCenter )

inline

Definition at line 212 of file tool_transform_args.h.

                                                                {
        m_transformedCenter = transformedCenter;
    }

◆ setWarpCalculation()

void ToolTransformArgs::setWarpCalculation ( KisWarpTransformWorker::WarpCalculation warpCalc )

inline

Definition at line 154 of file tool_transform_args.h.

                                                                                   {
        m_warpCalculation = warpCalc;
    }

◆ setWarpType()

void ToolTransformArgs::setWarpType ( KisWarpTransformWorker::WarpType warpType )

inline

Definition at line 151 of file tool_transform_args.h.

                                                                     {
        m_warpType = warpType;
    }

◆ shearX()

double ToolTransformArgs::shearX ( ) const

inline

Definition at line 202 of file tool_transform_args.h.

                                 {
        return m_shearX;
    }

◆ shearY()

double ToolTransformArgs::shearY ( ) const

inline

Definition at line 205 of file tool_transform_args.h.

                                 {
        return m_shearY;
    }

◆ toXML()

void ToolTransformArgs::toXML ( QDomElement * e ) const

Definition at line 373 of file tool_transform_args.cc.

{
    e->setAttribute("mode", (int) m_mode);
 
    QDomDocument doc = e->ownerDocument();
 
    if (m_mode == FREE_TRANSFORM || m_mode == PERSPECTIVE_4POINT) {
 
        QDomElement freeEl = doc.createElement("free_transform");
        e->appendChild(freeEl);
 
        KisDomUtils::saveValue(&freeEl, "transformedCenter", m_transformedCenter);
        KisDomUtils::saveValue(&freeEl, "originalCenter", m_originalCenter);
        KisDomUtils::saveValue(&freeEl, "rotationCenterOffset", m_rotationCenterOffset);
        KisDomUtils::saveValue(&freeEl, "transformAroundRotationCenter", m_transformAroundRotationCenter);
 
        KisDomUtils::saveValue(&freeEl, "aX", m_aX);
        KisDomUtils::saveValue(&freeEl, "aY", m_aY);
        KisDomUtils::saveValue(&freeEl, "aZ", m_aZ);
 
        KisDomUtils::saveValue(&freeEl, "cameraPos", m_cameraPos);
 
        KisDomUtils::saveValue(&freeEl, "scaleX", m_scaleX);
        KisDomUtils::saveValue(&freeEl, "scaleY", m_scaleY);
 
        KisDomUtils::saveValue(&freeEl, "shearX", m_shearX);
        KisDomUtils::saveValue(&freeEl, "shearY", m_shearY);
 
        // bounds rotation is currently not supported by transform masks, so it should be null
        KisDomUtils::saveValue(&freeEl, "boundsRotation", m_boundsRotation);
 
        KisDomUtils::saveValue(&freeEl, "keepAspectRatio", m_keepAspectRatio);
        KisDomUtils::saveValue(&freeEl, "flattenedPerspectiveTransform", m_flattenedPerspectiveTransform);
 
        KisDomUtils::saveValue(&freeEl, "filterId", m_filter->id());
 
    } else if (m_mode == WARP || m_mode == CAGE) {
        QDomElement warpEl = doc.createElement("warp_transform");
        e->appendChild(warpEl);
 
        KisDomUtils::saveValue(&warpEl, "defaultPoints", m_defaultPoints);
        KisDomUtils::saveValue(&warpEl, "originalPoints", m_origPoints);
        KisDomUtils::saveValue(&warpEl, "transformedPoints", m_transfPoints);
 
        KisDomUtils::saveValue(&warpEl, "warpType", (int)m_warpType); // limited!
        KisDomUtils::saveValue(&warpEl, "alpha", m_alpha);
 
        if(m_mode == CAGE){
            KisDomUtils::saveValue(&warpEl,"pixelPrecision",m_pixelPrecision);
            KisDomUtils::saveValue(&warpEl,"previewPixelPrecision",m_previewPixelPrecision);
        }
 
    } else if (m_mode == LIQUIFY) {
        QDomElement liqEl = doc.createElement("liquify_transform");
        e->appendChild(liqEl);
 
        m_liquifyProperties->toXML(&liqEl);
        m_liquifyWorker->toXML(&liqEl);
    } else if (m_mode == MESH) {
        QDomElement meshEl = doc.createElement("mesh_transform");
        e->appendChild(meshEl);
 
        KisDomUtils::saveValue(&meshEl, "mesh", m_meshTransform);
    } else {
        KIS_ASSERT_RECOVER_RETURN(0 && "Unknown transform mode");
    }
 
    // m_editTransformPoints should not be saved since it is reset explicitly
}

References CAGE, FREE_TRANSFORM, KisFilterStrategy::id(), KIS_ASSERT_RECOVER_RETURN, LIQUIFY, m_alpha, m_aX, m_aY, m_aZ, m_boundsRotation, m_cameraPos, m_defaultPoints, m_filter, m_flattenedPerspectiveTransform, m_keepAspectRatio, m_liquifyProperties, m_liquifyWorker, m_meshTransform, m_mode, m_originalCenter, m_origPoints, m_pixelPrecision, m_previewPixelPrecision, m_rotationCenterOffset, m_scaleX, m_scaleY, m_shearX, m_shearY, m_transformAroundRotationCenter, m_transformedCenter, m_transfPoints, m_warpType, MESH, PERSPECTIVE_4POINT, KisDomUtils::saveValue(), and WARP.

◆ transformAroundRotationCenter()

bool ToolTransformArgs::transformAroundRotationCenter ( ) const

inline

Definition at line 178 of file tool_transform_args.h.

                                                      {
        return m_transformAroundRotationCenter;
    }

◆ transformedCenter()

QPointF ToolTransformArgs::transformedCenter ( ) const

inline

Definition at line 169 of file tool_transform_args.h.

                                             {
        return m_transformedCenter;
    }

◆ transformSrcAndDst()

void ToolTransformArgs::transformSrcAndDst ( const QTransform & t )

Definition at line 281 of file tool_transform_args.cc.

{
    if (m_mode == FREE_TRANSFORM ) {
        m_originalCenter = t.map(m_originalCenter);
        m_transformedCenter = t.map(m_transformedCenter);
 
        QMatrix4x4 m(t);
        m_cameraPos = m * m_cameraPos;
    } else if (m_mode == PERSPECTIVE_4POINT) {
        m_originalCenter = t.map(m_originalCenter);
        m_transformedCenter = t.map(m_transformedCenter);
 
        m_flattenedPerspectiveTransform = t.inverted() * m_flattenedPerspectiveTransform * t;
 
    } else if(m_mode == WARP || m_mode == CAGE) {
        for (auto &pt : m_origPoints) {
            pt = t.map(pt);
        }
 
        for (auto &pt : m_transfPoints) {
            pt = t.map(pt);
        }
    } else if (m_mode == LIQUIFY) {
        KIS_ASSERT_RECOVER_RETURN(m_liquifyWorker);
        m_liquifyWorker->transformSrcAndDst(t);
    } else if (m_mode == MESH) {
        m_meshTransform.transformSrcAndDst(t);
    } else {
        KIS_ASSERT_RECOVER_NOOP(0 && "unknown transform mode");
    }
}

References CAGE, FREE_TRANSFORM, KIS_ASSERT_RECOVER_NOOP, KIS_ASSERT_RECOVER_RETURN, LIQUIFY, m_cameraPos, m_flattenedPerspectiveTransform, m_liquifyWorker, m_meshTransform, m_mode, m_originalCenter, m_origPoints, m_transformedCenter, m_transfPoints, MESH, PERSPECTIVE_4POINT, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::transformSrcAndDst(), and WARP.

◆ transfPoint()

QPointF & ToolTransformArgs::transfPoint ( int i )

inline

Definition at line 121 of file tool_transform_args.h.

                                       {
        return m_transfPoints[i];
    }

◆ transfPoints()

const QVector< QPointF > & ToolTransformArgs::transfPoints ( ) const

inline

Definition at line 127 of file tool_transform_args.h.

                                                        {
        return m_transfPoints;
    }

◆ translateDstSpace()

void ToolTransformArgs::translateDstSpace ( const QPointF & offset )

Definition at line 313 of file tool_transform_args.cc.

{
    if (m_mode == FREE_TRANSFORM || m_mode == PERSPECTIVE_4POINT) {
        m_transformedCenter += offset;
    } else if(m_mode == WARP || m_mode == CAGE) {
        for (auto &pt : m_transfPoints) {
            pt += offset;
        }
    } else if (m_mode == LIQUIFY) {
        KIS_ASSERT_RECOVER_RETURN(m_liquifyWorker);
        m_liquifyWorker->translateDstSpace(offset);
    } else if (m_mode == MESH) {
        m_meshTransform.translate(offset);
    } else {
        KIS_ASSERT_RECOVER_NOOP(0 && "unknown transform mode");
    }
}

References CAGE, FREE_TRANSFORM, KIS_ASSERT_RECOVER_NOOP, KIS_ASSERT_RECOVER_RETURN, LIQUIFY, m_liquifyWorker, m_meshTransform, m_mode, m_transformedCenter, m_transfPoints, MESH, PERSPECTIVE_4POINT, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::translate(), and WARP.

◆ translateSrcAndDst()

void ToolTransformArgs::translateSrcAndDst ( const QPointF & offset )

Definition at line 276 of file tool_transform_args.cc.

{
    transformSrcAndDst(QTransform::fromTranslate(offset.x(), offset.y()));
}

References transformSrcAndDst().

◆ warpCalculation()

KisWarpTransformWorker::WarpCalculation ToolTransformArgs::warpCalculation ( )

inline

Definition at line 157 of file tool_transform_args.h.

                                                                   {
        return m_warpCalculation;
    }

◆ warpType()

KisWarpTransformWorker::WarpType ToolTransformArgs::warpType ( ) const

inline

Definition at line 138 of file tool_transform_args.h.

                                                           {
        return m_warpType;
    }

Member Data Documentation

◆ m_alpha

double ToolTransformArgs::m_alpha {1.0}

private

Definition at line 342 of file tool_transform_args.h.

342{1.0};

◆ m_aX

double ToolTransformArgs::m_aX {0}

private

Definition at line 354 of file tool_transform_args.h.

354{0};

◆ m_aY

double ToolTransformArgs::m_aY {0}

private

Definition at line 355 of file tool_transform_args.h.

355{0};

◆ m_aZ

double ToolTransformArgs::m_aZ {0}

private

Definition at line 356 of file tool_transform_args.h.

356{0};

◆ m_boundsRotation

double ToolTransformArgs::m_boundsRotation {0.0}

private

Definition at line 362 of file tool_transform_args.h.

362{0.0};

◆ m_cameraPos

QVector3D ToolTransformArgs::m_cameraPos {QVector3D(0,0,1024)}

private

Definition at line 357 of file tool_transform_args.h.

357{QVector3D(0,0,1024)};

◆ m_continuedTransformation

QScopedPointer<ToolTransformArgs> ToolTransformArgs::m_continuedTransformation

private

When we continue a transformation, m_continuedTransformation stores the initial step of our transform. All cancel and revert operations should revert to it.

Definition at line 383 of file tool_transform_args.h.

◆ m_defaultPoints

bool ToolTransformArgs::m_defaultPoints {true}

private

Definition at line 336 of file tool_transform_args.h.

336{true}; // true : the original points are set to make a grid

◆ m_editTransformPoints

bool ToolTransformArgs::m_editTransformPoints {false}

private

Definition at line 369 of file tool_transform_args.h.

369{false};

◆ m_externalSource

KisPaintDeviceSP ToolTransformArgs::m_externalSource

private

Optional external image, for example from the clipboard, that can be transformed directly over an existing paint layer or mask.

Definition at line 393 of file tool_transform_args.h.

◆ m_filter

KisFilterStrategy* ToolTransformArgs::m_filter {0}

private

Definition at line 368 of file tool_transform_args.h.

368{0};

◆ m_flattenedPerspectiveTransform

QTransform ToolTransformArgs::m_flattenedPerspectiveTransform

private

Definition at line 366 of file tool_transform_args.h.

◆ m_keepAspectRatio

bool ToolTransformArgs::m_keepAspectRatio {false}

private

Definition at line 363 of file tool_transform_args.h.

363{false};

◆ m_liquifyProperties

QSharedPointer<KisLiquifyProperties> ToolTransformArgs::m_liquifyProperties

private

Definition at line 370 of file tool_transform_args.h.

◆ m_liquifyWorker

QScopedPointer<KisLiquifyTransformWorker> ToolTransformArgs::m_liquifyWorker

private

Definition at line 371 of file tool_transform_args.h.

◆ m_meshScaleHandles

bool ToolTransformArgs::m_meshScaleHandles = false

private

Definition at line 376 of file tool_transform_args.h.

◆ m_meshShowHandles

bool ToolTransformArgs::m_meshShowHandles = true

private

Definition at line 374 of file tool_transform_args.h.

◆ m_meshSymmetricalHandles

bool ToolTransformArgs::m_meshSymmetricalHandles = true

private

Definition at line 375 of file tool_transform_args.h.

◆ m_meshTransform

KisBezierTransformMesh ToolTransformArgs::m_meshTransform

private

Definition at line 373 of file tool_transform_args.h.

◆ m_mode

TransformMode ToolTransformArgs::m_mode {ToolTransformArgs::TransformMode::FREE_TRANSFORM}

private

Definition at line 332 of file tool_transform_args.h.

332{ToolTransformArgs::TransformMode::FREE_TRANSFORM};

◆ m_originalCenter

QPointF ToolTransformArgs::m_originalCenter

private

Definition at line 347 of file tool_transform_args.h.

◆ m_origPoints

QVector<QPointF> ToolTransformArgs::m_origPoints

private

Definition at line 338 of file tool_transform_args.h.

◆ m_pixelPrecision

int ToolTransformArgs::m_pixelPrecision {8}

private

Definition at line 386 of file tool_transform_args.h.

386{8};

◆ m_previewPixelPrecision

int ToolTransformArgs::m_previewPixelPrecision {16}

private

Definition at line 387 of file tool_transform_args.h.

387{16};

◆ m_rotationCenterOffset

QPointF ToolTransformArgs::m_rotationCenterOffset

private

Definition at line 348 of file tool_transform_args.h.

◆ m_scaleX

double ToolTransformArgs::m_scaleX {1.0}

private

Definition at line 358 of file tool_transform_args.h.

358{1.0};

◆ m_scaleY

double ToolTransformArgs::m_scaleY {1.0}

private

Definition at line 359 of file tool_transform_args.h.

359{1.0};

◆ m_shearX

double ToolTransformArgs::m_shearX {0.0}

private

Definition at line 360 of file tool_transform_args.h.

360{0.0};

◆ m_shearY

double ToolTransformArgs::m_shearY {0.0}

private

Definition at line 361 of file tool_transform_args.h.

361{0.0};

◆ m_transformAroundRotationCenter

bool ToolTransformArgs::m_transformAroundRotationCenter {false}

private

Definition at line 351 of file tool_transform_args.h.

351{false}; // In freehand mode makes the scaling and other transformations

◆ m_transformedCenter

QPointF ToolTransformArgs::m_transformedCenter

private

Definition at line 346 of file tool_transform_args.h.

◆ m_transfPoints

QVector<QPointF> ToolTransformArgs::m_transfPoints

private

Definition at line 339 of file tool_transform_args.h.

◆ m_warpCalculation

KisWarpTransformWorker::WarpCalculation ToolTransformArgs::m_warpCalculation {KisWarpTransformWorker::WarpCalculation::DRAW}

private

Definition at line 341 of file tool_transform_args.h.

341{KisWarpTransformWorker::WarpCalculation::DRAW}; // DRAW or GRID

◆ m_warpType

KisWarpTransformWorker::WarpType ToolTransformArgs::m_warpType {KisWarpTransformWorker::WarpType_::RIGID_TRANSFORM}

private

Definition at line 340 of file tool_transform_args.h.

340{KisWarpTransformWorker::WarpType_::RIGID_TRANSFORM};

KisWarpTransformWorker::RIGID_TRANSFORM

@ RIGID_TRANSFORM

Definition kis_warptransform_worker.h:37

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

plugins/tools/tool_transform2/tool_transform_args.h
plugins/tools/tool_transform2/tool_transform_args.cc

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ TransformMode

Constructor & Destructor Documentation

◆ ToolTransformArgs() [1/3]

◆ ToolTransformArgs() [2/3]

◆ ToolTransformArgs() [3/3]

◆ ~ToolTransformArgs()

Member Function Documentation

◆ alpha()

◆ aX()

◆ aY()

◆ aZ()

◆ boundsRotation()

◆ cameraPos()

◆ clear()

◆ clone()

◆ continuedTransform()

◆ defaultPoints()

◆ externalSource()

◆ filter()

◆ filterId()

◆ flattenedPerspectiveTransform()

◆ fromXML()

◆ init()

◆ initLiquifyTransformMode()

◆ isEditingTransformPoints()

◆ isIdentity()

◆ isSameMode()

◆ isUnchanging()

◆ keepAspectRatio()

◆ liquifyProperties() [1/2]

◆ liquifyProperties() [2/2]

◆ liquifyWorker()

◆ meshScaleHandles()

◆ meshShowHandles()

◆ meshSymmetricalHandles()

◆ meshTransform() [1/2]

◆ meshTransform() [2/2]

◆ mode()

◆ numPoints()

◆ operator=()

◆ operator==()

◆ originalCenter()

◆ origPoint()

◆ origPoints()

◆ pixelPrecision()

◆ previewPixelPrecision()

◆ refOriginalPoints()

◆ refTransformedPoints()

◆ restoreContinuedState()

◆ rotationCenterOffset()

◆ saveContinuedState()

◆ saveLiquifyTransformMode()

◆ scale3dSrcAndDst()

◆ scaleX()

◆ scaleY()

◆ setAlpha()

◆ setAX()

◆ setAY()

◆ setAZ()

◆ setBoundsRotation()

◆ setCameraPos()

◆ setDefaultPoints()

◆ setEditingTransformPoints()

◆ setExternalSource()

◆ setFilterId()

◆ setFlattenedPerspectiveTransform()

◆ setKeepAspectRatio()

◆ setMeshScaleHandles()

◆ setMeshShowHandles()

◆ setMeshSymmetricalHandles()

◆ setMode()

◆ setOriginalCenter()

◆ setPixelPrecision()