QPathSegments Class Reference

#include <qpathclipper_p.h>

Classes
struct	Intersection
struct	Segment

Public Functions
void	addIntersection (int index, const Intersection &intersection)
void	addPath (const QPainterPath &path)
int	addPoint (const QPointF &point)
const QRectF &	elementBounds (int index) const
const Intersection *	intersectionAt (int index) const
int	intersections () const
const QLineF	lineAt (int index) const
void	mergePoints ()
int	pathId (int index) const
const QPointF &	pointAt (int vertex) const
int	points () const
	QPathSegments (int reserve)
const Segment &	segmentAt (int index) const
int	segments () const
void	setPath (const QPainterPath &path)

Properties
QDataBuffer< Intersection >	m_intersections
int	m_pathId
QDataBuffer< QPointF >	m_points
QDataBuffer< Segment >	m_segments

Detailed Description

Definition at line 166 of file qpathclipper_p.h.

Constructors and Destructors

QPathSegments()

QPathSegments::QPathSegments ( int  reserve )

inline

Definition at line 348 of file qpathclipper_p.h.

                                               :
    m_points(reserve),
    m_segments(reserve),
    m_intersections(reserve)
{
}

Functions

addIntersection()

void QPathSegments::addIntersection ( int  index, const Intersection &  intersection  )

inline

Definition at line 411 of file qpathclipper_p.h.

{
    m_intersections << intersection;

    Segment &segment = m_segments.at(index);
    if (segment.intersection < 0) {
        segment.intersection = m_intersections.size() - 1;
    } else {
        Intersection *isect = &m_intersections.at(segment.intersection);

        while (isect->next != 0)
            isect += isect->next;

        isect->next = (m_intersections.size() - 1) - (isect - m_intersections.data());
    }
}

addPath()

void QPathSegments::addPath

(

const QPainterPath &

path

)

Definition at line 927 of file qpathclipper.cpp.

Referenced by QWingedEdge::QWingedEdge().

{
    int firstSegment = m_segments.size();

    bool hasMoveTo = false;
    int lastMoveTo = 0;
    int last = 0;
    for (int i = 0; i < path.elementCount(); ++i) {
        int current = m_points.size();

        QPointF currentPoint;
        if (path.elementAt(i).type == QPainterPath::CurveToElement)
            currentPoint = path.elementAt(i+2);
        else
            currentPoint = path.elementAt(i);

        if (i > 0 && comparePoints(m_points.at(lastMoveTo), currentPoint))
            current = lastMoveTo;
        else
            m_points << currentPoint;

        switch (path.elementAt(i).type) {
        case QPainterPath::MoveToElement:
            if (hasMoveTo && last != lastMoveTo && !comparePoints(m_points.at(last), m_points.at(lastMoveTo)))
                m_segments << Segment(m_pathId, last, lastMoveTo);
            hasMoveTo = true;
            last = lastMoveTo = current;
            break;
        case QPainterPath::LineToElement:
            m_segments << Segment(m_pathId, last, current);
            last = current;
            break;
        case QPainterPath::CurveToElement:
            {
                QBezier bezier = QBezier::fromPoints(m_points.at(last), path.elementAt(i), path.elementAt(i+1), path.elementAt(i+2));
                if (isLine(bezier)) {
                    m_segments << Segment(m_pathId, last, current);
                } else {
                    QRectF bounds = bezier.bounds();

                    // threshold based on similar algorithm as in qtriangulatingstroker.cpp
                    int threshold = qMin<float>(64, qMax(bounds.width(), bounds.height()) * (2 * qreal(3.14) / 6));

                    if (threshold < 3) threshold = 3;
                    qreal one_over_threshold_minus_1 = qreal(1) / (threshold - 1);

                    for (int t = 1; t < threshold - 1; ++t) {
                        currentPoint = bezier.pointAt(t * one_over_threshold_minus_1);

                        int index = m_points.size();
                        m_segments << Segment(m_pathId, last, index);
                        last = index;

                        m_points << currentPoint;
                    }

                    m_segments << Segment(m_pathId, last, current);
                }
            }
            last = current;
            i += 2;
            break;
        default:
            Q_ASSERT(false);
            break;
        }
    }

    if (hasMoveTo && last != lastMoveTo && !comparePoints(m_points.at(last), m_points.at(lastMoveTo)))
        m_segments << Segment(m_pathId, last, lastMoveTo);

    for (int i = firstSegment; i < m_segments.size(); ++i) {
        const QLineF line = lineAt(i);

        qreal x1 = line.p1().x();
        qreal y1 = line.p1().y();
        qreal x2 = line.p2().x();
        qreal y2 = line.p2().y();

        if (x2 < x1)
            qSwap(x1, x2);
        if (y2 < y1)
            qSwap(y1, y2);

        m_segments.at(i).bounds = QRectF(x1, y1, x2 - x1, y2 - y1);
    }

    ++m_pathId;
}

addPoint()

int QPathSegments::addPoint ( const QPointF &  point )

inline

Definition at line 370 of file qpathclipper_p.h.

{
    m_points << point;
    return m_points.size() - 1;
}

elementBounds()

const QRectF & QPathSegments::elementBounds ( int  index ) const

inline

Definition at line 387 of file qpathclipper_p.h.

Referenced by QIntersectionFinder::hasIntersections().

{
    return m_segments.at(index).bounds;
}

intersectionAt()

const QPathSegments::Intersection * QPathSegments::intersectionAt ( int  index ) const

inline

Definition at line 397 of file qpathclipper_p.h.

{
    const int intersection = m_segments.at(index).intersection;
    if (intersection < 0)
        return 0;
    else
        return &m_intersections.at(intersection);
}

intersections()

int QPathSegments::intersections ( ) const

inline

Definition at line 406 of file qpathclipper_p.h.

{
    return m_intersections.size();
}

lineAt()

const QLineF QPathSegments::lineAt ( int  index ) const

inline

Definition at line 381 of file qpathclipper_p.h.

Referenced by QIntersectionFinder::hasIntersections().

{
    const Segment &segment = m_segments.at(index);
    return QLineF(m_points.at(segment.va), m_points.at(segment.vb));
}

mergePoints()

void QPathSegments::mergePoints

(

)

Definition at line 770 of file qpathclipper.cpp.

{
    QKdPointTree tree(*this);

    if (tree.rootNode()) {
        QDataBuffer<QPointF> mergedPoints(points());
        QDataBuffer<int> pointIndices(points());

        for (int i = 0; i < points(); ++i) {
            QKdPointFinder finder(i, *this, tree);
            QT_PREPEND_NAMESPACE(qTraverseKdPointTree<QKdPointFinder>)(*tree.rootNode(), finder);

            Q_ASSERT(finder.result() != -1);

            if (finder.result() >= mergedPoints.size())
                mergedPoints << m_points.at(i);

            pointIndices << finder.result();
        }

        for (int i = 0; i < m_segments.size(); ++i) {
            m_segments.at(i).va = pointIndices.at(m_segments.at(i).va);
            m_segments.at(i).vb = pointIndices.at(m_segments.at(i).vb);
        }

        for (int i = 0; i < m_intersections.size(); ++i)
            m_intersections.at(i).vertex = pointIndices.at(m_intersections.at(i).vertex);

        m_points.swap(mergedPoints);
    }
}

pathId()

int QPathSegments::pathId ( int  index ) const

inline

Definition at line 392 of file qpathclipper_p.h.

{
    return m_segments.at(index).path;
}

pointAt()

const QPointF & QPathSegments::pointAt ( int  vertex ) const

inline

Definition at line 365 of file qpathclipper_p.h.

Referenced by QKdPointFinder::QKdPointFinder().

{
    return m_points.at(i);
}

points()

int QPathSegments::points ( ) const

inline

Definition at line 360 of file qpathclipper_p.h.

{
    return m_points.size();
}

segmentAt()

const QPathSegments::Segment & QPathSegments::segmentAt ( int  index ) const

inline

Definition at line 376 of file qpathclipper_p.h.

{
    return m_segments.at(index);
}

segments()

int QPathSegments::segments ( ) const

inline

Definition at line 355 of file qpathclipper_p.h.

Referenced by QIntersectionFinder::hasIntersections(), and QIntersectionFinder::produceIntersections().

{
    return m_segments.size();
}

setPath()

void QPathSegments::setPath

(

const QPainterPath &

path

)

Definition at line 916 of file qpathclipper.cpp.

Referenced by QPathClipper::contains(), QPathClipper::intersect(), and QWingedEdge::QWingedEdge().

{
    m_points.reset();
    m_intersections.reset();
    m_segments.reset();

    m_pathId = 0;

    addPath(path);
}

Properties

m_intersections

QDataBuffer<Intersection> QPathSegments::m_intersections

private

Definition at line 227 of file qpathclipper_p.h.

Referenced by addIntersection(), intersectionAt(), and intersections().

m_pathId

int QPathSegments::m_pathId

private

Definition at line 229 of file qpathclipper_p.h.

m_points

QDataBuffer<QPointF> QPathSegments::m_points

private

Definition at line 225 of file qpathclipper_p.h.

Referenced by addPoint(), lineAt(), pointAt(), and points().

m_segments

QDataBuffer<Segment> QPathSegments::m_segments

private

Definition at line 226 of file qpathclipper_p.h.

Referenced by addIntersection(), elementBounds(), intersectionAt(), lineAt(), pathId(), segmentAt(), and segments().

---

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

• /src/gui/painting/qpathclipper_p.h
• /src/gui/painting/qpathclipper.cpp