ranges.hh 7.99 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#pragma once

#include <cstddef>
#include <vector>

#include "iterators.hh"

namespace polymesh
{
/// Collection of all vertices of a mesh, including deleted ones
/// Basically a smart std::vector
struct vertex_collection
{
    Mesh* mesh;

    /// Number of vertices, INCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;
    /// Ensures that a given number of vertices can be stored without reallocation
    void reserve(int capacity) const;

    /// Adds a new vertex and returns its handle
    /// Does NOT invalidate any iterator!
    vertex_handle add() const;

    // TODO: delete

28
    /// Creates a new vertex attribute
Philip Trettner's avatar
Philip Trettner committed
29
    template <typename PropT>
30
    vertex_attribute<PropT> make_attribute(PropT const& def_value = PropT());
Philip Trettner's avatar
Philip Trettner committed
31

32
33
34
35
36
    // Iteration:
    vertex_iterator begin() const;
    vertex_iterator end() const;
};

37
38
39
40
41
42
43
44
45
/// same as vertex_collection but const
struct const_vertex_collection
{
    Mesh const* mesh;

    /// Number of vertices, INCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;

46
47
48
49
    /// Creates a new vertex attribute
    template <typename PropT>
    vertex_attribute<PropT> make_attribute(PropT const& def_value = PropT());

50
51
52
53
54
    // Iteration:
    vertex_iterator begin() const;
    vertex_iterator end() const;
};

55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/// Same as vertex_collection but only including valid, non-deleted vertices
/// (a bit slower than the normal collection)
/// (if mesh->is_compact(), identical to vertex_collection)
struct valid_vertex_collection
{
    Mesh const* mesh;

    /// Number of vertices, EXCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;

    // Iteration:
    valid_vertex_iterator begin() const;
    valid_vertex_iterator end() const;
};

/// Collection of all faces of a mesh, including deleted ones
/// Basically a smart std::vector
struct face_collection
{
    Mesh* mesh;

    /// Number of vertices, INCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;
    /// Ensures that a given number of faces can be stored without reallocation
    void reserve(int capacity) const;

    /// Adds a face consisting of N vertices
    /// The vertices must already be sorted in CCW order
    /// (note: trying to add already existing halfedges triggers assertions)
    template <size_t N>
Philip Trettner's avatar
Philip Trettner committed
87
88
89
90
91
    face_handle add(const vertex_handle (&v_handles)[N]) const;
    face_handle add(vertex_handle v0, vertex_handle v1, vertex_handle v2) const;
    face_handle add(vertex_handle v0, vertex_handle v1, vertex_handle v2, vertex_handle v3) const;
    face_handle add(std::vector<vertex_handle> const& v_handles) const;
    face_handle add(vertex_handle const* v_handles, size_t vcnt) const;
Philip Trettner's avatar
Philip Trettner committed
92
    template <size_t N>
Philip Trettner's avatar
Philip Trettner committed
93
94
95
96
97
    face_handle add(const halfedge_handle (&half_loop)[N]) const;
    face_handle add(halfedge_handle h0, halfedge_handle h1, halfedge_handle h2) const;
    face_handle add(halfedge_handle h0, halfedge_handle h1, halfedge_handle h2, halfedge_handle h3) const;
    face_handle add(std::vector<halfedge_handle> const& half_loop) const;
    face_handle add(halfedge_handle const* half_loop, size_t vcnt) const;
98
99
100

    // TODO: delete

101
    /// Creates a new face attribute
Philip Trettner's avatar
Philip Trettner committed
102
    template <typename PropT>
103
    face_attribute<PropT> make_attribute(PropT const& def_value = PropT());
Philip Trettner's avatar
Philip Trettner committed
104

105
106
107
108
109
    // Iteration:
    face_iterator begin() const;
    face_iterator end() const;
};

110
111
112
113
114
115
116
117
118
/// same as face_collection but const
struct const_face_collection
{
    Mesh const* mesh;

    /// Number of faces, INCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;

119
120
121
122
    /// Creates a new face attribute
    template <typename PropT>
    face_attribute<PropT> make_attribute(PropT const& def_value = PropT());

123
124
125
126
127
    // Iteration:
    face_iterator begin() const;
    face_iterator end() const;
};

128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/// Same as face_collection but only including valid, non-deleted faces
/// (a bit slower than the normal collection)
/// (if mesh->is_compact(), identical to face_collection)
struct valid_face_collection
{
    Mesh const* mesh;

    /// Number of faces, EXCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;

    // Iteration:
    valid_face_iterator begin() const;
    valid_face_iterator end() const;
};

/// Collection of all edges of a mesh, including deleted ones
/// Basically a smart std::vector
struct edge_collection
{
    Mesh* mesh;

    /// Number of vertices, INCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;
    /// Ensures that a given number of edges can be stored without reallocation
    void reserve(int capacity) const;

Philip Trettner's avatar
Philip Trettner committed
156
157
158
159
    /// Adds an edge between two existing, distinct vertices
    /// if edge already exists, returns it
    edge_handle add_or_get(vertex_handle v_from, vertex_handle v_to);

Philip Trettner's avatar
Philip Trettner committed
160
161
    // TODO: delete

162
    /// Creates a new edge attribute
Philip Trettner's avatar
Philip Trettner committed
163
    template <typename PropT>
164
    edge_attribute<PropT> make_attribute(PropT const& def_value = PropT());
Philip Trettner's avatar
Philip Trettner committed
165

166
167
168
169
170
    // Iteration:
    edge_iterator begin() const;
    edge_iterator end() const;
};

171
172
173
174
175
176
177
178
179
/// same as edge_collection but const
struct const_edge_collection
{
    Mesh const* mesh;

    /// Number of edges, INCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;

180
181
182
183
    /// Creates a new edge attribute
    template <typename PropT>
    edge_attribute<PropT> make_attribute(PropT const& def_value = PropT());

184
185
186
187
188
    // Iteration:
    edge_iterator begin() const;
    edge_iterator end() const;
};

189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
/// Same as edge_collection but only including valid, non-deleted edges
/// (a bit slower than the normal collection)
/// (if mesh->is_compact(), identical to edge_collection)
struct valid_edge_collection
{
    Mesh const* mesh;

    /// Number of edges, EXCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;

    // Iteration:
    valid_edge_iterator begin() const;
    valid_edge_iterator end() const;
};

/// Collection of all half-edges of a mesh, including deleted ones
/// Basically a smart std::vector
struct halfedge_collection
{
    Mesh* mesh;

    /// Number of vertices, INCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;
    /// Ensures that a given number of half-edges can be stored without reallocation
    void reserve(int capacity) const;

Philip Trettner's avatar
Philip Trettner committed
217
218
219
220
221
    /// Adds an half-edge between two existing, distinct vertices
    /// if half-edge already exists, returns it
    /// (always adds opposite half-edge as well)
    halfedge_handle add_or_get(vertex_handle v_from, vertex_handle v_to);

222
    /// Creates a new half-edge attribute
Philip Trettner's avatar
Philip Trettner committed
223
    template <typename PropT>
224
    halfedge_attribute<PropT> make_attribute(PropT const& def_value = PropT());
Philip Trettner's avatar
Philip Trettner committed
225

226
227
228
229
230
    // Iteration:
    halfedge_iterator begin() const;
    halfedge_iterator end() const;
};

231
232
233
234
235
236
237
238
239
/// same as halfedge_collection but const
struct const_halfedge_collection
{
    Mesh const* mesh;

    /// Number of halfedges, INCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;

240
241
242
243
    /// Creates a new half-edge attribute
    template <typename PropT>
    halfedge_attribute<PropT> make_attribute(PropT const& def_value = PropT());

244
245
246
247
248
    // Iteration:
    halfedge_iterator begin() const;
    halfedge_iterator end() const;
};

249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
/// Same as halfedge_collection but only including valid, non-deleted halfedges
/// (a bit slower than the normal collection)
/// (if mesh->is_compact(), identical to halfedge_collection)
struct valid_halfedge_collection
{
    Mesh const* mesh;

    /// Number of halfedges, EXCLUDING deleted/invalid ones
    /// O(1) computation
    int size() const;

    // Iteration:
    valid_halfedge_iterator begin() const;
    valid_halfedge_iterator end() const;
};
Philip Trettner's avatar
Philip Trettner committed
264

Philip Trettner's avatar
Philip Trettner committed
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
/// all vertices belonging to a face
struct face_vertex_ring
{
    face_handle face;

    /// Number of vertices
    /// O(result) computation
    int size() const;

    // Iteration:
    face_vertex_circulator begin() const { return {face, false}; }
    face_vertex_circulator end() const { return {face, true}; }
};


/// ======== IMPLEMENTATION ========

inline int face_vertex_ring::size() const
{
    auto cnt = 0;
    for (auto v : *this)
    {
        (void)v; // unused
        cnt++;
    }
    return cnt;
}
292
}