QTriangulator< T > Class Template Reference

Classes
class	ComplexToSimple
class	MonotoneToTriangles
class	SimpleToMonotone

Public Types
typedef QVarLengthArray< int, 6 >	ShortArray

Public Functions
void	initialize (const qreal *polygon, int count, uint hint, const QTransform &matrix)
void	initialize (const QVectorPath &path, const QTransform &matrix, qreal lod)
void	initialize (const QPainterPath &path, const QTransform &matrix, qreal lod)
QVertexSet< T >	polyline ()
	QTriangulator ()
QVertexSet< T >	triangulate ()

Properties
uint	m_hint
QVector< T >	m_indices
QDataBuffer< QPodPoint >	m_vertices

Friends
class	ComplexToSimple
class	MonotoneToTriangles
class	SimpleToMonotone

Detailed Description

template<typename T>
class QTriangulator< T >

Definition at line 1316 of file qtriangulator.cpp.

Typedefs

ShortArray

template<typename T>

typedef QVarLengthArray<int, 6> QTriangulator< T >::ShortArray

Definition at line 1319 of file qtriangulator.cpp.

Constructors and Destructors

QTriangulator()

template<typename T>

QTriangulator< T >::QTriangulator ( )

inline

Definition at line 1516 of file qtriangulator.cpp.

: m_vertices(0) { }

Functions

initialize() [1/3]

template<typename T >

void QTriangulator< T >::initialize	(	const qreal *	polygon,
		int	count,
		uint	hint,
		const QTransform &	matrix
	)

Definition at line 1581 of file qtriangulator.cpp.

Referenced by qPolyline(), and qTriangulate().

{
    m_hint = hint;
    m_vertices.resize(count);
    m_indices.resize(count + 1);
    for (int i = 0; i < count; ++i) {
        qreal x, y;
        matrix.map(polygon[2 * i + 0], polygon[2 * i + 1], &x, &y);
        m_vertices.at(i).x = qRound(x * Q_FIXED_POINT_SCALE);
        m_vertices.at(i).y = qRound(y * Q_FIXED_POINT_SCALE);
        m_indices[i] = i;
    }
    m_indices[count] = T(-1); //Q_TRIANGULATE_END_OF_POLYGON
}

initialize() [2/3]

template<typename T >

void QTriangulator< T >::initialize	(	const QVectorPath &	path,
		const QTransform &	matrix,
		qreal	lod
	)

Definition at line 1597 of file qtriangulator.cpp.

{
    m_hint = path.hints();
    // Curved paths will be converted to complex polygons.
    m_hint &= ~QVectorPath::CurvedShapeMask;

    const qreal *p = path.points();
    const QPainterPath::ElementType *e = path.elements();
    if (e) {
        for (int i = 0; i < path.elementCount(); ++i, ++e, p += 2) {
            switch (*e) {
            case QPainterPath::MoveToElement:
                if (!m_indices.isEmpty())
                    m_indices.push_back(T(-1)); // Q_TRIANGULATE_END_OF_POLYGON
                // Fall through.
            case QPainterPath::LineToElement:
                m_indices.push_back(T(m_vertices.size()));
                m_vertices.resize(m_vertices.size() + 1);
                qreal x, y;
                matrix.map(p[0], p[1], &x, &y);
                m_vertices.last().x = qRound(x * Q_FIXED_POINT_SCALE);
                m_vertices.last().y = qRound(y * Q_FIXED_POINT_SCALE);
                break;
            case QPainterPath::CurveToElement:
                {
                    qreal pts[8];
                    for (int i = 0; i < 4; ++i)
                        matrix.map(p[2 * i - 2], p[2 * i - 1], &pts[2 * i + 0], &pts[2 * i + 1]);
                    for (int i = 0; i < 8; ++i)
                        pts[i] *= lod;
                    QBezier bezier = QBezier::fromPoints(QPointF(pts[0], pts[1]), QPointF(pts[2], pts[3]), QPointF(pts[4], pts[5]), QPointF(pts[6], pts[7]));
                    QPolygonF poly = bezier.toPolygon();
                    // Skip first point, it already exists in 'm_vertices'.
                    for (int j = 1; j < poly.size(); ++j) {
                        m_indices.push_back(T(m_vertices.size()));
                        m_vertices.resize(m_vertices.size() + 1);
                        m_vertices.last().x = qRound(poly.at(j).x() * Q_FIXED_POINT_SCALE / lod);
                        m_vertices.last().y = qRound(poly.at(j).y() * Q_FIXED_POINT_SCALE / lod);
                    }
                }
                i += 2;
                e += 2;
                p += 4;
                break;
            default:
                Q_ASSERT_X(0, "QTriangulator::triangulate", "Unexpected element type.");
                break;
            }
        }
    } else {
        for (int i = 0; i < path.elementCount(); ++i, p += 2) {
            m_indices.push_back(T(m_vertices.size()));
            m_vertices.resize(m_vertices.size() + 1);
            qreal x, y;
            matrix.map(p[0], p[1], &x, &y);
            m_vertices.last().x = qRound(x * Q_FIXED_POINT_SCALE);
            m_vertices.last().y = qRound(y * Q_FIXED_POINT_SCALE);
        }
    }
    m_indices.push_back(T(-1)); // Q_TRIANGULATE_END_OF_POLYGON
}

initialize() [3/3]

template<typename T >

void QTriangulator< T >::initialize	(	const QPainterPath &	path,
		const QTransform &	matrix,
		qreal	lod
	)

Definition at line 1660 of file qtriangulator.cpp.

{
    initialize(qtVectorPathForPath(path), matrix, lod);
}

polyline()

template<typename T >

QVertexSet< T > QTriangulator< T >::polyline

(

)

Definition at line 1568 of file qtriangulator.cpp.

Referenced by qPolyline().

{
    QVertexSet<T> result;
    result.indices = m_indices;
    result.vertices.resize(2 * m_vertices.size());
    for (int i = 0; i < m_vertices.size(); ++i) {
        result.vertices[2 * i + 0] = qreal(m_vertices.at(i).x) / Q_FIXED_POINT_SCALE;
        result.vertices[2 * i + 1] = qreal(m_vertices.at(i).y) / Q_FIXED_POINT_SCALE;
    }
    return result;
}

triangulate()

template<typename T >

QVertexSet< T > QTriangulator< T >::triangulate

(

)

Definition at line 1538 of file qtriangulator.cpp.

Referenced by qPolyline(), and qTriangulate().

{
    for (int i = 0; i < m_vertices.size(); ++i) {
        Q_ASSERT(qAbs(m_vertices.at(i).x) < (1 << 21));
        Q_ASSERT(qAbs(m_vertices.at(i).y) < (1 << 21));
    }

    if (!(m_hint & (QVectorPath::OddEvenFill | QVectorPath::WindingFill)))
        m_hint |= QVectorPath::OddEvenFill;

    if (m_hint & QVectorPath::NonConvexShapeMask) {
        ComplexToSimple c2s(this);
        c2s.decompose();
        SimpleToMonotone s2m(this);
        s2m.decompose();
    }
    MonotoneToTriangles m2t(this);
    m2t.decompose();

    QVertexSet<T> result;
    result.indices = m_indices;
    result.vertices.resize(2 * m_vertices.size());
    for (int i = 0; i < m_vertices.size(); ++i) {
        result.vertices[2 * i + 0] = qreal(m_vertices.at(i).x) / Q_FIXED_POINT_SCALE;
        result.vertices[2 * i + 1] = qreal(m_vertices.at(i).y) / Q_FIXED_POINT_SCALE;
    }
    return result;
}

Friends and Related Functions

ComplexToSimple

template<typename T>

friend class ComplexToSimple

friend

Definition at line 1324 of file qtriangulator.cpp.

MonotoneToTriangles

template<typename T>

friend class MonotoneToTriangles

friend

Definition at line 1494 of file qtriangulator.cpp.

SimpleToMonotone

template<typename T>

friend class SimpleToMonotone

friend

Definition at line 1438 of file qtriangulator.cpp.

Properties

m_hint

template<typename T>

uint QTriangulator< T >::m_hint

private

Definition at line 1530 of file qtriangulator.cpp.

m_indices

template<typename T>

QVector<T> QTriangulator< T >::m_indices

private

Definition at line 1529 of file qtriangulator.cpp.

m_vertices

template<typename T>

QDataBuffer<QPodPoint> QTriangulator< T >::m_vertices

private

Definition at line 1528 of file qtriangulator.cpp.

---

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

• /src/opengl/gl2paintengineex/qtriangulator.cpp