qstroker_p.h File Reference

#include "QtGui/qpainterpath.h"
#include "private/qdatabuffer_p.h"
#include "private/qnumeric_p.h"

Go to the source code of this file.

Classes
class	QDashStroker
struct	qfixed2d
class	QStroker
class	QStrokerOps
struct	QStrokerOps::Element

Macros
#define	qt_fixed_to_real(fixed)   fixed
#define	QT_PATH_KAPPA   0.5522847498
#define	qt_real_to_fixed(real)   qfixed(real)

Typedefs
typedef qreal	qfixed
typedef void(*	qStrokerCubicToHook) (qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey, void *data)
typedef void(*	qStrokerLineToHook) (qfixed x, qfixed y, void *data)
typedef void(*	qStrokerMoveToHook) (qfixed x, qfixed y, void *data)

Functions
QPointF	qt_curves_for_arc (const QRectF &rect, qreal startAngle, qreal sweepLength, QPointF *controlPoints, int *point_count)
	Creates a number of curves for a given arc definition. More...
Q_GUI_EXPORT bool	qt_scaleForTransform (const QTransform &transform, qreal *scale)
qreal	qt_t_for_arc_angle (qreal angle)

Macro Definition Documentation

qt_fixed_to_real

#define qt_fixed_to_real

(

fixed

)

fixed

Definition at line 102 of file qstroker_p.h.

Referenced by QPainterPathStroker::curveThreshold(), QStroker::joinPoints(), QPainterPathStroker::miterLimit(), QSubpathFlatIterator::next(), QDashStroker::processCurrentSubpath(), qt_ft_outline_cubic_to(), qt_ft_outline_line_to(), qt_ft_outline_move_to(), qt_path_stroke_cubic_to(), qt_path_stroke_line_to(), qt_path_stroke_move_to(), qt_stroke_side(), and QPainterPathStroker::width().

QT_PATH_KAPPA

#define QT_PATH_KAPPA   0.5522847498

Definition at line 113 of file qstroker_p.h.

Referenced by QStroker::joinPoints(), qt_curves_for_arc(), qt_find_ellipse_coords(), and qt_t_for_arc_angle().

qt_real_to_fixed

#define qt_real_to_fixed

(

real

)

qfixed(real)

Definition at line 101 of file qstroker_p.h.

Referenced by QStroker::joinPoints(), QSubpathFlatIterator::next(), QDashStroker::processCurrentSubpath(), QStroker::QStroker(), qt_stroke_side(), QPainterPathStroker::setCurveThreshold(), QPainterPathStroker::setDashPattern(), QPainterPathStroker::setMiterLimit(), QPainterPathStroker::setWidth(), QStrokerOps::strokeEllipse(), QStrokerOps::strokePath(), and QStrokerOps::strokePolygon().

Typedef Documentation

qfixed

typedef qreal qfixed

Definition at line 100 of file qstroker_p.h.

qStrokerCubicToHook

typedef void(* qStrokerCubicToHook) (qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey, void *data)

Definition at line 122 of file qstroker_p.h.

qStrokerLineToHook

typedef void(* qStrokerLineToHook) (qfixed x, qfixed y, void *data)

Definition at line 121 of file qstroker_p.h.

qStrokerMoveToHook

typedef void(* qStrokerMoveToHook) (qfixed x, qfixed y, void *data)

Definition at line 120 of file qstroker_p.h.

Function Documentation

qt_curves_for_arc()

QPointF qt_curves_for_arc	(	const QRectF &	rect,
		qreal	startAngle,
		qreal	sweepLength,
		QPointF *	curves,
		int *	point_count
	)

Creates a number of curves for a given arc definition.

Warning

This function is not part of the public interface.

The arc is defined an arc along the ellipses that fits into rect starting at startAngle and an arc length of sweepLength.

The function has three out parameters. The return value is the starting point of the arc. The curves array represents the list of cubicTo elements up to a maximum of point_count. There are of course 3 points pr curve.

Definition at line 859 of file qstroker.cpp.

Referenced by QPainterPath::addEllipse(), QPainterPath::arcTo(), QPaintEngineEx::drawEllipse(), QStroker::joinPoints(), and QStrokerOps::strokeEllipse().

{
    Q_ASSERT(point_count);
    Q_ASSERT(curves);

    *point_count = 0;
    if (qt_is_nan(rect.x()) || qt_is_nan(rect.y()) || qt_is_nan(rect.width()) || qt_is_nan(rect.height())
        || qt_is_nan(startAngle) || qt_is_nan(sweepLength)) {
        qWarning("QPainterPath::arcTo: Adding arc where a parameter is NaN, results are undefined");
        return QPointF();
    }

    if (rect.isNull()) {
        return QPointF();
    }

    qreal x = rect.x();
    qreal y = rect.y();

    qreal w = rect.width();
    qreal w2 = rect.width() / 2;
    qreal w2k = w2 * QT_PATH_KAPPA;

    qreal h = rect.height();
    qreal h2 = rect.height() / 2;
    qreal h2k = h2 * QT_PATH_KAPPA;

    QPointF points[16] =
    {
        // start point
        QPointF(x + w, y + h2),

        // 0 -> 270 degrees
        QPointF(x + w, y + h2 + h2k),
        QPointF(x + w2 + w2k, y + h),
        QPointF(x + w2, y + h),

        // 270 -> 180 degrees
        QPointF(x + w2 - w2k, y + h),
        QPointF(x, y + h2 + h2k),
        QPointF(x, y + h2),

        // 180 -> 90 degrees
        QPointF(x, y + h2 - h2k),
        QPointF(x + w2 - w2k, y),
        QPointF(x + w2, y),

        // 90 -> 0 degrees
        QPointF(x + w2 + w2k, y),
        QPointF(x + w, y + h2 - h2k),
        QPointF(x + w, y + h2)
    };

    if (sweepLength > 360) sweepLength = 360;
    else if (sweepLength < -360) sweepLength = -360;

    // Special case fast paths
    if (startAngle == 0.0) {
        if (sweepLength == 360.0) {
            for (int i = 11; i >= 0; --i)
                curves[(*point_count)++] = points[i];
            return points[12];
        } else if (sweepLength == -360.0) {
            for (int i = 1; i <= 12; ++i)
                curves[(*point_count)++] = points[i];
            return points[0];
        }
    }

    int startSegment = int(qFloor(startAngle / 90));
    int endSegment = int(qFloor((startAngle + sweepLength) / 90));

    qreal startT = (startAngle - startSegment * 90) / 90;
    qreal endT = (startAngle + sweepLength - endSegment * 90) / 90;

    int delta = sweepLength > 0 ? 1 : -1;
    if (delta < 0) {
        startT = 1 - startT;
        endT = 1 - endT;
    }

    // avoid empty start segment
    if (qFuzzyIsNull(startT - qreal(1))) {
        startT = 0;
        startSegment += delta;
    }

    // avoid empty end segment
    if (qFuzzyIsNull(endT)) {
        endT = 1;
        endSegment -= delta;
    }

    startT = qt_t_for_arc_angle(startT * 90);
    endT = qt_t_for_arc_angle(endT * 90);

    const bool splitAtStart = !qFuzzyIsNull(startT);
    const bool splitAtEnd = !qFuzzyIsNull(endT - qreal(1));

    const int end = endSegment + delta;

    // empty arc?
    if (startSegment == end) {
        const int quadrant = 3 - ((startSegment % 4) + 4) % 4;
        const int j = 3 * quadrant;
        return delta > 0 ? points[j + 3] : points[j];
    }

    QPointF startPoint, endPoint;
    qt_find_ellipse_coords(rect, startAngle, sweepLength, &startPoint, &endPoint);

    for (int i = startSegment; i != end; i += delta) {
        const int quadrant = 3 - ((i % 4) + 4) % 4;
        const int j = 3 * quadrant;

        QBezier b;
        if (delta > 0)
            b = QBezier::fromPoints(points[j + 3], points[j + 2], points[j + 1], points[j]);
        else
            b = QBezier::fromPoints(points[j], points[j + 1], points[j + 2], points[j + 3]);

        // empty arc?
        if (startSegment == endSegment && qFuzzyCompare(startT, endT))
            return startPoint;

        if (i == startSegment) {
            if (i == endSegment && splitAtEnd)
                b = b.bezierOnInterval(startT, endT);
            else if (splitAtStart)
                b = b.bezierOnInterval(startT, 1);
        } else if (i == endSegment && splitAtEnd) {
            b = b.bezierOnInterval(0, endT);
        }

        // push control points
        curves[(*point_count)++] = b.pt2();
        curves[(*point_count)++] = b.pt3();
        curves[(*point_count)++] = b.pt4();
    }

    Q_ASSERT(*point_count > 0);
    curves[*(point_count)-1] = endPoint;

    return startPoint;
}

qt_scaleForTransform()

Q_GUI_EXPORT bool qt_scaleForTransform	(	const QTransform &	transform,
		qreal *	scale
	)

Definition at line 2407 of file qtransform.cpp.

Referenced by QStrokerOps::setCurveThresholdFromTransform().

{
    const QTransform::TransformationType type = transform.type();
    if (type <= QTransform::TxTranslate) {
        if (scale)
            *scale = 1;
        return true;
    } else if (type == QTransform::TxScale) {
        const qreal xScale = qAbs(transform.m11());
        const qreal yScale = qAbs(transform.m22());
        if (scale)
            *scale = qMax(xScale, yScale);
        return qFuzzyCompare(xScale, yScale);
    }

    const qreal xScale = transform.m11() * transform.m11()
                         + transform.m21() * transform.m21();
    const qreal yScale = transform.m12() * transform.m12()
                         + transform.m22() * transform.m22();
    if (scale)
        *scale = qSqrt(qMax(xScale, yScale));
    return type == QTransform::TxRotate && qFuzzyCompare(xScale, yScale);
}

qt_t_for_arc_angle()

qreal qt_t_for_arc_angle

(

qreal

angle

)

Warning

This function is not part of the public interface.

For a given angle in the range [0 .. 90], finds the corresponding parameter t of the prototype cubic bezier arc segment b = fromPoints(QPointF(1, 0), QPointF(1, KAPPA), QPointF(KAPPA, 1), QPointF(0, 1));

From the bezier equation: b.pointAt(t).x() = (1-t)^3 + t*(1-t)^2 + t^2*(1-t)*KAPPA b.pointAt(t).y() = t*(1-t)^2 * KAPPA + t^2*(1-t) + t^3

Third degree coefficients: b.pointAt(t).x() = at^3 + bt^2 + ct + d where a = 2-3*KAPPA, b = 3*(KAPPA-1), c = 0, d = 1

b.pointAt(t).y() = at^3 + bt^2 + ct + d where a = 3*KAPPA-2, b = 6*KAPPA+3, c = 3*KAPPA, d = 0

Newton's method to find the zero of a function: given a function f(x) and initial guess x_0 x_1 = f(x_0) / f'(x_0) x_2 = f(x_1) / f'(x_1) etc...

Definition at line 796 of file qstroker.cpp.

Referenced by qt_curves_for_arc(), and qt_find_ellipse_coords().

{
    if (qFuzzyIsNull(angle))
        return 0;

    if (qFuzzyCompare(angle, qreal(90)))
        return 1;

    qreal radians = Q_PI * angle / 180;
    qreal cosAngle = qCos(radians);
    qreal sinAngle = qSin(radians);

    // initial guess
    qreal tc = angle / 90;
    // do some iterations of newton's method to approximate cosAngle
    // finds the zero of the function b.pointAt(tc).x() - cosAngle
    tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value
         / (((6-9*QT_PATH_KAPPA) * tc + 6*(QT_PATH_KAPPA-1)) * tc); // derivative
    tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value
         / (((6-9*QT_PATH_KAPPA) * tc + 6*(QT_PATH_KAPPA-1)) * tc); // derivative

    // initial guess
    qreal ts = tc;
    // do some iterations of newton's method to approximate sinAngle
    // finds the zero of the function b.pointAt(tc).y() - sinAngle
    ts -= ((((3*QT_PATH_KAPPA-2) * ts -  6*QT_PATH_KAPPA + 3) * ts + 3*QT_PATH_KAPPA) * ts - sinAngle)
         / (((9*QT_PATH_KAPPA-6) * ts + 12*QT_PATH_KAPPA - 6) * ts + 3*QT_PATH_KAPPA);
    ts -= ((((3*QT_PATH_KAPPA-2) * ts -  6*QT_PATH_KAPPA + 3) * ts + 3*QT_PATH_KAPPA) * ts - sinAngle)
         / (((9*QT_PATH_KAPPA-6) * ts + 12*QT_PATH_KAPPA - 6) * ts + 3*QT_PATH_KAPPA);

    // use the average of the t that best approximates cosAngle
    // and the t that best approximates sinAngle
    qreal t = 0.5 * (tc + ts);

#if 0
    printf("angle: %f, t: %f\n", angle, t);
    qreal a, b, c, d;
    bezierCoefficients(t, a, b, c, d);
    printf("cosAngle: %.10f, value: %.10f\n", cosAngle, a + b + c * QT_PATH_KAPPA);
    printf("sinAngle: %.10f, value: %.10f\n", sinAngle, b * QT_PATH_KAPPA + c + d);
#endif

    return t;
}