Ellipse Class Reference

#include <Ellipse.h>

Public Member Functions
QRectF	boundingRect () const
	Ellipse ()
	Ellipse (const QPointF &p1, const QPointF &p2, const QPointF &p3)
const QTransform &	getInverse () const
const QTransform &	getTransform () const
const QPointF &	major1 () const
const QPointF &	major2 () const
const QPointF &	point () const
QPointF	project (const QPointF &) const
qreal	semiMajor () const
qreal	semiMinor () const
bool	set (const QPointF &m1, const QPointF &m2, const QPointF &p)
bool	setMajor1 (const QPointF &p)
bool	setMajor2 (const QPointF &p)
bool	setPoint (const QPointF &p)
	~Ellipse ()

Private Member Functions
bool	changeMajor ()
bool	changeMinor ()

Private Attributes
qreal	a
qreal	b
QTransform	inverse
QTransform	matrix
QPointF	p1
QPointF	p2
QPointF	p3

Detailed Description

Definition at line 13 of file Ellipse.h.

Constructor & Destructor Documentation

Ellipse() [1/2]

Ellipse::Ellipse

(

)

Definition at line 12 of file Ellipse.cc.

                 : a(-1), b(-1)
{
}

Ellipse() [2/2]

Ellipse::Ellipse	(	const QPointF &	p1,
		const QPointF &	p2,
		const QPointF &	p3 )

Definition at line 15 of file Ellipse.cc.

                                                                           : p1(_p1), p2(_p2), p3(_p3) {
    changeMajor();
}

References changeMajor().

~Ellipse()

Ellipse::~Ellipse

(

)

Definition at line 19 of file Ellipse.cc.

{
}

Member Function Documentation

boundingRect()

QRectF Ellipse::boundingRect

(

)

const

Definition at line 62 of file Ellipse.cc.

{
    const QPointF d = rotate90((p2 - p1) * 0.5 * b / a);
    const QPointF pts[4] = {
        p1 + d,
        p1 - d,
        p2 + d,
        p2 - d
    };
    QRectF ret;
    for (int i = 0; i < 4; ++i) {
        ret = ret.united(QRectF(pts[i], QSizeF(0.0001, 0.0001)));
    }
    return ret;
}

References a, b, p1, p2, and rotate90().

changeMajor()

bool Ellipse::changeMajor ( )

private

Definition at line 87 of file Ellipse.cc.

{
    a = length(p1 - p2) * 0.5;
    
    /*
     * calculate transformation matrix
     * x' = m11*x + m21*y + dx
     * y' = m22*y + m12*x + dy
     * m11 = m22, m12 = -m21 (rotations and translations only)
     * x' = m11*x - m12*y + dx
     * y' = m11*y + m12*x + dy
     * 
     * then, transforming (x1, y1) to (x1', y1') and (x2, y2) to (x2', y2'):
     * 
     * m11 = (y2*y2' + y1 * (y1'-y2') - y2*y1' + x2*x'2 - x1*x'2 + (x1-x2)*x1')
     *       ------------------------------------------------------------------
     *                 (y2^2 - 2*y1*y2 + y1^2 + x2^2 - 2*x1*x2 + x1^2)
     * m12 = -(x1*(y2'-y1') - x2*y2' + x2*y1' + x2'*y2 - x1'*y2 + (x1'-x2')*y1)
     *       ------------------------------------------------------------------
     *                 (y2^2 - 2*y1*y2 + y1^2 + x2^2 - 2*x1*x2 + x1^2)
     * dx = (x1*(-y2*y2' + y2*y1' - x2*x2') + y1*( x2*y2' - x2*y1' - x2'*y2 - x1'*y2) + x2'*y1^2 + x1^2*x2' + x1'*(y2^2 + x2^2 - x1*x2))
     *      ----------------------------------------------------------------------------------------------------------------------------
     *                 (y2^2 - 2*y1*y2 + y1^2 + x2^2 - 2*x1*x2 + x1^2)
     * dy = (x1*(-x2*y2' - x2*y1' + x2'*y2) + y1*(-y2*y2' - y2*y1' - x2*x2' + x2*x1') + y2'*y1^2 + x1^2*y2' + y1'(y2^2 + x2^2) - x1*x1'*y2)
     *      -------------------------------------------------------------------------------------------------------------------------------
     *                 (y2^2 - 2*y1*y2 + y1^2 + x2^2 - 2*x1*x2 + x1^2)
     * 
     * in our usage, to move the ellipse into canonical position:
     * 
     * (x1, y1) = p1
     * (x2, y2) = p2
     * (x1', y1') = (-a, 0)
     * (x2', y2') = (a, 0)
     */
    
    const qreal
        x1 = p1.x(),
        x2 = p2.x(),
        y1 = p1.y(),
        y2 = p2.y(),
        x1p = -a,
        x2p = a,
        x1sqr = x1 * x1,
        x2sqr = x2 * x2,
        y1sqr = y1 * y1,
        y2sqr = y2 * y2,
        factor = 1.0 / (x1sqr + y1sqr + x2sqr + y2sqr - 2.0 * y1 * y2 - 2.0 * x1 * x2),
        m11 = (x2*x2p - x1*x2p + (x1-x2)*x1p) * factor,
        m12 = -(x2p*y2 - x1p*y2 + (x1p-x2p)*y1) * factor,
        dx = (x1*(-x2*x2p) + y1*(-x2p*y2 - x1p*y2) + x2p*y1sqr + x1sqr*x2p + x1p*(y2sqr + x2sqr - x1*x2)) * factor,
        dy = (x1*(x2p*y2) + y1*(-x2*x2p + x2*x1p) - x1*x1p*y2) * factor;
    
    matrix = QTransform(m11, m12, -m12, m11, dx, dy);
    inverse = matrix.inverted();
 
    return changeMinor();
}

References a, changeMinor(), inverse, length(), matrix, p1, and p2.

changeMinor()

bool Ellipse::changeMinor ( )

private

Definition at line 145 of file Ellipse.cc.

{
    QPointF p = matrix.map(p3);
 
    /*
     * ellipse formula:
     * x^2/a^2 + y^2/b^2 = 1
     * b = sqrt(y^2 / (1 - x^2/a^2))
     */
    const qreal
        asqr = a * a,
        xsqr = p.x() * p.x(),
        ysqr = p.y() * p.y(),
        divisor = (1.0 - xsqr / asqr);
    if (divisor <= 0) {
        // division by zero!
        b = -1;
        return false;
    }
    b = sqrt(ysqr / divisor);
    return true;
}

References a, b, matrix, p, and p3.

getInverse()

const QTransform & Ellipse::getInverse ( ) const

inline

Definition at line 32 of file Ellipse.h.

{ return inverse; }

References inverse.

getTransform()

const QTransform & Ellipse::getTransform ( ) const

inline

Definition at line 31 of file Ellipse.h.

{ return matrix; }

References matrix.

major1()

const QPointF & Ellipse::major1 ( ) const

inline

Definition at line 25 of file Ellipse.h.

{ return p1; }

References p1.

major2()

const QPointF & Ellipse::major2 ( ) const

inline

Definition at line 27 of file Ellipse.h.

{ return p2; }

References p2.

point()

const QPointF & Ellipse::point ( ) const

inline

Definition at line 29 of file Ellipse.h.

{ return p3; }

References p3.

project()

QPointF Ellipse::project

(

const QPointF &

pt

)

const

Definition at line 39 of file Ellipse.cc.

{
    if (a <= 0 || b <= 0) return pt; // not a valid ellipse
    QPointF p = matrix.map(pt);
    /*
     * intersect line from (0,0) to p with the ellipse in canonical position
     * the equation of the line is y = py/px x
     * the equation of the ellipse is x^2/a^2 + y^2/b^2 = 1
     * x=(a*b*px)/sqrt(a^2*py^2+b^2*px^2)
     * y=(a*b*py)/sqrt(a^2*py^2+b^2*px^2)
     */
    const qreal divisor = sqrt(a * a * p.y() * p.y() + b * b * p.x() * p.x());
    if (divisor <= 0) return inverse.map(QPointF(a, 0)); // give up
    const qreal ab = a * b, factor = 1.0 / divisor;
    QPointF ep(ab * p.x() * factor, ab * p.y() * factor);
    return inverse.map(ep);
/*    return inverse.map(closest(matrix.map(pt)));*/
}

References a, b, inverse, matrix, and p.

semiMajor()

qreal Ellipse::semiMajor ( ) const

inline

Definition at line 33 of file Ellipse.h.

{ return a; }

References a.

semiMinor()

qreal Ellipse::semiMinor ( ) const

inline

Definition at line 34 of file Ellipse.h.

{ return b; }

References b.

set()

bool Ellipse::set	(	const QPointF &	m1,
		const QPointF &	m2,
		const QPointF &	p )

Definition at line 23 of file Ellipse.cc.

{
    bool changedMajor = m1 != p1 || m2 != p2,
         changedMinor = !changedMajor && p != p3;
    p1 = m1;
    p2 = m2;
    p3 = p;
    if (changedMajor) {
        return changeMajor();
    } else if (changedMinor) {
        return changeMinor();
    } else {
        return a > 0 && b > 0;
    }
}

References a, b, changeMajor(), changeMinor(), p, p1, p2, and p3.

setMajor1()

bool Ellipse::setMajor1

(

const QPointF &

p

)

Definition at line 168 of file Ellipse.cc.

{
    p1 = p;
    return changeMajor();
}

References changeMajor(), p, and p1.

setMajor2()

bool Ellipse::setMajor2

(

const QPointF &

p

)

Definition at line 173 of file Ellipse.cc.

                                        {
    p2 = p;
    return changeMajor();
}

References changeMajor(), p, and p2.

setPoint()

bool Ellipse::setPoint

(

const QPointF &

p

)

Definition at line 177 of file Ellipse.cc.

{
    p3 = p;
    return changeMinor();
}

References changeMinor(), p, and p3.

Member Data Documentation

a

qreal Ellipse::a

private

Definition at line 42 of file Ellipse.h.

b

qreal Ellipse::b

private

Definition at line 43 of file Ellipse.h.

inverse

QTransform Ellipse::inverse

private

Definition at line 41 of file Ellipse.h.

matrix

QTransform Ellipse::matrix

private

Definition at line 40 of file Ellipse.h.

p1

QPointF Ellipse::p1

private

Definition at line 46 of file Ellipse.h.

p2

QPointF Ellipse::p2

private

Definition at line 47 of file Ellipse.h.

p3

QPointF Ellipse::p3

private

Definition at line 48 of file Ellipse.h.

---

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

• plugins/assistants/Assistants/Ellipse.h
• plugins/assistants/Assistants/Ellipse.cc