Qt 4.8
Classes | Public Functions | Private Types | Private Functions | Properties | Friends | List of all members
QTriangulator< T >::SimpleToMonotone Class Reference

Classes

class  CompareVertices
 
struct  Edge
 

Public Functions

void decompose ()
 
 SimpleToMonotone (QTriangulator< T > *parent)
 

Private Types

enum  VertexType {
  MergeVertex, EndVertex, RegularVertex, StartVertex,
  SplitVertex
}
 

Private Functions

void classifyVertex (int i)
 
void classifyVertices ()
 
void createDiagonal (int lower, int upper)
 
bool edgeIsLeftOfEdge (int leftEdgeIndex, int rightEdgeIndex) const
 
void fillPriorityQueue ()
 
int findSector (int edge, int vertex)
 
void monotoneDecomposition ()
 
bool pointIsInSector (const QPodPoint &p, const QPodPoint &v1, const QPodPoint &v2, const QPodPoint &v3)
 
bool pointIsInSector (int vertex, int sector)
 
void removeZeroLengthEdges ()
 
QRBTree< int >::NodesearchEdgeLeftOfEdge (int edgeIndex) const
 
QRBTree< int >::NodesearchEdgeLeftOfPoint (int pointIndex) const
 
void setupDataStructures ()
 

Properties

bool m_clockwiseOrder
 
QRBTree< int > m_edgeList
 
QDataBuffer< Edgem_edges
 
QTriangulatorm_parent
 
QDataBuffer< int > m_upperVertex
 

Friends

class CompareVertices
 

Detailed Description

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

Definition at line 1439 of file qtriangulator.cpp.

Enumerations

◆ VertexType

template<typename T>
enum QTriangulator::SimpleToMonotone::VertexType
private

Constructors and Destructors

◆ SimpleToMonotone()

template<typename T>
QTriangulator< T >::SimpleToMonotone::SimpleToMonotone ( QTriangulator< T > *  parent)
inline

Definition at line 1442 of file qtriangulator.cpp.

1442 : m_parent(parent), m_edges(0), m_upperVertex(0) { }

Functions

◆ classifyVertex()

template<typename T >
void QTriangulator< T >::SimpleToMonotone::classifyVertex ( int  i)
private

Definition at line 2663 of file qtriangulator.cpp.

2664 {
2665  Edge &e2 = m_edges.at(i);
2666  const Edge &e1 = m_edges.at(e2.previous);
2667 
2668  bool startOrSplit = (e1.pointingUp && !e2.pointingUp);
2669  bool endOrMerge = (!e1.pointingUp && e2.pointingUp);
2670 
2671  const QPodPoint &p1 = m_parent->m_vertices.at(e1.from);
2672  const QPodPoint &p2 = m_parent->m_vertices.at(e2.from);
2673  const QPodPoint &p3 = m_parent->m_vertices.at(e2.to);
2675  Q_ASSERT(d != 0 || (!startOrSplit && !endOrMerge));
2676 
2677  e2.type = RegularVertex;
2678 
2679  if (m_clockwiseOrder) {
2680  if (startOrSplit)
2681  e2.type = (d < 0 ? SplitVertex : StartVertex);
2682  else if (endOrMerge)
2683  e2.type = (d < 0 ? MergeVertex : EndVertex);
2684  } else {
2685  if (startOrSplit)
2686  e2.type = (d > 0 ? SplitVertex : StartVertex);
2687  else if (endOrMerge)
2688  e2.type = (d > 0 ? MergeVertex : EndVertex);
2689  }
2690 }
double d
Definition: qnumeric_p.h:62
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
static qint64 qPointDistanceFromLine(const QPodPoint &p, const QPodPoint &v1, const QPodPoint &v2)
#define QT_PREPEND_NAMESPACE(name)
This macro qualifies identifier with the full namespace.
Definition: qglobal.h:87
Type & at(int i)
Definition: qdatabuffer_p.h:86
__int64 qint64
Definition: qglobal.h:942
QDataBuffer< QPodPoint > m_vertices

◆ classifyVertices()

template<typename T >
void QTriangulator< T >::SimpleToMonotone::classifyVertices ( )
private

Definition at line 2693 of file qtriangulator.cpp.

2694 {
2695  for (int i = 0; i < m_edges.size(); ++i)
2696  classifyVertex(i);
2697 }

◆ createDiagonal()

template<typename T >
void QTriangulator< T >::SimpleToMonotone::createDiagonal ( int  lower,
int  upper 
)
private

Definition at line 2745 of file qtriangulator.cpp.

2746 {
2747  lower = findSector(lower, upper);
2748  upper = findSector(upper, lower);
2749 
2750  int prevLower = m_edges.at(lower).previous;
2751  int prevUpper = m_edges.at(upper).previous;
2752 
2753  Edge e;
2754 
2755  e.twin = m_edges.size() + 1;
2756  e.next = upper;
2757  e.previous = prevLower;
2758  e.from = m_edges.at(lower).from;
2759  e.to = m_edges.at(upper).from;
2760  m_edges.at(upper).previous = m_edges.at(prevLower).next = int(m_edges.size());
2761  m_edges.add(e);
2762 
2763  e.twin = m_edges.size() - 1;
2764  e.next = lower;
2765  e.previous = prevUpper;
2766  e.from = m_edges.at(upper).from;
2767  e.to = m_edges.at(lower).from;
2768  m_edges.at(lower).previous = m_edges.at(prevUpper).next = int(m_edges.size());
2769  m_edges.add(e);
2770 }
int findSector(int edge, int vertex)

◆ decompose()

template<typename T >
void QTriangulator< T >::SimpleToMonotone::decompose ( )

Definition at line 2510 of file qtriangulator.cpp.

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

2511 {
2515 
2516  m_parent->m_indices.clear();
2517  QBitArray processed(m_edges.size(), false);
2518  for (int first = 0; first < m_edges.size(); ++first) {
2519  if (processed.at(first))
2520  continue;
2521  int i = first;
2522  do {
2523  Q_ASSERT(!processed.at(i));
2524  Q_ASSERT(m_edges.at(m_edges.at(i).next).previous == i);
2525  m_parent->m_indices.push_back(m_edges.at(i).from);
2526  processed.setBit(i);
2527  i = m_edges.at(i).next;
2528  } while (i != first);
2529  if (m_parent->m_indices.size() > 0 && m_parent->m_indices.back() != T(-1)) // Q_TRIANGULATE_END_OF_POLYGON
2530  m_parent->m_indices.push_back(T(-1)); // Q_TRIANGULATE_END_OF_POLYGON
2531  }
2532 }
QVector< T > m_indices
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
The QBitArray class provides an array of bits.
Definition: qbitarray.h:54

◆ edgeIsLeftOfEdge()

template<typename T >
bool QTriangulator< T >::SimpleToMonotone::edgeIsLeftOfEdge ( int  leftEdgeIndex,
int  rightEdgeIndex 
) const
private

Definition at line 2612 of file qtriangulator.cpp.

2613 {
2614  const Edge &leftEdge = m_edges.at(leftEdgeIndex);
2615  const Edge &rightEdge = m_edges.at(rightEdgeIndex);
2616  const QPodPoint &u = m_parent->m_vertices.at(rightEdge.upper());
2617  const QPodPoint &l = m_parent->m_vertices.at(rightEdge.lower());
2619  // d < 0: left, d > 0: right, d == 0: on top
2620  if (d == 0)
2621  d = QT_PREPEND_NAMESPACE(qPointDistanceFromLine)(m_parent->m_vertices.at(leftEdge.lower()), l, u);
2622  return d < 0;
2623 }
double d
Definition: qnumeric_p.h:62
quint16 u
static qint64 qPointDistanceFromLine(const QPodPoint &p, const QPodPoint &v1, const QPodPoint &v2)
#define QT_PREPEND_NAMESPACE(name)
This macro qualifies identifier with the full namespace.
Definition: qglobal.h:87
Type & at(int i)
Definition: qdatabuffer_p.h:86
__int64 qint64
Definition: qglobal.h:942
QFactoryLoader * l
QDataBuffer< QPodPoint > m_vertices

◆ fillPriorityQueue()

template<typename T >
void QTriangulator< T >::SimpleToMonotone::fillPriorityQueue ( )
private

Definition at line 2597 of file qtriangulator.cpp.

2598 {
2599  m_upperVertex.reset();
2600  m_upperVertex.reserve(m_edges.size());
2601  for (int i = 0; i < m_edges.size(); ++i)
2602  m_upperVertex.add(i);
2603  CompareVertices cmp(this);
2604  //qSort(m_upperVertex.data(), m_upperVertex.data() + m_upperVertex.size(), cmp);
2606  //for (int i = 1; i < m_upperVertex.size(); ++i) {
2607  // Q_ASSERT(!cmp(m_upperVertex.at(i), m_upperVertex.at(i - 1)));
2608  //}
2609 }
Type * data() const
Definition: qdatabuffer_p.h:84
void reserve(int size)
static void sort(T *array, int count, LessThan lessThan)
void add(const Type &t)
Definition: qdatabuffer_p.h:93
static int cmp(const ushort *s1, const ushort *s2, size_t len)
void reset()
Definition: qdatabuffer_p.h:79
int size() const
Definition: qdatabuffer_p.h:83

◆ findSector()

template<typename T >
int QTriangulator< T >::SimpleToMonotone::findSector ( int  edge,
int  vertex 
)
private

Definition at line 2735 of file qtriangulator.cpp.

2736 {
2737  while (!pointIsInSector(vertex, edge)) {
2738  edge = m_edges.at(m_edges.at(edge).previous).twin;
2739  Q_ASSERT(edge != -1);
2740  }
2741  return edge;
2742 }
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
bool pointIsInSector(const QPodPoint &p, const QPodPoint &v1, const QPodPoint &v2, const QPodPoint &v3)

◆ monotoneDecomposition()

template<typename T >
void QTriangulator< T >::SimpleToMonotone::monotoneDecomposition ( )
private

Definition at line 2773 of file qtriangulator.cpp.

2774 {
2775  if (m_edges.isEmpty())
2776  return;
2777 
2780 
2781  int i = 0;
2782  for (int index = 1; index < m_edges.size(); ++index) {
2783  if (m_parent->m_vertices.at(m_edges.at(index).from) < m_parent->m_vertices.at(m_edges.at(i).from))
2784  i = index;
2785  }
2786  Q_ASSERT(i < m_edges.size());
2787  int j = m_edges.at(i).previous;
2788  Q_ASSERT(j < m_edges.size());
2790  m_parent->m_vertices.at((quint32)m_edges.at(j).from), m_parent->m_vertices.at((quint32)m_edges.at(i).to));
2791 
2792  classifyVertices();
2794 
2795  // debug: set helpers explicitly (shouldn't be necessary)
2796  //for (int i = 0; i < m_edges.size(); ++i)
2797  // m_edges.at(i).helper = m_edges.at(i).upper();
2798 
2799  while (!m_upperVertex.isEmpty()) {
2800  i = m_upperVertex.last();
2801  Q_ASSERT(i < m_edges.size());
2803  j = m_edges.at(i).previous;
2804  Q_ASSERT(j < m_edges.size());
2805 
2806  QRBTree<int>::Node *leftEdgeNode = 0;
2807 
2808  switch (m_edges.at(i).type) {
2809  case RegularVertex:
2810  // If polygon interior is to the right of the vertex...
2811  if (m_edges.at(i).pointingUp == m_clockwiseOrder) {
2812  if (m_edges.at(i).node) {
2813  Q_ASSERT(!m_edges.at(j).node);
2814  if (m_edges.at(m_edges.at(i).helper).type == MergeVertex)
2815  diagonals.add(QPair<int, int>(i, m_edges.at(i).helper));
2816  m_edges.at(j).node = m_edges.at(i).node;
2817  m_edges.at(i).node = 0;
2818  m_edges.at(j).node->data = j;
2819  m_edges.at(j).helper = i;
2820  } else if (m_edges.at(j).node) {
2821  Q_ASSERT(!m_edges.at(i).node);
2822  if (m_edges.at(m_edges.at(j).helper).type == MergeVertex)
2823  diagonals.add(QPair<int, int>(i, m_edges.at(j).helper));
2824  m_edges.at(i).node = m_edges.at(j).node;
2825  m_edges.at(j).node = 0;
2826  m_edges.at(i).node->data = i;
2827  m_edges.at(i).helper = i;
2828  } else {
2829  qWarning("Inconsistent polygon. (#1)");
2830  }
2831  } else {
2832  leftEdgeNode = searchEdgeLeftOfPoint(m_edges.at(i).from);
2833  if (leftEdgeNode) {
2834  if (m_edges.at(m_edges.at(leftEdgeNode->data).helper).type == MergeVertex)
2835  diagonals.add(QPair<int, int>(i, m_edges.at(leftEdgeNode->data).helper));
2836  m_edges.at(leftEdgeNode->data).helper = i;
2837  } else {
2838  qWarning("Inconsistent polygon. (#2)");
2839  }
2840  }
2841  break;
2842  case SplitVertex:
2843  leftEdgeNode = searchEdgeLeftOfPoint(m_edges.at(i).from);
2844  if (leftEdgeNode) {
2845  diagonals.add(QPair<int, int>(i, m_edges.at(leftEdgeNode->data).helper));
2846  m_edges.at(leftEdgeNode->data).helper = i;
2847  } else {
2848  qWarning("Inconsistent polygon. (#3)");
2849  }
2850  // Fall through.
2851  case StartVertex:
2852  if (m_clockwiseOrder) {
2853  leftEdgeNode = searchEdgeLeftOfEdge(j);
2855  node->data = j;
2856  m_edges.at(j).node = node;
2857  m_edges.at(j).helper = i;
2858  m_edgeList.attachAfter(leftEdgeNode, node);
2860  } else {
2861  leftEdgeNode = searchEdgeLeftOfEdge(i);
2863  node->data = i;
2864  m_edges.at(i).node = node;
2865  m_edges.at(i).helper = i;
2866  m_edgeList.attachAfter(leftEdgeNode, node);
2868  }
2869  break;
2870  case MergeVertex:
2871  leftEdgeNode = searchEdgeLeftOfPoint(m_edges.at(i).from);
2872  if (leftEdgeNode) {
2873  if (m_edges.at(m_edges.at(leftEdgeNode->data).helper).type == MergeVertex)
2874  diagonals.add(QPair<int, int>(i, m_edges.at(leftEdgeNode->data).helper));
2875  m_edges.at(leftEdgeNode->data).helper = i;
2876  } else {
2877  qWarning("Inconsistent polygon. (#4)");
2878  }
2879  // Fall through.
2880  case EndVertex:
2881  if (m_clockwiseOrder) {
2882  if (m_edges.at(m_edges.at(i).helper).type == MergeVertex)
2883  diagonals.add(QPair<int, int>(i, m_edges.at(i).helper));
2884  if (m_edges.at(i).node) {
2885  m_edgeList.deleteNode(m_edges.at(i).node);
2887  } else {
2888  qWarning("Inconsistent polygon. (#5)");
2889  }
2890  } else {
2891  if (m_edges.at(m_edges.at(j).helper).type == MergeVertex)
2892  diagonals.add(QPair<int, int>(i, m_edges.at(j).helper));
2893  if (m_edges.at(j).node) {
2894  m_edgeList.deleteNode(m_edges.at(j).node);
2896  } else {
2897  qWarning("Inconsistent polygon. (#6)");
2898  }
2899  }
2900  break;
2901  }
2902  }
2903 
2904  for (int i = 0; i < diagonals.size(); ++i)
2905  createDiagonal(diagonals.at(i).first, diagonals.at(i).second);
2906 }
int type
Definition: qmetatype.cpp:239
Node * newNode()
QRBTree< int >::Node * searchEdgeLeftOfEdge(int edgeIndex) const
Node * root
bool isEmpty() const
Definition: qdatabuffer_p.h:81
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
QRBTree< int >::Node * searchEdgeLeftOfPoint(int pointIndex) const
Q_CORE_EXPORT void qWarning(const char *,...)
Type & at(int i)
Definition: qdatabuffer_p.h:86
void attachAfter(Node *parent, Node *child)
static bool qPointIsLeftOfLine(const QPodPoint &p, const QPodPoint &v1, const QPodPoint &v2)
void deleteNode(Node *&node)
void pop_back()
Definition: qdatabuffer_p.h:99
bool validate() const
Type & last()
Definition: qdatabuffer_p.h:88
unsigned int quint32
Definition: qglobal.h:938
quint16 index
QDataBuffer< QPodPoint > m_vertices
void createDiagonal(int lower, int upper)
int size() const
Definition: qdatabuffer_p.h:83

◆ pointIsInSector() [1/2]

template<typename T >
bool QTriangulator< T >::SimpleToMonotone::pointIsInSector ( const QPodPoint p,
const QPodPoint v1,
const QPodPoint v2,
const QPodPoint v3 
)
private

Definition at line 2700 of file qtriangulator.cpp.

2701 {
2702  bool leftOfPreviousEdge = !qPointIsLeftOfLine(p, v2, v1);
2703  bool leftOfNextEdge = !qPointIsLeftOfLine(p, v3, v2);
2704 
2705  if (qPointIsLeftOfLine(v1, v2, v3))
2706  return leftOfPreviousEdge && leftOfNextEdge;
2707  else
2708  return leftOfPreviousEdge || leftOfNextEdge;
2709 }
static bool qPointIsLeftOfLine(const QPodPoint &p, const QPodPoint &v1, const QPodPoint &v2)

◆ pointIsInSector() [2/2]

template<typename T >
bool QTriangulator< T >::SimpleToMonotone::pointIsInSector ( int  vertex,
int  sector 
)
private

Definition at line 2712 of file qtriangulator.cpp.

2713 {
2714  const QPodPoint &center = m_parent->m_vertices.at(m_edges.at(sector).from);
2715  // Handle degenerate edges.
2716  while (m_parent->m_vertices.at(m_edges.at(vertex).from) == center)
2717  vertex = m_edges.at(vertex).next;
2718  int next = m_edges.at(sector).next;
2719  while (m_parent->m_vertices.at(m_edges.at(next).from) == center)
2720  next = m_edges.at(next).next;
2721  int previous = m_edges.at(sector).previous;
2722  while (m_parent->m_vertices.at(m_edges.at(previous).from) == center)
2723  previous = m_edges.at(previous).previous;
2724 
2725  const QPodPoint &p = m_parent->m_vertices.at(m_edges.at(vertex).from);
2726  const QPodPoint &v1 = m_parent->m_vertices.at(m_edges.at(previous).from);
2727  const QPodPoint &v3 = m_parent->m_vertices.at(m_edges.at(next).from);
2728  if (m_clockwiseOrder)
2729  return pointIsInSector(p, v3, center, v1);
2730  else
2731  return pointIsInSector(p, v1, center, v3);
2732 }
Type & at(int i)
Definition: qdatabuffer_p.h:86
Q_CORE_EXPORT QTextStream & center(QTextStream &s)
QDataBuffer< QPodPoint > m_vertices
bool pointIsInSector(const QPodPoint &p, const QPodPoint &v1, const QPodPoint &v2, const QPodPoint &v3)

◆ removeZeroLengthEdges()

template<typename T >
void QTriangulator< T >::SimpleToMonotone::removeZeroLengthEdges ( )
private

Definition at line 2568 of file qtriangulator.cpp.

2569 {
2570  for (int i = 0; i < m_edges.size(); ++i) {
2571  if (m_parent->m_vertices.at(m_edges.at(i).from) == m_parent->m_vertices.at(m_edges.at(i).to)) {
2572  m_edges.at(m_edges.at(i).previous).next = m_edges.at(i).next;
2573  m_edges.at(m_edges.at(i).next).previous = m_edges.at(i).previous;
2574  m_edges.at(m_edges.at(i).next).from = m_edges.at(i).from;
2575  m_edges.at(i).next = -1; // Mark as removed.
2576  }
2577  }
2578 
2579  QDataBuffer<int> newMapping(m_edges.size());
2580  newMapping.resize(m_edges.size());
2581  int count = 0;
2582  for (int i = 0; i < m_edges.size(); ++i) {
2583  if (m_edges.at(i).next != -1) {
2584  m_edges.at(count) = m_edges.at(i);
2585  newMapping.at(i) = count;
2586  ++count;
2587  }
2588  }
2589  m_edges.resize(count);
2590  for (int i = 0; i < m_edges.size(); ++i) {
2591  m_edges.at(i).next = newMapping.at(m_edges.at(i).next);
2592  m_edges.at(i).previous = newMapping.at(m_edges.at(i).previous);
2593  }
2594 }
void resize(int size)
Type & at(int i)
Definition: qdatabuffer_p.h:86
QDataBuffer< QPodPoint > m_vertices

◆ searchEdgeLeftOfEdge()

template<typename T >
QRBTree< int >::Node * QTriangulator< T >::SimpleToMonotone::searchEdgeLeftOfEdge ( int  edgeIndex) const
private

Definition at line 2627 of file qtriangulator.cpp.

2628 {
2629  QRBTree<int>::Node *current = m_edgeList.root;
2630  QRBTree<int>::Node *result = 0;
2631  while (current) {
2632  if (edgeIsLeftOfEdge(edgeIndex, current->data)) {
2633  current = current->left;
2634  } else {
2635  result = current;
2636  current = current->right;
2637  }
2638  }
2639  return result;
2640 }
Node * root
bool edgeIsLeftOfEdge(int leftEdgeIndex, int rightEdgeIndex) const

◆ searchEdgeLeftOfPoint()

template<typename T >
QRBTree< int >::Node * QTriangulator< T >::SimpleToMonotone::searchEdgeLeftOfPoint ( int  pointIndex) const
private

Definition at line 2644 of file qtriangulator.cpp.

2645 {
2646  QRBTree<int>::Node *current = m_edgeList.root;
2647  QRBTree<int>::Node *result = 0;
2648  while (current) {
2649  const QPodPoint &p1 = m_parent->m_vertices.at(m_edges.at(current->data).lower());
2650  const QPodPoint &p2 = m_parent->m_vertices.at(m_edges.at(current->data).upper());
2652  if (d <= 0) {
2653  current = current->left;
2654  } else {
2655  result = current;
2656  current = current->right;
2657  }
2658  }
2659  return result;
2660 }
double d
Definition: qnumeric_p.h:62
Node * root
static qint64 qPointDistanceFromLine(const QPodPoint &p, const QPodPoint &v1, const QPodPoint &v2)
#define QT_PREPEND_NAMESPACE(name)
This macro qualifies identifier with the full namespace.
Definition: qglobal.h:87
Type & at(int i)
Definition: qdatabuffer_p.h:86
__int64 qint64
Definition: qglobal.h:942
QDataBuffer< QPodPoint > m_vertices

◆ setupDataStructures()

template<typename T >
void QTriangulator< T >::SimpleToMonotone::setupDataStructures ( )
private

Definition at line 2535 of file qtriangulator.cpp.

2536 {
2537  int i = 0;
2538  Edge e;
2539  e.node = 0;
2540  e.twin = -1;
2541 
2542  while (i + 3 <= m_parent->m_indices.size()) {
2543  int start = m_edges.size();
2544 
2545  do {
2546  e.from = m_parent->m_indices.at(i);
2547  e.type = RegularVertex;
2548  e.next = m_edges.size() + 1;
2549  e.previous = m_edges.size() - 1;
2550  m_edges.add(e);
2551  ++i;
2552  Q_ASSERT(i < m_parent->m_indices.size());
2553  } while (m_parent->m_indices.at(i) != T(-1)); // Q_TRIANGULATE_END_OF_POLYGON
2554 
2555  m_edges.last().next = start;
2556  m_edges.at(start).previous = m_edges.size() - 1;
2557  ++i; // Skip Q_TRIANGULATE_END_OF_POLYGON.
2558  }
2559 
2560  for (i = 0; i < m_edges.size(); ++i) {
2561  m_edges.at(i).to = m_edges.at(m_edges.at(i).next).from;
2562  m_edges.at(i).pointingUp = m_parent->m_vertices.at(m_edges.at(i).to) < m_parent->m_vertices.at(m_edges.at(i).from);
2563  m_edges.at(i).helper = -1; // Not initialized here.
2564  }
2565 }
QVector< T > m_indices
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
Type & at(int i)
Definition: qdatabuffer_p.h:86
QDataBuffer< QPodPoint > m_vertices

Friends and Related Functions

◆ CompareVertices

template<typename T>
friend class CompareVertices
friend

Definition at line 1458 of file qtriangulator.cpp.

Properties

◆ m_clockwiseOrder

template<typename T>
bool QTriangulator< T >::SimpleToMonotone::m_clockwiseOrder
private

Definition at line 1488 of file qtriangulator.cpp.

◆ m_edgeList

template<typename T>
QRBTree<int> QTriangulator< T >::SimpleToMonotone::m_edgeList
private

Definition at line 1485 of file qtriangulator.cpp.

◆ m_edges

template<typename T>
QDataBuffer<Edge> QTriangulator< T >::SimpleToMonotone::m_edges
private

Definition at line 1486 of file qtriangulator.cpp.

◆ m_parent

template<typename T>
QTriangulator* QTriangulator< T >::SimpleToMonotone::m_parent
private

Definition at line 1484 of file qtriangulator.cpp.

◆ m_upperVertex

template<typename T>
QDataBuffer<int> QTriangulator< T >::SimpleToMonotone::m_upperVertex
private

Definition at line 1487 of file qtriangulator.cpp.


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