KisBezierMeshDetails Namespace Reference

Classes
struct	BaseMeshNode
class	Mesh

Enumerations
enum	SmartMoveMeshControlMode { MoveFree , MoveSymmetricLock , MoveRotationLock }

Functions
void	assignPatchData (KisBezierPatch *patch, const QRectF &srcRect, const BaseMeshNode &tl, const BaseMeshNode &tr, const BaseMeshNode &bl, const BaseMeshNode &br)
void	lerpNodeData (const BaseMeshNode &left, const BaseMeshNode &right, qreal t, BaseMeshNode &dst)
KRITAGLOBAL_EXPORT bool	loadValue (const QDomElement &parent, BaseMeshNode *node)
KRITAGLOBAL_EXPORT QDebug	operator<< (QDebug dbg, const BaseMeshNode &n)
template<typename Node , typename Patch >
QDebug	operator<< (QDebug dbg, const Mesh< Node, Patch > &mesh)
KRITAGLOBAL_EXPORT void	saveValue (QDomElement *parent, const QString &tag, const BaseMeshNode &node)
template<typename NodeArg , typename PatchArg >
void	smartMoveControl (Mesh< NodeArg, PatchArg > &mesh, typename Mesh< NodeArg, PatchArg >::ControlPointIndex index, const QPointF &move, SmartMoveMeshControlMode mode, bool scaleNodeMoves)

Enumeration Type Documentation

SmartMoveMeshControlMode

enum KisBezierMeshDetails::SmartMoveMeshControlMode

Enumerator
MoveFree
MoveSymmetricLock
MoveRotationLock

Definition at line 1434 of file KisBezierMesh.h.

                              {
    MoveFree,
    MoveSymmetricLock,
    MoveRotationLock
};

Function Documentation

assignPatchData()

void KisBezierMeshDetails::assignPatchData ( KisBezierPatch * patch, const QRectF & srcRect, const BaseMeshNode & tl, const BaseMeshNode & tr, const BaseMeshNode & bl, const BaseMeshNode & br )

inline

Definition at line 112 of file KisBezierMesh.h.

{
    patch->originalRect = srcRect;
    Q_UNUSED(tl);
    Q_UNUSED(tr);
    Q_UNUSED(bl);
    Q_UNUSED(br);
}

References KisBezierPatch::originalRect.

lerpNodeData()

void KisBezierMeshDetails::lerpNodeData ( const BaseMeshNode & left, const BaseMeshNode & right, qreal t, BaseMeshNode & dst )

inline

Definition at line 104 of file KisBezierMesh.h.

{
    Q_UNUSED(left);
    Q_UNUSED(right);
    Q_UNUSED(t);
    Q_UNUSED(dst);
}

loadValue()

bool KisBezierMeshDetails::loadValue	(	const QDomElement &	parent,
		KisBezierMeshDetails::BaseMeshNode *	node )

Definition at line 38 of file KisBezierMesh.cpp.

{
    if (!KisDomUtils::Private::checkType(parent, "mesh-node")) return false;
 
    KisDomUtils::loadValue(parent, "node", &node->node);
    KisDomUtils::loadValue(parent, "left-control", &node->leftControl);
    KisDomUtils::loadValue(parent, "right-control", &node->rightControl);
    KisDomUtils::loadValue(parent, "top-control", &node->topControl);
    KisDomUtils::loadValue(parent, "bottom-control", &node->bottomControl);
 
    return true;
}

References KisBezierMeshDetails::BaseMeshNode::bottomControl, KisDomUtils::Private::checkType(), KisBezierMeshDetails::BaseMeshNode::leftControl, KisDomUtils::loadValue(), KisBezierMeshDetails::BaseMeshNode::node, KisBezierMeshDetails::BaseMeshNode::rightControl, and KisBezierMeshDetails::BaseMeshNode::topControl.

operator<<() [1/2]

QDebug KisBezierMeshDetails::operator<<	(	QDebug	dbg,
		const BaseMeshNode &	n )

Definition at line 13 of file KisBezierMesh.cpp.

                                                                         {
    dbg.nospace() << "Node " << n.node << " "
                  << "(lC: " << n.leftControl << " "
                  << "tC: " << n.topControl << " "
                  << "rC: " << n.rightControl << " "
                  << "bC: " << n.bottomControl << ") ";
    return dbg.nospace();
}

References KisBezierMeshDetails::BaseMeshNode::bottomControl, KisBezierMeshDetails::BaseMeshNode::leftControl, KisBezierMeshDetails::BaseMeshNode::node, KisBezierMeshDetails::BaseMeshNode::rightControl, and KisBezierMeshDetails::BaseMeshNode::topControl.

operator<<() [2/2]

template<typename Node , typename Patch >

QDebug KisBezierMeshDetails::operator<<	(	QDebug	dbg,
		const Mesh< Node, Patch > &	mesh )

Definition at line 1293 of file KisBezierMesh.h.

{
    dbg.nospace() << "Mesh " << mesh.size() << "\n";
 
    for (int y = 0; y < mesh.size().height(); y++) {
        for (int x = 0; x < mesh.size().width(); x++) {
            dbg.nospace() << "    node(" << x << ", " << y << ") " << mesh.node(x, y) << "\n";
        }
    }
    return dbg.space();
}

References KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::node(), and KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::size().

saveValue()

void KisBezierMeshDetails::saveValue	(	QDomElement *	parent,
		const QString &	tag,
		const BaseMeshNode &	node )

Definition at line 24 of file KisBezierMesh.cpp.

{
    QDomDocument doc = parent->ownerDocument();
    QDomElement e = doc.createElement(tag);
    parent->appendChild(e);
 
    e.setAttribute("type", "mesh-node");
    KisDomUtils::saveValue(&e, "node", node.node);
    KisDomUtils::saveValue(&e, "left-control", node.leftControl);
    KisDomUtils::saveValue(&e, "right-control", node.rightControl);
    KisDomUtils::saveValue(&e, "top-control", node.topControl);
    KisDomUtils::saveValue(&e, "bottom-control", node.bottomControl);
}

References KisBezierMeshDetails::BaseMeshNode::bottomControl, KisBezierMeshDetails::BaseMeshNode::leftControl, KisBezierMeshDetails::BaseMeshNode::node, KisBezierMeshDetails::BaseMeshNode::rightControl, KisDomUtils::saveValue(), and KisBezierMeshDetails::BaseMeshNode::topControl.

smartMoveControl()

template<typename NodeArg , typename PatchArg >

void KisBezierMeshDetails::smartMoveControl	(	Mesh< NodeArg, PatchArg > &	mesh,
		typename Mesh< NodeArg, PatchArg >::ControlPointIndex	index,
		const QPointF &	move,
		SmartMoveMeshControlMode	mode,
		bool	scaleNodeMoves )

Definition at line 1441 of file KisBezierMesh.h.

{
    using ControlType = typename Mesh<NodeArg, PatchArg>::ControlType;
    using ControlPointIndex = typename Mesh<NodeArg, PatchArg>::ControlPointIndex;
//    using ControlPointIterator = typename Mesh<NodeArg, PatchArg>::control_point_iterator;
    using SegmentIterator = typename Mesh<NodeArg, PatchArg>::segment_iterator;
 
    auto it = mesh.find(index);
    KIS_SAFE_ASSERT_RECOVER_RETURN(it != mesh.endControlPoints());
 
    if (it.isNode()) {
        auto preAdjustSegment = [] (Mesh<NodeArg, PatchArg> &mesh,
                                    SegmentIterator it,
                                    const QPointF &normalizedOffset) {
 
            if (it == mesh.endSegments()) return;
 
            const QPointF base1 = it.p3() - it.p0();
            const QPointF base2 = it.p3() - it.p0() - normalizedOffset;
 
            {
                const QPointF control = it.p1() - it.p0();
                const qreal dist0 = KisAlgebra2D::norm(base1);
                const qreal dist1 = KisAlgebra2D::dotProduct(base2, base1) / dist0;
                const qreal coeff = dist1 / dist0;
 
                it.p1() = it.p0() + coeff * (control);
            }
            {
                const QPointF control = it.p2() - it.p3();
                const qreal dist0 = KisAlgebra2D::norm(base1);
                const qreal dist1 = KisAlgebra2D::dotProduct(base2, base1) / dist0;
                const qreal coeff = dist1 / dist0;
 
                it.p2() = it.p3() + coeff * (control);
            }
        };
 
        if (scaleNodeMoves) {
            preAdjustSegment(mesh, it.topSegment(), -move);
            preAdjustSegment(mesh, it.leftSegment(), -move);
            preAdjustSegment(mesh, it.bottomSegment(), move);
            preAdjustSegment(mesh, it.rightSegment(), move);
        }
 
        it.node().translate(move);
 
    } else {
        const QPointF newPos = *it + move;
 
        if (mode == MoveRotationLock || mode == MoveSymmetricLock) {
            const qreal rotation = KisAlgebra2D::angleBetweenVectors(*it - it.node().node,
                                                                     newPos - it.node().node);
            QTransform R;
            R.rotateRadians(rotation);
 
            const QTransform t =
                    QTransform::fromTranslate(-it.node().node.x(), -it.node().node.y()) *
                    R *
                    QTransform::fromTranslate(it.node().node.x(), it.node().node.y());
 
            if (mode == MoveRotationLock) {
                for (int intType = 0; intType < 4; intType++) {
                    ControlType type = static_cast<ControlType>(intType);
 
                    if (type == ControlType::Node ||
                            type == index.controlType) {
 
                        continue;
                    }
 
                    auto neighbourIt = mesh.find(ControlPointIndex(index.nodeIndex, type));
                    if (neighbourIt == mesh.endControlPoints()) continue;
 
                    *neighbourIt = t.map(*neighbourIt);
                }
            } else {
                auto neighbourIt = it.symmetricControl();
                if (neighbourIt != mesh.endControlPoints()) {
                    *neighbourIt = t.map(*neighbourIt);
                }
            }
        }
 
        *it = newPos;
    }
}

References KisAlgebra2D::angleBetweenVectors(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::ControlPointIndex::controlType, KisAlgebra2D::dotProduct(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endControlPoints(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endSegments(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::find(), KIS_SAFE_ASSERT_RECOVER_RETURN, MoveRotationLock, MoveSymmetricLock, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::node(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::ControlPointIndex::nodeIndex, KisAlgebra2D::norm(), R, and KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::control_point_iterator_impl< is_const >::symmetricControl().