#include <kis_green_coordinates_math.h>

Inheritance diagram for KisGreenCoordinatesMath:

Public Member Functions
void	generateTransformedCageNormals (const QVector< QPointF > &transformedCage)

	KisGreenCoordinatesMath ()

void	precalculateGreenCoordinates (const QVector< QPointF > &originalCage, const QVector< QPointF > &points)

void	precalculateOneEdge (const QPointF &pt, const QPointF &v1, const QPointF &v2, qreal edge_psi, qreal vertex1_phi, qreal *vertex2_phi, int polygonDirection)

void	precalculateOnePoint (const QVector< QPointF > &originalCage, PrecalculatedCoords *coords, const QPointF &pt, int polygonDirection)

	Private ()

QPointF	transformedPoint (int pointIndex, const QVector< QPointF > &transformedCage)

	~KisGreenCoordinatesMath ()

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Attributes
QVector< qreal >	originalCageEdgeSizes

QVector< PrecalculatedCoords >	precalculatedCoords

int	transformedCageDirection

QVector< QPointF >	transformedCageNormals

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 29 of file kis_green_coordinates_math.cpp.

Constructor & Destructor Documentation

◆ KisGreenCoordinatesMath()

KisGreenCoordinatesMath::KisGreenCoordinatesMath ( )

Definition at line 115 of file kis_green_coordinates_math.cpp.

    : m_d(new Private())
{
}

◆ ~KisGreenCoordinatesMath()

KisGreenCoordinatesMath::~KisGreenCoordinatesMath ( )

Definition at line 120 of file kis_green_coordinates_math.cpp.

121{

122}

Member Function Documentation

◆ generateTransformedCageNormals()

void KisGreenCoordinatesMath::generateTransformedCageNormals ( const QVector< QPointF > & transformedCage )

Precalculate coefficients of the destination cage. Should be called once for every cage change

Definition at line 153 of file kis_green_coordinates_math.cpp.

{
    m_d->transformedCageDirection = polygonDirection(transformedCage);
 
    const int numCagePoints = transformedCage.size();
    m_d->transformedCageNormals.resize(numCagePoints);
 
    for (int i = 1; i <= numCagePoints; i++) {
        int endIndex = i != numCagePoints ? i : 0;
        int startIndex = i - 1;
 
        QPointF transformedEdge =
            transformedCage[endIndex] - transformedCage[startIndex];
 
        qreal scaleCoeff =
            norm(transformedEdge) / m_d->originalCageEdgeSizes[startIndex];
 
        m_d->transformedCageNormals[startIndex] =
            scaleCoeff * inwardUnitNormal(transformedEdge, m_d->transformedCageDirection);
    }
}

References KisAlgebra2D::inwardUnitNormal(), m_d, KisAlgebra2D::norm(), and KisAlgebra2D::polygonDirection().

◆ precalculateGreenCoordinates()

void KisGreenCoordinatesMath::precalculateGreenCoordinates	(	const QVector< QPointF > &	originalCage,
		const QVector< QPointF > &	points )

Prepare the transformation framework by computing internal coordinates of the points in cage.

Please note that the points in points will later be accessed with indexes only.

Definition at line 124 of file kis_green_coordinates_math.cpp.

{
    const int cageDirection = polygonDirection(originalCage);
    const int numPoints = points.size();
    const int numCagePoints = originalCage.size();
 
    m_d->originalCageEdgeSizes.resize(numCagePoints);
 
    for (int i = 1; i <= numCagePoints; i++) {
        int endIndex = i != numCagePoints ? i : 0;
        int startIndex = i - 1;
 
        m_d->originalCageEdgeSizes[startIndex] =
            norm(originalCage[endIndex] - originalCage[startIndex]);
    }
 
    m_d->precalculatedCoords.resize(numPoints);
 
    for (int i = 0; i < numPoints; i++) {
        m_d->precalculatedCoords[i].psi.resize(numCagePoints);
        m_d->precalculatedCoords[i].phi.resize(numCagePoints);
 
        m_d->precalculateOnePoint(originalCage,
                                  &m_d->precalculatedCoords[i],
                                  points[i],
                                  cageDirection);
    }
}

References m_d, KisAlgebra2D::norm(), and KisAlgebra2D::polygonDirection().

◆ precalculateOneEdge()

void KisGreenCoordinatesMath::precalculateOneEdge	(	const QPointF &	pt,
		const QPointF &	v1,
		const QPointF &	v2,
		qreal *	edge_psi,
		qreal *	vertex1_phi,
		qreal *	vertex2_phi,
		int	polygonDirection )

inline

◆ precalculateOnePoint()

void KisGreenCoordinatesMath::precalculateOnePoint	(	const QVector< QPointF > &	originalCage,
		PrecalculatedCoords *	coords,
		const QPointF &	pt,
		int	polygonDirection )

◆ Private()

KisGreenCoordinatesMath::Private ( )

inline

Definition at line 31 of file kis_green_coordinates_math.cpp.

31: transformedCageDirection(0) {}

KisGreenCoordinatesMath::transformedCageDirection

int transformedCageDirection

Definition kis_green_coordinates_math.cpp:35

◆ transformedPoint()

QPointF KisGreenCoordinatesMath::transformedPoint	(	int	pointIndex,
		const QVector< QPointF > &	transformedCage )

Transform one point according to its index

Definition at line 175 of file kis_green_coordinates_math.cpp.

{
    QPointF result;
 
    const int numCagePoints = transformedCage.size();
 
 
    PrecalculatedCoords *coords = &m_d->precalculatedCoords[pointIndex];
 
    for (int i = 0; i < numCagePoints; i++) {
        result += coords->phi[i] * transformedCage[i];
        result += coords->psi[i] * m_d->transformedCageNormals[i];
    }
 
    return result;
}