QTriangulator< T >::MonotoneToTriangles Class Reference

Public Functions
void	decompose ()
	MonotoneToTriangles (QTriangulator< T > *parent)

Private Functions
T	indices (int index) const
bool	leftOfEdge (int i, int j, int k) const
bool	less (int i, int j) const
int	next (int index) const
int	previous (int index) const

Properties
int	m_first
int	m_length
QTriangulator< T > *	m_parent

Detailed Description

template<typename T>
class QTriangulator< T >::MonotoneToTriangles

Definition at line 1495 of file qtriangulator.cpp.

Constructors and Destructors

MonotoneToTriangles()

template<typename T>

QTriangulator< T >::MonotoneToTriangles::MonotoneToTriangles ( QTriangulator< T > *  parent )

inline

Definition at line 1498 of file qtriangulator.cpp.

: m_parent(parent) { }

Functions

decompose()

template<typename T >

void QTriangulator< T >::MonotoneToTriangles::decompose

(

)

Definition at line 2921 of file qtriangulator.cpp.

Referenced by QTriangulator< T >::triangulate().

{
    QVector<T> result;
    QDataBuffer<int> stack(m_parent->m_indices.size());
    m_first = 0;
    // Require at least three more indices.
    while (m_first + 3 <= m_parent->m_indices.size()) {
        m_length = 0;
        while (m_parent->m_indices.at(m_first + m_length) != T(-1)) { // Q_TRIANGULATE_END_OF_POLYGON
            ++m_length;
            Q_ASSERT(m_first + m_length < m_parent->m_indices.size());
        }
        if (m_length < 3) {
            m_first += m_length + 1;
            continue;
        }

        int minimum = 0;
        while (less(next(minimum), minimum))
            minimum = next(minimum);
        while (less(previous(minimum), minimum))
            minimum = previous(minimum);

        stack.reset();
        stack.add(minimum);
        int left = previous(minimum);
        int right = next(minimum);
        bool stackIsOnLeftSide;
        bool clockwiseOrder = leftOfEdge(minimum, left, right);

        if (less(left, right)) {
            stack.add(left);
            left = previous(left);
            stackIsOnLeftSide = true;
        } else {
            stack.add(right);
            right = next(right);
            stackIsOnLeftSide = false;
        }

        for (int count = 0; count + 2 < m_length; ++count)
        {
            Q_ASSERT(stack.size() >= 2);
            if (less(left, right)) {
                if (stackIsOnLeftSide == false) {
                    for (int i = 0; i + 1 < stack.size(); ++i) {
                        result.push_back(indices(stack.at(i + 1)));
                        result.push_back(indices(left));
                        result.push_back(indices(stack.at(i)));
                    }
                    stack.first() = stack.last();
                    stack.resize(1);
                } else {
                    while (stack.size() >= 2 && (clockwiseOrder ^ !leftOfEdge(left, stack.at(stack.size() - 2), stack.last()))) {
                        result.push_back(indices(stack.at(stack.size() - 2)));
                        result.push_back(indices(left));
                        result.push_back(indices(stack.last()));
                        stack.pop_back();
                    }
                }
                stack.add(left);
                left = previous(left);
                stackIsOnLeftSide = true;
            } else {
                if (stackIsOnLeftSide == true) {
                    for (int i = 0; i + 1 < stack.size(); ++i) {
                        result.push_back(indices(stack.at(i)));
                        result.push_back(indices(right));
                        result.push_back(indices(stack.at(i + 1)));
                    }
                    stack.first() = stack.last();
                    stack.resize(1);
                } else {
                    while (stack.size() >= 2 && (clockwiseOrder ^ !leftOfEdge(right, stack.last(), stack.at(stack.size() - 2)))) {
                        result.push_back(indices(stack.last()));
                        result.push_back(indices(right));
                        result.push_back(indices(stack.at(stack.size() - 2)));
                        stack.pop_back();
                    }
                }
                stack.add(right);
                right = next(right);
                stackIsOnLeftSide = false;
            }
        }

        m_first += m_length + 1;
    }
    m_parent->m_indices = result;
}

indices()

template<typename T>

T QTriangulator< T >::MonotoneToTriangles::indices ( int  index ) const

inlineprivate

Definition at line 1501 of file qtriangulator.cpp.

{return m_parent->m_indices.at(index + m_first);}

leftOfEdge()

template<typename T>

bool QTriangulator< T >::MonotoneToTriangles::leftOfEdge ( int  i, int  j, int  k  ) const

inlineprivate

Definition at line 1505 of file qtriangulator.cpp.

        {
            return qPointIsLeftOfLine(m_parent->m_vertices.at((qint32)indices(i)),
                m_parent->m_vertices.at((qint32)indices(j)), m_parent->m_vertices.at((qint32)indices(k)));
        }

less()

template<typename T>

bool QTriangulator< T >::MonotoneToTriangles::less ( int  i, int  j  ) const

inlineprivate

Definition at line 1504 of file qtriangulator.cpp.

{return m_parent->m_vertices.at((qint32)indices(i)) < m_parent->m_vertices.at(indices(j));}

next()

template<typename T>

int QTriangulator< T >::MonotoneToTriangles::next ( int  index ) const

inlineprivate

Definition at line 1502 of file qtriangulator.cpp.

{return (index + 1) % m_length;}

previous()

template<typename T>

int QTriangulator< T >::MonotoneToTriangles::previous ( int  index ) const

inlineprivate

Definition at line 1503 of file qtriangulator.cpp.

{return (index + m_length - 1) % m_length;}

Properties

m_first

template<typename T>

int QTriangulator< T >::MonotoneToTriangles::m_first

private

Definition at line 1512 of file qtriangulator.cpp.

m_length

template<typename T>

int QTriangulator< T >::MonotoneToTriangles::m_length

private

Definition at line 1513 of file qtriangulator.cpp.

m_parent

template<typename T>

QTriangulator<T>* QTriangulator< T >::MonotoneToTriangles::m_parent

private

Definition at line 1511 of file qtriangulator.cpp.

---

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

• /src/opengl/gl2paintengineex/qtriangulator.cpp