Public Member Functions
	EllipseInPolygon ()

bool	isValid () const

bool	setSimpleEllipseVertices (Ellipse &ellipse) const
	setSimpleEllipseVertices sets vertices of this ellipse to the "simple ellipse" class to be drawn and used

bool	updateToPolygon (QVector< QPointF > _polygon)
	updateToPolygon This function makes all the necessary calculations and updates all data, not just the polygon according to the polygon that was provided as the parameter

Static Public Member Functions
static bool	formulaRepresentsAnEllipse (double a, double b, double c)
	formulaRepresentsAnEllipse parameters are first three coefficients from a formula: ax^2 + bxy + cy^2 + dx + ey + f = 0

Public Attributes
double	axisXLength {0.0}

double	axisYLength {0.0}

double	finalAxisAngle {0.0}

double	finalAxisReverseAngleCos {0.0}

double	finalAxisReverseAngleSin {0.0}

QVector< double >	finalEllipseCenter

QVector< double >	finalFormula

QVector< QPointF >	finalVertices

QTransform	originalTransform

QVector< QPointF >	polygon

QVector< double >	rerotatedFormula

Protected Member Functions
void	setFormula (QVector< double > &formula, double a, double b, double c, double d, double e, double f)

void	setPoint (QVector< double > &point, double x, double y)

Protected Attributes
bool	m_valid {false}

Detailed Description

Definition at line 30 of file PerspectiveEllipseAssistant.cc.

Constructor & Destructor Documentation

◆ EllipseInPolygon()

EllipseInPolygon::EllipseInPolygon ( )

Definition at line 114 of file PerspectiveEllipseAssistant.cc.

{
    finalFormula.clear();
    rerotatedFormula.clear();
    finalFormula << 1 << 0 << 1 << 0 << 0 << 0;
    rerotatedFormula << 1 << 0 << 1 << 0 << 0 << 0;
 
    finalEllipseCenter.clear();
    finalEllipseCenter << 0 << 0;
 
    finalVertices.clear();
    finalVertices << QPointF(-1, 0) << QPointF(1, 0) << QPointF(0, 1);
}

References finalEllipseCenter, finalFormula, finalVertices, and rerotatedFormula.

Member Function Documentation

◆ formulaRepresentsAnEllipse()

bool EllipseInPolygon::formulaRepresentsAnEllipse	(	double	a,
		double	b,
		double	c )

static

formulaRepresentsAnEllipse parameters are first three coefficients from a formula: ax^2 + bxy + cy^2 + dx + ey + f = 0

Parameters

a	- first coefficient
b	- second coefficient
c	- third coefficient

Returns: true if the formula represents an ellipse, otherwise false

Definition at line 281 of file PerspectiveEllipseAssistant.cc.

{
    return (b*b - 4*a*c) < 0;
}

◆ isValid()

bool EllipseInPolygon::isValid ( ) const

inline

Definition at line 66 of file PerspectiveEllipseAssistant.cc.

66{ return m_valid; }

EllipseInPolygon::m_valid

bool m_valid

Definition PerspectiveEllipseAssistant.cc:109

References m_valid.

◆ setFormula()

void EllipseInPolygon::setFormula	(	QVector< double > &	formula,
		double	a,
		double	b,
		double	c,
		double	d,
		double	e,
		double	f )

protected

Definition at line 286 of file PerspectiveEllipseAssistant.cc.

{
    if (formula.size() != 6) {
        formula.clear();
        formula << a << b << c << d << e << f;
    } else {
        formula[0] = a;
        formula[1] = b;
        formula[2] = c;
        formula[3] = d;
        formula[4] = e;
        formula[5] = f;
    }
}

◆ setPoint()

void EllipseInPolygon::setPoint	(	QVector< double > &	point,
		double	x,
		double	y )

protected

Definition at line 301 of file PerspectiveEllipseAssistant.cc.

{
    if (point.size() != 2) {
        point.clear();
        point << x << y;
    } else {
        point[0] = x;
        point[1] = y;
    }
}

◆ setSimpleEllipseVertices()

bool EllipseInPolygon::setSimpleEllipseVertices ( Ellipse & ellipse ) const

setSimpleEllipseVertices sets vertices of this ellipse to the "simple ellipse" class to be drawn and used

Parameters

ellipse

Returns

Definition at line 273 of file PerspectiveEllipseAssistant.cc.

{
    if (finalVertices.size() > 2) {
        return ellipse.set(finalVertices[0], finalVertices[1], finalVertices[2]);
    }
    return false;
}

References finalVertices, and Ellipse::set().

◆ updateToPolygon()

bool EllipseInPolygon::updateToPolygon ( QVector< QPointF > _polygon )

updateToPolygon This function makes all the necessary calculations and updates all data, not just the polygon according to the polygon that was provided as the parameter

Parameters

polygon polygon that contains the ellipse

Returns: whether the ellipse is valid or not

Definition at line 128 of file PerspectiveEllipseAssistant.cc.

{
    QTransform transform;
 
    m_valid = false; // let's make it false in case we return in the middle of the work
    polygon = _polygon; // the assistant needs to know the polygon even when it doesn't allow for a correct ellipse
 
    // this calculates the perspective transform that represents the current quad (polygon)
    // this is the transform that changes the original (0, 0, 1, 1) square to the quad
    // that means that our "original" ellipse is the circle in that square (with center in (0.5, 0.5), and radius 0.5)
    if (!QTransform::squareToQuad(polygon, transform)) {
        return false;
    }
 
    originalTransform = transform;
 
    // using the perspective transform, we can calculate some points on the ellipse
    // any points from the original ellipse would work here
    // but pt1-4 are just the simplest ones to write
    // and pR is another one easy to calculate (common point between the original ellipse and a line `y = x`)
    QPointF pt1 = originalTransform.map(QPointF(0.5, 1.0));
    QPointF pt2 = originalTransform.map(QPointF(1.0, 0.5));
    QPointF pt3 = originalTransform.map(QPointF(0.5, 0.0));
    QPointF pt4 = originalTransform.map(QPointF(0.0, 0.5));
    // a point on the ellipse and on the `y = x` line
    QPointF ptR = originalTransform.map(QPointF(0.5 - 1/(2*sqrt(2)), 0.5 - 1/(2*sqrt(2))));
 
 
    // using the points from above (pt1-4 and ptR) we can construct a linear equation for the final ellipse formula
    // the general ellipse formula is: `ax^2 + bxy + cy^2 + dx + ey + f = 0`
    // but since a cannot ever be 0, we can temporarily reduce the formula to be `x^2 + Bxy + Cy^2 + Dx + Ey + F = 0`
    // where B = b/a etc.
    Eigen::MatrixXd A(5, 5);
    A <<          ptR.x() * ptR.y(), ptR.y() * ptR.y(), ptR.x(), ptR.y(), 1.0,
                  pt1.x() * pt1.y(), pt1.y() * pt1.y(), pt1.x(), pt1.y(), 1.0,
                  pt2.x() * pt2.y(), pt2.y() * pt2.y(), pt2.x(), pt2.y(), 1.0,
                  pt3.x() * pt3.y(), pt3.y() * pt3.y(), pt3.x(), pt3.y(), 1.0,
                  pt4.x() * pt4.y(), pt4.y() * pt4.y(), pt4.x(), pt4.y(), 1.0;
 
    Eigen::VectorXd bVector(5);
    bVector << - ptR.x() * ptR.x(), - pt1.x() * pt1.x(), - pt2.x() * pt2.x(),  - pt3.x() * pt3.x(), - pt4.x() * pt4.x();
 
    Eigen::VectorXd xSolution = A.fullPivLu().solve(bVector);
 
    // generic ellipse formula coefficients for the final formula
    // assigned to new variables to better see the calculations
    // (even with "x" as a solution vector variable, it would be difficult to spot error when everything looks like x(2)*x(4)/x(3)*x(1) etc.)
    qreal a = 1;
    qreal b = xSolution(0);
 
    qreal c = xSolution(1);
    qreal d = xSolution(2);
 
    qreal e = xSolution(3);
    qreal f = xSolution(4);
 
    // check if this is an ellipse
    if (!formulaRepresentsAnEllipse(a, b, c)) {
        return false;
    }
 
    setFormula(finalFormula, a, b, c, d, e, f);
 
    // x = (be - 2cd)/(4c - b^2)
    // y = (bd - 2e)/(4c - b^2)
    finalEllipseCenter.clear();
    finalEllipseCenter << ((double)b*e - 2*c*d)/(4*c - b*b) << ((double)b*d - 2*e)/(4*c - b*b);
    finalAxisAngle = qAtan2(b, a - c)/2;
 
    // use finalAxisAngle to find the cos and sin
    // and replace the final coordinate system with the rerotated one
    qreal K = qCos(-finalAxisAngle);
    qreal L = qSin(-finalAxisAngle);
 
    // this allows to calculate the formula for the rerotated ellipse
    qreal aprim = K*K*a - K*L*b + L*L*c;
    qreal bprim = 2*K*L*a + K*K*b - L*L*b - 2*K*L*c;
    qreal cprim = L*L*a + K*L*b + K*K*c;
    qreal dprim = K*d - L*e;
    qreal eprim = L*d + K*e;
    qreal fprim = f;
 
    if (!formulaRepresentsAnEllipse(aprim, bprim, cprim)) {
        return false;
    }
 
    finalAxisReverseAngleCos = K;
    finalAxisReverseAngleSin = L;
 
    setFormula(rerotatedFormula, aprim, bprim, cprim, dprim, eprim, fprim);
 
    // third attempt at new center:
    // K' = K
    // L' = -L
    // note that this will be in a different place, because the ellipse wasn't moved to have center in (0, 0), but still rotate around point (0,0)
    // and any point that is not (0, 0), when rotated around (0, 0) with an angle that isn't 0, 360 etc. degrees, will end up in a different place
    QPointF rerotatedCenter = QPointF(K*finalEllipseCenter[0] - L*finalEllipseCenter[1], K*finalEllipseCenter[1] + L*finalEllipseCenter[0]);
 
    qreal rx = sqrt(qPow(rerotatedCenter.x(), 2) + qPow(rerotatedCenter.y(), 2)*cprim/aprim - fprim/aprim);
    qreal ry = sqrt(rx*rx*aprim/cprim);
 
    axisXLength = rx;
    axisYLength = ry;
 
#if 0 // debug
    // they should be very close to cprim, dprim etc., when multiplied by aprim (since this only gives us a formula where aprim_recreated would be equal to 1)
    qreal cprim_recreated = (rx*rx)/(ry*ry);
    qreal dprim_recreated = -2*rerotatedCenter.x();
    qreal eprim_recreated = -2*rerotatedCenter.y()*(rx*rx)/(ry*ry);
    qreal fprim_recreated = qPow(rerotatedCenter.x(), 2) + qPow(rerotatedCenter.y(), 2)*(rx*rx)/(ry*ry) - (rx*rx);
 
    if (debug) qCritical() << "recreated equation (with 1): " << 1 << 0 << cprim_recreated << dprim_recreated << eprim_recreated << fprim_recreated;
    if (debug) qCritical() << "recreated equation: (actual)" << aprim << 0 << aprim*cprim_recreated << aprim*dprim_recreated << aprim*eprim_recreated << aprim*fprim_recreated;
 
    qreal eps = 0.00001;
    auto fuzzyCompareWithEps = [eps] (qreal a, qreal b) { return abs(a - b) < eps; };
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(fuzzyCompareWithEps(aprim*cprim_recreated, cprim));
    KIS_SAFE_ASSERT_RECOVER_NOOP(fuzzyCompareWithEps(aprim*dprim_recreated, dprim));
    KIS_SAFE_ASSERT_RECOVER_NOOP(fuzzyCompareWithEps(aprim*eprim_recreated, eprim));
    KIS_SAFE_ASSERT_RECOVER_NOOP(fuzzyCompareWithEps(aprim*fprim_recreated, fprim));
 
#endif
 
    auto convertToPreviousCoordsSystem = [K, L] (QPointF p) { return QPointF(K*p.x() + L*p.y(), K*p.y() - L*p.x()); };
 
    // they most probably don't need a higher precision than float
    // (though they are used to calculate the brush position...)
    QPointF leftVertexRerotated = rerotatedCenter + QPointF(-rx, 0);
    QPointF rightVertedRerotated = rerotatedCenter + QPointF(rx, 0);
    QPointF topVertedRerotated = rerotatedCenter + QPointF(0, ry);
 
    QPointF leftVertexFinal = convertToPreviousCoordsSystem(leftVertexRerotated);
    QPointF rightVertexFinal = convertToPreviousCoordsSystem(rightVertedRerotated);
    QPointF topVertexFinal = convertToPreviousCoordsSystem(topVertedRerotated);
 
    QVector<QPointF> result;
    result << leftVertexFinal << rightVertexFinal << topVertexFinal;
 
    finalVertices = result;
 
    m_valid = true;
    return true;
}