QBezier Class Reference

#include <qbezier_p.h>

Public Functions
void	addIfClose (qreal *length, qreal error) const
void	addToPolygon (QPolygonF *p, qreal bezier_flattening_threshold=0.5) const
QBezier	bezierOnInterval (qreal t0, qreal t1) const
QRectF	bounds () const
QPointF	derivedAt (qreal t) const
QLineF	endTangent () const
QBezier	getSubRange (qreal t0, qreal t1) const
qreal	length (qreal error=0.01) const
QBezier	mapBy (const QTransform &transform) const
QPointF	midPoint () const
QLineF	midTangent () const
QPointF	normalVector (qreal t) const
void	parameterSplitLeft (qreal t, QBezier *left)
QPointF	pointAt (qreal t) const
QPointF	pt1 () const
QPointF	pt2 () const
QPointF	pt3 () const
QPointF	pt4 () const
QPointF	secondDerivedAt (qreal t) const
int	shifted (QBezier *curveSegments, int maxSegmets, qreal offset, float threshold) const
void	split (QBezier *firstHalf, QBezier *secondHalf) const
QLineF	startTangent () const
int	stationaryYPoints (qreal &t0, qreal &t1) const
qreal	tAtLength (qreal len) const
qreal	tForY (qreal t0, qreal t1, qreal y) const
QPolygonF	toPolygon (qreal bezier_flattening_threshold=0.5) const

Static Public Functions
static void	coefficients (qreal t, qreal &a, qreal &b, qreal &c, qreal &d)
static QBezier	fromPoints (const QPointF &p1, const QPointF &p2, const QPointF &p3, const QPointF &p4)

Public Variables
qreal	x1
qreal	x2
qreal	x3
qreal	x4
qreal	y1
qreal	y2
qreal	y3
qreal	y4

Detailed Description

Definition at line 68 of file qbezier_p.h.

Functions

addIfClose()

void QBezier::addIfClose	(	qreal *	length,
		qreal	error
	)		const

Definition at line 538 of file qbezier.cpp.

Referenced by addIfClose(), and length().

{
    QBezier left, right;     /* bez poly splits */

    qreal len = qreal(0.0);  /* arc length */
    qreal chord;             /* chord length */

    len = len + QLineF(QPointF(x1, y1),QPointF(x2, y2)).length();
    len = len + QLineF(QPointF(x2, y2),QPointF(x3, y3)).length();
    len = len + QLineF(QPointF(x3, y3),QPointF(x4, y4)).length();

    chord = QLineF(QPointF(x1, y1),QPointF(x4, y4)).length();

    if((len-chord) > error) {
        split(&left, &right);                 /* split in two */
        left.addIfClose(length, error);       /* try left side */
        right.addIfClose(length, error);      /* try right side */
        return;
    }

    *length = *length + len;

    return;
}

addToPolygon()

void QBezier::addToPolygon	(	QPolygonF *	p,
		qreal	bezier_flattening_threshold = 0.5
	)		const

Definition at line 191 of file qbezier.cpp.

Referenced by toPolygon().

{
    QBezier beziers[32];
    beziers[0] = *this;
    QBezier *b = beziers;

    while (b >= beziers) {
        // check if we can pop the top bezier curve from the stack
        qreal y4y1 = b->y4 - b->y1;
        qreal x4x1 = b->x4 - b->x1;
        qreal l = qAbs(x4x1) + qAbs(y4y1);
        qreal d;
        if (l > 1.) {
            d = qAbs( (x4x1)*(b->y1 - b->y2) - (y4y1)*(b->x1 - b->x2) )
                + qAbs( (x4x1)*(b->y1 - b->y3) - (y4y1)*(b->x1 - b->x3) );
        } else {
            d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
                qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
            l = 1.;
        }
        if (d < bezier_flattening_threshold*l || b == beziers + 31) {
            // good enough, we pop it off and add the endpoint
            polygon->append(QPointF(b->x4, b->y4));
            --b;
        } else {
            // split, second half of the polygon goes lower into the stack
            b->split(b+1, b);
            ++b;
        }
    }
}

bezierOnInterval()

QBezier QBezier::bezierOnInterval	(	qreal	t0,
		qreal	t1
	)		const

Definition at line 687 of file qbezier.cpp.

Referenced by qt_curves_for_arc().

{
    if (t0 == 0 && t1 == 1)
        return *this;

    QBezier bezier = *this;

    QBezier result;
    bezier.parameterSplitLeft(t0, &result);
    qreal trueT = (t1-t0)/(1-t0);
    bezier.parameterSplitLeft(trueT, &result);

    return result;
}

bounds()

QRectF QBezier::bounds

(

)

const

Definition at line 223 of file qbezier.cpp.

Referenced by QGL2PEXVertexArray::addPath(), QPathSegments::addPath(), QTriangulatingStroker::cubicTo(), QDashedStrokeProcessor::process(), qt_isect_curve_horizontal(), qt_isect_curve_vertical(), qt_painterpath_isect_curve(), and shift().

{
    qreal xmin = x1;
    qreal xmax = x1;
    if (x2 < xmin)
        xmin = x2;
    else if (x2 > xmax)
        xmax = x2;
    if (x3 < xmin)
        xmin = x3;
    else if (x3 > xmax)
        xmax = x3;
    if (x4 < xmin)
        xmin = x4;
    else if (x4 > xmax)
        xmax = x4;

    qreal ymin = y1;
    qreal ymax = y1;
    if (y2 < ymin)
        ymin = y2;
    else if (y2 > ymax)
        ymax = y2;
    if (y3 < ymin)
        ymin = y3;
    else if (y3 > ymax)
        ymax = y3;
    if (y4 < ymin)
        ymin = y4;
    else if (y4 > ymax)
        ymax = y4;
    return QRectF(xmin, ymin, xmax-xmin, ymax-ymin);
}

coefficients()

void QBezier::coefficients ( qreal  t, qreal &  a, qreal &  b, qreal &  c, qreal &  d  )

inlinestatic

Definition at line 152 of file qbezier_p.h.

Referenced by qt_find_ellipse_coords(), and tForY().

{
    qreal m_t = 1. - t;
    b = m_t * m_t;
    c = t * t;
    d = c * t;
    a = b * m_t;
    b *= 3. * t;
    c *= 3. * m_t;
}

derivedAt()

QPointF QBezier::derivedAt ( qreal  t ) const

inline

Definition at line 198 of file qbezier_p.h.

{
    // p'(t) = 3 * (-(1-2t+t^2) * p0 + (1 - 4 * t + 3 * t^2) * p1 + (2 * t - 3 * t^2) * p2 + t^2 * p3)

    qreal m_t = 1. - t;

    qreal d = t * t;
    qreal a = -m_t * m_t;
    qreal b = 1 - 4 * t + 3 * d;
    qreal c = 2 * t - 3 * d;

    return 3 * QPointF(a * x1 + b * x2 + c * x3 + d * x4,
                       a * y1 + b * y2 + c * y3 + d * y4);
}

endTangent()

QLineF QBezier::endTangent ( ) const

inline

Definition at line 142 of file qbezier_p.h.

{
    QLineF tangent(pt4(), pt3());
    if (tangent.isNull())
        tangent = QLineF(pt4(), pt2());
    if (tangent.isNull())
        tangent = QLineF(pt4(), pt1());
    return tangent;
}

fromPoints()

QBezier QBezier::fromPoints ( const QPointF &  p1, const QPointF &  p2, const QPointF &  p3, const QPointF &  p4  )

static

Warning

This function is not part of the public interface.

Definition at line 71 of file qbezier.cpp.

Referenced by QGL2PEXVertexArray::addPath(), QPathSegments::addPath(), bezierAtT(), QPainterPath::computeBoundingRect(), QPainterPath::contains(), QTriangulatingStroker::cubicTo(), cubicTo_clipped(), QOpenGLPaintEnginePrivate::curveToStencil(), QTriangulator< T >::initialize(), QPainterPath::length(), mapBy(), QSubpathFlatIterator::next(), nextBezier(), QPainterPath::percentAtLength(), QDashedStrokeProcessor::process(), qt_curves_for_arc(), qt_painterpath_check_crossing(), qt_stroke_side(), shift(), QOpenGLPaintEnginePrivate::strokePathFastPen(), and QPainterPath::toSubpathPolygons().

{
    QBezier b;
    b.x1 = p1.x();
    b.y1 = p1.y();
    b.x2 = p2.x();
    b.y2 = p2.y();
    b.x3 = p3.x();
    b.y3 = p3.y();
    b.x4 = p4.x();
    b.y4 = p4.y();
    return b;
}

getSubRange()

QBezier QBezier::getSubRange	(	qreal	t0,
		qreal	t1
	)		const

Definition at line 113 of file qbezier.cpp.

{
    QBezier result;
    QBezier temp;

    // cut at t1
    if (qFuzzyIsNull(t1 - qreal(1.))) {
        result = *this;
    } else {
        temp = *this;
        temp.parameterSplitLeft(t1, &result);
    }

    // cut at t0
    if (!qFuzzyIsNull(t0))
        result.parameterSplitLeft(t0 / t1, &temp);

    return result;
}

length()

qreal QBezier::length

(

qreal

error = 0.01

)

const

Definition at line 529 of file qbezier.cpp.

Referenced by bezierAtT(), QPainterPath::length(), nextBezier(), QPainterPath::percentAtLength(), and tAtLength().

{
    qreal length = qreal(0.0);

    addIfClose(&length, error);

    return length;
}

mapBy()

QBezier QBezier::mapBy

(

const QTransform &

transform

)

const

Definition at line 108 of file qbezier.cpp.

{
    return QBezier::fromPoints(transform.map(pt1()), transform.map(pt2()), transform.map(pt3()), transform.map(pt4()));
}

midPoint()

QPointF QBezier::midPoint ( ) const

inline

Definition at line 119 of file qbezier_p.h.

{
    return QPointF((x1 + x4 + 3*(x2 + x3))/8., (y1 + y4 + 3*(y2 + y3))/8.);
}

midTangent()

QLineF QBezier::midTangent ( ) const

inline

Definition at line 124 of file qbezier_p.h.

{
    QPointF mid = midPoint();
    QLineF dir(QLineF(x1, y1, x2, y2).pointAt(0.5), QLineF(x3, y3, x4, y4).pointAt(0.5));
    return QLineF(mid.x() - dir.dx(), mid.y() - dir.dy(),
                  mid.x() + dir.dx(), mid.y() + dir.dy());
}

normalVector()

QPointF QBezier::normalVector ( qreal  t ) const

inline

Definition at line 188 of file qbezier_p.h.

Referenced by good_offset().

{
    qreal m_t = 1. - t;
    qreal a = m_t * m_t;
    qreal b = t * m_t;
    qreal c = t * t;

    return QPointF((y2-y1) * a + (y3-y2) * b + (y4-y3) * c,  -(x2-x1) * a - (x3-x2) * b - (x4-x3) * c);
}

parameterSplitLeft()

void QBezier::parameterSplitLeft ( qreal  t, QBezier *  left  )

inline

Definition at line 248 of file qbezier_p.h.

Referenced by bezierOnInterval(), getSubRange(), and tAtLength().

{
    left->x1 = x1;
    left->y1 = y1;

    left->x2 = x1 + t * ( x2 - x1 );
    left->y2 = y1 + t * ( y2 - y1 );

    left->x3 = x2 + t * ( x3 - x2 ); // temporary holding spot
    left->y3 = y2 + t * ( y3 - y2 ); // temporary holding spot

    x3 = x3 + t * ( x4 - x3 );
    y3 = y3 + t * ( y4 - y3 );

    x2 = left->x3 + t * ( x3 - left->x3);
    y2 = left->y3 + t * ( y3 - left->y3);

    left->x3 = left->x2 + t * ( left->x3 - left->x2 );
    left->y3 = left->y2 + t * ( left->y3 - left->y2 );

    left->x4 = x1 = left->x3 + t * (x2 - left->x3);
    left->y4 = y1 = left->y3 + t * (y2 - left->y3);
}

pointAt()

QPointF QBezier::pointAt ( qreal  t ) const

inline

Definition at line 163 of file qbezier_p.h.

Referenced by QGL2PEXVertexArray::addPath(), QPathSegments::addPath(), QDeclarativePath::createPointCache(), QTriangulatingStroker::cubicTo(), good_offset(), QPainterPath::pointAtPercent(), QDashedStrokeProcessor::process(), and tForY().

{
    // numerically more stable:
    qreal x, y;

    qreal m_t = 1. - t;
    {
        qreal a = x1*m_t + x2*t;
        qreal b = x2*m_t + x3*t;
        qreal c = x3*m_t + x4*t;
        a = a*m_t + b*t;
        b = b*m_t + c*t;
        x = a*m_t + b*t;
    }
    {
        qreal a = y1*m_t + y2*t;
        qreal b = y2*m_t + y3*t;
        qreal c = y3*m_t + y4*t;
        a = a*m_t + b*t;
        b = b*m_t + c*t;
        y = a*m_t + b*t;
    }
    return QPointF(x, y);
}

pt1()

QPointF QBezier::pt1 ( ) const

inline

Definition at line 94 of file qbezier_p.h.

Referenced by isLine(), mapBy(), qt_painterpath_isect_curve(), and qt_stroke_side().

{ return QPointF(x1, y1); }

pt2()

QPointF QBezier::pt2 ( ) const

inline

Definition at line 95 of file qbezier_p.h.

Referenced by isLine(), mapBy(), qt_curves_for_arc(), and qt_stroke_side().

{ return QPointF(x2, y2); }

pt3()

QPointF QBezier::pt3 ( ) const

inline

Definition at line 96 of file qbezier_p.h.

Referenced by isLine(), mapBy(), qt_curves_for_arc(), and qt_stroke_side().

{ return QPointF(x3, y3); }

pt4()

QPointF QBezier::pt4 ( ) const

inline

Definition at line 97 of file qbezier_p.h.

Referenced by isLine(), mapBy(), qt_curves_for_arc(), qt_painterpath_isect_curve(), and qt_stroke_side().

{ return QPointF(x4, y4); }

secondDerivedAt()

QPointF QBezier::secondDerivedAt ( qreal  t ) const

inline

Definition at line 213 of file qbezier_p.h.

{
    qreal a = 2. - 2. * t;
    qreal b = -4 + 6 * t;
    qreal c = 2 - 6 * t;
    qreal d = 2 * t;

    return 3 * QPointF(a * x1 + b * x2 + c * x3 + d * x4,
                       a * y1 + b * y2 + c * y3 + d * y4);
}

shifted()

int QBezier::shifted	(	QBezier *	curveSegments,
		int	maxSegmets,
		qreal	offset,
		float	threshold
	)		const

Definition at line 433 of file qbezier.cpp.

Referenced by qt_stroke_side().

{
    Q_ASSERT(curveSegments);
    Q_ASSERT(maxSegments > 0);

    if (x1 == x2 && x1 == x3 && x1 == x4 &&
        y1 == y2 && y1 == y3 && y1 == y4)
        return 0;

    --maxSegments;
    QBezier beziers[10];
redo:
    beziers[0] = *this;
    QBezier *b = beziers;
    QBezier *o = curveSegments;

    while (b >= beziers) {
        int stack_segments = b - beziers + 1;
        if ((stack_segments == 10) || (o - curveSegments == maxSegments - stack_segments)) {
            threshold *= qreal(1.5);
            if (threshold > qreal(2.0))
                goto give_up;
            goto redo;
        }
        ShiftResult res = shift(b, o, offset, threshold);
        if (res == Discard) {
            --b;
        } else if (res == Ok) {
            ++o;
            --b;
            continue;
        } else if (res == Circle && maxSegments - (o - curveSegments) >= 2) {
            // add semi circle
            if (addCircle(b, offset, o))
                o += 2;
            --b;
        } else {
            b->split(b+1, b);
            ++b;
        }
    }

give_up:
    while (b >= beziers) {
        ShiftResult res = shift(b, o, offset, threshold);

        // if res isn't Ok or Split then *o is undefined
        if (res == Ok || res == Split)
            ++o;

        --b;
    }

    Q_ASSERT(o - curveSegments <= maxSegments);
    return o - curveSegments;
}

split()

void QBezier::split ( QBezier *  firstHalf, QBezier *  secondHalf  ) const

inline

Definition at line 224 of file qbezier_p.h.

Referenced by addIfClose(), addToPolygon(), qt_isect_curve_horizontal(), qt_isect_curve_vertical(), qt_painterpath_isect_curve(), shifted(), and QOpenGLPaintEnginePrivate::strokePathFastPen().

{
    Q_ASSERT(firstHalf);
    Q_ASSERT(secondHalf);

    qreal c = (x2 + x3)*.5;
    firstHalf->x2 = (x1 + x2)*.5;
    secondHalf->x3 = (x3 + x4)*.5;
    firstHalf->x1 = x1;
    secondHalf->x4 = x4;
    firstHalf->x3 = (firstHalf->x2 + c)*.5;
    secondHalf->x2 = (secondHalf->x3 + c)*.5;
    firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*.5;

    c = (y2 + y3)/2;
    firstHalf->y2 = (y1 + y2)*.5;
    secondHalf->y3 = (y3 + y4)*.5;
    firstHalf->y1 = y1;
    secondHalf->y4 = y4;
    firstHalf->y3 = (firstHalf->y2 + c)*.5;
    secondHalf->y2 = (secondHalf->y3 + c)*.5;
    firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*.5;
}

startTangent()

QLineF QBezier::startTangent ( ) const

inline

Definition at line 132 of file qbezier_p.h.

Referenced by qt_stroke_side().

{
    QLineF tangent(pt1(), pt2());
    if (tangent.isNull())
        tangent = QLineF(pt1(), pt3());
    if (tangent.isNull())
        tangent = QLineF(pt1(), pt4());
    return tangent;
}

stationaryYPoints()

int QBezier::stationaryYPoints	(	qreal &	t0,
		qreal &	t1
	)		const

Definition at line 605 of file qbezier.cpp.

{
    // y(t) = (1 - t)^3 * y1 + 3 * (1 - t)^2 * t * y2 + 3 * (1 - t) * t^2 * y3 + t^3 * y4
    // y'(t) = 3 * (-(1-2t+t^2) * y1 + (1 - 4 * t + 3 * t^2) * y2 + (2 * t - 3 * t^2) * y3 + t^2 * y4)
    // y'(t) = 3 * ((-y1 + 3 * y2 - 3 * y3 + y4)t^2 + (2 * y1 - 4 * y2 + 2 * y3)t + (-y1 + y2))

    const qreal a = -y1 + 3 * y2 - 3 * y3 + y4;
    const qreal b = 2 * y1 - 4 * y2 + 2 * y3;
    const qreal c = -y1 + y2;

    if (qFuzzyIsNull(a)) {
        if (qFuzzyIsNull(b))
            return 0;

        t0 = -c / b;
        return t0 > 0 && t0 < 1;
    }

    qreal reciprocal = b * b - 4 * a * c;

    if (qFuzzyIsNull(reciprocal)) {
        t0 = -b / (2 * a);
        return t0 > 0 && t0 < 1;
    } else if (reciprocal > 0) {
        qreal temp = qSqrt(reciprocal);

        t0 = (-b - temp)/(2*a);
        t1 = (-b + temp)/(2*a);

        if (t1 < t0)
            qSwap(t0, t1);

        int count = 0;
        qreal t[2] = { 0, 1 };

        if (t0 > 0 && t0 < 1)
            t[count++] = t0;
        if (t1 > 0 && t1 < 1)
            t[count++] = t1;

        t0 = t[0];
        t1 = t[1];

        return count;
    }

    return 0;
}

tAtLength()

qreal QBezier::tAtLength

(

qreal

len

)

const

Definition at line 654 of file qbezier.cpp.

Referenced by QPainterPath::percentAtLength().

{
    qreal len = length();
    qreal t   = qreal(1.0);
    const qreal error = qreal(0.01);
    if (l > len || qFuzzyCompare(l, len))
        return t;

    t *= qreal(0.5);
    //int iters = 0;
    //qDebug()<<"LEN is "<<l<<len;
    qreal lastBigger = qreal(1.0);
    while (1) {
        //qDebug()<<"\tt is "<<t;
        QBezier right = *this;
        QBezier left;
        right.parameterSplitLeft(t, &left);
        qreal lLen = left.length();
        if (qAbs(lLen - l) < error)
            break;

        if (lLen < l) {
            t += (lastBigger - t) * qreal(0.5);
        } else {
            lastBigger = t;
            t -= t * qreal(0.5);
        }
        //++iters;
    }
    //qDebug()<<"number of iters is "<<iters;
    return t;
}

tForY()

qreal QBezier::tForY	(	qreal	t0,
		qreal	t1,
		qreal	y
	)		const

Definition at line 563 of file qbezier.cpp.

{
    qreal py0 = pointAt(t0).y();
    qreal py1 = pointAt(t1).y();

    if (py0 > py1) {
        qSwap(py0, py1);
        qSwap(t0, t1);
    }

    Q_ASSERT(py0 <= py1);

    if (py0 >= y)
        return t0;
    else if (py1 <= y)
        return t1;

    Q_ASSERT(py0 < y && y < py1);

    qreal lt = t0;
    qreal dt;
    do {
        qreal t = qreal(0.5) * (t0 + t1);

        qreal a, b, c, d;
        QBezier::coefficients(t, a, b, c, d);
        qreal yt = a * y1 + b * y2 + c * y3 + d * y4;

        if (yt < y) {
            t0 = t;
            py0 = yt;
        } else {
            t1 = t;
            py1 = yt;
        }
        dt = lt - t;
        lt = t;
    } while (qAbs(dt) > qreal(1e-7));

    return t0;
}

toPolygon()

QPolygonF QBezier::toPolygon

(

qreal

bezier_flattening_threshold = 0.5

)

const

Warning

This function is not part of the public interface.

Definition at line 89 of file qbezier.cpp.

Referenced by cubicTo_clipped(), and QTriangulator< T >::initialize().

{
    // flattening is done by splitting the bezier until we can replace the segment by a straight
    // line. We split further until the control points are close enough to the line connecting the
    // boundary points.
    //
    // the Distance of a point p from a line given by the points (a,b) is given by:
    //
    // d = abs( (bx - ax)(ay - py) - (by - ay)(ax - px) ) / line_length
    //
    // We can stop splitting if both control points are close enough to the line.
    // To make the algorithm faster we use the manhattan length of the line.

    QPolygonF polygon;
    polygon.append(QPointF(x1, y1));
    addToPolygon(&polygon, bezier_flattening_threshold);
    return polygon;
}

Properties

x1

qreal QBezier::x1

Definition at line 116 of file qbezier_p.h.

Referenced by addCircle(), addIfClose(), addToPolygon(), QPainterPath::angleAtPercent(), bounds(), fromPoints(), parameterSplitLeft(), qt_painterpath_bezier_extrema(), shift(), shifted(), QPainterPath::slopeAtPercent(), split(), splitBezierAt(), QOpenGLPaintEnginePrivate::strokePathFastPen(), and toPolygon().

x2

qreal QBezier::x2

Definition at line 116 of file qbezier_p.h.

Referenced by addCircle(), addIfClose(), addToPolygon(), QPainterPath::angleAtPercent(), bounds(), fromPoints(), parameterSplitLeft(), shift(), shifted(), QPainterPath::slopeAtPercent(), split(), splitBezierAt(), and QOpenGLPaintEnginePrivate::strokePathFastPen().

x3

qreal QBezier::x3

Definition at line 116 of file qbezier_p.h.

Referenced by addCircle(), addIfClose(), addToPolygon(), QPainterPath::angleAtPercent(), bounds(), fromPoints(), parameterSplitLeft(), shift(), shifted(), QPainterPath::slopeAtPercent(), split(), splitBezierAt(), and QOpenGLPaintEnginePrivate::strokePathFastPen().

x4

qreal QBezier::x4

Definition at line 116 of file qbezier_p.h.

Referenced by addCircle(), addIfClose(), addToPolygon(), QPainterPath::angleAtPercent(), bounds(), fromPoints(), parameterSplitLeft(), qt_painterpath_bezier_extrema(), shift(), shifted(), QPainterPath::slopeAtPercent(), split(), splitBezierAt(), and QOpenGLPaintEnginePrivate::strokePathFastPen().

y1

qreal QBezier::y1

Definition at line 116 of file qbezier_p.h.

Referenced by addCircle(), addIfClose(), addToPolygon(), QPainterPath::angleAtPercent(), bounds(), fromPoints(), parameterSplitLeft(), qt_painterpath_bezier_extrema(), shift(), shifted(), QPainterPath::slopeAtPercent(), split(), splitBezierAt(), stationaryYPoints(), QOpenGLPaintEnginePrivate::strokePathFastPen(), tForY(), and toPolygon().

y2

qreal QBezier::y2

Definition at line 116 of file qbezier_p.h.

Referenced by addCircle(), addIfClose(), addToPolygon(), QPainterPath::angleAtPercent(), bounds(), fromPoints(), parameterSplitLeft(), shift(), shifted(), QPainterPath::slopeAtPercent(), split(), splitBezierAt(), stationaryYPoints(), QOpenGLPaintEnginePrivate::strokePathFastPen(), and tForY().

y3

qreal QBezier::y3

Definition at line 116 of file qbezier_p.h.

Referenced by addCircle(), addIfClose(), addToPolygon(), QPainterPath::angleAtPercent(), bounds(), fromPoints(), parameterSplitLeft(), shift(), shifted(), QPainterPath::slopeAtPercent(), split(), splitBezierAt(), stationaryYPoints(), QOpenGLPaintEnginePrivate::strokePathFastPen(), and tForY().

y4

qreal QBezier::y4

Definition at line 116 of file qbezier_p.h.

Referenced by addCircle(), addIfClose(), addToPolygon(), QPainterPath::angleAtPercent(), bounds(), fromPoints(), parameterSplitLeft(), qt_painterpath_bezier_extrema(), shift(), shifted(), QPainterPath::slopeAtPercent(), split(), splitBezierAt(), stationaryYPoints(), QOpenGLPaintEnginePrivate::strokePathFastPen(), and tForY().

---

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

• /src/gui/painting/qbezier_p.h
• /src/gui/painting/qbezier.cpp