#include <KisBezierGradientMesh.h>

Inheritance diagram for KisBezierGradientMeshDetail::KisBezierGradientMesh:

Public Member Functions
PatchIndex	hitTestPatch (const QPointF &pt, QPointF *localPointResult) const

void	renderMesh (const QPoint &dstQImageOffset, QImage *dstImage) const

Public Member Functions inherited from KisBezierMeshDetails::Mesh< NodeArg, PatchArg >
control_point_iterator	beginControlPoints ()

control_point_const_iterator	beginControlPoints () const

patch_iterator	beginPatches ()

patch_const_iterator	beginPatches () const

segment_iterator	beginSegments ()

segment_const_iterator	beginSegments () const

control_point_const_iterator	constBeginControlPoints () const

patch_const_iterator	constBeginPatches () const

segment_const_iterator	constBeginSegments () const

control_point_const_iterator	constEndControlPoints () const

patch_const_iterator	constEndPatches () const

segment_const_iterator	constEndSegments () const

control_point_const_iterator	constFind (const ControlPointIndex &index) const

control_point_const_iterator	constFind (const NodeIndex &index) const

patch_const_iterator	constFind (const PatchIndex &index) const

segment_const_iterator	constFind (const SegmentIndex &index) const

QRectF	dstBoundingRect () const

control_point_iterator	endControlPoints ()

control_point_const_iterator	endControlPoints () const

patch_iterator	endPatches ()

patch_const_iterator	endPatches () const

segment_iterator	endSegments ()

segment_const_iterator	endSegments () const

control_point_iterator	find (const ControlPointIndex &index)

control_point_const_iterator	find (const ControlPointIndex &index) const

control_point_iterator	find (const NodeIndex &index)

control_point_const_iterator	find (const NodeIndex &index) const

patch_iterator	find (const PatchIndex &index)

patch_const_iterator	find (const PatchIndex &index) const

segment_iterator	find (const SegmentIndex &index)

segment_const_iterator	find (const SegmentIndex &index) const

ControlPointIndex	hitTestControlPoint (const QPointF &pt, qreal distanceThreshold) const

ControlPointIndex	hitTestNode (const QPointF &pt, qreal distanceThreshold) const

SegmentIndex	hitTestSegment (const QPointF &pt, qreal distanceThreshold, qreal *t=0) const

bool	isIdentity () const

template<typename T >
bool	isIndexValid (const T &index) const

Patch	makePatch (const PatchIndex &index) const

Patch	makePatch (int col, int row) const

	Mesh ()

	Mesh (const QRectF &mapRect, const QSize &size=QSize(2, 2))

Node &	node (const NodeIndex &index)

const Node &	node (const NodeIndex &index) const

Node &	node (int col, int row)

const Node &	node (int col, int row) const

bool	operator== (const Mesh &rhs) const

QRectF	originalRect () const

void	removeColumn (int column)

void	removeColumnOrRow (NodeIndex index, bool row)

void	removeRow (int row)

void	reshapeMeshHorizontally (int numColumns)

void	reshapeMeshVertically (int numRows)

QSize	size () const

int	subdivideColumn (int leftColumn, qreal relProportionalT)

int	subdivideColumn (qreal proportionalT)

int	subdivideRow (int topRow, qreal relProportionalT)

int	subdivideRow (qreal proportionalT)

void	subdivideSegment (SegmentIndex index, qreal proportionalT)

void	transform (const QTransform &t)

void	transformSrcAndDst (const QTransform &t)

void	translate (const QPointF &offset)

Static Public Member Functions
static void	renderPatch (const GradientMeshPatch &patch, const QPoint &dstQImageOffset, QImage *dstImage)

Friends
KRITAIMAGE_EXPORT bool	loadValue (const QDomElement &parent, const QString &tag, KisBezierGradientMesh *mesh)

KRITAIMAGE_EXPORT void	saveValue (QDomElement *parent, const QString &tag, const KisBezierGradientMesh &mesh)

Additional Inherited Members
Public Types inherited from KisBezierMeshDetails::Mesh< NodeArg, PatchArg >
using	control_point_const_iterator = control_point_iterator_impl<true>

using	control_point_iterator = control_point_iterator_impl<false>

using	ControlType = typename ControlPointIndex::ControlType

using	Node = NodeArg

using	Patch = PatchArg

using	patch_const_iterator = patch_iterator_impl<true>

using	patch_iterator = patch_iterator_impl<false>

using	segment_const_iterator = segment_iterator_impl<true>

using	segment_iterator = segment_iterator_impl<false>

using	SegmentIndex = std::pair<NodeIndex, int>

Protected Attributes inherited from KisBezierMeshDetails::Mesh< NodeArg, PatchArg >
std::vector< qreal >	m_columns

std::vector< Node >	m_nodes

QRectF	m_originalRect

std::vector< qreal >	m_rows

QSize	m_size

Detailed Description

Definition at line 63 of file KisBezierGradientMesh.h.

Member Function Documentation

◆ hitTestPatch()

KisBezierGradientMesh::PatchIndex KisBezierGradientMesh::hitTestPatch	(	const QPointF &	pt,
		QPointF *	localPointResult ) const

Definition at line 134 of file KisBezierGradientMesh.cpp.

                                                                                                                      {
    auto result = endPatches();
 
    const QRectF unitRect(0, 0, 1, 1);
 
    for (auto it = beginPatches(); it != endPatches(); ++it) {
        Patch patch = *it;
 
        if (patch.dstBoundingRect().contains(pt)) {
            const QPointF localPos = KisBezierUtils::calculateLocalPosSVG2(patch.points, pt);
 
            if (unitRect.contains(localPos)) {
 
                if (localPointResult) {
                    *localPointResult = localPos;
                }
 
                result = it;
                break;
            }
        }
    }
 
    return result.patchIndex();
}

References KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::beginPatches(), KisBezierUtils::calculateLocalPosSVG2(), and KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endPatches().

◆ renderMesh()

void KisBezierGradientMesh::renderMesh	(	const QPoint &	dstQImageOffset,
		QImage *	dstImage ) const

Definition at line 188 of file KisBezierGradientMesh.cpp.

{
    for (auto it = beginPatches(); it != endPatches(); ++it) {
        renderPatch(*it, dstQImageOffset, dstImage);
    }
}

References KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::beginPatches(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endPatches(), and renderPatch().

◆ renderPatch()

void KisBezierGradientMesh::renderPatch	(	const GradientMeshPatch &	patch,
		const QPoint &	dstQImageOffset,
		QImage *	dstImage )

static

Definition at line 160 of file KisBezierGradientMesh.cpp.

{
    QVector<QPointF> originalPointsLocal;
    QVector<QPointF> transformedPointsLocal;
    QSize gridSize;
 
    patch.sampleRegularGridSVG2(gridSize, originalPointsLocal, transformedPointsLocal, QPointF(8,8));
 
    const QRect dstBoundsI = patch.dstBoundingRect().toAlignedRect();
    const QRect imageSize = QRect(dstQImageOffset, dstImage->size());
    KIS_SAFE_ASSERT_RECOVER_NOOP(imageSize.contains(dstBoundsI));
 
    {
        QImageGradientOp polygonOp(patch.colors, *dstImage, dstQImageOffset);
 
 
        GridIterationTools::RegularGridIndexesOp indexesOp(gridSize);
        GridIterationTools::iterateThroughGrid
                <GridIterationTools::AlwaysCompletePolygonPolicy>(polygonOp, indexesOp,
                                                                  gridSize,
                                                                  originalPointsLocal,
                                                                  transformedPointsLocal);
 
    }
}

References KisBezierGradientMeshDetail::GradientMeshPatch::colors, KisBezierPatch::dstBoundingRect(), GridIterationTools::iterateThroughGrid(), KIS_SAFE_ASSERT_RECOVER_NOOP, and KisBezierPatch::sampleRegularGridSVG2().

Friends And Related Symbol Documentation

◆ loadValue

KRITAIMAGE_EXPORT bool loadValue	(	const QDomElement &	parent,
		const QString &	tag,
		KisBezierGradientMesh *	mesh )

friend

Definition at line 112 of file KisBezierGradientMesh.cpp.

{
    QDomElement e;
    if (!KisDomUtils::findOnlyElement(parent, tag, &e)) return false;
 
    if (!KisDomUtils::Private::checkType(e, "gradient-mesh")) return false;
 
    mesh->m_columns.clear();
    mesh->m_rows.clear();
    mesh->m_nodes.clear();
 
    KisDomUtils::loadValue(e, "size", &mesh->m_size);
    KisDomUtils::loadValue(e, "srcRect", &mesh->m_originalRect);
    KisDomUtils::loadValue(e, "columns", &mesh->m_columns);
    KisDomUtils::loadValue(e, "rows", &mesh->m_rows);
    KisDomUtils::loadValue(e, "nodes", &mesh->m_nodes);
 
    return true;
}

◆ saveValue

KRITAIMAGE_EXPORT void saveValue	(	QDomElement *	parent,
		const QString &	tag,
		const KisBezierGradientMesh &	mesh )

friend

Definition at line 97 of file KisBezierGradientMesh.cpp.

{
    QDomDocument doc = parent->ownerDocument();
    QDomElement e = doc.createElement(tag);
    parent->appendChild(e);
 
    e.setAttribute("type", "gradient-mesh");
 
    KisDomUtils::saveValue(&e, "size", mesh.m_size);
    KisDomUtils::saveValue(&e, "srcRect", mesh.m_originalRect);
    KisDomUtils::saveValue(&e, "columns", mesh.m_columns);
    KisDomUtils::saveValue(&e, "rows", mesh.m_rows);
    KisDomUtils::saveValue(&e, "nodes", mesh.m_nodes);
}

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

libs/image/KisBezierGradientMesh.h
libs/image/KisBezierGradientMesh.cpp

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members