KisTransformUtils Class Reference

#include <kis_transform_utils.h>

Classes
struct	AnchorHolder
class	HandleChooser
struct	MatricesPack

Static Public Member Functions
static QRect	changeRect (const ToolTransformArgs &config, const QRect &rc)
static bool	checkImageTooBig (const QRectF &bounds, const MatricesPack &m, qreal cameraHeight)
static QPointF	clipInRect (QPointF p, QRectF r)
static KisTransformWorker	createTransformWorker (const ToolTransformArgs &config, KisPaintDeviceSP device, KoUpdaterPtr updater)
static qreal	effectiveHandleGrabRadius (const KisCoordinatesConverter *converter)
static qreal	effectiveRotationHandleGrabRadius (const KisCoordinatesConverter *converter)
static qreal	effectiveSize (const QRectF &rc)
static bool	fetchArgsFromCommand (const KUndo2Command *command, ToolTransformArgs *args, KisNodeList *rootNodes, KisNodeList *transformedNodes, int *oldTime)
static int	fetchCurrentImageTime (KisNodeList rootNodes)
static QList< KisNodeSP >	fetchNodesList (ToolTransformArgs::TransformMode mode, KisNodeList rootNodes, bool isExternalSourcePresent, KisSelectionSP selection)
template<class T >
static T	flakeToImage (const KisCoordinatesConverter *converter, T object)
static QRectF	handleRect (qreal radius, const QTransform &t, const QRectF &limitingRect, const QPointF &basePoint)
static QRectF	handleRect (qreal radius, const QTransform &t, const QRectF &limitingRect, qreal *dOutX, qreal *dOutY)
template<class T >
static T	imageToFlake (const KisCoordinatesConverter *converter, T object)
static QTransform	imageToFlakeTransform (const KisCoordinatesConverter *converter)
static QRect	needRect (const ToolTransformArgs &config, const QRect &rc, const QRect &srcBounds)
static void	postProcessToplevelCommand (KUndo2Command *command, const ToolTransformArgs &args, KisNodeList rootNodes, KisNodeList processedNodes, int currentTime, const KisSavedMacroCommand *overriddenCommand)
static ToolTransformArgs	resetArgsForMode (ToolTransformArgs::TransformMode mode, const QString &filterId, const TransformTransactionProperties &transaction, KisPaintDeviceSP externalSource)
static qreal	scaleFromAffineMatrix (const QTransform &t)
static qreal	scaleFromPerspectiveMatrixX (const QTransform &t, const QPointF &basePt)
static qreal	scaleFromPerspectiveMatrixY (const QTransform &t, const QPointF &basePt)
static void	setDefaultWarpPoints (int pointsPerLine, const TransformTransactionProperties *transaction, ToolTransformArgs *config)
static bool	shouldRestartStrokeOnModeChange (ToolTransformArgs::TransformMode oldMode, ToolTransformArgs::TransformMode newMode, KisNodeList processedNodes)
static bool	thumbnailTooSmall (const QTransform &resultThumbTransform, const QRect &originalImageRect)
static void	transformAndMergeDevice (const ToolTransformArgs &config, KisPaintDeviceSP src, KisPaintDeviceSP dst, KisProcessingVisitor::ProgressHelper *helper)
static void	transformDevice (const ToolTransformArgs &config, KisPaintDeviceSP device, KisProcessingVisitor::ProgressHelper *helper)
static void	transformDevice (const ToolTransformArgs &config, KisPaintDeviceSP srcDevice, KisPaintDeviceSP dstDevice, KisProcessingVisitor::ProgressHelper *helper)
static void	transformDeviceWithCroppedDst (const ToolTransformArgs &config, KisPaintDeviceSP srcDevice, KisPaintDeviceSP dstDevice, KisProcessingVisitor::ProgressHelper *helper, bool forceSubPixelTranslation)
static bool	tryFetchArgsFromCommandAndUndo (ToolTransformArgs *outArgs, ToolTransformArgs::TransformMode mode, KisNodeList currentNodes, KisNodeList selectedNodes, KisStrokeUndoFacade *undoFacade, int currentTime, QVector< KisStrokeJobData * > *undoJobs, const KisSavedMacroCommand **overriddenCommand)
static bool	tryInitArgsFromNode (KisNodeList rootNodes, ToolTransformArgs *args)
static KisNodeSP	tryOverrideRootToTransformMask (KisNodeSP root)

Static Public Attributes
static const int	handleRadius = 8
static const int	handleVisualRadius = 12
static const int	rotationHandleRadius = 8
static const int	rotationHandleVisualRadius = 12

Detailed Description

Definition at line 31 of file kis_transform_utils.h.

Member Function Documentation

changeRect()

QRect KisTransformUtils::changeRect ( const ToolTransformArgs & config, const QRect & rc )

static

Definition at line 418 of file kis_transform_utils.cpp.

{
    QRect result = rc;
 
    if (config.mode() == ToolTransformArgs::WARP) {
        KisWarpTransformWorker worker(config.warpType(),
                                      config.origPoints(),
                                      config.transfPoints(),
                                      config.alpha(),
                                      0);
 
        result = worker.approxChangeRect(rc);
 
    } else if (config.mode() == ToolTransformArgs::CAGE) {
        KisCageTransformWorker worker(rc,
                                      config.origPoints(),
                                      0,
                                      config.pixelPrecision());
 
        worker.setTransformedCage(config.transfPoints());
        result = worker.approxChangeRect(rc);
    } else if (config.mode() == ToolTransformArgs::LIQUIFY) {
        result = config.liquifyWorker() ?
            config.liquifyWorker()->approxChangeRect(rc) : rc;
    } else if (config.mode() == ToolTransformArgs::MESH) {
        result = config.meshTransform()->approxChangeRect(rc);
 
    } else {
        KIS_ASSERT_RECOVER_NOOP(0 && "this works for non-affine transformations only!");
    }
 
    return result;
}

References ToolTransformArgs::alpha(), KisCageTransformWorker::approxChangeRect(), KisLiquifyTransformWorker::approxChangeRect(), KisWarpTransformWorker::approxChangeRect(), KisBezierTransformMeshDetail::KisBezierTransformMesh::approxChangeRect(), ToolTransformArgs::CAGE, KIS_ASSERT_RECOVER_NOOP, ToolTransformArgs::LIQUIFY, ToolTransformArgs::liquifyWorker(), ToolTransformArgs::MESH, ToolTransformArgs::meshTransform(), ToolTransformArgs::mode(), ToolTransformArgs::origPoints(), ToolTransformArgs::pixelPrecision(), KisCageTransformWorker::setTransformedCage(), ToolTransformArgs::transfPoints(), ToolTransformArgs::WARP, and ToolTransformArgs::warpType().

checkImageTooBig()

bool KisTransformUtils::checkImageTooBig ( const QRectF & bounds, const MatricesPack & m, qreal cameraHeight )

static

Definition at line 191 of file kis_transform_utils.cpp.

{
    bool imageTooBig = false;
 
    QMatrix4x4 unprojectedMatrix = QMatrix4x4(m.T) * m.P * QMatrix4x4(m.TS * m.SC * m.S);
    QVector<QPointF> points;
    points << bounds.topLeft();
    points << bounds.topRight();
    points << bounds.bottomRight();
    points << bounds.bottomLeft();
 
    Q_FOREACH (const QPointF &pt, points) {
        QVector4D v(pt.x(), pt.y(), 0, 1);
 
        v = unprojectedMatrix * v;
        qreal z = v.z() / v.w();
 
        imageTooBig = z > 1.5 * cameraHeight;
 
        if (imageTooBig) {
            break;
        }
    }
 
    return imageTooBig;
}

References bounds, KisTransformUtils::MatricesPack::P, KisTransformUtils::MatricesPack::S, KisTransformUtils::MatricesPack::SC, KisTransformUtils::MatricesPack::T, KisTransformUtils::MatricesPack::TS, and v.

clipInRect()

QPointF KisTransformUtils::clipInRect ( QPointF p, QRectF r )

static

Definition at line 112 of file kis_transform_utils.cpp.

{
    QPointF center = r.center();
    QPointF t = p - center;
    r.translate(- center);
 
    if (t.y() != 0) {
        if (t.x() != 0) {
            double slope = t.y() / t.x();
 
            if (t.x() < r.left()) {
                t.setY(r.left() * slope);
                t.setX(r.left());
            }
            else if (t.x() > r.right()) {
                t.setY(r.right() * slope);
                t.setX(r.right());
            }
 
            if (t.y() < r.top()) {
                t.setX(r.top() / slope);
                t.setY(r.top());
            }
            else if (t.y() > r.bottom()) {
                t.setX(r.bottom() / slope);
                t.setY(r.bottom());
            }
        }
        else {
            if (t.y() < r.top())
                t.setY(r.top());
            else if (t.y() > r.bottom())
                t.setY(r.bottom());
        }
    }
    else {
        if (t.x() < r.left())
            t.setX(r.left());
        else if (t.x() > r.right())
            t.setX(r.right());
    }
 
    t += center;
 
    return t;
}

References p.

createTransformWorker()

KisTransformWorker KisTransformUtils::createTransformWorker ( const ToolTransformArgs & config, KisPaintDeviceSP device, KoUpdaterPtr updater )

static

Definition at line 218 of file kis_transform_utils.cpp.

{
    double scaleX = config.scaleX();
    double scaleY = config.scaleY();
    double shearX = config.shearX();
    double shearY = config.shearY();
    double aZ = config.aZ();
 
    if (config.boundsRotation() != 0.0) {
        const KisTransformUtils::MatricesPack m(config);
        QTransform Z; Z.rotateRadians(aZ);
        QTransform desired = m.BRI * m.SC * m.S * Z;
        KisAlgebra2D::DecomposedMatrix dm(desired);
        if (dm.isValid()) {
            scaleX = dm.scaleX;
            scaleY = dm.scaleY;
            shearX = dm.shearXY;
            shearY = 0;
            aZ = kisDegreesToRadians(dm.angle);
        }
    }
 
    QPointF transformedCenter;
    {
        KisTransformWorker t(0,
                             scaleX, scaleY,
                             shearX, shearY,
                             aZ,
                             0, // set X and Y translation
                             0, // to null for calculation
                             0,
                             config.filter());
 
        transformedCenter = t.transform().map(config.originalCenter());
    }
 
    QPointF translation = config.transformedCenter() - transformedCenter;
 
    KisTransformWorker transformWorker(device,
                                       scaleX, scaleY,
                                       shearX, shearY,
                                       normalizeAngle(aZ),
                                       translation.x(),
                                       translation.y(),
                                       updater,
                                       config.filter());
 
    // MatricesPack m(config);
    // ENTER_FUNCTION() << ppVar(m.finalTransform() - transformWorker.transform());
 
    return transformWorker;
}

References KisAlgebra2D::DecomposedMatrix::angle, ToolTransformArgs::aZ(), ToolTransformArgs::boundsRotation(), KisTransformUtils::MatricesPack::BRI, ToolTransformArgs::filter(), KisAlgebra2D::DecomposedMatrix::isValid(), kisDegreesToRadians(), normalizeAngle(), ToolTransformArgs::originalCenter(), KisTransformUtils::MatricesPack::S, KisTransformUtils::MatricesPack::SC, KisAlgebra2D::DecomposedMatrix::scaleX, ToolTransformArgs::scaleX(), KisAlgebra2D::DecomposedMatrix::scaleY, ToolTransformArgs::scaleY(), ToolTransformArgs::shearX(), KisAlgebra2D::DecomposedMatrix::shearXY, ToolTransformArgs::shearY(), KisTransformWorker::transform(), and ToolTransformArgs::transformedCenter().

effectiveHandleGrabRadius()

qreal KisTransformUtils::effectiveHandleGrabRadius ( const KisCoordinatesConverter * converter )

static

Definition at line 45 of file kis_transform_utils.cpp.

{
    QPointF handleRadiusPt = flakeToImage(converter, QPointF(handleRadius, handleRadius));
    return (handleRadiusPt.x() > handleRadiusPt.y()) ? handleRadiusPt.x() : handleRadiusPt.y();
}

References flakeToImage(), and handleRadius.

effectiveRotationHandleGrabRadius()

qreal KisTransformUtils::effectiveRotationHandleGrabRadius ( const KisCoordinatesConverter * converter )

static

Definition at line 51 of file kis_transform_utils.cpp.

{
    QPointF handleRadiusPt = flakeToImage(converter, QPointF(rotationHandleRadius, rotationHandleRadius));
    return (handleRadiusPt.x() > handleRadiusPt.y()) ? handleRadiusPt.x() : handleRadiusPt.y();
}

References flakeToImage(), and rotationHandleRadius.

effectiveSize()

qreal KisTransformUtils::effectiveSize ( const QRectF & rc )

static

Definition at line 71 of file kis_transform_utils.cpp.

                                                       {
    return 0.5 * (rc.width() + rc.height());
}

fetchArgsFromCommand()

bool KisTransformUtils::fetchArgsFromCommand ( const KUndo2Command * command, ToolTransformArgs * args, KisNodeList * rootNodes, KisNodeList * transformedNodes, int * oldTime )

static

Definition at line 625 of file kis_transform_utils.cpp.

{
    const TransformExtraData *data = dynamic_cast<const TransformExtraData*>(command->extraData());
 
    if (data) {
        *args = data->savedTransformArgs;
        *rootNodes = data->rootNodes;
        *transformedNodes = data->transformedNodes;
        *oldTime = data->transformedTime;
    }
 
    return bool(data);
}

References KUndo2Command::extraData(), TransformExtraData::rootNodes, TransformExtraData::savedTransformArgs, TransformExtraData::transformedNodes, and TransformExtraData::transformedTime.

fetchCurrentImageTime()

int KisTransformUtils::fetchCurrentImageTime ( KisNodeList rootNodes )

static

We cannot just use projection's default bounds, because masks don't have any projection

Definition at line 658 of file kis_transform_utils.cpp.

{
    Q_FOREACH(KisNodeSP node, rootNodes) {
        if (node && node->image()) {
            return node->image()->animationInterface()->currentTime();
        }
    }
    return -1;
}

References KisImage::animationInterface(), KisImageAnimationInterface::currentTime(), and KisBaseNode::image.

fetchNodesList()

QList< KisNodeSP > KisTransformUtils::fetchNodesList ( ToolTransformArgs::TransformMode mode, KisNodeList rootNodes, bool isExternalSourcePresent, KisSelectionSP selection )

static

Cannot transform nodes with visible transform masks inside, this situation should have been caught either in tryOverrideRootToTransformMask or in the transform tool stroke initialization routine.

Definition at line 672 of file kis_transform_utils.cpp.

{
    QList<KisNodeSP> result;
 
    Q_FOREACH (KisNodeSP root, rootNodes) {
        bool hasTransformMaskDescendant =
            KisLayerUtils::recursiveFindNode(root, [root] (KisNodeSP node) {
                return node != root && node->visible() && node->inherits("KisTransformMask");
            });
 
        KIS_SAFE_ASSERT_RECOVER_NOOP(!hasTransformMaskDescendant);
 
        KisNodeSP selectionNode = selection ? selection->parentNode() : 0;
 
        auto fetchFunc =
            [&result, mode, root, selectionNode] (KisNodeSP node) {
            if (node->isEditable(node == root) &&
                    (!node->inherits("KisShapeLayer") || mode == ToolTransformArgs::FREE_TRANSFORM) &&
                    !node->inherits("KisFileLayer") &&
                    !node->inherits("KisColorizeMask") &&
                    (!node->inherits("KisTransformMask") || node == root) &&
                    (!selectionNode || node != selectionNode)) {
 
                    result << node;
                }
        };
 
        if (isExternalSourcePresent) {
            fetchFunc(root);
        } else {
            KisLayerUtils::recursiveApplyNodes(root, fetchFunc);
        }
    }
 
    result = KisLayerUtils::sortMergeableInternalNodes(result);
    return result;
}

References ToolTransformArgs::FREE_TRANSFORM, KisBaseNode::isEditable(), KIS_SAFE_ASSERT_RECOVER_NOOP, KisSelection::parentNode, KisLayerUtils::recursiveApplyNodes(), KisLayerUtils::recursiveFindNode(), KisLayerUtils::sortMergeableInternalNodes(), and KisBaseNode::visible().

flakeToImage()

template<class T >

static T KisTransformUtils::flakeToImage ( const KisCoordinatesConverter * converter, T object )

inlinestatic

Definition at line 41 of file kis_transform_utils.h.

                                                                              {
        return converter->documentToImage(converter->flakeToDocument(object));
    }

References KisCoordinatesConverter::documentToImage(), and KisCoordinatesConverter::flakeToDocument().

handleRect() [1/2]

QRectF KisTransformUtils::handleRect ( qreal radius, const QTransform & t, const QRectF & limitingRect, const QPointF & basePoint )

static

Definition at line 108 of file kis_transform_utils.cpp.

                                                                                                                            {
    return handleRectImpl(radius, t, limitingRect, basePoint, 0, 0);
}

References handleRectImpl().

handleRect() [2/2]

QRectF KisTransformUtils::handleRect ( qreal radius, const QTransform & t, const QRectF & limitingRect, qreal * dOutX, qreal * dOutY )

static

Definition at line 104 of file kis_transform_utils.cpp.

                                                                                                                              {
    return handleRectImpl(radius, t, limitingRect, limitingRect.center(), dOutX, dOutY);
}

References handleRectImpl().

imageToFlake()

template<class T >

static T KisTransformUtils::imageToFlake ( const KisCoordinatesConverter * converter, T object )

inlinestatic

Definition at line 46 of file kis_transform_utils.h.

                                                                              {
        return converter->documentToFlake(converter->imageToDocument(object));
    }

References KisCoordinatesConverter::documentToFlake(), and KisCoordinatesConverter::imageToDocument().

imageToFlakeTransform()

QTransform KisTransformUtils::imageToFlakeTransform ( const KisCoordinatesConverter * converter )

static

Definition at line 40 of file kis_transform_utils.cpp.

{
    return converter->imageToDocumentTransform() * converter->documentToFlakeTransform();
}

References KisCoordinatesConverter::documentToFlakeTransform(), and KisCoordinatesConverter::imageToDocumentTransform().

needRect()

QRect KisTransformUtils::needRect ( const ToolTransformArgs & config, const QRect & rc, const QRect & srcBounds )

static

Definition at line 384 of file kis_transform_utils.cpp.

{
    QRect result = rc;
 
    if (config.mode() == ToolTransformArgs::WARP) {
        KisWarpTransformWorker worker(config.warpType(),
                                      config.origPoints(),
                                      config.transfPoints(),
                                      config.alpha(),
                                      0);
 
        result = worker.approxNeedRect(rc, srcBounds);
 
    } else if (config.mode() == ToolTransformArgs::CAGE) {
        KisCageTransformWorker worker(srcBounds,
                                      config.origPoints(),
                                      0,
                                      config.pixelPrecision());
        worker.setTransformedCage(config.transfPoints());
        result = worker.approxNeedRect(rc, srcBounds);
    } else if (config.mode() == ToolTransformArgs::LIQUIFY) {
        result = config.liquifyWorker() ?
            config.liquifyWorker()->approxNeedRect(rc, srcBounds) : rc;
    } else if (config.mode() == ToolTransformArgs::MESH) {
        result = config.meshTransform()->approxNeedRect(rc);
    } else {
        KIS_ASSERT_RECOVER_NOOP(0 && "this works for non-affine transformations only!");
    }
 
    return result;
}

References ToolTransformArgs::alpha(), KisBezierTransformMeshDetail::KisBezierTransformMesh::approxNeedRect(), KisCageTransformWorker::approxNeedRect(), KisLiquifyTransformWorker::approxNeedRect(), KisWarpTransformWorker::approxNeedRect(), ToolTransformArgs::CAGE, KIS_ASSERT_RECOVER_NOOP, ToolTransformArgs::LIQUIFY, ToolTransformArgs::liquifyWorker(), ToolTransformArgs::MESH, ToolTransformArgs::meshTransform(), ToolTransformArgs::mode(), ToolTransformArgs::origPoints(), ToolTransformArgs::pixelPrecision(), KisCageTransformWorker::setTransformedCage(), ToolTransformArgs::transfPoints(), ToolTransformArgs::WARP, and ToolTransformArgs::warpType().

postProcessToplevelCommand()

void KisTransformUtils::postProcessToplevelCommand ( KUndo2Command * command, const ToolTransformArgs & args, KisNodeList rootNodes, KisNodeList processedNodes, int currentTime, const KisSavedMacroCommand * overriddenCommand )

static

Definition at line 607 of file kis_transform_utils.cpp.

{
    TransformExtraData *data = new TransformExtraData();
    data->savedTransformArgs = args;
    data->rootNodes = rootNodes;
    data->transformedNodes = processedNodes;
    data->transformedTime = currentTime;
 
    command->setExtraData(data);
 
    KisSavedMacroCommand *macroCommand = dynamic_cast<KisSavedMacroCommand*>(command);
    KIS_SAFE_ASSERT_RECOVER_NOOP(macroCommand);
 
    if (overriddenCommand && macroCommand) {
        macroCommand->setOverrideInfo(overriddenCommand, {});
    }
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, TransformExtraData::rootNodes, TransformExtraData::savedTransformArgs, KUndo2Command::setExtraData(), KisSavedMacroCommand::setOverrideInfo(), TransformExtraData::transformedNodes, and TransformExtraData::transformedTime.

resetArgsForMode()

ToolTransformArgs KisTransformUtils::resetArgsForMode ( ToolTransformArgs::TransformMode mode, const QString & filterId, const TransformTransactionProperties & transaction, KisPaintDeviceSP externalSource )

static

Definition at line 515 of file kis_transform_utils.cpp.

{
    ToolTransformArgs args;
 
    args.setOriginalCenter(transaction.originalCenterGeometric());
    args.setTransformedCenter(transaction.originalCenterGeometric());
    args.setFilterId(filterId);
    args.setExternalSource(externalSource);
 
    if (mode == ToolTransformArgs::FREE_TRANSFORM) {
        args.setMode(ToolTransformArgs::FREE_TRANSFORM);
    } else if (mode == ToolTransformArgs::WARP) {
        args.setMode(ToolTransformArgs::WARP);
        KisTransformUtils::setDefaultWarpPoints(-1, &transaction, &args);
        args.setEditingTransformPoints(false);
    } else if (mode == ToolTransformArgs::CAGE) {
        args.setMode(ToolTransformArgs::CAGE);
        args.setEditingTransformPoints(true);
    } else if (mode == ToolTransformArgs::LIQUIFY) {
        args.setMode(ToolTransformArgs::LIQUIFY);
        const QRect srcRect = transaction.originalRect().toAlignedRect();
        if (!srcRect.isEmpty()) {
            args.initLiquifyTransformMode(srcRect);
        }
    } else if (mode == ToolTransformArgs::MESH) {
        args.setMode(ToolTransformArgs::MESH);
        const QRect srcRect = transaction.originalRect().toAlignedRect();
        if (!srcRect.isEmpty()) {
            *args.meshTransform() = KisBezierTransformMesh(QRectF(srcRect));
        }
    } else if (mode == ToolTransformArgs::PERSPECTIVE_4POINT) {
        args.setMode(ToolTransformArgs::PERSPECTIVE_4POINT);
    }
 
    return args;
}

References ToolTransformArgs::CAGE, ToolTransformArgs::FREE_TRANSFORM, ToolTransformArgs::initLiquifyTransformMode(), ToolTransformArgs::LIQUIFY, ToolTransformArgs::MESH, ToolTransformArgs::meshTransform(), TransformTransactionProperties::originalCenterGeometric(), TransformTransactionProperties::originalRect(), ToolTransformArgs::PERSPECTIVE_4POINT, setDefaultWarpPoints(), ToolTransformArgs::setEditingTransformPoints(), ToolTransformArgs::setExternalSource(), ToolTransformArgs::setFilterId(), ToolTransformArgs::setMode(), ToolTransformArgs::setOriginalCenter(), ToolTransformArgs::setTransformedCenter(), and ToolTransformArgs::WARP.

scaleFromAffineMatrix()

qreal KisTransformUtils::scaleFromAffineMatrix ( const QTransform & t )

static

Definition at line 57 of file kis_transform_utils.cpp.

                                                                  {
    return KoUnit::approxTransformScale(t);
}

References KoUnit::approxTransformScale().

scaleFromPerspectiveMatrixX()

qreal KisTransformUtils::scaleFromPerspectiveMatrixX ( const QTransform & t, const QPointF & basePt )

static

Definition at line 61 of file kis_transform_utils.cpp.

                                                                                               {
    const QPointF pt = basePt + QPointF(1.0, 0);
    return kisDistance(t.map(pt), t.map(basePt));
}

References kisDistance().

scaleFromPerspectiveMatrixY()

qreal KisTransformUtils::scaleFromPerspectiveMatrixY ( const QTransform & t, const QPointF & basePt )

static

Definition at line 66 of file kis_transform_utils.cpp.

                                                                                               {
    const QPointF pt = basePt + QPointF(0, 1.0);
    return kisDistance(t.map(pt), t.map(basePt));
}

References kisDistance().

setDefaultWarpPoints()

void KisTransformUtils::setDefaultWarpPoints ( int pointsPerLine, const TransformTransactionProperties * transaction, ToolTransformArgs * config )

static

Definition at line 476 of file kis_transform_utils.cpp.

{
    static const int DEFAULT_POINTS_PER_LINE = 3;
 
    if (pointsPerLine < 0) {
        pointsPerLine = DEFAULT_POINTS_PER_LINE;
    }
 
    int nbPoints = pointsPerLine * pointsPerLine;
    QVector<QPointF> origPoints(nbPoints);
    QVector<QPointF> transfPoints(nbPoints);
    qreal gridSpaceX, gridSpaceY;
 
    if (nbPoints == 1) {
        //there is actually no grid
        origPoints[0] = transaction->originalCenterGeometric();
        transfPoints[0] = transaction->originalCenterGeometric();
    }
    else if (nbPoints > 1) {
        gridSpaceX = transaction->originalRect().width() / (pointsPerLine - 1);
        gridSpaceY = transaction->originalRect().height() / (pointsPerLine - 1);
        double y = transaction->originalRect().top();
        for (int i = 0; i < pointsPerLine; ++i) {
            double x = transaction->originalRect().left();
            for (int j = 0 ; j < pointsPerLine; ++j) {
                origPoints[i * pointsPerLine + j] = QPointF(x, y);
                transfPoints[i * pointsPerLine + j] = QPointF(x, y);
                x += gridSpaceX;
            }
            y += gridSpaceY;
        }
    }
 
    config->setDefaultPoints(nbPoints > 0);
    config->setPoints(origPoints, transfPoints);
}

References TransformTransactionProperties::originalCenterGeometric(), TransformTransactionProperties::originalRect(), ToolTransformArgs::setDefaultPoints(), and ToolTransformArgs::setPoints().

shouldRestartStrokeOnModeChange()

bool KisTransformUtils::shouldRestartStrokeOnModeChange ( ToolTransformArgs::TransformMode oldMode, ToolTransformArgs::TransformMode newMode, KisNodeList processedNodes )

static

Definition at line 555 of file kis_transform_utils.cpp.

{
    bool hasExternalLayers = false;
    Q_FOREACH (KisNodeSP node, processedNodes) {
        if (node->inherits("KisShapeLayer")) {
            hasExternalLayers = true;
            break;
        }
    }
 
    bool result = false;
 
    if (hasExternalLayers) {
        result =
            (oldMode == ToolTransformArgs::FREE_TRANSFORM) !=
            (newMode == ToolTransformArgs::FREE_TRANSFORM);
    }
 
    return result;
}

References ToolTransformArgs::FREE_TRANSFORM.

thumbnailTooSmall()

bool KisTransformUtils::thumbnailTooSmall ( const QTransform & resultThumbTransform, const QRect & originalImageRect )

static

Definition at line 75 of file kis_transform_utils.cpp.

{
    return KisAlgebra2D::minDimension(resultThumbTransform.mapRect(originalImageRect)) < 32;
}

References KisAlgebra2D::minDimension().

transformAndMergeDevice()

void KisTransformUtils::transformAndMergeDevice ( const ToolTransformArgs & config, KisPaintDeviceSP src, KisPaintDeviceSP dst, KisProcessingVisitor::ProgressHelper * helper )

static

Definition at line 576 of file kis_transform_utils.cpp.

{
    KoUpdaterPtr mergeUpdater = helper->updater();
 
    KisPaintDeviceSP tmp = new KisPaintDevice(src->colorSpace());
    tmp->prepareClone(src);
 
    KisTransformUtils::transformDevice(config, src, tmp, helper);
 
    QRect mergeRect = tmp->extent();
    KisPainter painter(dst);
    painter.setProgress(mergeUpdater);
    painter.bitBlt(mergeRect.topLeft(), tmp, mergeRect);
    painter.end();
}

References KisPainter::bitBlt(), KisPainter::end(), KisPainter::setProgress(), transformDevice(), and KisProcessingVisitor::ProgressHelper::updater().

transformDevice() [1/2]

void KisTransformUtils::transformDevice ( const ToolTransformArgs & config, KisPaintDeviceSP device, KisProcessingVisitor::ProgressHelper * helper )

static

Definition at line 273 of file kis_transform_utils.cpp.

{
    KisPaintDeviceSP tmp = new KisPaintDevice(*device);
    transformDevice(config, tmp, device, helper);
}

References transformDevice().

transformDevice() [2/2]

void KisTransformUtils::transformDevice ( const ToolTransformArgs & config, KisPaintDeviceSP srcDevice, KisPaintDeviceSP dstDevice, KisProcessingVisitor::ProgressHelper * helper )

static

Definition at line 371 of file kis_transform_utils.cpp.

{
    transformDeviceImpl(config, srcDevice, dstDevice, helper, false, false);
}

transformDeviceWithCroppedDst()

void KisTransformUtils::transformDeviceWithCroppedDst ( const ToolTransformArgs & config, KisPaintDeviceSP srcDevice, KisPaintDeviceSP dstDevice, KisProcessingVisitor::ProgressHelper * helper, bool forceSubPixelTranslation )

static

Definition at line 379 of file kis_transform_utils.cpp.

{
    transformDeviceImpl(config, srcDevice, dstDevice, helper, true, forceSubPixelTranslation);
}

tryFetchArgsFromCommandAndUndo()

bool KisTransformUtils::tryFetchArgsFromCommandAndUndo ( ToolTransformArgs * outArgs, ToolTransformArgs::TransformMode mode, KisNodeList currentNodes, KisNodeList selectedNodes, KisStrokeUndoFacade * undoFacade, int currentTime, QVector< KisStrokeJobData * > * undoJobs, const KisSavedMacroCommand ** overriddenCommand )

static

Definition at line 738 of file kis_transform_utils.cpp.

{
    bool result = false;
 
    const KUndo2Command *lastCommand = undoFacade->lastExecutedCommand();
    KisNodeList oldRootNodes;
    KisNodeList oldTransformedNodes;
    int oldTime = -1;
 
    ToolTransformArgs args;
 
    if (lastCommand &&
        KisTransformUtils::fetchArgsFromCommand(lastCommand, &args, &oldRootNodes, &oldTransformedNodes, &oldTime) &&
        args.mode() == mode &&
        oldRootNodes == currentNodes &&
        oldTime == currentTime) {
 
        if (KritaUtils::compareListsUnordered(oldTransformedNodes, selectedNodes)) {
            args.saveContinuedState();
 
            *outArgs = args;
 
            const KisSavedMacroCommand *command = dynamic_cast<const KisSavedMacroCommand*>(lastCommand);
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(command, false);
 
            // the jobs are fetched as !shouldGoToHistory,
            // so there is no need to put them into
            // m_s->skippedWhileMergeCommands
            command->getCommandExecutionJobs(undoJobs, true, false);
            *overriddenCommand = command;
 
            result = true;
        }
    }
 
    return result;
}

References KritaUtils::compareListsUnordered(), fetchArgsFromCommand(), KisSavedMacroCommand::getCommandExecutionJobs(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisStrokeUndoFacade::lastExecutedCommand(), ToolTransformArgs::mode(), and ToolTransformArgs::saveContinuedState().

tryInitArgsFromNode()

bool KisTransformUtils::tryInitArgsFromNode ( KisNodeList rootNodes, ToolTransformArgs * args )

static

Definition at line 714 of file kis_transform_utils.cpp.

{
    bool result = false;
 
    Q_FOREACH(KisNodeSP node, rootNodes) {
        if (KisTransformMaskSP mask =
            dynamic_cast<KisTransformMask*>(node.data())) {
 
            KisTransformMaskParamsInterfaceSP savedParams =
                mask->transformParams();
 
            KisTransformMaskAdapter *adapter =
                dynamic_cast<KisTransformMaskAdapter*>(savedParams.data());
 
            if (adapter && adapter->isInitialized()) {
                *args = *adapter->transformArgs();
                result = true;
            }
        }
    }
 
    return result;
}

References KisSharedPtr< T >::data(), KisTransformMaskAdapter::isInitialized(), and KisTransformMaskAdapter::transformArgs().

tryOverrideRootToTransformMask()

KisNodeSP KisTransformUtils::tryOverrideRootToTransformMask ( KisNodeSP root )

static

Definition at line 639 of file kis_transform_utils.cpp.

{
    // we search for masks only at the first level of hierarchy,
    // all other masks are just ignored.
 
    KisNodeSP node = root->firstChild();
 
    while (node) {
        if (node->inherits("KisTransformMask") && node->isEditable()) {
            root = node;
            break;
        }
 
        node = node->nextSibling();
    }
 
    return root;
}

References KisNode::firstChild(), KisBaseNode::isEditable(), and KisNode::nextSibling().

Member Data Documentation

handleRadius

const int KisTransformUtils::handleRadius = 8

static

Definition at line 37 of file kis_transform_utils.h.

handleVisualRadius

const int KisTransformUtils::handleVisualRadius = 12

static

Definition at line 36 of file kis_transform_utils.h.

rotationHandleRadius

const int KisTransformUtils::rotationHandleRadius = 8

static

Definition at line 38 of file kis_transform_utils.h.

rotationHandleVisualRadius

const int KisTransformUtils::rotationHandleVisualRadius = 12

static

Definition at line 35 of file kis_transform_utils.h.

---

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

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