#include <kis_four_point_interpolator_backward.h>

Public Member Functions
QPointF	fallbackSourcePoint () const

QPointF	getValue () const

bool	isValid (const qreal tolerance=0.1) const

	KisFourPointInterpolatorBackward (const QPolygonF &srcPolygon, const QPolygonF &dstPolygon)

QPointF	map (const QPointF &pt)

void	setX (qreal x)

void	setY (qreal y)

Private Attributes
QPointF	m_a

QPointF	m_b

QPointF	m_c

QPointF	m_d

QPointF	m_dstBase

qreal	m_px {0.0}

qreal	m_py {0.0}

qreal	m_qA {0.0}

qreal	m_qB_const {0.0}

qreal	m_qB_varX {0.0}

qreal	m_qB_varY {0.0}

qreal	m_qC_varX {0.0}

qreal	m_qC_varY {0.0}

qreal	m_qD_div {0.0}

QPointF	m_srcBase

qreal	m_xCoeff {0.0}

qreal	m_yCoeff {0.0}

Detailed Description

A--—B The polygons must be initialized in this order: | | | | polygon << A << B << D << C; C--—D

Definition at line 24 of file kis_four_point_interpolator_backward.h.

Constructor & Destructor Documentation

◆ KisFourPointInterpolatorBackward()

KisFourPointInterpolatorBackward::KisFourPointInterpolatorBackward	(	const QPolygonF &	srcPolygon,
		const QPolygonF &	dstPolygon )

inline

Definition at line 27 of file kis_four_point_interpolator_backward.h.

                                                                                               {
        m_a = dstPolygon[1] - dstPolygon[0]; // AB
        m_b = dstPolygon[2] - dstPolygon[1]; // BD
        m_c = dstPolygon[3] - dstPolygon[0]; // AC
        m_d = m_b - m_c; // BD - AC
 
        m_qA = m_c.x() * m_d.y() - m_c.y() * m_d.x();
 
        m_srcBase = srcPolygon[0];
        m_dstBase = dstPolygon[0];
        m_xCoeff = srcPolygon[1].x() - srcPolygon[0].x(); // AB_src
        m_yCoeff = srcPolygon[3].y() - srcPolygon[0].y(); // AC_src
 
        m_qB_const = m_c.x() * m_a.y() - m_c.y() * m_a.x();
 
        m_qD_div = 1.0 / (2 * m_qA);
 
        //m_qB_varX = 0.0;
        //m_qB_varY = 0.0;
    }

References m_a, m_b, m_c, m_d, m_dstBase, m_qA, m_qB_const, m_qD_div, m_srcBase, m_xCoeff, and m_yCoeff.

Member Function Documentation

◆ fallbackSourcePoint()

QPointF KisFourPointInterpolatorBackward::fallbackSourcePoint ( ) const

inline

Definition at line 61 of file kis_four_point_interpolator_backward.h.

                                               {
        return m_srcBase + QPointF(0.5 * m_xCoeff, 0.5 * m_yCoeff);
    }

References m_srcBase, m_xCoeff, and m_yCoeff.

◆ getValue()

QPointF KisFourPointInterpolatorBackward::getValue ( ) const

inline

Definition at line 87 of file kis_four_point_interpolator_backward.h.

                                    {
        static const qreal eps = 1e-10;
 
        qreal qB = m_qB_const + m_qB_varX + m_qB_varY;
        qreal qC = m_qC_varX + m_qC_varY;
 
        qreal nu = 0.0;
 
        if (qAbs(m_qA) < eps) {
            nu = -qC / qB;
        } else {
            qreal D = pow2(qB) - 4 * m_qA * qC;
            if (D > 0.0) {
                qreal sqrtD = std::sqrt(D);
                nu = (-qB - sqrtD) * m_qD_div;
                if (nu < 0.0 || nu > 1.0) {
                    qreal nu2 = (-qB + sqrtD) * m_qD_div;
 
                    if (nu2 < 0.0 || nu2 > 1.0) {
                        nu = qBound(qreal(0.0), nu, qreal(1.0));
                    } else {
                        nu = nu2;
                    }
                }
            } else {
                nu = 0.0;
            }
        }
 
        qreal xBasedDenominator = m_a.x() + nu * m_d.x();
 
        qreal mu;
 
        if (qAbs(xBasedDenominator) > eps) {
            mu = (m_px - nu * m_c.x()) / xBasedDenominator;
        } else {
            mu = (m_py - nu * m_c.y()) / (m_a.y() + nu * m_d.y());
        }
 
        return m_srcBase + QPointF(mu * m_xCoeff, nu * m_yCoeff);
    }

References D(), eps, m_a, m_c, m_d, m_px, m_py, m_qA, m_qB_const, m_qB_varX, m_qB_varY, m_qC_varX, m_qC_varY, m_qD_div, m_srcBase, m_xCoeff, m_yCoeff, and pow2().

◆ isValid()

bool KisFourPointInterpolatorBackward::isValid ( const qreal tolerance = 0.1 ) const

inline

Checks if linear dimensions of the destination polygon are bigger than tolerance.

Definition at line 52 of file kis_four_point_interpolator_backward.h.

                                                           {
        const qreal toleranceSq = pow2(tolerance);
 
        const qreal sq1 = qAbs(m_qB_const);
        const qreal sq2 = qAbs(KisAlgebra2D::crossProduct(m_b, m_c - m_b + m_a));
 
        return sq1 + sq2 > 2 * toleranceSq;
    }

References KisAlgebra2D::crossProduct(), m_a, m_b, m_c, m_qB_const, and pow2().

◆ map()

QPointF KisFourPointInterpolatorBackward::map ( const QPointF & pt )

inline

Definition at line 65 of file kis_four_point_interpolator_backward.h.

                                          {
        setX(pt.x());
        setY(pt.y());
        return getValue();
    }

References getValue(), setX(), and setY().

◆ setX()

void KisFourPointInterpolatorBackward::setX ( qreal x )

inline

Definition at line 71 of file kis_four_point_interpolator_backward.h.

                              {
        x -= m_dstBase.x();
 
        m_qB_varX = - x * m_d.y();
        m_qC_varX = - x * m_a.y();
        m_px = x;
    }

References m_a, m_d, m_dstBase, m_px, m_qB_varX, and m_qC_varX.

◆ setY()

void KisFourPointInterpolatorBackward::setY ( qreal y )

inline

Definition at line 79 of file kis_four_point_interpolator_backward.h.

                              {
        y -= m_dstBase.y();
 
        m_qB_varY = y * m_d.x();
        m_qC_varY = y * m_a.x();
        m_py = y;
    }