QhullPoints.h
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (c) 2009-2015 C.B. Barber. All rights reserved.
4 ** $Id: //main/2015/qhull/src/libqhullcpp/QhullPoints.h#4 $$Change: 2066 $
5 ** $DateTime: 2016/01/18 19:29:17 $$Author: bbarber $
6 **
7 ****************************************************************************/
8 
9 #ifndef QHULLPOINTS_H
10 #define QHULLPOINTS_H
11 
12 extern "C" {
13  #include "libqhull_r/qhull_ra.h"
14 }
15 #include "libqhullcpp/QhullPoint.h"
16 
17 #include <cstddef> // ptrdiff_t, size_t
18 #include <ostream>
19 
20 namespace orgQhull {
21 
22 #
23  class QhullPoints;
24  class QhullPointsIterator;
25 
26 class QhullPoints {
29 
30 private:
31 #
32  coordT * point_first;
33  coordT * point_end;
34  QhullQh * qh_qh;
35  int point_dimension;
37 
38 public:
39 #
40  class const_iterator;
41  class iterator;
44 
45 #
46  QhullPoints() : point_first(0), point_end(0), qh_qh(0), point_dimension(0) { }
50  QhullPoints(int pointDimension, countT coordinateCount2, coordT *c) : point_first(c), point_end(c+coordinateCount2), qh_qh(0), point_dimension(pointDimension) { QHULL_ASSERT(pointDimension>=0); }
51  explicit QhullPoints(const Qhull &q);
52  QhullPoints(const Qhull &q, countT coordinateCount2, coordT *c);
53  QhullPoints(const Qhull &q, int pointDimension, countT coordinateCount2, coordT *c);
54  explicit QhullPoints(QhullQh *qqh) : point_first(0), point_end(0), qh_qh(qqh), point_dimension(qqh ? qqh->hull_dim : 0) { }
55  QhullPoints(QhullQh *qqh, countT coordinateCount2, coordT *c) : point_first(c), point_end(c+coordinateCount2), qh_qh(qqh), point_dimension(qqh ? qqh->hull_dim : 0) { QHULL_ASSERT(qqh && qqh->hull_dim>0); }
56  QhullPoints(QhullQh *qqh, int pointDimension, countT coordinateCount2, coordT *c);
59  QhullPoints & operator=(const QhullPoints &other) { point_first= other.point_first; point_end= other.point_end; qh_qh= other.qh_qh; point_dimension= other.point_dimension; return *this; }
61 
62 public:
63 
64 #
65 
66 #ifndef QHULL_NO_STL
67  std::vector<QhullPoint> toStdVector() const;
68 #endif //QHULL_NO_STL
69 #ifdef QHULL_USES_QT
70  QList<QhullPoint> toQList() const;
71 #endif //QHULL_USES_QT
72 
73 #
74  // Constructs QhullPoint. Cannot return reference.
75  const QhullPoint at(countT idx) const { /* point_first==0 caught by point_end assert */ coordT *p= point_first+idx*point_dimension; QHULL_ASSERT(p<point_end); return QhullPoint(qh_qh, point_dimension, p); }
76  // Constructs QhullPoint. Cannot return reference.
77  const QhullPoint back() const { return last(); }
78  QhullPoint back() { return last(); }
79  ConstIterator begin() const { return ConstIterator(*this); }
80  Iterator begin() { return Iterator(*this); }
81  ConstIterator constBegin() const { return ConstIterator(*this); }
82  const coordT * constData() const { return point_first; }
83  ConstIterator constEnd() const { return ConstIterator(qh_qh, point_dimension, point_end); }
84  coordT * coordinates() const { return point_first; }
85  countT coordinateCount() const { return (countT)(point_end-point_first); } // WARN64
86  countT count() const { return (countT)size(); } // WARN64
87  const coordT * data() const { return point_first; }
88  coordT * data() { return point_first; }
89  void defineAs(int pointDimension, countT coordinatesCount, coordT *c) { QHULL_ASSERT(pointDimension>=0 && coordinatesCount>=0 && c!=0); point_first= c; point_end= c+coordinatesCount; point_dimension= pointDimension; }
90  void defineAs(countT coordinatesCount, coordT *c) { QHULL_ASSERT((point_dimension>0 && coordinatesCount>=0 && c!=0) || (c==0 && coordinatesCount==0)); point_first= c; point_end= c+coordinatesCount; }
91  void defineAs(const QhullPoints &other) { point_first= other.point_first; point_end= other.point_end; qh_qh= other.qh_qh; point_dimension= other.point_dimension; }
92  int dimension() const { return point_dimension; }
93  ConstIterator end() const { return ConstIterator(qh_qh, point_dimension, point_end); }
94  Iterator end() { return Iterator(qh_qh, point_dimension, point_end); }
96  countT extraCoordinatesCount() const; // WARN64
97  // Constructs QhullPoint. Cannot return reference.
100  // Constructs QhullPoint. Cannot return reference.
101  const QhullPoint front() const { return first(); }
102  QhullPoint front() { return first(); }
103  bool includesCoordinates(const coordT *c) const { return c>=point_first && c<point_end; }
104  bool isEmpty() const { return (point_end==point_first || point_dimension==0); }
105  // Constructs QhullPoint. Cannot return reference.
108  bool operator==(const QhullPoints &other) const;
109  bool operator!=(const QhullPoints &other) const { return ! operator==(other); }
110  QhullPoint operator[](countT idx) const { return at(idx); }
111  QhullQh * qh() const { return qh_qh; }
112  void resetQhullQh(QhullQh *qqh);
113  void setDimension(int d) { point_dimension= d; }
114  size_t size() const { return point_dimension ? (point_end-point_first)/point_dimension : 0; }
115  QhullPoint value(countT idx) const;
116  QhullPoint value(countT idx, QhullPoint &defaultValue) const;
117 
118 #
119  bool contains(const QhullPoint &t) const;
120  countT count(const QhullPoint &t) const;
121  countT indexOf(const coordT *pointCoordinates) const;
122  countT indexOf(const coordT *pointCoordinates, int noThrow) const;
123  countT indexOf(const QhullPoint &t) const;
124  countT lastIndexOf(const QhullPoint &t) const;
126  QhullPoints mid(countT idx, countT length= -1) const;
127 
128 #
129  // Modeled on qlist.h w/o QT_STRICT_ITERATORS
130  // before const_iterator for conversion with comparison operators
131  // See: QhullSet.h
132  class iterator : public QhullPoint {
133 
134  public:
135  typedef std::random_access_iterator_tag iterator_category;
137  typedef value_type * pointer;
138  typedef value_type & reference;
139  typedef ptrdiff_t difference_type;
140 
141  explicit iterator(const QhullPoints &ps) : QhullPoint(ps.qh(), ps.dimension(), ps.coordinates()) {}
142  iterator(const int pointDimension, coordT *c): QhullPoint(pointDimension, c) {}
143  iterator(const Qhull &q, coordT *c): QhullPoint(q, c) {}
144  iterator(const Qhull &q, int pointDimension, coordT *c): QhullPoint(q, pointDimension, c) {}
145  iterator(QhullQh *qqh, coordT *c): QhullPoint(qqh, c) {}
146  iterator(QhullQh *qqh, int pointDimension, coordT *c): QhullPoint(qqh, pointDimension, c) {}
147  iterator(const iterator &other): QhullPoint(*other) {}
148  iterator & operator=(const iterator &other) { defineAs( const_cast<iterator &>(other)); return *this; }
149 
150  // Need 'const QhullPoint' to maintain const
151  const QhullPoint & operator*() const { return *this; }
152  QhullPoint & operator*() { return *this; }
153  const QhullPoint * operator->() const { return this; }
154  QhullPoint * operator->() { return this; }
155  // value instead of reference since advancePoint() modifies self
156  QhullPoint operator[](countT idx) const { QhullPoint result= *this; result.advancePoint(idx); return result; }
157  bool operator==(const iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return (point_coordinates==o.point_coordinates && point_dimension==o.point_dimension); }
158  bool operator!=(const iterator &o) const { return !operator==(o); }
159  bool operator<(const iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return point_coordinates < o.point_coordinates; }
160  bool operator<=(const iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return point_coordinates <= o.point_coordinates; }
161  bool operator>(const iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return point_coordinates > o.point_coordinates; }
162  bool operator>=(const iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return point_coordinates >= o.point_coordinates; }
163  // reinterpret_cast to break circular dependency
164  bool operator==(const QhullPoints::const_iterator &o) const { QHULL_ASSERT(qh_qh==reinterpret_cast<const iterator &>(o).qh_qh); return (point_coordinates==reinterpret_cast<const iterator &>(o).point_coordinates && point_dimension==reinterpret_cast<const iterator &>(o).point_dimension); }
165  bool operator!=(const QhullPoints::const_iterator &o) const { return !operator==(reinterpret_cast<const iterator &>(o)); }
166  bool operator<(const QhullPoints::const_iterator &o) const { QHULL_ASSERT(qh_qh==reinterpret_cast<const iterator &>(o).qh_qh); return point_coordinates < reinterpret_cast<const iterator &>(o).point_coordinates; }
167  bool operator<=(const QhullPoints::const_iterator &o) const { QHULL_ASSERT(qh_qh==reinterpret_cast<const iterator &>(o).qh_qh); return point_coordinates <= reinterpret_cast<const iterator &>(o).point_coordinates; }
168  bool operator>(const QhullPoints::const_iterator &o) const { QHULL_ASSERT(qh_qh==reinterpret_cast<const iterator &>(o).qh_qh); return point_coordinates > reinterpret_cast<const iterator &>(o).point_coordinates; }
169  bool operator>=(const QhullPoints::const_iterator &o) const { QHULL_ASSERT(qh_qh==reinterpret_cast<const iterator &>(o).qh_qh); return point_coordinates >= reinterpret_cast<const iterator &>(o).point_coordinates; }
170  iterator & operator++() { advancePoint(1); return *this; }
171  iterator operator++(int) { iterator n= *this; operator++(); return iterator(n); }
172  iterator & operator--() { advancePoint(-1); return *this; }
173  iterator operator--(int) { iterator n= *this; operator--(); return iterator(n); }
174  iterator & operator+=(countT idx) { advancePoint(idx); return *this; }
175  iterator & operator-=(countT idx) { advancePoint(-idx); return *this; }
176  iterator operator+(countT idx) const { iterator n= *this; n.advancePoint(idx); return n; }
177  iterator operator-(countT idx) const { iterator n= *this; n.advancePoint(-idx); return n; }
178  difference_type operator-(iterator o) const { QHULL_ASSERT(qh_qh==o.qh_qh && point_dimension==o.point_dimension); return (point_dimension ? (point_coordinates-o.point_coordinates)/point_dimension : 0); }
179  };//QhullPoints::iterator
180 
181 #
182  class const_iterator : public QhullPoint {
184 
185  public:
186  typedef std::random_access_iterator_tag iterator_category;
188  typedef const value_type * pointer;
189  typedef const value_type & reference;
190  typedef ptrdiff_t difference_type;
191 
193  explicit const_iterator(const QhullPoints &ps) : QhullPoint(ps.qh(), ps.dimension(), ps.coordinates()) {}
194  const_iterator(const int pointDimension, coordT *c): QhullPoint(pointDimension, c) {}
195  const_iterator(const Qhull &q, coordT *c): QhullPoint(q, c) {}
196  const_iterator(const Qhull &q, int pointDimension, coordT *c): QhullPoint(q, pointDimension, c) {}
197  const_iterator(QhullQh *qqh, coordT *c): QhullPoint(qqh, c) {}
198  const_iterator(QhullQh *qqh, int pointDimension, coordT *c): QhullPoint(qqh, pointDimension, c) {}
200  const_iterator &operator=(const const_iterator &o) { defineAs(const_cast<const_iterator &>(o)); return *this; }
201 
202  // value/non-const since advancePoint(1), etc. modifies self
203  const QhullPoint & operator*() const { return *this; }
204  const QhullPoint * operator->() const { return this; }
205  // value instead of reference since advancePoint() modifies self
206  const QhullPoint operator[](countT idx) const { QhullPoint n= *this; n.advancePoint(idx); return n; }
207  bool operator==(const const_iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return (point_coordinates==o.point_coordinates && point_dimension==o.point_dimension); }
208  bool operator!=(const const_iterator &o) const { return ! operator==(o); }
209  bool operator<(const const_iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return point_coordinates < o.point_coordinates; }
210  bool operator<=(const const_iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return point_coordinates <= o.point_coordinates; }
211  bool operator>(const const_iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return point_coordinates > o.point_coordinates; }
212  bool operator>=(const const_iterator &o) const { QHULL_ASSERT(qh_qh==o.qh_qh); return point_coordinates >= o.point_coordinates; }
213  const_iterator &operator++() { advancePoint(1); return *this; }
215  const_iterator &operator--() { advancePoint(-1); return *this; }
217  const_iterator &operator+=(countT idx) { advancePoint(idx); return *this; }
218  const_iterator &operator-=(countT idx) { advancePoint(-idx); return *this; }
219  const_iterator operator+(countT idx) const { const_iterator n= *this; n.advancePoint(idx); return n; }
220  const_iterator operator-(countT idx) const { const_iterator n= *this; n.advancePoint(-idx); return n; }
221  difference_type operator-(const_iterator o) const { QHULL_ASSERT(qh_qh==o.qh_qh && point_dimension==o.point_dimension); return (point_dimension ? (point_coordinates-o.point_coordinates)/point_dimension : 0); }
222  };//QhullPoints::const_iterator
223 
224 #
225  struct PrintPoints{
227  const char * point_message;
229  PrintPoints(const char *message, bool withIdentifier, const QhullPoints &ps) : points(&ps), point_message(message), with_identifier(withIdentifier) {}
230  };//PrintPoints
231  PrintPoints print(const char *message) const { return PrintPoints(message, false, *this); }
232  PrintPoints printWithIdentifier(const char *message) const { return PrintPoints(message, true, *this); }
233 };//QhullPoints
234 
235 // Instead of QHULL_DECLARE_SEQUENTIAL_ITERATOR because next(),etc would return a reference to a temporary
237 {
239 
240 #
241 private:
242  const QhullPoints *ps;
243  const_iterator i;
244 
245 public:
246  QhullPointsIterator(const QhullPoints &other) : ps(&other), i(ps->constBegin()) {}
247  QhullPointsIterator &operator=(const QhullPoints &other) { ps = &other; i = ps->constBegin(); return *this; }
248 
249  bool findNext(const QhullPoint &t);
250  bool findPrevious(const QhullPoint &t);
251  bool hasNext() const { return i != ps->constEnd(); }
252  bool hasPrevious() const { return i != ps->constBegin(); }
253  QhullPoint next() { return *i++; }
254  QhullPoint peekNext() const { return *i; }
255  QhullPoint peekPrevious() const { const_iterator p = i; return *--p; }
256  QhullPoint previous() { return *--i; }
257  void toBack() { i = ps->constEnd(); }
258  void toFront() { i = ps->constBegin(); }
259 };//QhullPointsIterator
260 
261 }//namespace orgQhull
262 
263 #
264 
265 std::ostream & operator<<(std::ostream &os, const orgQhull::QhullPoints &p);
266 std::ostream & operator<<(std::ostream &os, const orgQhull::QhullPoints::PrintPoints &pr);
267 
268 #endif // QHULLPOINTS_H
int hull_dim
Definition: libqhull.h:591
bool operator<(const QhullPoints::const_iterator &o) const
Definition: QhullPoints.h:166
iterator(const Qhull &q, coordT *c)
Definition: QhullPoints.h:143
const coordT * constData() const
Definition: QhullPoints.h:82
void defineAs(const QhullPoints &other)
Definition: QhullPoints.h:91
void defineAs(int pointDimension, countT coordinatesCount, coordT *c)
Definition: QhullPoints.h:89
bool operator<(const iterator &o) const
Definition: QhullPoints.h:159
QhullRidge – Qhull&#39;s ridge structure, ridgeT, as a C++ class.
Definition: Coordinates.cpp:21
q
const_iterator(QhullQh *qqh, coordT *c)
Definition: QhullPoints.h:197
QhullPoint back()
Definition: QhullPoints.h:78
iterator(const iterator &other)
Definition: QhullPoints.h:147
bool operator>=(const iterator &o) const
Definition: QhullPoints.h:162
QhullQh * qh()
Definition: QhullPoint.h:97
countT count() const
Definition: QhullPoints.h:86
iterator(QhullQh *qqh, int pointDimension, coordT *c)
Definition: QhullPoints.h:146
bool operator>(const const_iterator &o) const
Definition: QhullPoints.h:211
const_iterator(const Qhull &q, int pointDimension, coordT *c)
Definition: QhullPoints.h:196
QhullPoint first()
Definition: QhullPoints.h:99
POD type equivalent to qhT. No virtual members.
Definition: QhullQh.h:58
QhullPointsIterator(const QhullPoints &other)
Definition: QhullPoints.h:246
t
void setDimension(int d)
Definition: QhullPoints.h:113
ConstIterator constEnd() const
Definition: QhullPoints.h:83
coordT * extraCoordinates() const
Definition: QhullPoints.h:95
bool operator!=(const QhullPoints::const_iterator &o) const
Definition: QhullPoints.h:165
int dimension() const
Definition: QhullPoint.h:89
const_iterator constBegin() const
Definition: QhullPoint.h:104
std::random_access_iterator_tag iterator_category
Definition: QhullPoints.h:186
QhullQh * qh() const
Definition: QhullPoints.h:111
QhullPoints(QhullQh *qqh)
Definition: QhullPoints.h:54
void resetQhullQh(QhullQh *qqh)
iterator operator-(countT idx) const
Definition: QhullPoints.h:177
QhullPoints::const_iterator const_iterator
Definition: QhullPoints.h:238
int dimension() const
Definition: QhullPoints.h:92
bool operator<=(const QhullPoints::const_iterator &o) const
Definition: QhullPoints.h:167
int point_dimension
Default dimension is qh_qh->hull_dim.
Definition: QhullPoint.h:49
bool operator!=(const QhullPoints &other) const
Definition: QhullPoints.h:109
const QhullPoints * ps
Definition: QhullPoints.h:242
const_iterator operator+(countT idx) const
Definition: QhullPoints.h:219
Java-style iterator.
Definition: QhullPoints.h:28
c
const QhullPoint & operator*() const
Definition: QhullPoints.h:151
int point_dimension
Dimension, >=0.
Definition: QhullPoints.h:36
coordT * point_coordinates
Pointer to first coordinate, 0 if undefined.
Definition: QhullPoint.h:45
bool operator==(const const_iterator &o) const
Definition: QhullPoints.h:207
QhullPointsIterator & operator=(const QhullPoints &other)
Definition: QhullPoints.h:247
iterator & operator=(const iterator &other)
Definition: QhullPoints.h:148
bool operator<=(const const_iterator &o) const
Definition: QhullPoints.h:210
coordT * point_first
First coordinate of an array of points of point_dimension.
Definition: QhullPoints.h:32
void defineAs(coordT *c)
Definition: QhullPoint.h:86
QhullPoint peekNext() const
Definition: QhullPoints.h:254
QhullPoints(int pointDimension, countT coordinateCount2, coordT *c)
Definition: QhullPoints.h:50
#define coordT
Definition: libqhull.h:80
iterator(const int pointDimension, coordT *c)
Definition: QhullPoints.h:142
countT lastIndexOf(const QhullPoint &t) const
QhullPoint peekPrevious() const
Definition: QhullPoints.h:255
const_iterator(const int pointDimension, coordT *c)
Definition: QhullPoints.h:194
QhullPoints & operator=(const QhullPoints &other)
Definition: QhullPoints.h:59
#define QHULL_ASSERT
Definition: QhullError.h:16
ConstIterator end() const
Definition: QhullPoints.h:93
const_iterator(const const_iterator &o)
Definition: QhullPoints.h:199
bool operator!=(const iterator &o) const
Definition: QhullPoints.h:158
iterator & operator+=(countT idx)
Definition: QhullPoints.h:174
const_iterator & operator+=(countT idx)
Definition: QhullPoints.h:217
const_iterator operator-(countT idx) const
Definition: QhullPoints.h:220
void advancePoint(countT idx)
Definition: QhullPoint.h:112
const_iterator(QhullQh *qqh, int pointDimension, coordT *c)
Definition: QhullPoints.h:198
const_iterator & operator-=(countT idx)
Definition: QhullPoints.h:218
std::ostream & operator<<(std::ostream &os, const orgQhull::QhullPoints &p)
QhullPoint front()
Definition: QhullPoints.h:102
QhullPoints(const QhullPoints &other)
Copy constructor copies pointers but not contents. Needed for return by value and parameter passing...
Definition: QhullPoints.h:58
QhullPoint operator[](countT idx) const
Definition: QhullPoints.h:156
Interface to Qhull from C++.
Definition: Qhull.h:43
QhullPoints(QhullQh *qqh, countT coordinateCount2, coordT *c)
Definition: QhullPoints.h:55
const coordT * iterator
Definition: QhullPoint.h:38
PrintPoints print(const char *message) const
Definition: QhullPoints.h:231
const QhullPoint & operator*() const
Definition: QhullPoints.h:203
iterator operator+(countT idx) const
Definition: QhullPoints.h:176
countT indexOf(const coordT *pointCoordinates) const
const_iterator(const QhullPoints &ps)
Definition: QhullPoints.h:193
const QhullPoint operator[](countT idx) const
Definition: QhullPoints.h:206
bool operator!=(const const_iterator &o) const
Definition: QhullPoints.h:208
ConstIterator constBegin() const
Definition: QhullPoints.h:81
const QhullPoint * operator->() const
Definition: QhullPoints.h:153
bool operator==(const iterator &o) const
Definition: QhullPoints.h:157
countT coordinateCount() const
Definition: QhullPoints.h:85
const coordT * data() const
Definition: QhullPoints.h:87
countT extraCoordinatesCount() const
Definition: QhullPoints.cpp:87
void defineAs(countT coordinatesCount, coordT *c)
Definition: QhullPoints.h:90
coordT * coordinates() const
Definition: QhullPoints.h:84
bool operator>(const QhullPoints::const_iterator &o) const
Definition: QhullPoints.h:168
difference_type operator-(const_iterator o) const
Definition: QhullPoints.h:221
iterator(const Qhull &q, int pointDimension, coordT *c)
Definition: QhullPoints.h:144
bool operator<(const const_iterator &o) const
Definition: QhullPoints.h:209
bool operator>(const iterator &o) const
Definition: QhullPoints.h:161
const coordT * const_iterator
Definition: QhullPoint.h:39
bool operator>=(const QhullPoints::const_iterator &o) const
Definition: QhullPoints.h:169
size_t size() const
Definition: QhullPoints.h:114
const_iterator(const QhullPoints::iterator &o)
Definition: QhullPoints.h:192
QhullPoints::iterator Iterator
Definition: QhullPoints.h:43
QhullPoints::const_iterator ConstIterator
Definition: QhullPoints.h:41
iterator & operator-=(countT idx)
Definition: QhullPoints.h:175
bool includesCoordinates(const coordT *c) const
Definition: QhullPoints.h:103
const_iterator & operator=(const const_iterator &o)
Definition: QhullPoints.h:200
QhullPoints mid(countT idx, countT length=-1) const
Returns a subset of the points, not a copy.
QhullPoint value(countT idx) const
bool operator>=(const const_iterator &o) const
Definition: QhullPoints.h:212
const_iterator(const Qhull &q, coordT *c)
Definition: QhullPoints.h:195
const QhullPoint last() const
Definition: QhullPoints.h:106
iterator(QhullQh *qqh, coordT *c)
Definition: QhullPoints.h:145
coordT * point_end
End of point coordinates (end>=first). Trailing coordinates ignored.
Definition: QhullPoints.h:33
difference_type operator-(iterator o) const
Definition: QhullPoints.h:178
QhullPoint operator[](countT idx) const
Definition: QhullPoints.h:110
ConstIterator begin() const
Definition: QhullPoints.h:79
std::random_access_iterator_tag iterator_category
Definition: QhullPoints.h:135
iterator(const QhullPoints &ps)
Definition: QhullPoints.h:141
int countT
Definition: user_r.h:182
const QhullPoint at(countT idx) const
Definition: QhullPoints.h:75
const QhullPoint front() const
Definition: QhullPoints.h:101
std::vector< QhullPoint > toStdVector() const
Definition: QhullPoints.cpp:73
bool operator==(const QhullPoints &other) const
Definition: QhullPoints.cpp:98
bool operator==(const QhullPoints::const_iterator &o) const
Definition: QhullPoints.h:164
const QhullPoint first() const
Definition: QhullPoints.h:98
bool operator<=(const iterator &o) const
Definition: QhullPoints.h:160
const coordT * coordinates() const
0 if undefined
Definition: QhullPoint.h:84
const QhullPoint * operator->() const
Definition: QhullPoints.h:204
const QhullPoint back() const
Definition: QhullPoints.h:77
bool isEmpty() const
Definition: QhullPoints.h:104
PrintPoints printWithIdentifier(const char *message) const
Definition: QhullPoints.h:232
PrintPoints(const char *message, bool withIdentifier, const QhullPoints &ps)
Definition: QhullPoints.h:229


hpp-fcl
Author(s):
autogenerated on Fri Jun 2 2023 02:39:02