TTK
Loading...
Searching...
No Matches
MultiresTriangulation.cpp
Go to the documentation of this file.
1#include <MultiresTriangulation.h>
2
3using ttk::MultiresTriangulation;
4using ttk::SimplexId;
5
6MultiresTriangulation::MultiresTriangulation() {
7 decimation_ = 1;
8 decimationLevel_ = 0;
9 debugLevel_ = 0;
10 gridDimensions_[0] = gridDimensions_[1] = gridDimensions_[2] = -1;
11 triangulation_ = nullptr;
12 this->setDebugMsgPrefix("MultiresTriangulation");
13}
14
15MultiresTriangulation::~MultiresTriangulation() = default;
16
17int ttk::MultiresTriangulation::preconditionVerticesInternal() {
18 vertexPositions_.resize(vertexNumber_);
19 vertexCoords_.resize(vertexNumber_);
20
21 if(dimensionality_ == 1) {
22 vertexPositions_[0] = VertexPosition::LEFT_CORNER_1D;
23#ifdef TTK_ENABLE_OPENMP
24#pragma omp parallel for num_threads(threadNumber_)
25#endif // TTK_ENABLE_OPENMP
26 for(SimplexId i = 1; i < vertexNumber_ - 1; ++i) {
27 vertexPositions_[i] = VertexPosition::CENTER_1D;
28 }
29 vertexPositions_[vertexNumber_ - 1] = VertexPosition::RIGHT_CORNER_1D;
30
31 } else if(dimensionality_ == 2) {
32#ifdef TTK_ENABLE_OPENMP
33#pragma omp parallel for num_threads(threadNumber_)
34#endif // TTK_ENABLE_OPENMP
35 for(SimplexId i = 0; i < vertexNumber_; ++i) {
36 std::array<SimplexId, 3> p{};
37 vertexToPosition2d(i, p);
38
39 if(0 < p[0] and p[0] < nbvoxels_[Di_]) {
40 if(0 < p[1] and p[1] < nbvoxels_[Dj_])
41 vertexPositions_[i] = VertexPosition::CENTER_2D;
42 else if(p[1] == 0)
43 vertexPositions_[i] = VertexPosition::TOP_EDGE_2D; // ab
44 else
45 vertexPositions_[i] = VertexPosition::BOTTOM_EDGE_2D; // cd
46 } else if(p[0] == 0) {
47 if(0 < p[1] and p[1] < nbvoxels_[Dj_])
48 vertexPositions_[i] = VertexPosition::LEFT_EDGE_2D; // ac
49 else if(p[1] == 0)
50 vertexPositions_[i] = VertexPosition::TOP_LEFT_CORNER_2D; // a
51 else
52 vertexPositions_[i] = VertexPosition::BOTTOM_LEFT_CORNER_2D; // c
53 } else {
54 if(0 < p[1] and p[1] < nbvoxels_[Dj_])
55 vertexPositions_[i] = VertexPosition::RIGHT_EDGE_2D; // bd
56 else if(p[1] == 0)
57 vertexPositions_[i] = VertexPosition::TOP_RIGHT_CORNER_2D; // b
58 else
59 vertexPositions_[i] = VertexPosition::BOTTOM_RIGHT_CORNER_2D; // d
60 }
61 vertexCoords_[i] = p;
62 }
63
64 } else if(dimensionality_ == 3) {
65#ifdef TTK_ENABLE_OPENMP
66#pragma omp parallel for num_threads(threadNumber_)
67#endif // TTK_ENABLE_OPENMP
68 for(SimplexId i = 0; i < vertexNumber_; ++i) {
69 std::array<SimplexId, 3> p{};
70 vertexToPosition(i, p);
71
72 if(0 < p[0] and p[0] < nbvoxels_[0]) {
73 if(0 < p[1] and p[1] < nbvoxels_[1]) {
74 if(0 < p[2] and p[2] < nbvoxels_[2])
75 vertexPositions_[i] = VertexPosition::CENTER_3D;
76 else if(p[2] == 0)
77 vertexPositions_[i] = VertexPosition::FRONT_FACE_3D; // abcd
78 else
79 vertexPositions_[i] = VertexPosition::BACK_FACE_3D; // efgh
80 } else if(p[1] == 0) {
81 if(0 < p[2] and p[2] < nbvoxels_[2])
82 vertexPositions_[i] = VertexPosition::TOP_FACE_3D; // abef
83 else if(p[2] == 0)
84 vertexPositions_[i] = VertexPosition::TOP_FRONT_EDGE_3D; // ab
85 else
86 vertexPositions_[i] = VertexPosition::TOP_BACK_EDGE_3D; // ef
87 } else {
88 if(0 < p[2] and p[2] < nbvoxels_[2])
89 vertexPositions_[i] = VertexPosition::BOTTOM_FACE_3D; // cdgh
90 else if(p[2] == 0)
91 vertexPositions_[i] = VertexPosition::BOTTOM_FRONT_EDGE_3D; // cd
92 else
93 vertexPositions_[i] = VertexPosition::BOTTOM_BACK_EDGE_3D; // gh
94 }
95 } else if(p[0] == 0) {
96 if(0 < p[1] and p[1] < nbvoxels_[1]) {
97 if(0 < p[2] and p[2] < nbvoxels_[2])
98 vertexPositions_[i] = VertexPosition::LEFT_FACE_3D; // aceg
99 else if(p[2] == 0)
100 vertexPositions_[i] = VertexPosition::LEFT_FRONT_EDGE_3D; // ac
101 else
102 vertexPositions_[i] = VertexPosition::LEFT_BACK_EDGE_3D; // eg
103 } else if(p[1] == 0) {
104 if(0 < p[2] and p[2] < nbvoxels_[2])
105 vertexPositions_[i] = VertexPosition::TOP_LEFT_EDGE_3D; // ae
106 else if(p[2] == 0)
107 vertexPositions_[i] = VertexPosition::TOP_LEFT_FRONT_CORNER_3D; // a
108 else
109 vertexPositions_[i] = VertexPosition::TOP_LEFT_BACK_CORNER_3D; // e
110 } else {
111 if(0 < p[2] and p[2] < nbvoxels_[2])
112 vertexPositions_[i] = VertexPosition::BOTTOM_LEFT_EDGE_3D; // cg
113 else if(p[2] == 0)
114 vertexPositions_[i]
115 = VertexPosition::BOTTOM_LEFT_FRONT_CORNER_3D; // c
116 else
117 vertexPositions_[i]
118 = VertexPosition::BOTTOM_LEFT_BACK_CORNER_3D; // g
119 }
120 } else {
121 if(0 < p[1] and p[1] < nbvoxels_[1]) {
122 if(0 < p[2] and p[2] < nbvoxels_[2])
123 vertexPositions_[i] = VertexPosition::RIGHT_FACE_3D; // bdfh
124 else if(p[2] == 0)
125 vertexPositions_[i] = VertexPosition::RIGHT_FRONT_EDGE_3D; // bd
126 else
127 vertexPositions_[i] = VertexPosition::RIGHT_BACK_EDGE_3D; // fh
128 } else if(p[1] == 0) {
129 if(0 < p[2] and p[2] < nbvoxels_[2])
130 vertexPositions_[i] = VertexPosition::TOP_RIGHT_EDGE_3D; // bf
131 else if(p[2] == 0)
132 vertexPositions_[i]
133 = VertexPosition::TOP_RIGHT_FRONT_CORNER_3D; // b
134 else
135 vertexPositions_[i] = VertexPosition::TOP_RIGHT_BACK_CORNER_3D; // f
136 } else {
137 if(0 < p[2] and p[2] < nbvoxels_[2])
138 vertexPositions_[i] = VertexPosition::BOTTOM_RIGHT_EDGE_3D; // dh
139 else if(p[2] == 0)
140 vertexPositions_[i]
141 = VertexPosition::BOTTOM_RIGHT_FRONT_CORNER_3D; // d
142 else
143 vertexPositions_[i]
144 = VertexPosition::BOTTOM_RIGHT_BACK_CORNER_3D; // h
145 }
146 }
147 vertexCoords_[i] = p;
148 }
149 }
150 return 0;
151}
152
153int ttk::MultiresTriangulation::computeVerticesShifts() {
154 vertexShifts_.resize(vertexNumber_);
155
156 if(dimensionality_ == 3) {
157#ifdef TTK_ENABLE_OPENMP
158#pragma omp parallel for num_threads(threadNumber_)
159#endif // TTK_ENABLE_OPENMP
160 for(SimplexId i = 0; i < decimatedVertexNumber_; ++i) {
161 const auto v = localToGlobalVertexId(i);
162 const auto &p = this->vertexCoords_[v];
163 std::array<SimplexId, 3> shifts{decimation_, decimation_, decimation_};
164
165 if((nbvoxels_[0] % decimation_) and (p[0] + decimation_ > nbvoxels_[0])) {
166 shifts[0] = nbvoxels_[0] % decimation_;
167 }
168 if((nbvoxels_[1] % decimation_) and (p[1] + decimation_ > nbvoxels_[1])) {
169 shifts[1] = nbvoxels_[1] % decimation_;
170 }
171 if((nbvoxels_[2] % decimation_) and (p[2] + decimation_ > nbvoxels_[2])) {
172 shifts[2] = nbvoxels_[2] % decimation_;
173 }
174 this->vertexShifts_[v] = shifts;
175 }
176 } else if(dimensionality_ == 2) {
177#ifdef TTK_ENABLE_OPENMP
178#pragma omp parallel for num_threads(threadNumber_)
179#endif // TTK_ENABLE_OPENMP
180 for(SimplexId i = 0; i < decimatedVertexNumber_; ++i) {
181 const auto v = localToGlobalVertexId(i);
182 const auto &p = this->vertexCoords_[v];
183 std::array<SimplexId, 3> shifts{decimation_, decimation_, decimation_};
184
185 if((nbvoxels_[Di_] % decimation_)
186 and (p[0] + decimation_ > nbvoxels_[Di_])) {
187 shifts[0] = nbvoxels_[0] % decimation_;
188 }
189 if((nbvoxels_[Dj_] % decimation_)
190 and (p[1] + decimation_ > nbvoxels_[Dj_])) {
191 shifts[1] = nbvoxels_[1] % decimation_;
192 }
193 this->vertexShifts_[v] = shifts;
194 }
195 }
196
197 return 0;
198}
199
200int MultiresTriangulation::getInvertVertexNeighbor(
201 const SimplexId &vertexId,
202 const SimplexId &neighborId,
203 SimplexId &localNeighborId) const {
204
205#ifndef TTK_ENABLE_KAMIKAZE
206 // if(triangulation_->isEmptyCheck()) {
207 // return -1;
208 // }
209 // if(localNeighborId < 0
210 // or localNeighborId >= getInvertVertexNeighborNumber(vertexId))
211 // return -1;
212#endif
213
214 const auto &p = this->vertexCoords_[vertexId];
215
216 SimplexId shiftX = decimation_;
217 SimplexId shiftY = decimation_;
218 SimplexId shiftZ = decimation_;
219
220 if(dimensionality_ == 3) {
221 if((nbvoxels_[0] % decimation_) and (p[0] + decimation_ > nbvoxels_[0])) {
222 shiftX = nbvoxels_[0] % decimation_;
223 }
224 if((nbvoxels_[1] % decimation_) and (p[1] + decimation_ > nbvoxels_[1])) {
225 shiftY = nbvoxels_[1] % decimation_;
226 }
227 if((nbvoxels_[2] % decimation_) and (p[2] + decimation_ > nbvoxels_[2])) {
228 shiftZ = nbvoxels_[2] % decimation_;
229 }
230 } else if(dimensionality_ == 2) {
231 if((nbvoxels_[Di_] % decimation_)
232 and (p[0] + decimation_ > nbvoxels_[Di_])) {
233 shiftX = nbvoxels_[0] % decimation_;
234 }
235 if((nbvoxels_[Dj_] % decimation_)
236 and (p[1] + decimation_ > nbvoxels_[Dj_])) {
237 shiftY = nbvoxels_[1] % decimation_;
238 }
239 }
240
241 switch(vertexPositions_[vertexId]) {
242 case VertexPosition::CENTER_3D:
243 localNeighborId = getInvertVertexNeighborABCDEFGH(
244 vertexId, neighborId, shiftX, shiftY, shiftZ); //
245 break;
246 case VertexPosition::FRONT_FACE_3D:
247 localNeighborId = getInvertVertexNeighborABDC(
248 vertexId, neighborId, shiftX, shiftY, shiftZ); //
249 break;
250 case VertexPosition::BACK_FACE_3D:
251 localNeighborId = getInvertVertexNeighborEFHG(
252 vertexId, neighborId, shiftX, shiftY, shiftZ); //
253 break;
254 case VertexPosition::TOP_FACE_3D:
255 localNeighborId = getInvertVertexNeighborAEFB(
256 vertexId, neighborId, shiftX, shiftY, shiftZ); //
257 break;
258 case VertexPosition::TOP_FRONT_EDGE_3D:
259 localNeighborId = getInvertVertexNeighborAB(
260 vertexId, neighborId, shiftX, shiftY, shiftZ); //
261 break;
262 case VertexPosition::TOP_BACK_EDGE_3D:
263 localNeighborId = getInvertVertexNeighborEF(
264 vertexId, neighborId, shiftX, shiftY, shiftZ); //
265 break;
266 case VertexPosition::BOTTOM_FACE_3D:
267 localNeighborId = getInvertVertexNeighborGHDC(
268 vertexId, neighborId, shiftX, shiftY, shiftZ); //
269 break;
270 case VertexPosition::BOTTOM_FRONT_EDGE_3D: // cd
271 localNeighborId = getInvertVertexNeighborCD(
272 vertexId, neighborId, shiftX, shiftY, shiftZ); //
273 break;
274 case VertexPosition::BOTTOM_BACK_EDGE_3D: // gh
275 localNeighborId = getInvertVertexNeighborGH(
276 vertexId, neighborId, shiftX, shiftY, shiftZ); //
277 break;
278 case VertexPosition::LEFT_FACE_3D:
279 localNeighborId = getInvertVertexNeighborAEGC(
280 vertexId, neighborId, shiftX, shiftY, shiftZ); //
281 break;
282 case VertexPosition::LEFT_FRONT_EDGE_3D: // ac
283 localNeighborId = getInvertVertexNeighborAC(
284 vertexId, neighborId, shiftX, shiftY, shiftZ); //
285 break;
286 case VertexPosition::LEFT_BACK_EDGE_3D: // eg
287 localNeighborId = getInvertVertexNeighborEG(
288 vertexId, neighborId, shiftX, shiftY, shiftZ); //
289 break;
290 case VertexPosition::TOP_LEFT_EDGE_3D: // ae
291 localNeighborId = getInvertVertexNeighborAE(
292 vertexId, neighborId, shiftX, shiftY, shiftZ); //
293 break;
294 case VertexPosition::TOP_LEFT_FRONT_CORNER_3D: // a
295 localNeighborId = getInvertVertexNeighborA(
296 vertexId, neighborId, shiftX, shiftY, shiftZ); // e
297 break;
298 case VertexPosition::TOP_LEFT_BACK_CORNER_3D: // e
299 localNeighborId = getInvertVertexNeighborE(
300 vertexId, neighborId, shiftX, shiftY, shiftZ); // a
301 break;
302 case VertexPosition::BOTTOM_LEFT_EDGE_3D: // cg
303 localNeighborId = getInvertVertexNeighborCG(
304 vertexId, neighborId, shiftX, shiftY, shiftZ); //
305 break;
306 case VertexPosition::BOTTOM_LEFT_FRONT_CORNER_3D: // c
307 localNeighborId = getInvertVertexNeighborC(
308 vertexId, neighborId, shiftX, shiftY, shiftZ); // g
309 break;
310 case VertexPosition::BOTTOM_LEFT_BACK_CORNER_3D: // g
311 localNeighborId = getInvertVertexNeighborG(
312 vertexId, neighborId, shiftX, shiftY, shiftZ); // c
313 break;
314 case VertexPosition::RIGHT_FACE_3D:
315 localNeighborId = getInvertVertexNeighborBFHD(
316 vertexId, neighborId, shiftX, shiftY, shiftZ); //
317 break;
318 case VertexPosition::RIGHT_FRONT_EDGE_3D: // bd
319 localNeighborId = getInvertVertexNeighborBD(
320 vertexId, neighborId, shiftX, shiftY, shiftZ); //
321 break;
322 case VertexPosition::RIGHT_BACK_EDGE_3D: // fh
323 localNeighborId = getInvertVertexNeighborFH(
324 vertexId, neighborId, shiftX, shiftY, shiftZ); //
325 break;
326 case VertexPosition::TOP_RIGHT_EDGE_3D: // bf
327 localNeighborId = getInvertVertexNeighborBF(
328 vertexId, neighborId, shiftX, shiftY, shiftZ); //
329 break;
330 case VertexPosition::TOP_RIGHT_FRONT_CORNER_3D: // b
331 localNeighborId = getInvertVertexNeighborB(
332 vertexId, neighborId, shiftX, shiftY, shiftZ); // f
333 break;
334 case VertexPosition::TOP_RIGHT_BACK_CORNER_3D: // f
335 localNeighborId = getInvertVertexNeighborF(
336 vertexId, neighborId, shiftX, shiftY, shiftZ); // b
337 break;
338 case VertexPosition::BOTTOM_RIGHT_EDGE_3D: // dh
339 localNeighborId = getInvertVertexNeighborDH(
340 vertexId, neighborId, shiftX, shiftY, shiftZ); //
341 break;
342 case VertexPosition::BOTTOM_RIGHT_FRONT_CORNER_3D: // d
343 localNeighborId = getInvertVertexNeighborD(
344 vertexId, neighborId, shiftX, shiftY, shiftZ); // h
345 break;
346 case VertexPosition::BOTTOM_RIGHT_BACK_CORNER_3D: // h
347 localNeighborId = getInvertVertexNeighborH(
348 vertexId, neighborId, shiftX, shiftY, shiftZ); // d
349 break;
350 case VertexPosition::CENTER_2D:
351 localNeighborId = getInvertVertexNeighbor2dABCD(
352 vertexId, neighborId, shiftX, shiftY); // abcd
353 break;
354 case VertexPosition::TOP_EDGE_2D:
355 localNeighborId = getInvertVertexNeighbor2dAB(
356 vertexId, neighborId, shiftX, shiftY); // ab
357 break;
358 case VertexPosition::BOTTOM_EDGE_2D:
359 localNeighborId = getInvertVertexNeighbor2dCD(
360 vertexId, neighborId, shiftX, shiftY); // cd
361 break;
362 case VertexPosition::LEFT_EDGE_2D:
363 localNeighborId = getInvertVertexNeighbor2dAC(
364 vertexId, neighborId, shiftX, shiftY); // ac
365 break;
366 case VertexPosition::TOP_LEFT_CORNER_2D: // a
367 localNeighborId
368 = getInvertVertexNeighbor2dA(vertexId, neighborId, shiftX, shiftY); // a
369 break;
370 case VertexPosition::BOTTOM_LEFT_CORNER_2D: // c
371 localNeighborId
372 = getInvertVertexNeighbor2dC(vertexId, neighborId, shiftX, shiftY); // c
373 break;
374 case VertexPosition::RIGHT_EDGE_2D:
375 localNeighborId = getInvertVertexNeighbor2dBD(
376 vertexId, neighborId, shiftX, shiftY); // bd
377 break;
378 case VertexPosition::TOP_RIGHT_CORNER_2D: // b
379 localNeighborId
380 = getInvertVertexNeighbor2dB(vertexId, neighborId, shiftX, shiftY); // b
381 break;
382 case VertexPosition::BOTTOM_RIGHT_CORNER_2D: // d
383 localNeighborId
384 = getInvertVertexNeighbor2dD(vertexId, neighborId, shiftX, shiftY); // d
385 break;
386 case VertexPosition::CENTER_1D:
387 localNeighborId = localNeighborId == 0 ? vertexId + decimation_
388 : vertexId - decimation_;
389 break;
390 case VertexPosition::LEFT_CORNER_1D:
391 localNeighborId = vertexId + decimation_;
392 break;
393 case VertexPosition::RIGHT_CORNER_1D:
394 localNeighborId = vertexId - decimation_;
395 break;
396 default:
397 localNeighborId = -1;
398 break;
399 }
400
401 return 0;
402}
403int MultiresTriangulation::getVertexNeighbor(const SimplexId &vertexId,
404 const int &localNeighborId,
405 SimplexId &neighborId) const {
406#ifndef TTK_ENABLE_KAMIKAZE
407 // if(triangulation_->isEmptyCheck()) {
408 // return -1;
409 // }
410 // if(localNeighborId < 0
411 // or localNeighborId >= getVertexNeighborNumber(vertexId))
412 // return -1;
413#endif
414
415 const auto &s = vertexShifts_[vertexId];
416
417 switch(vertexPositions_[vertexId]) {
418 case VertexPosition::CENTER_3D:
419 neighborId = getVertexNeighborABCDEFGH(
420 vertexId, localNeighborId, s[0], s[1], s[2]);
421 break;
422 case VertexPosition::FRONT_FACE_3D:
423 neighborId
424 = getVertexNeighborABDC(vertexId, localNeighborId, s[0], s[1], s[2]);
425 break;
426 case VertexPosition::BACK_FACE_3D:
427 neighborId
428 = getVertexNeighborEFHG(vertexId, localNeighborId, s[0], s[1], s[2]);
429 break;
430 case VertexPosition::TOP_FACE_3D:
431 neighborId
432 = getVertexNeighborAEFB(vertexId, localNeighborId, s[0], s[1], s[2]);
433 break;
434 case VertexPosition::BOTTOM_FACE_3D:
435 neighborId
436 = getVertexNeighborGHDC(vertexId, localNeighborId, s[0], s[1], s[2]);
437 break;
438 case VertexPosition::LEFT_FACE_3D:
439 neighborId
440 = getVertexNeighborAEGC(vertexId, localNeighborId, s[0], s[1], s[2]);
441 break;
442 case VertexPosition::RIGHT_FACE_3D:
443 neighborId
444 = getVertexNeighborBFHD(vertexId, localNeighborId, s[0], s[1], s[2]);
445 break;
446 case VertexPosition::TOP_FRONT_EDGE_3D: // ab
447 neighborId
448 = getVertexNeighborAB(vertexId, localNeighborId, s[0], s[1], s[2]);
449 break;
450 case VertexPosition::BOTTOM_FRONT_EDGE_3D: // cd
451 neighborId
452 = getVertexNeighborCD(vertexId, localNeighborId, s[0], s[1], s[2]);
453 break;
454 case VertexPosition::LEFT_FRONT_EDGE_3D: // ac
455 neighborId
456 = getVertexNeighborAC(vertexId, localNeighborId, s[0], s[1], s[2]);
457 break;
458 case VertexPosition::RIGHT_FRONT_EDGE_3D: // bd
459 neighborId
460 = getVertexNeighborBD(vertexId, localNeighborId, s[0], s[1], s[2]);
461 break;
462 case VertexPosition::TOP_BACK_EDGE_3D: // ef
463 neighborId
464 = getVertexNeighborEF(vertexId, localNeighborId, s[0], s[1], s[2]);
465 break;
466 case VertexPosition::BOTTOM_BACK_EDGE_3D: // gh
467 neighborId
468 = getVertexNeighborGH(vertexId, localNeighborId, s[0], s[1], s[2]);
469 break;
470 case VertexPosition::LEFT_BACK_EDGE_3D: // eg
471 neighborId
472 = getVertexNeighborEG(vertexId, localNeighborId, s[0], s[1], s[2]);
473 break;
474 case VertexPosition::RIGHT_BACK_EDGE_3D: // fh
475 neighborId
476 = getVertexNeighborFH(vertexId, localNeighborId, s[0], s[1], s[2]);
477 break;
478 case VertexPosition::TOP_LEFT_EDGE_3D: // ae
479 neighborId
480 = getVertexNeighborAE(vertexId, localNeighborId, s[0], s[1], s[2]);
481 break;
482 case VertexPosition::TOP_RIGHT_EDGE_3D: // bf
483 neighborId
484 = getVertexNeighborBF(vertexId, localNeighborId, s[0], s[1], s[2]);
485 break;
486 case VertexPosition::BOTTOM_LEFT_EDGE_3D: // cg
487 neighborId
488 = getVertexNeighborCG(vertexId, localNeighborId, s[0], s[1], s[2]);
489 break;
490 case VertexPosition::BOTTOM_RIGHT_EDGE_3D: // dh
491 neighborId
492 = getVertexNeighborDH(vertexId, localNeighborId, s[0], s[1], s[2]);
493 break;
494 case VertexPosition::TOP_LEFT_FRONT_CORNER_3D: // a
495 neighborId
496 = getVertexNeighborA(vertexId, localNeighborId, s[0], s[1], s[2]);
497 break;
498 case VertexPosition::TOP_RIGHT_FRONT_CORNER_3D: // b
499 neighborId
500 = getVertexNeighborB(vertexId, localNeighborId, s[0], s[1], s[2]);
501 break;
502 case VertexPosition::BOTTOM_LEFT_FRONT_CORNER_3D: // c
503 neighborId
504 = getVertexNeighborC(vertexId, localNeighborId, s[0], s[1], s[2]);
505 break;
506 case VertexPosition::BOTTOM_RIGHT_FRONT_CORNER_3D: // d
507 neighborId
508 = getVertexNeighborD(vertexId, localNeighborId, s[0], s[1], s[2]);
509 break;
510 case VertexPosition::TOP_LEFT_BACK_CORNER_3D: // e
511 neighborId
512 = getVertexNeighborE(vertexId, localNeighborId, s[0], s[1], s[2]);
513 break;
514 case VertexPosition::TOP_RIGHT_BACK_CORNER_3D: // f
515 neighborId
516 = getVertexNeighborF(vertexId, localNeighborId, s[0], s[1], s[2]);
517 break;
518 case VertexPosition::BOTTOM_LEFT_BACK_CORNER_3D: // g
519 neighborId
520 = getVertexNeighborG(vertexId, localNeighborId, s[0], s[1], s[2]);
521 break;
522 case VertexPosition::BOTTOM_RIGHT_BACK_CORNER_3D: // h
523 neighborId
524 = getVertexNeighborH(vertexId, localNeighborId, s[0], s[1], s[2]);
525 break;
526 case VertexPosition::CENTER_2D:
527 neighborId
528 = getVertexNeighbor2dABCD(vertexId, localNeighborId, s[0], s[1]);
529 break;
530 case VertexPosition::TOP_EDGE_2D:
531 neighborId = getVertexNeighbor2dAB(vertexId, localNeighborId, s[0], s[1]);
532 break;
533 case VertexPosition::BOTTOM_EDGE_2D:
534 neighborId = getVertexNeighbor2dCD(vertexId, localNeighborId, s[0], s[1]);
535 break;
536 case VertexPosition::LEFT_EDGE_2D:
537 neighborId = getVertexNeighbor2dAC(vertexId, localNeighborId, s[0], s[1]);
538 break;
539 case VertexPosition::RIGHT_EDGE_2D:
540 neighborId = getVertexNeighbor2dBD(vertexId, localNeighborId, s[0], s[1]);
541 break;
542 case VertexPosition::TOP_LEFT_CORNER_2D: // a
543 neighborId = getVertexNeighbor2dA(vertexId, localNeighborId, s[0], s[1]);
544 break;
545 case VertexPosition::TOP_RIGHT_CORNER_2D: // b
546 neighborId = getVertexNeighbor2dB(vertexId, localNeighborId, s[0], s[1]);
547 break;
548 case VertexPosition::BOTTOM_LEFT_CORNER_2D: // c
549 neighborId = getVertexNeighbor2dC(vertexId, localNeighborId, s[0], s[1]);
550 break;
551 case VertexPosition::BOTTOM_RIGHT_CORNER_2D: // d
552 neighborId = getVertexNeighbor2dD(vertexId, localNeighborId, s[0], s[1]);
553 break;
554 case VertexPosition::CENTER_1D:
555 neighborId = (localNeighborId == 0 ? vertexId + decimation_
556 : vertexId - decimation_);
557 break;
558 case VertexPosition::LEFT_CORNER_1D:
559 neighborId = vertexId + decimation_;
560 break;
561 case VertexPosition::RIGHT_CORNER_1D:
562 neighborId = vertexId - decimation_;
563 break;
564 default:
565 neighborId = -1;
566 break;
567 }
568
569 return 0;
570}
571
572SimplexId MultiresTriangulation::getInvertVertexNeighbor2dA(
573 const SimplexId v,
574 const SimplexId neighborId,
575 const SimplexId shiftX,
576 const SimplexId shiftY) const {
577 // V(a)={b,c}
578 if(neighborId == v + shiftX)
579 return 0; // b
580 else if(neighborId == v + gridDimensions_[Di_] * shiftY)
581 return 1; // c
582 return -1;
583}
584
585SimplexId
586 MultiresTriangulation::getVertexNeighbor2dA(const SimplexId v,
587 const int id,
588 const SimplexId shiftX,
589 const SimplexId shiftY) const {
590 // V(a)={b,c}
591 switch(id) {
592 case 0:
593 return v + shiftX; // b
594 case 1:
595 return v + gridDimensions_[Di_] * shiftY; // c
596 }
597 return -1;
598}
599
600SimplexId MultiresTriangulation::getInvertVertexNeighbor2dB(
601 const SimplexId v,
602 const SimplexId neighborId,
603 const SimplexId shiftX,
604 const SimplexId shiftY) const {
605 // V(b)={a,c,d}
606 if(neighborId == v - shiftX)
607 return 0; // a
608 else if(neighborId == v + gridDimensions_[Di_] * shiftY)
609 return 1; // d
610 else if(neighborId == v + (gridDimensions_[Di_] * shiftY - shiftX))
611 return 2; // c
612 return -1;
613}
614
615SimplexId
616 MultiresTriangulation::getVertexNeighbor2dB(const SimplexId v,
617 const int id,
618 const SimplexId shiftX,
619 const SimplexId shiftY) const {
620 // V(b)={a,c,d}
621 switch(id) {
622 case 0:
623 return v - shiftX; // a
624 case 1:
625 return v + gridDimensions_[Di_] * shiftY; // d
626 case 2:
627 return v + (gridDimensions_[Di_] * shiftY - shiftX); // c
628 }
629 return -1;
630}
631
632SimplexId MultiresTriangulation::getInvertVertexNeighbor2dC(
633 const SimplexId v,
634 const SimplexId neighborId,
635 const SimplexId shiftX,
636 const SimplexId shiftY) const {
637 // V(c)={a,b,d}
638 if(neighborId == v + shiftX)
639 return 0;
640 else if(neighborId == v - gridDimensions_[Di_] * shiftY)
641 return 1; // a
642 else if(neighborId == v + (shiftX - gridDimensions_[Di_] * shiftY))
643 return 2; // b
644 return -1;
645}
646
647SimplexId
648 MultiresTriangulation::getVertexNeighbor2dC(const SimplexId v,
649 const int id,
650 const SimplexId shiftX,
651 const SimplexId shiftY) const {
652 // V(c)={a,b,d}
653 switch(id) {
654 case 0:
655 return v + shiftX;
656 case 1:
657 return v - gridDimensions_[Di_] * shiftY; // a
658 case 2:
659 return v + (shiftX - gridDimensions_[Di_] * shiftY); // b
660 }
661 return -1;
662}
663
664SimplexId MultiresTriangulation::getInvertVertexNeighbor2dD(
665 const SimplexId v,
666 const SimplexId neighborId,
667 const SimplexId shiftX,
668 const SimplexId shiftY) const {
669 // V(d)={c,b}
670 if(neighborId == v - shiftX)
671 return 0; // c
672 else if(neighborId == v - gridDimensions_[Di_] * shiftY)
673 return 1; // b
674 return -1;
675}
676
677SimplexId
678 MultiresTriangulation::getVertexNeighbor2dD(const SimplexId v,
679 const int id,
680 const SimplexId shiftX,
681 const SimplexId shiftY) const {
682 // V(d)={c,b}
683 switch(id) {
684 case 0:
685 return v - shiftX; // c
686 case 1:
687 return v - gridDimensions_[Di_] * shiftY; // b
688 }
689 return -1;
690}
691
692SimplexId MultiresTriangulation::getInvertVertexNeighbor2dAB(
693 const SimplexId v,
694 const SimplexId neighborId,
695 const SimplexId shiftX,
696 const SimplexId shiftY) const {
697 // V(ab)=V(b)::{a,c,d}+V(a)::{b}
698 if(neighborId == v - decimation_)
699 return 0; // V(b)::a
700 else if(neighborId == v + (gridDimensions_[Di_] * shiftY - decimation_))
701 return 1; // V(b)::c
702 else if(neighborId == v + gridDimensions_[Di_] * shiftY)
703 return 2; // V(b)::d
704 else if(neighborId == v + shiftX)
705 return 3; // V(a)::b
706 return -1;
707}
708
709SimplexId
710 MultiresTriangulation::getVertexNeighbor2dAB(const SimplexId v,
711 const int id,
712 const SimplexId shiftX,
713 const SimplexId shiftY) const {
714 // V(ab)=V(b)::{a,c,d}+V(a)::{b}
715 switch(id) {
716 case 0:
717 return v - decimation_; // V(b)::a
718 case 1:
719 return v + (gridDimensions_[Di_] * shiftY - decimation_); // V(b)::c
720 case 2:
721 return v + gridDimensions_[Di_] * shiftY; // V(b)::d
722 case 3:
723 return v + shiftX; // V(a)::b
724 }
725 return -1;
726}
727
728SimplexId MultiresTriangulation::getInvertVertexNeighbor2dCD(
729 const SimplexId v,
730 const SimplexId neighborId,
731 const SimplexId shiftX,
732 const SimplexId shiftY) const {
733 // V(cd)=V(c)::{a,b,d}+V(d)::{c}
734 if(neighborId == v - decimation_)
735 return 0; // V(d)::c
736 else if(neighborId == v - gridDimensions_[Di_] * shiftY)
737 return 1; // V(c)::a
738 else if(neighborId == v + (shiftX - gridDimensions_[Di_] * shiftY))
739 return 2; // V(c)::b
740 else if(neighborId == v + shiftX)
741 return 3; // V(c)::d
742 return -1;
743}
744
745SimplexId
746 MultiresTriangulation::getVertexNeighbor2dCD(const SimplexId v,
747 const int id,
748 const SimplexId shiftX,
749 const SimplexId shiftY) const {
750 // V(cd)=V(c)::{a,b,d}+V(d)::{c}
751 switch(id) {
752 case 0:
753 return v - decimation_; // V(d)::c
754 case 1:
755 return v - gridDimensions_[Di_] * shiftY; // V(c)::a
756 case 2:
757 return v + (shiftX - gridDimensions_[Di_] * shiftY); // V(c)::b
758 case 3:
759 return v + shiftX; // V(c)::d
760 }
761 return -1;
762}
763
764SimplexId MultiresTriangulation::getInvertVertexNeighbor2dAC(
765 const SimplexId v,
766 const SimplexId neighborId,
767 const SimplexId shiftX,
768 const SimplexId shiftY) const {
769 // V(ac)=V(c)::{a,b,d}+V(a)::{c}
770 if(neighborId == v - gridDimensions_[Di_] * decimation_)
771 return 0; // V(c)::{a}
772 else if(neighborId == v + (shiftX - gridDimensions_[Di_] * decimation_))
773 return 1; // V(c)::{b}
774 else if(neighborId == v + shiftX)
775 return 2; // V(c)::{d}
776 else if(neighborId == v + gridDimensions_[Di_] * shiftY)
777 return 3; // V(a)::{c}
778 return -1;
779}
780
781SimplexId
782 MultiresTriangulation::getVertexNeighbor2dAC(const SimplexId v,
783 const int id,
784 const SimplexId shiftX,
785 const SimplexId shiftY) const {
786 // V(ac)=V(c)::{a,b,d}+V(a)::{c}
787 switch(id) {
788 case 0:
789 return v - gridDimensions_[Di_] * decimation_; // V(c)::{a}
790 case 1:
791 return v + (shiftX - gridDimensions_[Di_] * decimation_); // V(c)::{b}
792 case 2:
793 return v + shiftX; // V(c)::{d}
794 case 3:
795 return v + gridDimensions_[Di_] * shiftY; // V(a)::{c}
796 }
797 return -1;
798}
799
800SimplexId MultiresTriangulation::getInvertVertexNeighbor2dBD(
801 const SimplexId v,
802 const SimplexId neighborId,
803 const SimplexId shiftX,
804 const SimplexId shiftY) const {
805 // V(bd)=V(b)::{c,d}+V(d)::{b,c}
806 if(neighborId == v + (gridDimensions_[Di_] * shiftY - shiftX))
807 return 0; // V(b)::{c}
808 else if(neighborId == v + gridDimensions_[Di_] * shiftY)
809 return 1; // V(b)::{d}
810 else if(neighborId == v - gridDimensions_[Di_] * decimation_)
811 return 2; // V(d)::{b}
812 else if(neighborId == v - shiftX)
813 return 3; // V(d)::{c}
814 return -1;
815}
816
817SimplexId
818 MultiresTriangulation::getVertexNeighbor2dBD(const SimplexId v,
819 const int id,
820 const SimplexId shiftX,
821 const SimplexId shiftY) const {
822 // V(bd)=V(b)::{c,d}+V(d)::{b,c}
823 switch(id) {
824 case 0:
825 return v + (gridDimensions_[Di_] * shiftY - shiftX); // V(b)::{c}
826 case 1:
827 return v + gridDimensions_[Di_] * shiftY; // V(b)::{d}
828 case 2:
829 return v - gridDimensions_[Di_] * decimation_; // V(d)::{b}
830 case 3:
831 return v - shiftX; // V(d)::{c}
832 }
833 return -1;
834}
835
836SimplexId MultiresTriangulation::getInvertVertexNeighbor2dABCD(
837 const SimplexId v,
838 const SimplexId neighborId,
839 const SimplexId shiftX,
840 const SimplexId shiftY) const {
841 // V(abcd)=V(d)::{b,c}+V(c)::{b,d}+V(a)::{b}+V(b)::{c}
842 if(neighborId == v - decimation_)
843 return 0;
844 else if(neighborId == v - gridDimensions_[Di_] * decimation_)
845 return 1;
846 else if(neighborId == v + (shiftX - gridDimensions_[Di_] * decimation_))
847 return 2;
848 else if(neighborId == v + shiftX)
849 return 3;
850 else if(neighborId == v + gridDimensions_[Di_] * shiftY)
851 return 4;
852 else if(neighborId == v + (gridDimensions_[Di_] * shiftY - decimation_))
853 return 5;
854 return -1;
855}
856
857SimplexId
858 MultiresTriangulation::getVertexNeighbor2dABCD(const SimplexId v,
859 const int id,
860 const SimplexId shiftX,
861 const SimplexId shiftY) const {
862 // V(abcd)=V(d)::{b,c}+V(c)::{b,d}+V(a)::{b}+V(b)::{c}
863 switch(id) {
864 case 0:
865 return v - decimation_;
866 case 1:
867 return v - gridDimensions_[Di_] * decimation_;
868 case 2:
869 return v + (shiftX - gridDimensions_[Di_] * decimation_);
870 case 3:
871 return v + shiftX;
872 case 4:
873 return v + gridDimensions_[Di_] * shiftY;
874 case 5:
875 return v + (gridDimensions_[Di_] * shiftY - decimation_);
876 }
877 return -1;
878}
879
880SimplexId MultiresTriangulation::getVertexNeighborNumber(
881 const SimplexId &vertexId) const {
882
883#ifndef TTK_ENABLE_KAMIKAZE
884 if(vertexId < 0 or vertexId >= vertexNumber_)
885 return -1;
886#endif
887
888 switch(vertexPositions_[vertexId]) {
889 case VertexPosition::CENTER_3D:
890 return 14;
891 case VertexPosition::FRONT_FACE_3D:
892 case VertexPosition::BACK_FACE_3D:
893 case VertexPosition::TOP_FACE_3D:
894 case VertexPosition::BOTTOM_FACE_3D:
895 case VertexPosition::LEFT_FACE_3D:
896 case VertexPosition::RIGHT_FACE_3D:
897 return 10;
898 case VertexPosition::TOP_FRONT_EDGE_3D: // ab
899 case VertexPosition::RIGHT_FRONT_EDGE_3D: // bd
900 case VertexPosition::BOTTOM_BACK_EDGE_3D: // gh
901 case VertexPosition::LEFT_BACK_EDGE_3D: // eg
902 case VertexPosition::BOTTOM_LEFT_EDGE_3D: // cg
903 case VertexPosition::TOP_RIGHT_EDGE_3D: // bf
904 return 8;
905 case VertexPosition::TOP_RIGHT_FRONT_CORNER_3D: // b
906 case VertexPosition::BOTTOM_LEFT_BACK_CORNER_3D: // g
907 return 7;
908 case VertexPosition::TOP_BACK_EDGE_3D: // ef
909 case VertexPosition::BOTTOM_FRONT_EDGE_3D: // cd
910 case VertexPosition::LEFT_FRONT_EDGE_3D: // ac
911 case VertexPosition::TOP_LEFT_EDGE_3D: // ae
912 case VertexPosition::RIGHT_BACK_EDGE_3D: // fh
913 case VertexPosition::BOTTOM_RIGHT_EDGE_3D: // dh
914 case VertexPosition::CENTER_2D:
915 return 6;
916 case VertexPosition::TOP_LEFT_FRONT_CORNER_3D: // a
917 case VertexPosition::BOTTOM_LEFT_FRONT_CORNER_3D: // c
918 case VertexPosition::BOTTOM_RIGHT_FRONT_CORNER_3D: // d
919 case VertexPosition::TOP_LEFT_BACK_CORNER_3D: // e
920 case VertexPosition::TOP_RIGHT_BACK_CORNER_3D: // f
921 case VertexPosition::BOTTOM_RIGHT_BACK_CORNER_3D: // h
922 case VertexPosition::TOP_EDGE_2D:
923 case VertexPosition::BOTTOM_EDGE_2D:
924 case VertexPosition::LEFT_EDGE_2D:
925 case VertexPosition::RIGHT_EDGE_2D:
926 return 4;
927 case VertexPosition::TOP_RIGHT_CORNER_2D: // b
928 case VertexPosition::BOTTOM_LEFT_CORNER_2D: // c
929 return 3;
930 case VertexPosition::TOP_LEFT_CORNER_2D: // a
931 case VertexPosition::BOTTOM_RIGHT_CORNER_2D: // d
932 case VertexPosition::CENTER_1D:
933 return 2;
934 case VertexPosition::LEFT_CORNER_1D:
935 case VertexPosition::RIGHT_CORNER_1D:
936 return 1;
937 }
938
939 return -1;
940}
941
942inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborA(
943 const SimplexId v,
944 const SimplexId neighborId,
945 const SimplexId shiftX,
946 const SimplexId shiftY,
947 const SimplexId shiftZ) const {
948 // V(a)={b,c,e,g}
949 if(neighborId == v + shiftX)
950 return 0; // b
951 else if(neighborId == v + vshift_[0] * shiftY)
952 return 1; // c
953 else if(neighborId == v + vshift_[1] * shiftZ)
954 return 2; // e
955 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
956 return 3; // g
957 return -1;
958}
959
960inline ttk::SimplexId
961 MultiresTriangulation::getVertexNeighborA(const SimplexId v,
962 const int id,
963 const SimplexId shiftX,
964 const SimplexId shiftY,
965 const SimplexId shiftZ) const {
966 // V(a)={b,c,e,g}
967 switch(id) {
968 case 0:
969 return v + shiftX; // b
970 case 1:
971 return v + vshift_[0] * shiftY; // c
972 case 2:
973 return v + vshift_[1] * shiftZ; // e
974 case 3:
975 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // g
976 }
977 return -1;
978}
979
980inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborB(
981 const SimplexId v,
982 const SimplexId neighborId,
983 const SimplexId shiftX,
984 const SimplexId shiftY,
985 const SimplexId shiftZ) const {
986 // V(b)={a,c,d,e,f,g,h}
987 if(neighborId == v - shiftX)
988 return 0; // a
989 else if(neighborId == v + (vshift_[0] * shiftY - shiftX))
990 return 1; // c
991 else if(neighborId == v + vshift_[0] * shiftY)
992 return 2; // d
993 else if(neighborId == v + (vshift_[1] * shiftZ - shiftX))
994 return 3; // e
995 else if(neighborId == v + vshift_[1] * shiftZ)
996 return 4; // f
997 else if(neighborId
998 == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - shiftX))
999 return 5; // g
1000 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1001 return 6; // h
1002 return -1;
1003}
1004
1005inline ttk::SimplexId
1006 MultiresTriangulation::getVertexNeighborB(const SimplexId v,
1007 const int id,
1008 const SimplexId shiftX,
1009 const SimplexId shiftY,
1010 const SimplexId shiftZ) const {
1011 // V(b)={a,c,d,e,f,g,h}
1012 switch(id) {
1013 case 0:
1014 return v - shiftX; // a
1015 case 1:
1016 return v + (vshift_[0] * shiftY - shiftX); // c
1017 case 2:
1018 return v + vshift_[0] * shiftY; // d
1019 case 3:
1020 return v + (vshift_[1] * shiftZ - shiftX); // e
1021 case 4:
1022 return v + vshift_[1] * shiftZ; // f
1023 case 5:
1024 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - shiftX); // g
1025 case 6:
1026 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // h
1027 }
1028 return -1;
1029}
1030
1031inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborC(
1032 const SimplexId v,
1033 const SimplexId neighborId,
1034 const SimplexId shiftX,
1035 const SimplexId shiftY,
1036 const SimplexId shiftZ) const {
1037 // V(c)={a,b,d,g}
1038 if(neighborId == v - vshift_[0] * shiftY)
1039 return 0; // a
1040 else if(neighborId == v + (shiftX - vshift_[0] * shiftY))
1041 return 1; // b
1042 else if(neighborId == v + shiftX)
1043 return 2; // d
1044 else if(neighborId == v + vshift_[1] * shiftZ)
1045 return 3; // g
1046 return -1;
1047}
1048
1049inline ttk::SimplexId
1050 MultiresTriangulation::getVertexNeighborC(const SimplexId v,
1051 const int id,
1052 const SimplexId shiftX,
1053 const SimplexId shiftY,
1054 const SimplexId shiftZ) const {
1055 // V(c)={a,b,d,g}
1056 switch(id) {
1057 case 0:
1058 return v - vshift_[0] * shiftY; // a
1059 case 1:
1060 return v + (shiftX - vshift_[0] * shiftY); // b
1061 case 2:
1062 return v + shiftX; // d
1063 case 3:
1064 return v + vshift_[1] * shiftZ; // g
1065 }
1066 return -1;
1067}
1068
1069inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborD(
1070 const SimplexId v,
1071 const SimplexId neighborId,
1072 const SimplexId shiftX,
1073 const SimplexId shiftY,
1074 const SimplexId shiftZ) const {
1075 // V(d)={b,c,g,h}
1076 if(neighborId == v - vshift_[0] * shiftY)
1077 return 0; // b
1078 else if(neighborId == v - shiftX)
1079 return 1; // c
1080 else if(neighborId == v + (-shiftX + vshift_[1] * shiftZ))
1081 return 2; // g
1082 else if(neighborId == v + vshift_[1] * shiftZ)
1083 return 3; // h
1084 return -1;
1085}
1086
1087inline ttk::SimplexId
1088 MultiresTriangulation::getVertexNeighborD(const SimplexId v,
1089 const int id,
1090 const SimplexId shiftX,
1091 const SimplexId shiftY,
1092 const SimplexId shiftZ) const {
1093 // V(d)={b,c,g,h}
1094 switch(id) {
1095 case 0:
1096 return v - vshift_[0] * shiftY; // b
1097 case 1:
1098 return v - shiftX; // c
1099 case 2:
1100 return v + (-shiftX + vshift_[1] * shiftZ); // g
1101 case 3:
1102 return v + vshift_[1] * shiftZ; // h
1103 }
1104 return -1;
1105}
1106
1107inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborE(
1108 const SimplexId v,
1109 const SimplexId neighborId,
1110 const SimplexId shiftX,
1111 const SimplexId shiftY,
1112 const SimplexId shiftZ) const {
1113 // V(e)={a,b,f,g}
1114 if(neighborId == v - vshift_[1] * shiftZ)
1115 return 0; // a
1116 else if(neighborId == v + (shiftX - vshift_[1] * shiftZ))
1117 return 1; // b
1118 else if(neighborId == v + shiftX)
1119 return 2; // f
1120 else if(neighborId == v + vshift_[0] * shiftY)
1121 return 3; // g
1122 return -1;
1123}
1124
1125inline ttk::SimplexId
1126 MultiresTriangulation::getVertexNeighborE(const SimplexId v,
1127 const int id,
1128 const SimplexId shiftX,
1129 const SimplexId shiftY,
1130 const SimplexId shiftZ) const {
1131 // V(e)={a,b,f,g}
1132 switch(id) {
1133 case 0:
1134 return v - vshift_[1] * shiftZ; // a
1135 case 1:
1136 return v + (shiftX - vshift_[1] * shiftZ); // b
1137 case 2:
1138 return v + shiftX; // f
1139 case 3:
1140 return v + vshift_[0] * shiftY; // g
1141 }
1142 return -1;
1143}
1144
1145inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborF(
1146 const SimplexId v,
1147 const SimplexId neighborId,
1148 const SimplexId shiftX,
1149 const SimplexId shiftY,
1150 const SimplexId shiftZ) const {
1151 // V(f)={b,e,g,h}
1152 if(neighborId == v - vshift_[1] * shiftZ)
1153 return 0; // b
1154 else if(neighborId == v - shiftX)
1155 return 1; // e
1156 else if(neighborId == v + (vshift_[0] * shiftY - shiftX))
1157 return 2; // g
1158 else if(neighborId == v + vshift_[0] * shiftY)
1159 return 3; // h
1160 return -1;
1161}
1162
1163inline ttk::SimplexId
1164 MultiresTriangulation::getVertexNeighborF(const SimplexId v,
1165 const int id,
1166 const SimplexId shiftX,
1167 const SimplexId shiftY,
1168 const SimplexId shiftZ) const {
1169 // V(f)={b,e,g,h}
1170 switch(id) {
1171 case 0:
1172 return v - vshift_[1] * shiftZ; // b
1173 case 1:
1174 return v - shiftX; // e
1175 case 2:
1176 return v + (vshift_[0] * shiftY - shiftX); // g
1177 case 3:
1178 return v + vshift_[0] * shiftY; // h
1179 }
1180 return -1;
1181}
1182
1183inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborG(
1184 const SimplexId v,
1185 const SimplexId neighborId,
1186 const SimplexId shiftX,
1187 const SimplexId shiftY,
1188 const SimplexId shiftZ) const {
1189 // V(g)={a,b,c,d,e,f,h}
1190 if(neighborId == v - (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1191 return 0; // a
1192 else if(neighborId
1193 == v + (shiftX - vshift_[0] * shiftY - vshift_[1] * shiftZ))
1194 return 1; // b
1195 else if(neighborId == v - vshift_[1] * shiftZ)
1196 return 2; // c
1197 else if(neighborId == v + (shiftX - vshift_[1] * shiftZ))
1198 return 3; // d
1199 else if(neighborId == v - vshift_[0] * shiftY)
1200 return 4; // e
1201 else if(neighborId == v + (shiftX - vshift_[0] * shiftY))
1202 return 5; // f
1203 else if(neighborId == v + shiftX)
1204 return 6; // h
1205 return -1;
1206}
1207
1208inline ttk::SimplexId
1209 MultiresTriangulation::getVertexNeighborG(const SimplexId v,
1210 const int id,
1211 const SimplexId shiftX,
1212 const SimplexId shiftY,
1213 const SimplexId shiftZ) const {
1214 // V(g)={a,b,c,d,e,f,h}
1215 switch(id) {
1216 case 0:
1217 return v - (vshift_[0] * shiftY + vshift_[1] * shiftZ); // a
1218 case 1:
1219 return v + (shiftX - vshift_[0] * shiftY - vshift_[1] * shiftZ); // b
1220 case 2:
1221 return v - vshift_[1] * shiftZ; // c
1222 case 3:
1223 return v + (shiftX - vshift_[1] * shiftZ); // d
1224 case 4:
1225 return v - vshift_[0] * shiftY; // e
1226 case 5:
1227 return v + (shiftX - vshift_[0] * shiftY); // f
1228 case 6:
1229 return v + shiftX; // h
1230 }
1231 return -1;
1232}
1233
1234inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborH(
1235 const SimplexId v,
1236 const SimplexId neighborId,
1237 const SimplexId shiftX,
1238 const SimplexId shiftY,
1239 const SimplexId shiftZ) const {
1240 // V(h)={b,d,f,g}
1241 if(neighborId == v - (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1242 return 0; // b
1243 else if(neighborId == v - vshift_[1] * shiftZ)
1244 return 1; // d
1245 else if(neighborId == v - vshift_[0] * shiftY)
1246 return 2; // f
1247 else if(neighborId == v - shiftX)
1248 return 3; // g
1249 return -1;
1250}
1251
1252inline ttk::SimplexId
1253 MultiresTriangulation::getVertexNeighborH(const SimplexId v,
1254 const int id,
1255 const SimplexId shiftX,
1256 const SimplexId shiftY,
1257 const SimplexId shiftZ) const {
1258 // V(h)={b,d,f,g}
1259 switch(id) {
1260 case 0:
1261 return v - (vshift_[0] * shiftY + vshift_[1] * shiftZ); // b
1262 case 1:
1263 return v - vshift_[1] * shiftZ; // d
1264 case 2:
1265 return v - vshift_[0] * shiftY; // f
1266 case 3:
1267 return v - shiftX; // g
1268 }
1269 return -1;
1270}
1271
1272inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborAB(
1273 const SimplexId v,
1274 const SimplexId neighborId,
1275 const SimplexId shiftX,
1276 const SimplexId shiftY,
1277 const SimplexId shiftZ) const {
1278 // V(ab)=V(b)+V(a)::{b}
1279 if(neighborId == v - decimation_)
1280 return 0; // a
1281 else if(neighborId == v + (vshift_[0] * shiftY - decimation_))
1282 return 1; // c
1283 else if(neighborId == v + vshift_[0] * shiftY)
1284 return 2; // d
1285 else if(neighborId == v + (vshift_[1] * shiftZ - decimation_))
1286 return 3; // e
1287 else if(neighborId == v + vshift_[1] * shiftZ)
1288 return 4; // f
1289 else if(neighborId
1290 == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - decimation_))
1291 return 5; // g
1292 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1293 return 6; // h
1294 else if(neighborId == v + shiftX)
1295 return 7; // V(a)::{b}
1296 return -1;
1297}
1298
1299inline ttk::SimplexId
1300 MultiresTriangulation::getVertexNeighborAB(const SimplexId v,
1301 const int id,
1302 const SimplexId shiftX,
1303 const SimplexId shiftY,
1304 const SimplexId shiftZ) const {
1305 // V(ab)=V(b)+V(a)::{b}
1306 switch(id) {
1307 case 0:
1308 return v - decimation_; // a
1309 case 1:
1310 return v + (vshift_[0] * shiftY - decimation_); // c
1311 case 2:
1312 return v + vshift_[0] * shiftY; // d
1313 case 3:
1314 return v + (vshift_[1] * shiftZ - decimation_); // e
1315 case 4:
1316 return v + vshift_[1] * shiftZ; // f
1317 case 5:
1318 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - decimation_); // g
1319 case 6:
1320 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // h
1321 case 7:
1322 return v + shiftX; // V(a)::{b}
1323 }
1324 return -1;
1325}
1326
1327inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborCD(
1328 const SimplexId v,
1329 const SimplexId neighborId,
1330 const SimplexId shiftX,
1331 const SimplexId shiftY,
1332 const SimplexId shiftZ) const {
1333 // V(cd)=V(d)+V(c)::{b,d}
1334 if(neighborId == v - vshift_[0] * shiftY)
1335 return 0; // b
1336 else if(neighborId == v - decimation_)
1337 return 1; // c
1338 else if(neighborId == v + (vshift_[1] * shiftZ - decimation_))
1339 return 2; // g
1340 else if(neighborId == v + vshift_[1] * shiftZ)
1341 return 3; // h
1342 else if(neighborId == v + (shiftX - vshift_[0] * shiftY))
1343 return 4; // V(c)::{b}
1344 else if(neighborId == v + shiftX)
1345 return 5; // V(c)::{d}
1346 return -1;
1347}
1348inline ttk::SimplexId
1349 MultiresTriangulation::getVertexNeighborCD(const SimplexId v,
1350 const int id,
1351 const SimplexId shiftX,
1352 const SimplexId shiftY,
1353 const SimplexId shiftZ) const {
1354 // V(cd)=V(d)+V(c)::{b,d}
1355 switch(id) {
1356 case 0:
1357 return v - vshift_[0] * shiftY; // b
1358 case 1:
1359 return v - decimation_; // c
1360 case 2:
1361 return v + (vshift_[1] * shiftZ - decimation_); // g
1362 case 3:
1363 return v + vshift_[1] * shiftZ; // h
1364 case 4:
1365 return v + (shiftX - vshift_[0] * shiftY); // V(c)::{b}
1366 case 5:
1367 return v + shiftX; // V(c)::{d}
1368 }
1369 return -1;
1370}
1371
1372inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborEF(
1373 const SimplexId v,
1374 const SimplexId neighborId,
1375 const SimplexId shiftX,
1376 const SimplexId shiftY,
1377 const SimplexId shiftZ) const {
1378 // V(ef)=V(f)+V(e)::{b,f}
1379 if(neighborId == v - vshift_[1] * shiftZ)
1380 return 0; // b
1381 else if(neighborId == v - decimation_)
1382 return 1; // e
1383 else if(neighborId == v + (vshift_[0] * shiftY - decimation_))
1384 return 2; // g
1385 else if(neighborId == v + vshift_[0] * shiftY)
1386 return 3; // h
1387 else if(neighborId == v + (shiftX - vshift_[1] * shiftZ))
1388 return 4; // V(e)::{b}
1389 else if(neighborId == v + shiftX)
1390 return 5; // V(e)::{f}
1391 return -1;
1392}
1393inline ttk::SimplexId
1394 MultiresTriangulation::getVertexNeighborEF(const SimplexId v,
1395 const int id,
1396 const SimplexId shiftX,
1397 const SimplexId shiftY,
1398 const SimplexId shiftZ) const {
1399 // V(ef)=V(f)+V(e)::{b,f}
1400 switch(id) {
1401 case 0:
1402 return v - vshift_[1] * shiftZ; // b
1403 case 1:
1404 return v - decimation_; // e
1405 case 2:
1406 return v + (vshift_[0] * shiftY - decimation_); // g
1407 case 3:
1408 return v + vshift_[0] * shiftY; // h
1409 case 4:
1410 return v + (shiftX - vshift_[1] * shiftZ); // V(e)::{b}
1411 case 5:
1412 return v + shiftX; // V(e)::{f}
1413 }
1414 return -1;
1415}
1416
1417inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborGH(
1418 const SimplexId v,
1419 const SimplexId neighborId,
1420 const SimplexId shiftX,
1421 const SimplexId shiftY,
1422 const SimplexId shiftZ) const {
1423 // V(gh)=V(g)+V(h)::{g}
1424 if(neighborId == v - (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1425 return 0; // a
1426 else if(neighborId
1427 == v + (shiftX - vshift_[0] * shiftY - vshift_[1] * shiftZ))
1428 return 1; // b
1429 else if(neighborId == v - vshift_[1] * shiftZ)
1430 return 2; // c
1431 else if(neighborId == v + (shiftX - vshift_[1] * shiftZ))
1432 return 3; // d
1433 else if(neighborId == v - vshift_[0] * shiftY)
1434 return 4; // e
1435 else if(neighborId == v + (shiftX - vshift_[0] * shiftY))
1436 return 5; // f
1437 else if(neighborId == v + shiftX)
1438 return 6; // h
1439 else if(neighborId == v - decimation_)
1440 return 7; // V(h)::{g}
1441
1442 return -1;
1443}
1444inline ttk::SimplexId
1445 MultiresTriangulation::getVertexNeighborGH(const SimplexId v,
1446 const int id,
1447 const SimplexId shiftX,
1448 const SimplexId shiftY,
1449 const SimplexId shiftZ) const {
1450 // V(gh)=V(g)+V(h)::{g}
1451 switch(id) {
1452 case 0:
1453 return v - (vshift_[0] * shiftY + vshift_[1] * shiftZ); // a
1454 case 1:
1455 return v + (shiftX - vshift_[0] * shiftY - vshift_[1] * shiftZ); // b
1456 case 2:
1457 return v - vshift_[1] * shiftZ; // c
1458 case 3:
1459 return v + (shiftX - vshift_[1] * shiftZ); // d
1460 case 4:
1461 return v - vshift_[0] * shiftY; // e
1462 case 5:
1463 return v + (shiftX - vshift_[0] * shiftY); // f
1464 case 6:
1465 return v + shiftX; // h
1466 case 7:
1467 return v - decimation_; // V(h)::{g}
1468 }
1469
1470 return -1;
1471}
1472
1473inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborAC(
1474 const SimplexId v,
1475 const SimplexId neighborId,
1476 const SimplexId shiftX,
1477 const SimplexId shiftY,
1478 const SimplexId shiftZ) const {
1479 // V(ac)=V(c)+V(a)::{c,g}
1480 if(neighborId == v - vshift_[0] * decimation_)
1481 return 0; // a
1482 else if(neighborId == v + (shiftX - vshift_[0] * decimation_))
1483 return 1; // b
1484 else if(neighborId == v + shiftX)
1485 return 2; // d
1486 else if(neighborId == v + vshift_[1] * shiftZ)
1487 return 3; // g
1488 else if(neighborId == v + vshift_[0] * shiftY)
1489 return 4; // V(a)::{c}
1490 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1491 return 5; // V(a)::{c}
1492 return -1;
1493}
1494inline ttk::SimplexId
1495 MultiresTriangulation::getVertexNeighborAC(const SimplexId v,
1496 const int id,
1497 const SimplexId shiftX,
1498 const SimplexId shiftY,
1499 const SimplexId shiftZ) const {
1500 // V(ac)=V(c)+V(a)::{c,g}
1501 switch(id) {
1502 case 0:
1503 return v - vshift_[0] * decimation_; // a
1504 case 1:
1505 return v + (shiftX - vshift_[0] * decimation_); // b
1506 case 2:
1507 return v + shiftX; // d
1508 case 3:
1509 return v + vshift_[1] * shiftZ; // g
1510 case 4:
1511 return v + vshift_[0] * shiftY; // V(a)::{c}
1512 case 5:
1513 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // V(a)::{c}
1514 }
1515 return -1;
1516}
1517
1518inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborBD(
1519 const SimplexId v,
1520 const SimplexId neighborId,
1521 const SimplexId shiftX,
1522 const SimplexId shiftY,
1523 const SimplexId shiftZ) const {
1524 // V(bd)=V(b)+V(d)::{b}
1525 if(neighborId == v - shiftX)
1526 return 0; // a
1527 else if(neighborId == v + (vshift_[0] * shiftY - shiftX))
1528 return 1; // c
1529 else if(neighborId == v + vshift_[0] * shiftY)
1530 return 2; // d
1531 else if(neighborId == v + (vshift_[1] * shiftZ - shiftX))
1532 return 3; // e
1533 else if(neighborId == v + vshift_[1] * shiftZ)
1534 return 4; // f
1535 else if(neighborId
1536 == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - shiftX))
1537 return 5; // g
1538 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1539 return 6; // h
1540 else if(neighborId == v - vshift_[0] * decimation_)
1541 return 7; // V(d)::{b}
1542 return -1;
1543}
1544inline ttk::SimplexId
1545 MultiresTriangulation::getVertexNeighborBD(const SimplexId v,
1546 const int id,
1547 const SimplexId shiftX,
1548 const SimplexId shiftY,
1549 const SimplexId shiftZ) const {
1550 // V(bd)=V(b)+V(d)::{b}
1551 switch(id) {
1552 case 0:
1553 return v - shiftX; // a
1554 case 1:
1555 return v + (vshift_[0] * shiftY - shiftX); // c
1556 case 2:
1557 return v + vshift_[0] * shiftY; // d
1558 case 3:
1559 return v + (vshift_[1] * shiftZ - shiftX); // e
1560 case 4:
1561 return v + vshift_[1] * shiftZ; // f
1562 case 5:
1563 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - shiftX); // g
1564 case 6:
1565 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // h
1566 case 7:
1567 return v - vshift_[0] * decimation_; // V(d)::{b}
1568 }
1569 return -1;
1570}
1571
1572inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborEG(
1573 const SimplexId v,
1574 const SimplexId neighborId,
1575 const SimplexId shiftX,
1576 const SimplexId shiftY,
1577 const SimplexId shiftZ) const {
1578 // V(eg)=V(g)+V(e)::{g}
1579 if(neighborId == v - (vshift_[0] * decimation_ + vshift_[1] * shiftZ))
1580 return 0; // a
1581 else if(neighborId
1582 == v + (shiftX - vshift_[0] * decimation_ - vshift_[1] * shiftZ))
1583 return 1; // b
1584 else if(neighborId == v - vshift_[1] * shiftZ)
1585 return 2; // c
1586 else if(neighborId == v + (shiftX - vshift_[1] * shiftZ))
1587 return 3; // d
1588 else if(neighborId == v - vshift_[0] * decimation_)
1589 return 4; // e
1590 else if(neighborId == v + (shiftX - vshift_[0] * decimation_))
1591 return 5; // f
1592 else if(neighborId == v + shiftX)
1593 return 6; // h
1594 else if(neighborId == v + vshift_[0] * shiftY)
1595 return 7; // V(e)::{g}
1596 return -1;
1597}
1598inline ttk::SimplexId
1599 MultiresTriangulation::getVertexNeighborEG(const SimplexId v,
1600 const int id,
1601 const SimplexId shiftX,
1602 const SimplexId shiftY,
1603 const SimplexId shiftZ) const {
1604 // V(eg)=V(g)+V(e)::{g}
1605 switch(id) {
1606 case 0:
1607 return v - (vshift_[0] * decimation_ + vshift_[1] * shiftZ); // a
1608 case 1:
1609 return v + (shiftX - vshift_[0] * decimation_ - vshift_[1] * shiftZ); // b
1610 case 2:
1611 return v - vshift_[1] * shiftZ; // c
1612 case 3:
1613 return v + (shiftX - vshift_[1] * shiftZ); // d
1614 case 4:
1615 return v - vshift_[0] * decimation_; // e
1616 case 5:
1617 return v + (shiftX - vshift_[0] * decimation_); // f
1618 case 6:
1619 return v + shiftX; // h
1620 case 7:
1621 return v + vshift_[0] * shiftY; // V(e)::{g}
1622 }
1623 return -1;
1624}
1625
1626inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborFH(
1627 const SimplexId v,
1628 const SimplexId neighborId,
1629 const SimplexId shiftX,
1630 const SimplexId shiftY,
1631 const SimplexId shiftZ) const {
1632 // V(fh)=V(f)+V(h)::{b,f}
1633 if(neighborId == v - vshift_[1] * shiftZ)
1634 return 0; // b
1635 else if(neighborId == v - shiftX)
1636 return 1; // e
1637 else if(neighborId == v + (vshift_[0] * shiftY - shiftX))
1638 return 2; // g
1639 else if(neighborId == v + vshift_[0] * shiftY)
1640 return 3; // h
1641 else if(neighborId == v - (vshift_[0] * decimation_ + vshift_[1] * shiftZ))
1642 return 4; // V(h)::{b}
1643 else if(neighborId == v - vshift_[0] * decimation_)
1644 return 5; // V(h)::{f}
1645 return -1;
1646}
1647inline ttk::SimplexId
1648 MultiresTriangulation::getVertexNeighborFH(const SimplexId v,
1649 const int id,
1650 const SimplexId shiftX,
1651 const SimplexId shiftY,
1652 const SimplexId shiftZ) const {
1653 // V(fh)=V(f)+V(h)::{b,f}
1654 switch(id) {
1655 case 0:
1656 return v - vshift_[1] * shiftZ; // b
1657 case 1:
1658 return v - shiftX; // e
1659 case 2:
1660 return v + (vshift_[0] * shiftY - shiftX); // g
1661 case 3:
1662 return v + vshift_[0] * shiftY; // h
1663 case 4:
1664 return v - (vshift_[0] * decimation_ + vshift_[1] * shiftZ); // V(h)::{b}
1665 case 5:
1666 return v - vshift_[0] * decimation_; // V(h)::{f}
1667 }
1668 return -1;
1669}
1670
1671inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborAE(
1672 const SimplexId v,
1673 const SimplexId neighborId,
1674 const SimplexId shiftX,
1675 const SimplexId shiftY,
1676 const SimplexId shiftZ) const {
1677 // V(ae)=V(a)+V(e)::{a,b}
1678 if(neighborId == v + shiftX)
1679 return 0; // b
1680 else if(neighborId == v + vshift_[0] * shiftY)
1681 return 1; // c
1682 else if(neighborId == v + vshift_[1] * shiftZ)
1683 return 2; // e
1684 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1685 return 3; // g
1686 else if(neighborId == v - vshift_[1] * decimation_)
1687 return 4; // V(e)::{a}
1688 else if(neighborId == v + (shiftX - vshift_[1] * decimation_))
1689 return 5; // V(e)::{b}
1690 return -1;
1691}
1692inline ttk::SimplexId
1693 MultiresTriangulation::getVertexNeighborAE(const SimplexId v,
1694 const int id,
1695 const SimplexId shiftX,
1696 const SimplexId shiftY,
1697 const SimplexId shiftZ) const {
1698 // V(ae)=V(a)+V(e)::{a,b}
1699 switch(id) {
1700 case 0:
1701 return v + shiftX; // b
1702 case 1:
1703 return v + vshift_[0] * shiftY; // c
1704 case 2:
1705 return v + vshift_[1] * shiftZ; // e
1706 case 3:
1707 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // g
1708 case 4:
1709 return v - vshift_[1] * decimation_; // V(e)::{a}
1710 case 5:
1711 return v + (shiftX - vshift_[1] * decimation_); // V(e)::{b}
1712 }
1713 return -1;
1714}
1715
1716inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborBF(
1717 const SimplexId v,
1718 const SimplexId neighborId,
1719 const SimplexId shiftX,
1720 const SimplexId shiftY,
1721 const SimplexId shiftZ) const {
1722 // V(bf)=V(b)+V(f)::{b}
1723 if(neighborId == v - shiftX)
1724 return 0; // a
1725 else if(neighborId == v + (vshift_[0] * shiftY - shiftX))
1726 return 1; // c
1727 else if(neighborId == v + vshift_[0] * shiftY)
1728 return 2; // d
1729 else if(neighborId == v + (vshift_[1] * shiftZ - shiftX))
1730 return 3; // e
1731 else if(neighborId == v + vshift_[1] * shiftZ)
1732 return 4; // f
1733 else if(neighborId
1734 == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - shiftX))
1735 return 5; // g
1736 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
1737 return 6; // h
1738 else if(neighborId == v - vshift_[1] * decimation_)
1739 return 7; // V(f)::{b}
1740 return -1;
1741}
1742
1743inline ttk::SimplexId
1744 MultiresTriangulation::getVertexNeighborBF(const SimplexId v,
1745 const int id,
1746 const SimplexId shiftX,
1747 const SimplexId shiftY,
1748 const SimplexId shiftZ) const {
1749 // V(bf)=V(b)+V(f)::{b}
1750 switch(id) {
1751 case 0:
1752 return v - shiftX; // a
1753 case 1:
1754 return v + (vshift_[0] * shiftY - shiftX); // c
1755 case 2:
1756 return v + vshift_[0] * shiftY; // d
1757 case 3:
1758 return v + (vshift_[1] * shiftZ - shiftX); // e
1759 case 4:
1760 return v + vshift_[1] * shiftZ; // f
1761 case 5:
1762 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - shiftX); // g
1763 case 6:
1764 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // h
1765 case 7:
1766 return v - vshift_[1] * decimation_; // V(f)::{b}
1767 }
1768 return -1;
1769}
1770
1771inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborCG(
1772 const SimplexId v,
1773 const SimplexId neighborId,
1774 const SimplexId shiftX,
1775 const SimplexId shiftY,
1776 const SimplexId shiftZ) const {
1777 // V(cg)=V(g)+V(c)::{g}
1778 if(neighborId == v - (vshift_[0] * shiftY + vshift_[1] * decimation_))
1779 return 0; // a
1780 else if(neighborId
1781 == v + (shiftX - vshift_[0] * shiftY - vshift_[1] * decimation_))
1782 return 1; // b
1783 else if(neighborId == v - vshift_[1] * decimation_)
1784 return 2; // c
1785 else if(neighborId == v + (shiftX - vshift_[1] * decimation_))
1786 return 3; // d
1787 else if(neighborId == v - vshift_[0] * shiftY)
1788 return 4; // e
1789 else if(neighborId == v + (shiftX - vshift_[0] * shiftY))
1790 return 5; // f
1791 else if(neighborId == v + shiftX)
1792 return 6; // h
1793 else if(neighborId == v + vshift_[1] * shiftZ)
1794 return 7; // V(c)::{g}
1795 return -1;
1796}
1797inline ttk::SimplexId
1798 MultiresTriangulation::getVertexNeighborCG(const SimplexId v,
1799 const int id,
1800 const SimplexId shiftX,
1801 const SimplexId shiftY,
1802 const SimplexId shiftZ) const {
1803 // V(cg)=V(g)+V(c)::{g}
1804 switch(id) {
1805 case 0:
1806 return v - (vshift_[0] * shiftY + vshift_[1] * decimation_); // a
1807 case 1:
1808 return v + (shiftX - vshift_[0] * shiftY - vshift_[1] * decimation_); // b
1809 case 2:
1810 return v - vshift_[1] * decimation_; // c
1811 case 3:
1812 return v + (shiftX - vshift_[1] * decimation_); // d
1813 case 4:
1814 return v - vshift_[0] * shiftY; // e
1815 case 5:
1816 return v + (shiftX - vshift_[0] * shiftY); // f
1817 case 6:
1818 return v + shiftX; // h
1819 case 7:
1820 return v + vshift_[1] * shiftZ; // V(c)::{g}
1821 }
1822 return -1;
1823}
1824
1825inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborDH(
1826 const SimplexId v,
1827 const SimplexId neighborId,
1828 const SimplexId shiftX,
1829 const SimplexId shiftY,
1830 const SimplexId shiftZ) const {
1831 // V(dh)=V(d)+V(h)::{b,d}
1832 if(neighborId == v - vshift_[0] * shiftY)
1833 return 0; // b
1834 else if(neighborId == v - shiftX)
1835 return 1; // c
1836 else if(neighborId == v + (vshift_[1] * shiftZ - shiftX))
1837 return 2; // g
1838 else if(neighborId == v + vshift_[1] * shiftZ)
1839 return 3; // h
1840 else if(neighborId == v - (vshift_[0] * shiftY + vshift_[1] * decimation_))
1841 return 4; // V(h)::{b}
1842 else if(neighborId == v - vshift_[1] * decimation_)
1843 return 5; // V(h)::{d}
1844 return -1;
1845}
1846inline ttk::SimplexId
1847 MultiresTriangulation::getVertexNeighborDH(const SimplexId v,
1848 const int id,
1849 const SimplexId shiftX,
1850 const SimplexId shiftY,
1851 const SimplexId shiftZ) const {
1852 // V(dh)=V(d)+V(h)::{b,d}
1853 switch(id) {
1854 case 0:
1855 return v - vshift_[0] * shiftY; // b
1856 case 1:
1857 return v - shiftX; // c
1858 case 2:
1859 return v + (vshift_[1] * shiftZ - shiftX); // g
1860 case 3:
1861 return v + vshift_[1] * shiftZ; // h
1862 case 4:
1863 return v - (vshift_[0] * shiftY + vshift_[1] * decimation_); // V(h)::{b}
1864 case 5:
1865 return v - vshift_[1] * decimation_; // V(h)::{d}
1866 }
1867 return -1;
1868}
1869
1870inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborABDC(
1871 const SimplexId v,
1872 const SimplexId neighborId,
1873 const SimplexId shiftX,
1874 const SimplexId shiftY,
1875 const SimplexId shiftZ) const {
1876 // V(abdc)=V(b)+V(d)::{b}+V(c)::{b}+V(a)::{b}
1877 if(neighborId == v - decimation_)
1878 return 0;
1879 else if(neighborId == v + (vshift_[0] * shiftY - decimation_)) // c
1880 return 1;
1881 else if(neighborId == v + vshift_[0] * shiftY) // d
1882 return 2;
1883 else if(neighborId == v + (vshift_[1] * shiftZ - decimation_)) // e
1884 return 3;
1885 else if(neighborId == v + vshift_[1] * shiftZ) // f
1886 return 4;
1887 else if(neighborId
1888 == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - decimation_)) // g
1889 return 5;
1890 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ)) // h
1891 return 6;
1892 else if(neighborId == v - vshift_[0] * decimation_) // V(d)::{b}
1893 return 7;
1894 else if(neighborId == v + (shiftX - vshift_[0] * decimation_)) // V(c)::{b}
1895 return 8;
1896 else if(neighborId == v + shiftX) // V(a)::{b}
1897 return 9;
1898 return -1;
1899}
1900
1901inline ttk::SimplexId
1902 MultiresTriangulation::getVertexNeighborABDC(const SimplexId v,
1903 const int id,
1904 const SimplexId shiftX,
1905 const SimplexId shiftY,
1906 const SimplexId shiftZ) const {
1907 // V(abdc)=V(b)+V(d)::{b}+V(c)::{b}+V(a)::{b}
1908 switch(id) {
1909 case 0:
1910 return v - decimation_; // a
1911 case 1:
1912 return v + (vshift_[0] * shiftY - decimation_); // c
1913 case 2:
1914 return v + vshift_[0] * shiftY; // d
1915 case 3:
1916 return v + (vshift_[1] * shiftZ - decimation_); // e
1917 case 4:
1918 return v + vshift_[1] * shiftZ; // f
1919 case 5:
1920 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - decimation_); // g
1921 case 6:
1922 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // h
1923 case 7:
1924 return v - vshift_[0] * decimation_; // V(d)::{b}
1925 case 8:
1926 return v + (shiftX - vshift_[0] * decimation_); // V(c)::{b}
1927 case 9:
1928 return v + shiftX; // V(a)::{b}
1929 }
1930 return -1;
1931}
1932
1933inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborEFHG(
1934 const SimplexId v,
1935 const SimplexId neighborId,
1936 const SimplexId shiftX,
1937 const SimplexId shiftY,
1938 const SimplexId shiftZ) const {
1939 // V(efhg)=V(g)+V(h)::{g}+V(f)::{g,h}
1940 if(neighborId == v - (vshift_[0] * decimation_ + vshift_[1] * shiftZ))
1941 return 0; // a
1942 else if(neighborId
1943 == v + (shiftX - vshift_[0] * decimation_ - vshift_[1] * shiftZ))
1944 return 1; // b
1945 else if(neighborId == v - vshift_[1] * shiftZ)
1946 return 2; // c
1947 else if(neighborId == v + (shiftX - vshift_[1] * shiftZ))
1948 return 3; // d
1949 else if(neighborId == v - vshift_[0] * decimation_)
1950 return 4; // e
1951 else if(neighborId == v + (shiftX - vshift_[0] * decimation_))
1952 return 5; // f
1953 else if(neighborId == v + shiftX)
1954 return 6; // h
1955 else if(neighborId == v - decimation_)
1956 return 7; // V(h)::{g}
1957 else if(neighborId == v + (vshift_[0] * shiftY - decimation_))
1958 return 8; // V(f)::{g}
1959 else if(neighborId == v + vshift_[0] * shiftY)
1960 return 9; // V(f)::{h}
1961 return -1;
1962}
1963inline ttk::SimplexId
1964 MultiresTriangulation::getVertexNeighborEFHG(const SimplexId v,
1965 const int id,
1966 const SimplexId shiftX,
1967 const SimplexId shiftY,
1968 const SimplexId shiftZ) const {
1969 // V(efhg)=V(g)+V(h)::{g}+V(f)::{g,h}
1970 switch(id) {
1971 case 0:
1972 return v - (vshift_[0] * decimation_ + vshift_[1] * shiftZ); // a
1973 case 1:
1974 return v + (shiftX - vshift_[0] * decimation_ - vshift_[1] * shiftZ); // b
1975 case 2:
1976 return v - vshift_[1] * shiftZ; // c
1977 case 3:
1978 return v + (shiftX - vshift_[1] * shiftZ); // d
1979 case 4:
1980 return v - vshift_[0] * decimation_; // e
1981 case 5:
1982 return v + (shiftX - vshift_[0] * decimation_); // f
1983 case 6:
1984 return v + shiftX; // h
1985 case 7:
1986 return v - decimation_; // V(h)::{g}
1987 case 8:
1988 return v + (vshift_[0] * shiftY - decimation_); // V(f)::{g}
1989 case 9:
1990 return v + vshift_[0] * shiftY; // V(f)::{h}
1991 }
1992 return -1;
1993}
1994
1995inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborAEGC(
1996 const SimplexId v,
1997 const SimplexId neighborId,
1998 const SimplexId shiftX,
1999 const SimplexId shiftY,
2000 const SimplexId shiftZ) const {
2001 // V(aegc)=V(g)+V(a)::{c,g}+V(c)::{g}
2002 if(neighborId == v - (vshift_[0] * decimation_ + vshift_[1] * decimation_))
2003 return 0; // a
2004 else if(neighborId
2005 == v + (shiftX - vshift_[0] * decimation_ - vshift_[1] * decimation_))
2006 return 1; // b
2007 else if(neighborId == v - vshift_[1] * decimation_)
2008 return 2; // c
2009 else if(neighborId == v + (shiftX - vshift_[1] * decimation_))
2010 return 3; // d
2011 else if(neighborId == v - vshift_[0] * decimation_)
2012 return 4; // e
2013 else if(neighborId == v + (shiftX - vshift_[0] * decimation_))
2014 return 5; // f
2015 else if(neighborId == v + shiftX)
2016 return 6; // h
2017 else if(neighborId == v + vshift_[0] * shiftY)
2018 return 7; // V(a)::{c}
2019 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
2020 return 8; // V(a)::{g}
2021 else if(neighborId == v + vshift_[1] * shiftZ)
2022 return 9; // V(c)::{g}
2023 return -1;
2024}
2025inline ttk::SimplexId
2026 MultiresTriangulation::getVertexNeighborAEGC(const SimplexId v,
2027 const int id,
2028 const SimplexId shiftX,
2029 const SimplexId shiftY,
2030 const SimplexId shiftZ) const {
2031 // V(aegc)=V(g)+V(a)::{c,g}+V(c)::{g}
2032 switch(id) {
2033 case 0:
2034 return v - (vshift_[0] * decimation_ + vshift_[1] * decimation_); // a
2035 case 1:
2036 return v
2037 + (shiftX - vshift_[0] * decimation_
2038 - vshift_[1] * decimation_); // b
2039 case 2:
2040 return v - vshift_[1] * decimation_; // c
2041 case 3:
2042 return v + (shiftX - vshift_[1] * decimation_); // d
2043 case 4:
2044 return v - vshift_[0] * decimation_; // e
2045 case 5:
2046 return v + (shiftX - vshift_[0] * decimation_); // f
2047 case 6:
2048 return v + shiftX; // h
2049 case 7:
2050 return v + vshift_[0] * shiftY; // V(a)::{c}
2051 case 8:
2052 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // V(a)::{g}
2053 case 9:
2054 return v + vshift_[1] * shiftZ; // V(c)::{g}
2055 }
2056 return -1;
2057}
2058
2059inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborBFHD(
2060 const SimplexId v,
2061 const SimplexId neighborId,
2062 const SimplexId shiftX,
2063 const SimplexId shiftY,
2064 const SimplexId shiftZ) const {
2065 // V(bfhd)=V(b)+V(f)::{b}+V(h)::{b}+V(d)::{b}
2066 if(neighborId == v - shiftX)
2067 return 0; // a
2068 else if(neighborId == v + (vshift_[0] * shiftY - shiftX))
2069 return 1; // c
2070 else if(neighborId == v + vshift_[0] * shiftY)
2071 return 2; // d
2072 else if(neighborId == v + (vshift_[1] * shiftZ - shiftX))
2073 return 3; // e
2074 else if(neighborId == v + vshift_[1] * shiftZ)
2075 return 4; // f
2076 else if(neighborId
2077 == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - shiftX))
2078 return 5; // g
2079 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
2080 return 6; // h
2081 else if(neighborId == v - vshift_[1] * decimation_)
2082 return 7; // V(f)::{b}
2083 else if(neighborId
2084 == v - (vshift_[0] * decimation_ + vshift_[1] * decimation_))
2085 return 8; // V(h)::{b}
2086 else if(neighborId == v - vshift_[0] * decimation_)
2087 return 9; // V(d)::{b}
2088 return -1;
2089}
2090inline ttk::SimplexId
2091 MultiresTriangulation::getVertexNeighborBFHD(const SimplexId v,
2092 const int id,
2093 const SimplexId shiftX,
2094 const SimplexId shiftY,
2095 const SimplexId shiftZ) const {
2096 // V(bfhd)=V(b)+V(f)::{b}+V(h)::{b}+V(d)::{b}
2097 switch(id) {
2098 case 0:
2099 return v - shiftX; // a
2100 case 1:
2101 return v + (vshift_[0] * shiftY - shiftX); // c
2102 case 2:
2103 return v + vshift_[0] * shiftY; // d
2104 case 3:
2105 return v + (vshift_[1] * shiftZ - shiftX); // e
2106 case 4:
2107 return v + vshift_[1] * shiftZ; // f
2108 case 5:
2109 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - shiftX); // g
2110 case 6:
2111 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // h
2112 case 7:
2113 return v - vshift_[1] * decimation_; // V(f)::{b}
2114 case 8:
2115 return v
2116 - (vshift_[0] * decimation_
2117 + vshift_[1] * decimation_); // V(h)::{b}
2118 case 9:
2119 return v - vshift_[0] * decimation_; // V(d)::{b}
2120 }
2121 return -1;
2122}
2123
2124inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborAEFB(
2125 const SimplexId v,
2126 const SimplexId neighborId,
2127 const SimplexId shiftX,
2128 const SimplexId shiftY,
2129 const SimplexId shiftZ) const {
2130 // V(aefb)=V(b)+V(a)::{b}+V(e)::{b}+V(f)::{b}
2131 if(neighborId == v - decimation_)
2132 return 0; // a
2133 else if(neighborId == v + (vshift_[0] * shiftY - decimation_))
2134 return 1; // c
2135 else if(neighborId == v + vshift_[0] * shiftY)
2136 return 2; // d
2137 else if(neighborId == v + (vshift_[1] * shiftZ - decimation_))
2138 return 3; // e
2139 else if(neighborId == v + vshift_[1] * shiftZ)
2140 return 4; // f
2141 else if(neighborId
2142 == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - decimation_))
2143 return 5; // g
2144 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
2145 return 6; // h
2146 else if(neighborId == v + shiftX)
2147 return 7; // V(a)::{b}
2148 else if(neighborId == v + (shiftX - vshift_[1] * decimation_))
2149 return 8; // V(e)::{b}
2150 else if(neighborId == v - vshift_[1] * decimation_)
2151 return 9; // V(f)::{b}
2152 return -1;
2153}
2154inline ttk::SimplexId
2155 MultiresTriangulation::getVertexNeighborAEFB(const SimplexId v,
2156 const int id,
2157 const SimplexId shiftX,
2158 const SimplexId shiftY,
2159 const SimplexId shiftZ) const {
2160 // V(aefb)=V(b)+V(a)::{b}+V(e)::{b}+V(f)::{b}
2161 switch(id) {
2162 case 0:
2163 return v - decimation_; // a
2164 case 1:
2165 return v + (vshift_[0] * shiftY - decimation_); // c
2166 case 2:
2167 return v + vshift_[0] * shiftY; // d
2168 case 3:
2169 return v + (vshift_[1] * shiftZ - decimation_); // e
2170 case 4:
2171 return v + vshift_[1] * shiftZ; // f
2172 case 5:
2173 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - decimation_); // g
2174 case 6:
2175 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // h
2176 case 7:
2177 return v + shiftX; // V(a)::{b}
2178 case 8:
2179 return v + (shiftX - vshift_[1] * decimation_); // V(e)::{b}
2180 case 9:
2181 return v - vshift_[1] * decimation_; // V(f)::{b}
2182 }
2183 return -1;
2184}
2185
2186inline ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborGHDC(
2187 const SimplexId v,
2188 const SimplexId neighborId,
2189 const SimplexId shiftX,
2190 const SimplexId shiftY,
2191 const SimplexId shiftZ) const {
2192 // V(ghdc)=V(g)+V(h)::{g}+V(d)::{g,h}
2193 if(neighborId == v - (vshift_[0] * shiftY + vshift_[1] * decimation_))
2194 return 0; // a
2195 else if(neighborId
2196 == v + (shiftX - vshift_[0] * shiftY - vshift_[1] * decimation_))
2197 return 1; // b
2198 else if(neighborId == v - vshift_[1] * decimation_)
2199 return 2; // c
2200 else if(neighborId == v + (shiftX - vshift_[1] * decimation_))
2201 return 3; // d
2202 else if(neighborId == v - vshift_[0] * shiftY)
2203 return 4; // e
2204 else if(neighborId == v + (shiftX - vshift_[0] * shiftY))
2205 return 5; // f
2206 else if(neighborId == v + shiftX)
2207 return 6; // h
2208 else if(neighborId == v - decimation_)
2209 return 7; // V(h)::{g}
2210 else if(neighborId == v + (vshift_[1] * shiftZ - decimation_))
2211 return 8; // V(d)::{g}
2212 else if(neighborId == v + vshift_[1] * shiftZ)
2213 return 9; // V(d)::{h}
2214 return -1;
2215}
2216inline ttk::SimplexId
2217 MultiresTriangulation::getVertexNeighborGHDC(const SimplexId v,
2218 const int id,
2219 const SimplexId shiftX,
2220 const SimplexId shiftY,
2221 const SimplexId shiftZ) const {
2222 // V(ghdc)=V(g)+V(h)::{g}+V(d)::{g,h}
2223 switch(id) {
2224 case 0:
2225 return v - (vshift_[0] * shiftY + vshift_[1] * decimation_); // a
2226 case 1:
2227 return v + (shiftX - vshift_[0] * shiftY - vshift_[1] * decimation_); // b
2228 case 2:
2229 return v - vshift_[1] * decimation_; // c
2230 case 3:
2231 return v + (shiftX - vshift_[1] * decimation_); // d
2232 case 4:
2233 return v - vshift_[0] * shiftY; // e
2234 case 5:
2235 return v + (shiftX - vshift_[0] * shiftY); // f
2236 case 6:
2237 return v + shiftX; // h
2238 case 7:
2239 return v - decimation_; // V(h)::{g}
2240 case 8:
2241 return v + (vshift_[1] * shiftZ - decimation_); // V(d)::{g}
2242 case 9:
2243 return v + vshift_[1] * shiftZ; // V(d)::{h}
2244 }
2245 return -1;
2246}
2247
2248ttk::SimplexId MultiresTriangulation::getInvertVertexNeighborABCDEFGH(
2249 const SimplexId v,
2250 const SimplexId neighborId,
2251 const SimplexId shiftX,
2252 const SimplexId shiftY,
2253 const SimplexId shiftZ) const {
2254 // V(abcdefgh)=V(g)+V(d)::{g,h}+V(h)::{g}+V(b)::{c,d,g,h}
2255 if(neighborId == v - (vshift_[0] * decimation_ + vshift_[1] * decimation_))
2256 return 0; // a
2257 else if(neighborId
2258 == v + (shiftX - vshift_[0] * decimation_ - vshift_[1] * decimation_))
2259 return 1; // b
2260 else if(neighborId == v - vshift_[1] * decimation_)
2261 return 2; // c
2262 else if(neighborId == v + (shiftX - vshift_[1] * decimation_))
2263 return 3; // d
2264 else if(neighborId == v - vshift_[0] * decimation_)
2265 return 4; // e
2266 else if(neighborId == v + (shiftX - vshift_[0] * decimation_))
2267 return 5; // f
2268 else if(neighborId == v + shiftX)
2269 return 6; // h
2270 else if(neighborId == v + (vshift_[1] * shiftZ - decimation_))
2271 return 7; // V(d)::{g}
2272 else if(neighborId == v + vshift_[1] * shiftZ)
2273 return 8; // V(d)::{h}
2274 else if(neighborId == v - decimation_)
2275 return 9; // V(h)::{g}
2276 else if(neighborId == v + (vshift_[0] * shiftY - decimation_))
2277 return 10; // V(b)::{c}
2278 else if(neighborId == v + vshift_[0] * shiftY)
2279 return 11; // V(b)::{d}
2280 else if(neighborId
2281 == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ - decimation_))
2282 return 12;
2283 else if(neighborId == v + (vshift_[0] * shiftY + vshift_[1] * shiftZ))
2284 return 13;
2285 return -1;
2286}
2287ttk::SimplexId MultiresTriangulation::getVertexNeighborABCDEFGH(
2288 const SimplexId v,
2289 const int id,
2290 const SimplexId shiftX,
2291 const SimplexId shiftY,
2292 const SimplexId shiftZ) const {
2293 // V(abcdefgh)=V(g)+V(d)::{g,h}+V(h)::{g}+V(b)::{c,d,g,h}
2294 switch(id) {
2295 case 0:
2296 return v - (vshift_[0] * decimation_ + vshift_[1] * decimation_); // a
2297 case 1:
2298 return v
2299 + (shiftX - vshift_[0] * decimation_
2300 - vshift_[1] * decimation_); // b
2301 case 2:
2302 return v - vshift_[1] * decimation_; // c
2303 case 3:
2304 return v + (shiftX - vshift_[1] * decimation_); // d
2305 case 4:
2306 return v - vshift_[0] * decimation_; // e
2307 case 5:
2308 return v + (shiftX - vshift_[0] * decimation_); // f
2309 case 6:
2310 return v + shiftX; // h
2311 case 7:
2312 return v + (vshift_[1] * shiftZ - decimation_); // V(d)::{g}
2313 case 8:
2314 return v + vshift_[1] * shiftZ; // V(d)::{h}
2315 case 9:
2316 return v - decimation_; // V(h)::{g}
2317 case 10:
2318 return v + (vshift_[0] * shiftY - decimation_); // V(b)::{c}
2319 case 11:
2320 return v + vshift_[0] * shiftY; // V(b)::{d}
2321 case 12:
2322 return v
2323 + (vshift_[0] * shiftY + vshift_[1] * shiftZ
2324 - decimation_); // V(b)::{g}
2325 case 13:
2326 return v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // V(b)::{h}
2327 }
2328 return -1;
2329}
2330ttk::SimplexId MultiresTriangulation::getInvertedVertexNeighborABCDEFGH(
2331 const SimplexId v,
2332 const int id,
2333 const SimplexId shiftX,
2334 const SimplexId shiftY,
2335 const SimplexId shiftZ,
2336 SimplexId &invertedLocalNeighbor) const {
2337 // V(abcdefgh)=V(g)+V(d)::{g,h}+V(h)::{g}+V(b)::{c,d,g,h}
2338 SimplexId invertedVertexId = -1;
2339 switch(id) {
2340 case 0:
2341 invertedLocalNeighbor = 13;
2342 invertedVertexId
2343 = v - (vshift_[0] * decimation_ + vshift_[1] * decimation_); // a
2344 break;
2345 case 1:
2346 invertedLocalNeighbor = 12;
2347 invertedVertexId
2348 = v
2349 + (shiftX - vshift_[0] * decimation_ - vshift_[1] * decimation_); // b
2350 break;
2351 case 2:
2352 invertedLocalNeighbor = 8;
2353 invertedVertexId = v - vshift_[1] * decimation_; // c
2354 break;
2355 case 3:
2356 invertedLocalNeighbor = 7;
2357 invertedVertexId = v + (shiftX - vshift_[1] * decimation_); // d
2358 break;
2359 case 4:
2360 invertedLocalNeighbor = 11;
2361 invertedVertexId = v - vshift_[0] * decimation_; // e
2362 break;
2363 case 5:
2364 invertedLocalNeighbor = 10;
2365 invertedVertexId = v + (shiftX - vshift_[0] * decimation_); // f
2366 break;
2367 case 6:
2368 invertedLocalNeighbor = 9;
2369 invertedVertexId = v + shiftX; // h
2370 break;
2371 case 7:
2372 invertedLocalNeighbor = 3;
2373 invertedVertexId = v + (vshift_[1] * shiftZ - decimation_); // V(d)::{g}
2374 break;
2375 case 8:
2376 invertedLocalNeighbor = 2;
2377 invertedVertexId = v + vshift_[1] * shiftZ; // V(d)::{h}
2378 break;
2379 case 9:
2380 invertedLocalNeighbor = 6;
2381 invertedVertexId = v - decimation_; // V(h)::{g}
2382 break;
2383 case 10:
2384 invertedLocalNeighbor = 5;
2385 invertedVertexId = v + (vshift_[0] * shiftY - decimation_); // V(b)::{c}
2386 break;
2387 case 11:
2388 invertedLocalNeighbor = 4;
2389 invertedVertexId = v + vshift_[0] * shiftY; // V(b)::{d}
2390 break;
2391 case 12:
2392 invertedLocalNeighbor = 1;
2393 invertedVertexId = v
2394 + (vshift_[0] * shiftY + vshift_[1] * shiftZ
2395 - decimation_); // V(b)::{g}
2396 break;
2397 case 13:
2398 invertedLocalNeighbor = 0;
2399 invertedVertexId
2400 = v + (vshift_[0] * shiftY + vshift_[1] * shiftZ); // V(b)::{h}
2401 break;
2402 }
2403 return invertedVertexId;
2404}
2405void MultiresTriangulation::getInvertedLocalNeighborABDC(
2406 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2407 switch(id) {
2408 case 0:
2409 invertedLocalNeighbor = 6;
2410 break;
2411 case 1:
2412 invertedLocalNeighbor = 5;
2413 break;
2414 case 2:
2415 invertedLocalNeighbor = 4;
2416 break;
2417 case 3:
2418 invertedLocalNeighbor = 3;
2419 break;
2420 case 4:
2421 invertedLocalNeighbor = 2;
2422 break;
2423 case 5:
2424 invertedLocalNeighbor = 1;
2425 break;
2426 case 6:
2427 invertedLocalNeighbor = 0;
2428 break;
2429 case 9:
2430 invertedLocalNeighbor = 9;
2431 break;
2432 case 10:
2433 invertedLocalNeighbor = 8;
2434 break;
2435 case 11:
2436 invertedLocalNeighbor = 7;
2437 break;
2438 }
2439}
2440
2441void MultiresTriangulation::getInvertedLocalNeighborEFHG(
2442 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2443 switch(id) {
2444 case 13:
2445 invertedLocalNeighbor = 0;
2446 break;
2447 case 12:
2448 invertedLocalNeighbor = 1;
2449 break;
2450 case 8:
2451 invertedLocalNeighbor = 2;
2452 break;
2453 case 7:
2454 invertedLocalNeighbor = 3;
2455 break;
2456 case 11:
2457 invertedLocalNeighbor = 4;
2458 break;
2459 case 10:
2460 invertedLocalNeighbor = 5;
2461 break;
2462 case 9:
2463 invertedLocalNeighbor = 6;
2464 break;
2465 case 6:
2466 invertedLocalNeighbor = 7;
2467 break;
2468 case 5:
2469 invertedLocalNeighbor = 8;
2470 break;
2471 case 4:
2472 invertedLocalNeighbor = 9;
2473 break;
2474 }
2475}
2476
2477void MultiresTriangulation::getInvertedLocalNeighborAEFB(
2478 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2479 switch(id) {
2480 case 6:
2481 invertedLocalNeighbor = 0;
2482 break;
2483 case 5:
2484 invertedLocalNeighbor = 1;
2485 break;
2486 case 4:
2487 invertedLocalNeighbor = 2;
2488 break;
2489 case 3:
2490 invertedLocalNeighbor = 3;
2491 break;
2492 case 2:
2493 invertedLocalNeighbor = 4;
2494 break;
2495 case 1:
2496 invertedLocalNeighbor = 5;
2497 break;
2498 case 0:
2499 invertedLocalNeighbor = 6;
2500 break;
2501 case 9:
2502 invertedLocalNeighbor = 7;
2503 break;
2504 case 7:
2505 invertedLocalNeighbor = 8;
2506 break;
2507 case 8:
2508 invertedLocalNeighbor = 9;
2509 break;
2510 }
2511}
2512void MultiresTriangulation::getInvertedLocalNeighborGHDC(
2513 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2514 switch(id) {
2515 case 13:
2516 invertedLocalNeighbor = 0;
2517 break;
2518 case 12:
2519 invertedLocalNeighbor = 1;
2520 break;
2521 case 8:
2522 invertedLocalNeighbor = 2;
2523 break;
2524 case 7:
2525 invertedLocalNeighbor = 3;
2526 break;
2527 case 11:
2528 invertedLocalNeighbor = 4;
2529 break;
2530 case 10:
2531 invertedLocalNeighbor = 5;
2532 break;
2533 case 9:
2534 invertedLocalNeighbor = 6;
2535 break;
2536 case 6:
2537 invertedLocalNeighbor = 7;
2538 break;
2539 case 3:
2540 invertedLocalNeighbor = 8;
2541 break;
2542 case 2:
2543 invertedLocalNeighbor = 9;
2544 break;
2545 }
2546}
2547void MultiresTriangulation::getInvertedLocalNeighborAEGC(
2548 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2549 switch(id) {
2550 case 13:
2551 invertedLocalNeighbor = 0;
2552 break;
2553 case 12:
2554 invertedLocalNeighbor = 1;
2555 break;
2556 case 8:
2557 invertedLocalNeighbor = 2;
2558 break;
2559 case 7:
2560 invertedLocalNeighbor = 3;
2561 break;
2562 case 11:
2563 invertedLocalNeighbor = 4;
2564 break;
2565 case 10:
2566 invertedLocalNeighbor = 5;
2567 break;
2568 case 9:
2569 invertedLocalNeighbor = 6;
2570 break;
2571 case 4:
2572 invertedLocalNeighbor = 7;
2573 break;
2574 case 0:
2575 invertedLocalNeighbor = 8;
2576 break;
2577 case 2:
2578 invertedLocalNeighbor = 9;
2579 break;
2580 }
2581}
2582void MultiresTriangulation::getInvertedLocalNeighborBFHD(
2583 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2584 switch(id) {
2585 case 6:
2586 invertedLocalNeighbor = 0;
2587 break;
2588 case 5:
2589 invertedLocalNeighbor = 1;
2590 break;
2591 case 4:
2592 invertedLocalNeighbor = 2;
2593 break;
2594 case 3:
2595 invertedLocalNeighbor = 3;
2596 break;
2597 case 2:
2598 invertedLocalNeighbor = 4;
2599 break;
2600 case 1:
2601 invertedLocalNeighbor = 5;
2602 break;
2603 case 0:
2604 invertedLocalNeighbor = 6;
2605 break;
2606 case 8:
2607 invertedLocalNeighbor = 7;
2608 break;
2609 case 13:
2610 invertedLocalNeighbor = 8;
2611 break;
2612 case 11:
2613 invertedLocalNeighbor = 9;
2614 break;
2615 }
2616}
2617void MultiresTriangulation::getInvertedLocalNeighborAB(
2618 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2619 switch(id) {
2620 case 6:
2621 invertedLocalNeighbor = 0;
2622 break;
2623 case 5:
2624 invertedLocalNeighbor = 1;
2625 break;
2626 case 4:
2627 invertedLocalNeighbor = 2;
2628 break;
2629 case 3:
2630 invertedLocalNeighbor = 3;
2631 break;
2632 case 2:
2633 invertedLocalNeighbor = 4;
2634 break;
2635 case 1:
2636 invertedLocalNeighbor = 5;
2637 break;
2638 case 0:
2639 invertedLocalNeighbor = 6;
2640 break;
2641 case 9:
2642 invertedLocalNeighbor = 7;
2643 break;
2644 }
2645}
2646void MultiresTriangulation::getInvertedLocalNeighborEF(
2647 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2648 switch(id) {
2649 case 8:
2650 invertedLocalNeighbor = 0;
2651 break;
2652 case 6:
2653 invertedLocalNeighbor = 1;
2654 break;
2655 case 5:
2656 invertedLocalNeighbor = 2;
2657 break;
2658 case 4:
2659 invertedLocalNeighbor = 3;
2660 break;
2661 case 7:
2662 invertedLocalNeighbor = 4;
2663 break;
2664 case 9:
2665 invertedLocalNeighbor = 5;
2666 break;
2667 }
2668}
2669void MultiresTriangulation::getInvertedLocalNeighborCD(
2670 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2671 switch(id) {
2672 case 11:
2673 invertedLocalNeighbor = 0;
2674 break;
2675 case 6:
2676 invertedLocalNeighbor = 1;
2677 break;
2678 case 3:
2679 invertedLocalNeighbor = 2;
2680 break;
2681 case 2:
2682 invertedLocalNeighbor = 3;
2683 break;
2684 case 10:
2685 invertedLocalNeighbor = 4;
2686 break;
2687 case 9:
2688 invertedLocalNeighbor = 5;
2689 break;
2690 }
2691}
2692void MultiresTriangulation::getInvertedLocalNeighborGH(
2693 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2694 switch(id) {
2695 case 13:
2696 invertedLocalNeighbor = 0;
2697 break;
2698 case 12:
2699 invertedLocalNeighbor = 1;
2700 break;
2701 case 8:
2702 invertedLocalNeighbor = 2;
2703 break;
2704 case 7:
2705 invertedLocalNeighbor = 3;
2706 break;
2707 case 11:
2708 invertedLocalNeighbor = 4;
2709 break;
2710 case 10:
2711 invertedLocalNeighbor = 5;
2712 break;
2713 case 9:
2714 invertedLocalNeighbor = 6;
2715 break;
2716 case 6:
2717 invertedLocalNeighbor = 7;
2718 break;
2719 }
2720}
2721void MultiresTriangulation::getInvertedLocalNeighborAC(
2722 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2723 switch(id) {
2724 case 11:
2725 invertedLocalNeighbor = 0;
2726 break;
2727 case 10:
2728 invertedLocalNeighbor = 1;
2729 break;
2730 case 9:
2731 invertedLocalNeighbor = 2;
2732 break;
2733 case 2:
2734 invertedLocalNeighbor = 3;
2735 break;
2736 case 4:
2737 invertedLocalNeighbor = 4;
2738 break;
2739 case 0:
2740 invertedLocalNeighbor = 5;
2741 break;
2742 }
2743}
2744void MultiresTriangulation::getInvertedLocalNeighborEG(
2745 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2746 switch(id) {
2747 case 13:
2748 invertedLocalNeighbor = 0;
2749 break;
2750 case 12:
2751 invertedLocalNeighbor = 1;
2752 break;
2753 case 8:
2754 invertedLocalNeighbor = 2;
2755 break;
2756 case 7:
2757 invertedLocalNeighbor = 3;
2758 break;
2759 case 11:
2760 invertedLocalNeighbor = 4;
2761 break;
2762 case 10:
2763 invertedLocalNeighbor = 5;
2764 break;
2765 case 9:
2766 invertedLocalNeighbor = 6;
2767 break;
2768 case 4:
2769 invertedLocalNeighbor = 7;
2770 break;
2771 }
2772}
2773void MultiresTriangulation::getInvertedLocalNeighborAE(
2774 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2775 switch(id) {
2776 case 9:
2777 invertedLocalNeighbor = 0;
2778 break;
2779 case 4:
2780 invertedLocalNeighbor = 1;
2781 break;
2782 case 2:
2783 invertedLocalNeighbor = 2;
2784 break;
2785 case 0:
2786 invertedLocalNeighbor = 3;
2787 break;
2788 case 8:
2789 invertedLocalNeighbor = 4;
2790 break;
2791 case 7:
2792 invertedLocalNeighbor = 5;
2793 break;
2794 }
2795}
2796void MultiresTriangulation::getInvertedLocalNeighborCG(
2797 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2798 switch(id) {
2799 case 13:
2800 invertedLocalNeighbor = 0;
2801 break;
2802 case 12:
2803 invertedLocalNeighbor = 1;
2804 break;
2805 case 8:
2806 invertedLocalNeighbor = 2;
2807 break;
2808 case 7:
2809 invertedLocalNeighbor = 3;
2810 break;
2811 case 11:
2812 invertedLocalNeighbor = 4;
2813 break;
2814 case 10:
2815 invertedLocalNeighbor = 5;
2816 break;
2817 case 9:
2818 invertedLocalNeighbor = 6;
2819 break;
2820 case 2:
2821 invertedLocalNeighbor = 7;
2822 break;
2823 }
2824}
2825void MultiresTriangulation::getInvertedLocalNeighborBD(
2826 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2827 switch(id) {
2828 case 6:
2829 invertedLocalNeighbor = 0;
2830 break;
2831 case 5:
2832 invertedLocalNeighbor = 1;
2833 break;
2834 case 4:
2835 invertedLocalNeighbor = 2;
2836 break;
2837 case 3:
2838 invertedLocalNeighbor = 3;
2839 break;
2840 case 2:
2841 invertedLocalNeighbor = 4;
2842 break;
2843 case 1:
2844 invertedLocalNeighbor = 5;
2845 break;
2846 case 0:
2847 invertedLocalNeighbor = 6;
2848 break;
2849 case 11:
2850 invertedLocalNeighbor = 7;
2851 break;
2852 }
2853}
2854void MultiresTriangulation::getInvertedLocalNeighborFH(
2855 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2856 switch(id) {
2857 case 8:
2858 invertedLocalNeighbor = 0;
2859 break;
2860 case 6:
2861 invertedLocalNeighbor = 1;
2862 break;
2863 case 5:
2864 invertedLocalNeighbor = 2;
2865 break;
2866 case 4:
2867 invertedLocalNeighbor = 3;
2868 break;
2869 case 13:
2870 invertedLocalNeighbor = 4;
2871 break;
2872 case 11:
2873 invertedLocalNeighbor = 5;
2874 break;
2875 }
2876}
2877void MultiresTriangulation::getInvertedLocalNeighborBF(
2878 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2879 switch(id) {
2880 case 6:
2881 invertedLocalNeighbor = 0;
2882 break;
2883 case 5:
2884 invertedLocalNeighbor = 1;
2885 break;
2886 case 4:
2887 invertedLocalNeighbor = 2;
2888 break;
2889 case 3:
2890 invertedLocalNeighbor = 3;
2891 break;
2892 case 2:
2893 invertedLocalNeighbor = 4;
2894 break;
2895 case 1:
2896 invertedLocalNeighbor = 5;
2897 break;
2898 case 0:
2899 invertedLocalNeighbor = 6;
2900 break;
2901 case 8:
2902 invertedLocalNeighbor = 7;
2903 break;
2904 }
2905}
2906void MultiresTriangulation::getInvertedLocalNeighborDH(
2907 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2908 switch(id) {
2909 case 11:
2910 invertedLocalNeighbor = 0;
2911 break;
2912 case 6:
2913 invertedLocalNeighbor = 1;
2914 break;
2915 case 3:
2916 invertedLocalNeighbor = 2;
2917 break;
2918 case 2:
2919 invertedLocalNeighbor = 3;
2920 break;
2921 case 13:
2922 invertedLocalNeighbor = 4;
2923 break;
2924 case 8:
2925 invertedLocalNeighbor = 5;
2926 break;
2927 }
2928}
2929void MultiresTriangulation::getInvertedLocalNeighborA(
2930 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2931 switch(id) {
2932 case 9:
2933 invertedLocalNeighbor = 0;
2934 break;
2935 case 4:
2936 invertedLocalNeighbor = 1;
2937 break;
2938 case 2:
2939 invertedLocalNeighbor = 2;
2940 break;
2941 case 0:
2942 invertedLocalNeighbor = 3;
2943 break;
2944 }
2945}
2946void MultiresTriangulation::getInvertedLocalNeighborE(
2947 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2948 switch(id) {
2949 case 8:
2950 invertedLocalNeighbor = 0;
2951 break;
2952 case 7:
2953 invertedLocalNeighbor = 1;
2954 break;
2955 case 9:
2956 invertedLocalNeighbor = 2;
2957 break;
2958 case 4:
2959 invertedLocalNeighbor = 3;
2960 break;
2961 }
2962}
2963void MultiresTriangulation::getInvertedLocalNeighborC(
2964 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2965 switch(id) {
2966 case 11:
2967 invertedLocalNeighbor = 0;
2968 break;
2969 case 10:
2970 invertedLocalNeighbor = 1;
2971 break;
2972 case 9:
2973 invertedLocalNeighbor = 2;
2974 break;
2975 case 2:
2976 invertedLocalNeighbor = 3;
2977 break;
2978 }
2979}
2980void MultiresTriangulation::getInvertedLocalNeighborG(
2981 SimplexId id, SimplexId &invertedLocalNeighbor) const {
2982 switch(id) {
2983 case 13:
2984 invertedLocalNeighbor = 0;
2985 break;
2986 case 12:
2987 invertedLocalNeighbor = 1;
2988 break;
2989 case 8:
2990 invertedLocalNeighbor = 2;
2991 break;
2992 case 7:
2993 invertedLocalNeighbor = 3;
2994 break;
2995 case 11:
2996 invertedLocalNeighbor = 4;
2997 break;
2998 case 10:
2999 invertedLocalNeighbor = 5;
3000 break;
3001 case 9:
3002 invertedLocalNeighbor = 6;
3003 break;
3004 }
3005}
3006void MultiresTriangulation::getInvertedLocalNeighborB(
3007 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3008 switch(id) {
3009 case 6:
3010 invertedLocalNeighbor = 0;
3011 break;
3012 case 5:
3013 invertedLocalNeighbor = 1;
3014 break;
3015 case 4:
3016 invertedLocalNeighbor = 2;
3017 break;
3018 case 3:
3019 invertedLocalNeighbor = 3;
3020 break;
3021 case 2:
3022 invertedLocalNeighbor = 4;
3023 break;
3024 case 1:
3025 invertedLocalNeighbor = 5;
3026 break;
3027 case 0:
3028 invertedLocalNeighbor = 6;
3029 break;
3030 }
3031}
3032void MultiresTriangulation::getInvertedLocalNeighborF(
3033 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3034 switch(id) {
3035 case 8:
3036 invertedLocalNeighbor = 0;
3037 break;
3038 case 6:
3039 invertedLocalNeighbor = 1;
3040 break;
3041 case 5:
3042 invertedLocalNeighbor = 2;
3043 break;
3044 case 4:
3045 invertedLocalNeighbor = 3;
3046 break;
3047 }
3048}
3049void MultiresTriangulation::getInvertedLocalNeighborD(
3050 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3051 switch(id) {
3052 case 11:
3053 invertedLocalNeighbor = 0;
3054 break;
3055 case 6:
3056 invertedLocalNeighbor = 1;
3057 break;
3058 case 3:
3059 invertedLocalNeighbor = 2;
3060 break;
3061 case 2:
3062 invertedLocalNeighbor = 3;
3063 break;
3064 }
3065}
3066void MultiresTriangulation::getInvertedLocalNeighborH(
3067 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3068 switch(id) {
3069 case 13:
3070 invertedLocalNeighbor = 0;
3071 break;
3072 case 8:
3073 invertedLocalNeighbor = 1;
3074 break;
3075 case 11:
3076 invertedLocalNeighbor = 2;
3077 break;
3078 case 6:
3079 invertedLocalNeighbor = 3;
3080 break;
3081 }
3082}
3083
3084void MultiresTriangulation::vertexToPosition2d(
3085 const SimplexId vertex, std::array<SimplexId, 3> &p) const {
3086 p[0] = vertex % vshift_[0];
3087 p[1] = vertex / vshift_[0];
3088}
3089
3090void MultiresTriangulation::vertexToPosition(
3091 const SimplexId vertex, std::array<SimplexId, 3> &p) const {
3092 p[0] = vertex % vshift_[0];
3093 p[1] = (vertex % vshift_[1]) / vshift_[0];
3094 p[2] = vertex / vshift_[1];
3095}
3096
3097bool MultiresTriangulation::isInTriangulation(const SimplexId vertexId) const {
3098 bool is_in_triangulation = false;
3099 if(dimensionality_ == 1) {
3100 is_in_triangulation = ((vertexId % decimation_) == 0);
3101 } else if(dimensionality_ == 2) {
3102 std::array<SimplexId, 3> p{};
3103 vertexToPosition2d(vertexId, p);
3104 is_in_triangulation
3105 = ((p[0] % decimation_) == 0) and ((p[1] % decimation_) == 0);
3106 } else if(dimensionality_ == 3) {
3107 std::array<SimplexId, 3> p{};
3108 vertexToPosition(vertexId, p);
3109 is_in_triangulation = ((p[0] % decimation_) == 0)
3110 and ((p[1] % decimation_) == 0)
3111 and ((p[2] % decimation_) == 0);
3112 } else {
3113 this->printErr("Unknown dimension " + std::to_string(dimensionality_));
3114 }
3115 return is_in_triangulation;
3116}
3117
3118SimplexId
3119 MultiresTriangulation::localToGlobalVertexId(const SimplexId localId) const {
3120 // ID in the decimated grid TO ID in the highest resolution grid
3121 if(decimation_ == 1)
3122 return localId;
3123 SimplexId pLocal[3];
3124 pLocal[0] = localId % gridDecimatedDimensions_[Di_];
3125 pLocal[1]
3126 = (localId
3127 % (gridDecimatedDimensions_[Di_] * gridDecimatedDimensions_[Dj_]))
3128 / gridDecimatedDimensions_[Di_];
3129 pLocal[2]
3130 = localId / (gridDecimatedDimensions_[Di_] * gridDecimatedDimensions_[Dj_]);
3131
3132 SimplexId p0 = pLocal[0] * decimation_;
3133 SimplexId p1 = pLocal[1] * decimation_;
3134 SimplexId p2 = pLocal[2] * decimation_;
3135
3136 if(nbvoxels_[0] % decimation_
3137 and pLocal[0] == gridDecimatedDimensions_[Di_] - 1) {
3138 p0 -= decimation_ - nbvoxels_[0] % decimation_;
3139 }
3140 if(nbvoxels_[1] % decimation_
3141 and pLocal[1] == gridDecimatedDimensions_[Dj_] - 1) {
3142 p1 -= decimation_ - nbvoxels_[1] % decimation_;
3143 }
3144 if(nbvoxels_[2] % decimation_
3145 and pLocal[2] == gridDecimatedDimensions_[2] - 1) {
3146 p2 -= decimation_ - nbvoxels_[2] % decimation_;
3147 }
3148 SimplexId globalId = p0 + p1 * gridDimensions_[0]
3149 + p2 * gridDimensions_[0] * gridDimensions_[1];
3150
3151 return globalId;
3152}
3153
3154// Gets impacted vertices v0 and v1 when a new point pops up on an edge.
3155// Fills the v0 and v1 array with 3 values:
3156// v[0] : the local neighbor index of v0 for vertexId
3157// v[1] : the global index of v0
3158// v[2] : the local neighbor index of vertexId for v0
3159void MultiresTriangulation::getImpactedVertices(SimplexId vertexId,
3160 SimplexId v0[3],
3161 SimplexId v1[3]) {
3162
3163 SimplexId localNeighborId0 = -1, localNeighborId1 = -1;
3164 if(dimensionality_ == 3) {
3165 std::array<SimplexId, 3> p{};
3166 vertexToPosition(vertexId, p);
3167
3168 if(0 < p[0] and p[0] < nbvoxels_[0]) {
3169 if(0 < p[1] and p[1] < nbvoxels_[1]) {
3170 if(0 < p[2] and p[2] < nbvoxels_[2])
3171 getImpactedVerticesABCDEFGH(p, localNeighborId0,
3172 localNeighborId1); //
3173 else if(p[2] == 0)
3174 getImpactedVerticesABDC(p, localNeighborId0, localNeighborId1); //
3175 else
3176 getImpactedVerticesEFHG(p, localNeighborId0, localNeighborId1); //
3177 } else if(p[1] == 0) {
3178 if(0 < p[2] and p[2] < nbvoxels_[2])
3179 getImpactedVerticesAEFB(p, localNeighborId0, localNeighborId1); //
3180 else if(p[2] == 0)
3181 getImpactedVerticesAB(p, localNeighborId0, localNeighborId1); //
3182 else
3183 getImpactedVerticesEF(p, localNeighborId0, localNeighborId1); //
3184 } else {
3185 if(0 < p[2] and p[2] < nbvoxels_[2])
3186 getImpactedVerticesGHDC(p, localNeighborId0, localNeighborId1); //
3187 else if(p[2] == 0)
3188 getImpactedVerticesCD(p, localNeighborId0, localNeighborId1); //
3189 else
3190 getImpactedVerticesGH(p, localNeighborId0, localNeighborId1); //
3191 }
3192 } else if(p[0] == 0) {
3193 if(0 < p[1] and p[1] < nbvoxels_[1]) {
3194 if(0 < p[2] and p[2] < nbvoxels_[2])
3195 getImpactedVerticesAEGC(p, localNeighborId0, localNeighborId1); //
3196 else if(p[2] == 0)
3197 getImpactedVerticesAC(p, localNeighborId0,
3198 localNeighborId1); //
3199 else
3200 getImpactedVerticesEG(p, localNeighborId0,
3201 localNeighborId1); //
3202 } else if(p[1] == 0) {
3203 if(0 < p[2] and p[2] < nbvoxels_[2])
3204 getImpactedVerticesAE(p, localNeighborId0,
3205 localNeighborId1); //
3206 } else {
3207 if(0 < p[2] and p[2] < nbvoxels_[2])
3208 getImpactedVerticesCG(p, localNeighborId0,
3209 localNeighborId1); //
3210 }
3211 } else {
3212 if(0 < p[1] and p[1] < nbvoxels_[1]) {
3213 if(0 < p[2] and p[2] < nbvoxels_[2])
3214 getImpactedVerticesBFHD(p, localNeighborId0,
3215 localNeighborId1); //
3216 else if(p[2] == 0)
3217 getImpactedVerticesBD(p, localNeighborId0,
3218 localNeighborId1); //
3219 else
3220 getImpactedVerticesFH(p, localNeighborId0,
3221 localNeighborId1); //
3222 } else if(p[1] == 0) {
3223 if(0 < p[2] and p[2] < nbvoxels_[2])
3224 getImpactedVerticesBF(p, localNeighborId0,
3225 localNeighborId1); //
3226 } else {
3227 if(0 < p[2] and p[2] < nbvoxels_[2])
3228 getImpactedVerticesDH(p, localNeighborId0,
3229 localNeighborId1); //
3230 }
3231 }
3232
3233 } else if(dimensionality_ == 2) {
3234 std::array<SimplexId, 3> p{};
3235 vertexToPosition2d(vertexId, p);
3236
3237 if(0 < p[0] and p[0] < nbvoxels_[Di_]) {
3238 if(0 < p[1] and p[1] < nbvoxels_[Dj_]) {
3239 getImpactedVertices2dABCD(p, localNeighborId0,
3240 localNeighborId1); // abcd
3241 } else if(p[1] == 0) {
3242 getImpactedVertices2dAB(p, localNeighborId0,
3243 localNeighborId1); // ab
3244 } else {
3245 getImpactedVertices2dCD(p, localNeighborId0,
3246 localNeighborId1); // cd
3247 }
3248 } else if(p[0] == 0) {
3249 if(0 < p[1] and p[1] < nbvoxels_[Dj_]) {
3250 getImpactedVertices2dAC(p, localNeighborId0,
3251 localNeighborId1); // ac
3252 }
3253 } else {
3254 if(0 < p[1] and p[1] < nbvoxels_[Dj_]) {
3255 getImpactedVertices2dBD(p, localNeighborId0,
3256 localNeighborId1); // bd
3257 }
3258 }
3259 } else {
3260 this->printWrn("getImpactedVertices not implemented for 1D yet");
3261 }
3262 v0[0] = localNeighborId0;
3263 v1[0] = localNeighborId1;
3264 getVertexNeighbor(vertexId, v0[0], v0[1]);
3265 getVertexNeighbor(vertexId, v1[0], v1[1]);
3266 getInvertVertexNeighbor(v0[1], vertexId, v0[2]);
3267 getInvertVertexNeighbor(v1[1], vertexId, v1[2]);
3268}
3269
3270char MultiresTriangulation::localNeighborId(SimplexId neighborId,
3271 SimplexId vertexId) {
3272 this->printMsg("BOUNDARY CASES TO TAKE CARE OF");
3273
3274 SimplexId pLocalNeighbor[3];
3275 pLocalNeighbor[0] = neighborId % gridDecimatedDimensions_[Di_];
3276 pLocalNeighbor[1]
3277 = (neighborId
3278 % (gridDecimatedDimensions_[Di_] * gridDecimatedDimensions_[Dj_]))
3279 / gridDecimatedDimensions_[Di_];
3280 pLocalNeighbor[2]
3281 = neighborId
3282 / (gridDecimatedDimensions_[Di_] * gridDecimatedDimensions_[Dj_]);
3283
3284 SimplexId pLocalVertex[3];
3285 pLocalVertex[0] = vertexId % gridDecimatedDimensions_[Di_];
3286 pLocalVertex[1]
3287 = (vertexId
3288 % (gridDecimatedDimensions_[Di_] * gridDecimatedDimensions_[Dj_]))
3289 / gridDecimatedDimensions_[Di_];
3290 pLocalVertex[2]
3291 = vertexId
3292 / (gridDecimatedDimensions_[Di_] * gridDecimatedDimensions_[Dj_]);
3293
3294 int localNeighbor = -1;
3295
3296 if(dimensionality_ == 2) {
3297 if(pLocalNeighbor[0] == pLocalVertex[0]) {
3298 if(pLocalNeighbor[1] == pLocalVertex[1]) {
3299 this->printErr("localNeighbor: not a neighbor!");
3300 } else if(pLocalNeighbor[1] == pLocalVertex[1] + 1) {
3301 localNeighbor = 4;
3302 } else if(pLocalNeighbor[1] == pLocalVertex[1] - 1) {
3303 localNeighbor = 1;
3304 }
3305 } else if(pLocalNeighbor[0] == pLocalVertex[0] + 1) {
3306 if(pLocalNeighbor[1] == pLocalVertex[1]) {
3307 localNeighbor = 3;
3308 } else if(pLocalNeighbor[1] == pLocalVertex[1] - 1) {
3309 localNeighbor = 2;
3310 } else {
3311 this->printErr("localNeighbor: not a neighbor!");
3312 }
3313 } else if(pLocalNeighbor[0] == pLocalVertex[0] - 1) {
3314 if(pLocalNeighbor[1] == pLocalVertex[1]) {
3315 localNeighbor = 0;
3316 } else if(pLocalNeighbor[1] == pLocalVertex[1] + 1) {
3317 localNeighbor = 5;
3318 } else {
3319 this->printErr("localNeighbor: not a neighbor!");
3320 }
3321 } else {
3322 this->printErr("localNeighbor: not a neighbor!");
3323 }
3324 } else if(dimensionality_ == 3) {
3325 this->printWrn("Local neighbors ids not implemented yet for 3D");
3326 }
3327
3328 return localNeighbor;
3329}
3330
3331int MultiresTriangulation::getInteriorInvertedVertexNeighbor(
3332 SimplexId vertexId,
3333 SimplexId localNeighborId,
3334 SimplexId &invertedVertexId,
3335 SimplexId &invertedLocalNeighborId) const {
3336
3337 if(dimensionality_ == 3) {
3338 std::array<SimplexId, 3> p{};
3339 vertexToPosition(vertexId, p);
3340 SimplexId shiftX = decimation_;
3341 SimplexId shiftY = decimation_;
3342 SimplexId shiftZ = decimation_;
3343
3344 if((nbvoxels_[0] % decimation_) and (p[0] + decimation_ > nbvoxels_[0])) {
3345 shiftX = nbvoxels_[0] % decimation_;
3346 }
3347 if((nbvoxels_[1] % decimation_) and (p[1] + decimation_ > nbvoxels_[1])) {
3348 shiftY = nbvoxels_[1] % decimation_;
3349 }
3350 if((nbvoxels_[2] % decimation_) and (p[2] + decimation_ > nbvoxels_[2])) {
3351 shiftZ = nbvoxels_[2] % decimation_;
3352 }
3353 invertedVertexId = getInvertedVertexNeighborABCDEFGH(
3354 vertexId, localNeighborId, shiftX, shiftY, shiftZ,
3355 invertedLocalNeighborId); //
3356
3357 if(decimation_ < p[0] and p[0] < nbvoxels_[0] - shiftX) {
3358 if(decimation_ < p[1] and p[1] < nbvoxels_[1] - shiftY) {
3359 if(decimation_ < p[2] and p[2] < nbvoxels_[2] - shiftZ) {
3360 // do nothing
3361 return 0;
3362 } else if(p[2] == decimation_)
3363 getInvertedLocalNeighborABDC(vertexId, invertedLocalNeighborId);
3364 // boundary = 0;
3365 else
3366 getInvertedLocalNeighborEFHG(vertexId, invertedLocalNeighborId);
3367 // boundary = 1;
3368 } else if(p[1] == decimation_) {
3369 if(decimation_ < p[2] and p[2] < nbvoxels_[2] - shiftZ)
3370 getInvertedLocalNeighborAEFB(vertexId, invertedLocalNeighborId);
3371 // boundary = 2;
3372 else if(p[2] == decimation_)
3373 getInvertedLocalNeighborAB(vertexId, invertedLocalNeighborId);
3374 // boundary = 6;
3375 else
3376 getInvertedLocalNeighborEF(vertexId, invertedLocalNeighborId);
3377 // boundary = 7;
3378 } else {
3379 if(decimation_ < p[2] and p[2] < nbvoxels_[2] - shiftZ)
3380 getInvertedLocalNeighborGHDC(vertexId, invertedLocalNeighborId);
3381 // boundary=3;
3382 else if(p[2] == decimation_)
3383 getInvertedLocalNeighborCD(vertexId, invertedLocalNeighborId);
3384 // boundary = 8;
3385 else
3386 getInvertedLocalNeighborGH(vertexId, invertedLocalNeighborId);
3387 // boundary = 9;
3388 }
3389 } else if(p[0] == decimation_) {
3390 if(decimation_ < p[1] and p[1] < nbvoxels_[1] - shiftY) {
3391 if(decimation_ < p[2] and p[2] < nbvoxels_[2] - shiftZ)
3392 getInvertedLocalNeighborAEGC(vertexId, invertedLocalNeighborId);
3393 // boundary = 4;
3394 else if(p[2] == decimation_)
3395 getInvertedLocalNeighborAC(vertexId, invertedLocalNeighborId);
3396 // boundary = 10;
3397 else
3398 getInvertedLocalNeighborEG(vertexId, invertedLocalNeighborId);
3399 // boundary = 11;
3400 } else if(p[1] == decimation_) {
3401 if(decimation_ < p[2] and p[2] < nbvoxels_[2] - shiftZ)
3402 getInvertedLocalNeighborAE(vertexId, invertedLocalNeighborId);
3403 // boundary = 12;
3404 else if(p[2] == decimation_)
3405 getInvertedLocalNeighborA(vertexId, invertedLocalNeighborId);
3406 // boundary = 19;
3407 else
3408 getInvertedLocalNeighborE(vertexId, invertedLocalNeighborId);
3409 // boundary = 18;
3410 } else {
3411 if(decimation_ < p[2] and p[2] < nbvoxels_[2] - shiftZ)
3412 // boundary = 13;
3413 getInvertedLocalNeighborCG(vertexId, invertedLocalNeighborId);
3414 else if(p[2] == decimation_)
3415 getInvertedLocalNeighborC(vertexId, invertedLocalNeighborId);
3416 // boundary = 20;
3417 else
3418 getInvertedLocalNeighborG(vertexId, invertedLocalNeighborId);
3419 // boundary = 21;
3420 }
3421 } else {
3422 if(decimation_ < p[1] and p[1] < nbvoxels_[1] - shiftY) {
3423 if(decimation_ < p[2] and p[2] < nbvoxels_[2] - shiftZ)
3424 getInvertedLocalNeighborBFHD(vertexId, invertedLocalNeighborId);
3425 // boundary = 5;
3426 else if(p[2] == decimation_)
3427 getInvertedLocalNeighborBD(vertexId, invertedLocalNeighborId);
3428 // boundary = 14;
3429 else
3430 getInvertedLocalNeighborFH(vertexId, invertedLocalNeighborId);
3431 // boundary = 15;
3432 } else if(p[1] == decimation_) {
3433 if(0 < p[2] and p[2] < nbvoxels_[2] - shiftZ)
3434 getInvertedLocalNeighborBF(vertexId, invertedLocalNeighborId);
3435 // boundary = 16;
3436 else if(p[2] == decimation_)
3437 getInvertedLocalNeighborB(vertexId, invertedLocalNeighborId);
3438 // boundary = 22;
3439 else
3440 getInvertedLocalNeighborF(vertexId, invertedLocalNeighborId);
3441 // boundary = 23;
3442 } else {
3443 if(decimation_ < p[2] and p[2] < nbvoxels_[2] - shiftZ)
3444 getInvertedLocalNeighborDH(vertexId, invertedLocalNeighborId);
3445 // boundary = 17;
3446 else if(p[2] == decimation_)
3447 getInvertedLocalNeighborD(vertexId, invertedLocalNeighborId);
3448 // boundary = 24;
3449 else
3450 getInvertedLocalNeighborH(vertexId, invertedLocalNeighborId);
3451 // boundary = 25;
3452 }
3453 }
3454 return -1;
3455
3456 } else if(dimensionality_ == 2) {
3457 std::array<SimplexId, 3> p{};
3458 vertexToPosition2d(vertexId, p);
3459 SimplexId shiftX = decimation_;
3460 SimplexId shiftY = decimation_;
3461
3462 if((nbvoxels_[Di_] % decimation_)
3463 and (p[0] + decimation_ > nbvoxels_[Di_])) {
3464 shiftX = nbvoxels_[0] % decimation_;
3465 }
3466 if((nbvoxels_[Dj_] % decimation_)
3467 and (p[1] + decimation_ > nbvoxels_[Dj_])) {
3468 shiftY = nbvoxels_[1] % decimation_;
3469 }
3470
3471 invertedVertexId = getInvertedVertexNeighbor2dABCD(
3472 vertexId, localNeighborId, shiftX, shiftY,
3473 invertedLocalNeighborId); // abcd
3474
3475 if(0 < p[0] and p[0] < nbvoxels_[Di_] - shiftX) {
3476 if(decimation_ < p[1] and p[1] < nbvoxels_[Dj_]) {
3477 // nothing to do here
3478 } else if(p[1] == decimation_) {
3479 getInvertedLocalNeighbor2dAB(vertexId, invertedLocalNeighborId);
3480 } else {
3481 getInvertedLocalNeighbor2dCD(vertexId, invertedLocalNeighborId); // cd
3482 }
3483 } else if(p[0] == decimation_) {
3484 if(decimation_ < p[1] and p[1] < nbvoxels_[Dj_] - shiftY) {
3485 getInvertedLocalNeighbor2dAC(vertexId, invertedLocalNeighborId); // ac
3486 } else if(p[1] == decimation_) {
3487 getInvertedLocalNeighbor2dA(vertexId, invertedLocalNeighborId); // a
3488 } else {
3489 getInvertedLocalNeighbor2dC(vertexId, invertedLocalNeighborId); // c
3490 }
3491 } else {
3492 if(decimation_ < p[1] and p[1] < nbvoxels_[Dj_] - shiftY) {
3493 getInvertedLocalNeighbor2dBD(vertexId, invertedLocalNeighborId); // bd
3494 } else if(p[1] == decimation_) {
3495 getInvertedLocalNeighbor2dB(vertexId, invertedLocalNeighborId); // b
3496 } else {
3497 getInvertedLocalNeighbor2dD(vertexId, invertedLocalNeighborId); // d
3498 }
3499 }
3500 } else if(dimensionality_ == 1) {
3501 // ab
3502 this->printWrn("NOT TESTED IN 1D");
3503 if(vertexId > decimation_ and vertexId < nbvoxels_[Di_]) {
3504 if(localNeighborId == decimation_)
3505 invertedVertexId = vertexId + decimation_;
3506 else
3507 invertedVertexId = vertexId - decimation_;
3508 } else if(vertexId == decimation_)
3509 invertedVertexId = vertexId + decimation_;
3510 else
3511 invertedVertexId = vertexId - decimation_;
3512 }
3513 return 0;
3514}
3515
3516SimplexId MultiresTriangulation::getInvertedVertexNeighbor2dABCD(
3517 const SimplexId v,
3518 const int id,
3519 const SimplexId shiftX,
3520 const SimplexId shiftY,
3521 SimplexId &invertedLocalNeighbor) const {
3522 SimplexId invertedVertexId = -1;
3523 switch(id) {
3524 case 0:
3525 invertedLocalNeighbor = 3;
3526 invertedVertexId = v - decimation_;
3527 break;
3528 case 1:
3529 invertedLocalNeighbor = 4;
3530 invertedVertexId = v - gridDimensions_[Di_] * decimation_;
3531 break;
3532 case 2:
3533 invertedLocalNeighbor = 5;
3534 invertedVertexId = v + (shiftX - gridDimensions_[Di_] * decimation_);
3535 break;
3536 case 3:
3537 invertedLocalNeighbor = 0;
3538 invertedVertexId = v + shiftX;
3539 break;
3540 case 4:
3541 invertedLocalNeighbor = 1;
3542 invertedVertexId = v + gridDimensions_[Di_] * shiftY;
3543 break;
3544 case 5:
3545 invertedLocalNeighbor = 2;
3546 invertedVertexId = v + (gridDimensions_[Di_] * shiftY - decimation_);
3547 break;
3548 }
3549 return invertedVertexId;
3550}
3551
3552SimplexId MultiresTriangulation::getInvertedLocalNeighbor2dA(
3553 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3554 switch(id) {
3555 case 0:
3556 invertedLocalNeighbor = 0;
3557 break;
3558 case 1:
3559 invertedLocalNeighbor = 1;
3560 break;
3561 }
3562 return 0;
3563}
3564
3565SimplexId MultiresTriangulation::getInvertedLocalNeighbor2dB(
3566 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3567 switch(id) {
3568 case 3:
3569 invertedLocalNeighbor = 0;
3570 break;
3571 case 1:
3572 invertedLocalNeighbor = 1;
3573 break;
3574 case 2:
3575 invertedLocalNeighbor = 2;
3576 break;
3577 }
3578 return 0;
3579}
3580
3581SimplexId MultiresTriangulation::getInvertedLocalNeighbor2dC(
3582 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3583 switch(id) {
3584 case 0:
3585 invertedLocalNeighbor = 0;
3586 break;
3587 case 4:
3588 invertedLocalNeighbor = 1;
3589 break;
3590 case 5:
3591 invertedLocalNeighbor = 2;
3592 break;
3593 }
3594 return 0;
3595}
3596
3597SimplexId MultiresTriangulation::getInvertedLocalNeighbor2dD(
3598 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3599 switch(id) {
3600 case 3:
3601 invertedLocalNeighbor = 0;
3602 break;
3603 case 4:
3604 invertedLocalNeighbor = 1;
3605 break;
3606 }
3607 return 0;
3608}
3609
3610SimplexId MultiresTriangulation::getInvertedLocalNeighbor2dAB(
3611 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3612 switch(id) {
3613 case 3:
3614 invertedLocalNeighbor = 0;
3615 break;
3616 case 2:
3617 invertedLocalNeighbor = 1;
3618 break;
3619 case 1:
3620 invertedLocalNeighbor = 2;
3621 break;
3622 case 0:
3623 invertedLocalNeighbor = 3;
3624 break;
3625 }
3626 return 0;
3627}
3628
3629SimplexId MultiresTriangulation::getInvertedLocalNeighbor2dAC(
3630 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3631 switch(id) {
3632 case 4:
3633 invertedLocalNeighbor = 0;
3634 break;
3635 case 5:
3636 invertedLocalNeighbor = 1;
3637 break;
3638 case 0:
3639 invertedLocalNeighbor = 2;
3640 break;
3641 case 1:
3642 invertedLocalNeighbor = 3;
3643 break;
3644 }
3645 return 0;
3646}
3647
3648SimplexId MultiresTriangulation::getInvertedLocalNeighbor2dBD(
3649 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3650 switch(id) {
3651 case 2:
3652 invertedLocalNeighbor = 0;
3653 break;
3654 case 1:
3655 invertedLocalNeighbor = 1;
3656 break;
3657 case 4:
3658 invertedLocalNeighbor = 2;
3659 break;
3660 case 3:
3661 invertedLocalNeighbor = 3;
3662 break;
3663 }
3664 return 0;
3665}
3666
3667SimplexId MultiresTriangulation::getInvertedLocalNeighbor2dCD(
3668 SimplexId id, SimplexId &invertedLocalNeighbor) const {
3669 switch(id) {
3670 case 3:
3671 invertedLocalNeighbor = 0;
3672 break;
3673 case 2:
3674 invertedLocalNeighbor = 1;
3675 break;
3676 case 1:
3677 invertedLocalNeighbor = 2;
3678 break;
3679 case 0:
3680 invertedLocalNeighbor = 3;
3681 break;
3682 }
3683 return 0;
3684}
3685
3686void MultiresTriangulation::getImpactedVerticesError(
3687 const int prev_decim, const std::array<SimplexId, 3> &p) const {
3688 this->printErr("THIS SHOULDNT HAPPEN");
3689 this->printErr("previous decimation: " + std::to_string(prev_decim));
3690 this->printErr("position: " + std::to_string(p[0]) + " "
3691 + std::to_string(p[1]) + " " + std::to_string(p[2]));
3692 this->printErr("grid size: " + std::to_string(gridDimensions_[0]) + " "
3693 + std::to_string(gridDimensions_[1]) + " "
3694 + std::to_string(gridDimensions_[2]));
3695}
3696
3697void MultiresTriangulation::getImpactedVerticesABCDEFGH(
3698 std::array<SimplexId, 3> &p,
3699 SimplexId &localNeighborId0,
3700 SimplexId &localNeighborId1) const {
3701
3702 int previous_decimation = pow(2, (decimationLevel_ + 1));
3703 if((p[0] % previous_decimation) and (p[1] % previous_decimation)
3704 and (p[2] % previous_decimation)) {
3705 localNeighborId0 = 1;
3706 localNeighborId1 = 12;
3707
3708 } else if((p[0] % previous_decimation) and (p[1] % previous_decimation)) {
3709 localNeighborId0 = 5;
3710 localNeighborId1 = 10;
3711 } else if((p[0] % previous_decimation) and (p[2] % previous_decimation)) {
3712 localNeighborId0 = 3;
3713 localNeighborId1 = 7;
3714
3715 } else if((p[1] % previous_decimation) and (p[2] % previous_decimation)) {
3716 localNeighborId0 = 0;
3717 localNeighborId1 = 13;
3718
3719 } else if(p[0] % previous_decimation) {
3720 localNeighborId0 = 6;
3721 localNeighborId1 = 9;
3722
3723 } else if(p[1] % previous_decimation) {
3724 localNeighborId0 = 4;
3725 localNeighborId1 = 11;
3726
3727 } else if(p[2] % previous_decimation) {
3728 localNeighborId0 = 2;
3729 localNeighborId1 = 8;
3730 } else {
3731 this->getImpactedVerticesError(previous_decimation, p);
3732 }
3733}
3734
3735void MultiresTriangulation::getImpactedVerticesABDC(
3736 std::array<SimplexId, 3> &p,
3737 SimplexId &localNeighborId0,
3738 SimplexId &localNeighborId1) const {
3739 int previous_decimation = pow(2, (decimationLevel_ + 1));
3740
3741 if((p[0] % previous_decimation) and (p[1] % previous_decimation)) {
3742 localNeighborId0 = 1;
3743 localNeighborId1 = 8;
3744
3745 } else if(p[0] % previous_decimation) {
3746 localNeighborId0 = 0;
3747 localNeighborId1 = 9;
3748
3749 } else if(p[1] % previous_decimation) {
3750 localNeighborId0 = 2;
3751 localNeighborId1 = 7;
3752
3753 } else {
3754 this->getImpactedVerticesError(previous_decimation, p);
3755 }
3756}
3757void MultiresTriangulation::getImpactedVerticesEFHG(
3758 std::array<SimplexId, 3> &p,
3759 SimplexId &localNeighborId0,
3760 SimplexId &localNeighborId1) const {
3761 int previous_decimation = pow(2, (decimationLevel_ + 1));
3762
3763 if((p[0] % previous_decimation) and (p[1] % previous_decimation)) {
3764 localNeighborId0 = 5;
3765 localNeighborId1 = 8;
3766
3767 } else if(p[0] % previous_decimation) {
3768 localNeighborId0 = 7;
3769 localNeighborId1 = 6;
3770
3771 } else if(p[1] % previous_decimation) {
3772 localNeighborId0 = 4;
3773 localNeighborId1 = 9;
3774
3775 } else {
3776 this->getImpactedVerticesError(previous_decimation, p);
3777 }
3778}
3779void MultiresTriangulation::getImpactedVerticesAEGC(
3780 std::array<SimplexId, 3> &p,
3781 SimplexId &localNeighborId0,
3782 SimplexId &localNeighborId1) const {
3783 int previous_decimation = pow(2, (decimationLevel_ + 1));
3784
3785 if((p[1] % previous_decimation) and (p[2] % previous_decimation)) {
3786 localNeighborId0 = 0;
3787 localNeighborId1 = 8;
3788
3789 } else if(p[1] % previous_decimation) {
3790 localNeighborId0 = 4;
3791 localNeighborId1 = 7;
3792
3793 } else if(p[2] % previous_decimation) {
3794 localNeighborId0 = 2;
3795 localNeighborId1 = 9;
3796 } else {
3797 this->getImpactedVerticesError(previous_decimation, p);
3798 }
3799}
3800void MultiresTriangulation::getImpactedVerticesBFHD(
3801 std::array<SimplexId, 3> &p,
3802 SimplexId &localNeighborId0,
3803 SimplexId &localNeighborId1) const {
3804 int previous_decimation = pow(2, (decimationLevel_ + 1));
3805
3806 if((p[1] % previous_decimation) and (p[2] % previous_decimation)) {
3807 localNeighborId0 = 8;
3808 localNeighborId1 = 6;
3809
3810 } else if(p[1] % previous_decimation) {
3811 localNeighborId0 = 9;
3812 localNeighborId1 = 2;
3813
3814 } else if(p[2] % previous_decimation) {
3815 localNeighborId0 = 7;
3816 localNeighborId1 = 4;
3817 } else {
3818 this->getImpactedVerticesError(previous_decimation, p);
3819 }
3820}
3821void MultiresTriangulation::getImpactedVerticesAEFB(
3822 std::array<SimplexId, 3> &p,
3823 SimplexId &localNeighborId0,
3824 SimplexId &localNeighborId1) const {
3825 int previous_decimation = pow(2, (decimationLevel_ + 1));
3826
3827 if((p[0] % previous_decimation) and (p[2] % previous_decimation)) {
3828 localNeighborId0 = 3;
3829 localNeighborId1 = 8;
3830
3831 } else if(p[0] % previous_decimation) {
3832 localNeighborId0 = 0;
3833 localNeighborId1 = 7;
3834
3835 } else if(p[2] % previous_decimation) {
3836 localNeighborId0 = 9;
3837 localNeighborId1 = 4;
3838 } else {
3839 this->getImpactedVerticesError(previous_decimation, p);
3840 }
3841}
3842void MultiresTriangulation::getImpactedVerticesGHDC(
3843 std::array<SimplexId, 3> &p,
3844 SimplexId &localNeighborId0,
3845 SimplexId &localNeighborId1) const {
3846 int previous_decimation = pow(2, (decimationLevel_ + 1));
3847
3848 if((p[0] % previous_decimation) and (p[2] % previous_decimation)) {
3849 localNeighborId0 = 3;
3850 localNeighborId1 = 8;
3851
3852 } else if(p[0] % previous_decimation) {
3853 localNeighborId0 = 7;
3854 localNeighborId1 = 6;
3855
3856 } else if(p[2] % previous_decimation) {
3857 localNeighborId0 = 2;
3858 localNeighborId1 = 9;
3859 } else {
3860 this->getImpactedVerticesError(previous_decimation, p);
3861 }
3862}
3863void MultiresTriangulation::getImpactedVerticesAB(
3864 std::array<SimplexId, 3> &p,
3865 SimplexId &localNeighborId0,
3866 SimplexId &localNeighborId1) const {
3867 int previous_decimation = pow(2, (decimationLevel_ + 1));
3868
3869 if(p[0] % previous_decimation) {
3870 localNeighborId0 = 0;
3871 localNeighborId1 = 7;
3872 } else {
3873 this->getImpactedVerticesError(previous_decimation, p);
3874 }
3875}
3876void MultiresTriangulation::getImpactedVerticesCD(
3877 std::array<SimplexId, 3> &p,
3878 SimplexId &localNeighborId0,
3879 SimplexId &localNeighborId1) const {
3880 int previous_decimation = pow(2, (decimationLevel_ + 1));
3881
3882 if(p[0] % previous_decimation) {
3883 localNeighborId0 = 1;
3884 localNeighborId1 = 5;
3885 } else {
3886 this->getImpactedVerticesError(previous_decimation, p);
3887 }
3888}
3889void MultiresTriangulation::getImpactedVerticesEF(
3890 std::array<SimplexId, 3> &p,
3891 SimplexId &localNeighborId0,
3892 SimplexId &localNeighborId1) const {
3893 int previous_decimation = pow(2, (decimationLevel_ + 1));
3894
3895 if(p[0] % previous_decimation) {
3896 localNeighborId0 = 1;
3897 localNeighborId1 = 5;
3898 } else {
3899 this->getImpactedVerticesError(previous_decimation, p);
3900 }
3901}
3902void MultiresTriangulation::getImpactedVerticesGH(
3903 std::array<SimplexId, 3> &p,
3904 SimplexId &localNeighborId0,
3905 SimplexId &localNeighborId1) const {
3906 int previous_decimation = pow(2, (decimationLevel_ + 1));
3907
3908 if(p[0] % previous_decimation) {
3909 localNeighborId0 = 7;
3910 localNeighborId1 = 6;
3911 } else {
3912 this->getImpactedVerticesError(previous_decimation, p);
3913 }
3914}
3915void MultiresTriangulation::getImpactedVerticesAC(
3916 std::array<SimplexId, 3> &p,
3917 SimplexId &localNeighborId0,
3918 SimplexId &localNeighborId1) const {
3919 int previous_decimation = pow(2, (decimationLevel_ + 1));
3920
3921 if(p[1] % previous_decimation) {
3922 localNeighborId0 = 0;
3923 localNeighborId1 = 4;
3924 } else {
3925 this->getImpactedVerticesError(previous_decimation, p);
3926 }
3927}
3928void MultiresTriangulation::getImpactedVerticesBD(
3929 std::array<SimplexId, 3> &p,
3930 SimplexId &localNeighborId0,
3931 SimplexId &localNeighborId1) const {
3932 int previous_decimation = pow(2, (decimationLevel_ + 1));
3933
3934 if(p[1] % previous_decimation) {
3935 localNeighborId0 = 2;
3936 localNeighborId1 = 7;
3937 } else {
3938 this->getImpactedVerticesError(previous_decimation, p);
3939 }
3940}
3941void MultiresTriangulation::getImpactedVerticesEG(
3942 std::array<SimplexId, 3> &p,
3943 SimplexId &localNeighborId0,
3944 SimplexId &localNeighborId1) const {
3945 int previous_decimation = pow(2, (decimationLevel_ + 1));
3946
3947 if(p[1] % previous_decimation) {
3948 localNeighborId0 = 4;
3949 localNeighborId1 = 7;
3950 } else {
3951 this->getImpactedVerticesError(previous_decimation, p);
3952 }
3953}
3954void MultiresTriangulation::getImpactedVerticesFH(
3955 std::array<SimplexId, 3> &p,
3956 SimplexId &localNeighborId0,
3957 SimplexId &localNeighborId1) const {
3958 int previous_decimation = pow(2, (decimationLevel_ + 1));
3959
3960 if(p[1] % previous_decimation) {
3961 localNeighborId0 = 5;
3962 localNeighborId1 = 3;
3963 } else {
3964 this->getImpactedVerticesError(previous_decimation, p);
3965 }
3966}
3967void MultiresTriangulation::getImpactedVerticesAE(
3968 std::array<SimplexId, 3> &p,
3969 SimplexId &localNeighborId0,
3970 SimplexId &localNeighborId1) const {
3971 int previous_decimation = pow(2, (decimationLevel_ + 1));
3972
3973 if(p[2] % previous_decimation) {
3974 localNeighborId0 = 4;
3975 localNeighborId1 = 2;
3976 } else {
3977 this->getImpactedVerticesError(previous_decimation, p);
3978 }
3979}
3980
3981void MultiresTriangulation::getImpactedVerticesBF(
3982 std::array<SimplexId, 3> &p,
3983 SimplexId &localNeighborId0,
3984 SimplexId &localNeighborId1) const {
3985 int previous_decimation = pow(2, (decimationLevel_ + 1));
3986
3987 if(p[2] % previous_decimation) {
3988 localNeighborId0 = 7;
3989 localNeighborId1 = 4;
3990 } else {
3991 this->getImpactedVerticesError(previous_decimation, p);
3992 }
3993}
3994
3995void MultiresTriangulation::getImpactedVerticesCG(
3996 std::array<SimplexId, 3> &p,
3997 SimplexId &localNeighborId0,
3998 SimplexId &localNeighborId1) const {
3999 int previous_decimation = pow(2, (decimationLevel_ + 1));
4000
4001 if(p[2] % previous_decimation) {
4002 localNeighborId0 = 2;
4003 localNeighborId1 = 7;
4004 } else {
4005 this->getImpactedVerticesError(previous_decimation, p);
4006 }
4007}
4008
4009void MultiresTriangulation::getImpactedVerticesDH(
4010 std::array<SimplexId, 3> &p,
4011 SimplexId &localNeighborId0,
4012 SimplexId &localNeighborId1) const {
4013 int previous_decimation = pow(2, (decimationLevel_ + 1));
4014
4015 if(p[2] % previous_decimation) {
4016 localNeighborId0 = 5;
4017 localNeighborId1 = 3;
4018 } else {
4019 this->getImpactedVerticesError(previous_decimation, p);
4020 }
4021}
4022
4023void MultiresTriangulation::getImpactedVertices2dABCD(
4024 std::array<SimplexId, 3> &p,
4025 SimplexId &localNeighborId0,
4026 SimplexId &localNeighborId1) const {
4027 int previous_decimation = pow(2, (decimationLevel_ + 1));
4028
4029 if((p[0] % previous_decimation) and (p[1] % previous_decimation)) {
4030 localNeighborId0 = 2;
4031 localNeighborId1 = 5;
4032
4033 } else if(p[0] % previous_decimation) {
4034 localNeighborId0 = 0;
4035 localNeighborId1 = 3;
4036
4037 } else if(p[1] % previous_decimation) {
4038 localNeighborId0 = 1;
4039 localNeighborId1 = 4;
4040 } else {
4041 this->getImpactedVerticesError(previous_decimation, p);
4042 }
4043}
4044
4045void MultiresTriangulation::getImpactedVertices2dAB(
4046 std::array<SimplexId, 3> &p,
4047 SimplexId &localNeighborId0,
4048 SimplexId &localNeighborId1) const {
4049 int previous_decimation = pow(2, (decimationLevel_ + 1));
4050
4051 if(p[0] % previous_decimation) {
4052 localNeighborId0 = 0;
4053 localNeighborId1 = 3;
4054 } else {
4055 this->getImpactedVerticesError(previous_decimation, p);
4056 }
4057}
4058
4059void MultiresTriangulation::getImpactedVertices2dCD(
4060 std::array<SimplexId, 3> &p,
4061 SimplexId &localNeighborId0,
4062 SimplexId &localNeighborId1) const {
4063 int previous_decimation = pow(2, (decimationLevel_ + 1));
4064
4065 if(p[0] % previous_decimation) {
4066 localNeighborId0 = 0;
4067 localNeighborId1 = 3;
4068 } else {
4069 this->getImpactedVerticesError(previous_decimation, p);
4070 }
4071}
4072
4073void MultiresTriangulation::getImpactedVertices2dAC(
4074 std::array<SimplexId, 3> &p,
4075 SimplexId &localNeighborId0,
4076 SimplexId &localNeighborId1) const {
4077 int previous_decimation = pow(2, (decimationLevel_ + 1));
4078
4079 if(p[1] % previous_decimation) {
4080 localNeighborId0 = 0;
4081 localNeighborId1 = 3;
4082 } else {
4083 this->getImpactedVerticesError(previous_decimation, p);
4084 }
4085}
4086void MultiresTriangulation::getImpactedVertices2dBD(
4087 std::array<SimplexId, 3> &p,
4088 SimplexId &localNeighborId0,
4089 SimplexId &localNeighborId1) const {
4090 int previous_decimation = pow(2, (decimationLevel_ + 1));
4091
4092 if(p[1] % previous_decimation) {
4093 localNeighborId0 = 2;
4094 localNeighborId1 = 1;
4095 } else {
4096 this->getImpactedVerticesError(previous_decimation, p);
4097 }
4098}
4099
4100std::vector<SimplexId>
4101 MultiresTriangulation::getExtendedStar(const SimplexId &vertexId) const {
4102
4103 std::vector<SimplexId> result;
4104 if(dimensionality_ == 3) {
4105 std::array<SimplexId, 3> p{};
4106 vertexToPosition(vertexId, p);
4107 SimplexId shiftX = decimation_;
4108 SimplexId shiftY = decimation_;
4109 SimplexId shiftZ = decimation_;
4110
4111 if((nbvoxels_[0] % decimation_) and (p[0] + decimation_ > nbvoxels_[0])) {
4112 shiftX = nbvoxels_[0] % decimation_;
4113 }
4114 if((nbvoxels_[1] % decimation_) and (p[1] + decimation_ > nbvoxels_[1])) {
4115 shiftY = nbvoxels_[1] % decimation_;
4116 }
4117 if((nbvoxels_[2] % decimation_) and (p[2] + decimation_ > nbvoxels_[2])) {
4118 shiftZ = nbvoxels_[2] % decimation_;
4119 }
4120
4121 std::vector<SimplexId> vi;
4122 vi.push_back(-decimation_);
4123 vi.push_back(0);
4124 vi.push_back(shiftX);
4125
4126 std::vector<SimplexId> vj;
4127 vj.push_back(-decimation_);
4128 vj.push_back(0);
4129 vj.push_back(shiftY);
4130
4131 std::vector<SimplexId> vk;
4132 vk.push_back(-decimation_);
4133 vk.push_back(0);
4134 vk.push_back(shiftZ);
4135
4136 if(p[0] == 0)
4137 vi.erase(vi.begin() + 0);
4138 if(p[0] == nbvoxels_[0])
4139 vi.erase(vi.begin() + 2);
4140 if(p[1] == 0)
4141 vj.erase(vj.begin() + 0);
4142 if(p[1] == nbvoxels_[1])
4143 vj.erase(vj.begin() + 2);
4144 if(p[2] == 0)
4145 vk.erase(vk.begin() + 0);
4146 if(p[2] == nbvoxels_[2])
4147 vk.erase(vk.begin() + 2);
4148
4149 for(SimplexId i : vi) {
4150 for(SimplexId j : vj) {
4151 for(SimplexId k : vk) {
4152 if(i != 0 or j != 0 or k != 0)
4153 result.push_back(vertexId + i + j * vshift_[0] + k * vshift_[1]);
4154 }
4155 }
4156 }
4157
4158 } else if(dimensionality_ == 2) {
4159 std::array<SimplexId, 3> p{};
4160 vertexToPosition2d(vertexId, p);
4161 SimplexId shiftX = decimation_;
4162 SimplexId shiftY = decimation_;
4163
4164 if((nbvoxels_[Di_] % decimation_)
4165 and (p[0] + decimation_ > nbvoxels_[Di_])) {
4166 shiftX = nbvoxels_[0] % decimation_;
4167 }
4168 if((nbvoxels_[Dj_] % decimation_)
4169 and (p[1] + decimation_ > nbvoxels_[Dj_])) {
4170 shiftY = nbvoxels_[1] % decimation_;
4171 }
4172
4173 std::vector<SimplexId> vi;
4174 vi.push_back(-decimation_);
4175 vi.push_back(0);
4176 vi.push_back(shiftX);
4177
4178 std::vector<SimplexId> vj;
4179 vj.push_back(-decimation_);
4180 vj.push_back(0);
4181 vj.push_back(shiftY);
4182
4183 if(p[0] == 0)
4184 vi.erase(vi.begin() + 0);
4185 if(p[0] == nbvoxels_[0])
4186 vi.erase(vi.begin() + 2);
4187 if(p[1] == 0)
4188 vj.erase(vj.begin() + 0);
4189 if(p[1] == nbvoxels_[1])
4190 vj.erase(vj.begin() + 2);
4191
4192 for(SimplexId i : vi) {
4193 for(SimplexId j : vj) {
4194 if(i != 0 or j != 0) {
4195 result.push_back(vertexId + i + j * vshift_[Di_]);
4196 }
4197 }
4198 }
4199 }
4200 return result;
4201}
4202
4203int MultiresTriangulation::getVertexBoundaryIndex(
4204 const SimplexId vertexId) const {
4205
4206 if(dimensionality_ == 3) {
4207 std::array<SimplexId, 3> p{};
4208 vertexToPosition(vertexId, p);
4209
4210 if(0 < p[0] and p[0] < nbvoxels_[0]) {
4211 if(0 < p[1] and p[1] < nbvoxels_[1]) {
4212 if(0 < p[2] and p[2] < nbvoxels_[2])
4213 return 0;
4214 else if(p[2] == 0)
4215 return 1;
4216 else
4217 return 2;
4218 } else if(p[1] == 0) {
4219 if(0 < p[2] and p[2] < nbvoxels_[2])
4220 return 3;
4221 else if(p[2] == 0)
4222 return 4;
4223 else
4224 return 5;
4225 } else {
4226 if(0 < p[2] and p[2] < nbvoxels_[2])
4227 return 6;
4228 else if(p[2] == 0)
4229 return 7;
4230 else
4231 return 8;
4232 }
4233 } else if(p[0] == 0) {
4234 if(0 < p[1] and p[1] < nbvoxels_[1]) {
4235 if(0 < p[2] and p[2] < nbvoxels_[2])
4236 return 9;
4237 else if(p[2] == 0)
4238 return 10;
4239 else
4240 return 11;
4241 } else if(p[1] == 0) {
4242 if(0 < p[2] and p[2] < nbvoxels_[2])
4243 return 12;
4244 else if(p[2] == 0)
4245 return 13;
4246 else
4247 return 14;
4248 } else {
4249 if(0 < p[2] and p[2] < nbvoxels_[2])
4250 return 15;
4251 else if(p[2] == 0)
4252 return 16;
4253 else
4254 return 17;
4255 }
4256 } else {
4257 if(0 < p[1] and p[1] < nbvoxels_[1]) {
4258 if(0 < p[2] and p[2] < nbvoxels_[2])
4259 return 18;
4260 else if(p[2] == 0)
4261 return 19;
4262 else
4263 return 20;
4264 } else if(p[1] == 0) {
4265 if(0 < p[2] and p[2] < nbvoxels_[2])
4266 return 21;
4267 else if(p[2] == 0)
4268 return 22;
4269 else
4270 return 23;
4271 } else {
4272 if(0 < p[2] and p[2] < nbvoxels_[2])
4273 return 24;
4274 else if(p[2] == 0)
4275 return 25;
4276 else
4277 return 26;
4278 }
4279 }
4280
4281 } else if(dimensionality_ == 2) {
4282 std::array<SimplexId, 3> p{};
4283 vertexToPosition2d(vertexId, p);
4284
4285 if(0 < p[0] and p[0] < nbvoxels_[Di_]) {
4286 if(0 < p[1] and p[1] < nbvoxels_[Dj_]) {
4287 return 0;
4288 } else if(p[1] == 0) {
4289 return 1;
4290 } else {
4291 return 2;
4292 }
4293 } else if(p[0] == 0) {
4294 if(0 < p[1] and p[1] < nbvoxels_[Dj_]) {
4295 return 3;
4296 } else if(p[1] == 0) {
4297 return 4;
4298 } else {
4299 return 5;
4300 }
4301 } else {
4302 if(0 < p[1] and p[1] < nbvoxels_[Dj_]) {
4303 return 6;
4304 } else if(p[1] == 0) {
4305 return 7;
4306 } else {
4307 return 8;
4308 }
4309 }
4310 }
4311 return -1;
4312}
4313
4314void MultiresTriangulation::findBoundaryRepresentatives(
4315 std::vector<SimplexId> &boundaryRepresentatives) {
4316 int currentDecimationLevel = decimationLevel_;
4317 setDecimationLevel(0);
4318 if(dimensionality_ == 3) { // here gridDimension[i] > 1 for all i =0,1,2
4319 boundaryRepresentatives.resize(27, -1);
4320 // ADD THE CORNERS
4321 boundaryRepresentatives[13] = 0; // 0 0 0
4322 boundaryRepresentatives[22] = gridDimensions_[0] - 1; // Nx 0 0
4323 boundaryRepresentatives[16]
4324 = vshift_[0] * (gridDimensions_[1] - 1); // 0 Ny 0
4325 boundaryRepresentatives[14]
4326 = vshift_[1] * (gridDimensions_[2] - 1); // 0 0 Nz
4327 boundaryRepresentatives[25]
4328 = gridDimensions_[0] - 1
4329 + vshift_[0] * (gridDimensions_[1] - 1); // Nx Ny 0
4330 boundaryRepresentatives[23]
4331 = gridDimensions_[0] - 1
4332 + vshift_[1] * (gridDimensions_[2] - 1); // Nx 0 Nz
4333 boundaryRepresentatives[17]
4334 = vshift_[0] * (gridDimensions_[1] - 1)
4335 + vshift_[1] * (gridDimensions_[2] - 1); // 0 Ny Nz
4336 boundaryRepresentatives[26]
4337 = gridDimensions_[0] - 1 + vshift_[0] * (gridDimensions_[1] - 1)
4338 + vshift_[1] * (gridDimensions_[2] - 1); // Nx Ny Nz
4339
4340 if(gridDimensions_[0] > 2) {
4341 boundaryRepresentatives[4] = 1; // 1 0 0
4342 boundaryRepresentatives[7]
4343 = 1 + vshift_[0] * (gridDimensions_[1] - 1); // 1 Ny 0
4344 boundaryRepresentatives[5]
4345 = 1 + vshift_[1] * (gridDimensions_[2] - 1); // 1 0 Nz
4346 boundaryRepresentatives[8]
4347 = 1 + vshift_[0] * (gridDimensions_[1] - 1)
4348 + vshift_[1] * (gridDimensions_[2] - 1); // 1 Ny Nz
4349 }
4350 if(gridDimensions_[1] > 2) {
4351 boundaryRepresentatives[10] = vshift_[0]; // 0 1 0
4352 boundaryRepresentatives[19]
4353 = gridDimensions_[0] - 1 + vshift_[0]; // Nx 1 0
4354 boundaryRepresentatives[11]
4355 = vshift_[0] + vshift_[1] * (gridDimensions_[2] - 1); // 0 1 Nz
4356 boundaryRepresentatives[20]
4357 = gridDimensions_[0] - 1 + vshift_[0]
4358 + vshift_[1] * (gridDimensions_[2] - 1); // Nx 1 Nz
4359 }
4360 if(gridDimensions_[2] > 2) {
4361 boundaryRepresentatives[12] = vshift_[1]; // 0 0 1
4362 boundaryRepresentatives[15]
4363 = vshift_[0] * (gridDimensions_[1] - 1) + vshift_[1]; // 0 Ny 1
4364 boundaryRepresentatives[21]
4365 = (gridDimensions_[0] - 1) + vshift_[1]; // Nx 0 1
4366 boundaryRepresentatives[24] = (gridDimensions_[0] - 1)
4367 + vshift_[0] * (gridDimensions_[1] - 1)
4368 + vshift_[1]; // Nx Ny 1
4369 }
4370 if(gridDimensions_[0] > 2 and gridDimensions_[1] > 2) {
4371 boundaryRepresentatives[1] = 1 + vshift_[0]; // 1 1 0
4372 boundaryRepresentatives[2]
4373 = 1 + vshift_[0] + vshift_[1] * (gridDimensions_[2] - 1); // 1 1 Nz
4374 }
4375 if(gridDimensions_[0] > 2 and gridDimensions_[2] > 2) {
4376 boundaryRepresentatives[3] = 1 + vshift_[1]; // 1 0 1
4377 boundaryRepresentatives[6]
4378 = 1 + vshift_[0] * (gridDimensions_[1] - 1) + vshift_[1]; // 1 Ny 1
4379 }
4380 if(gridDimensions_[1] > 2 and gridDimensions_[2] > 2) {
4381 boundaryRepresentatives[9] = vshift_[0] + vshift_[1]; // 0 1 1
4382 boundaryRepresentatives[18]
4383 = (gridDimensions_[0] - 1) + vshift_[0] + vshift_[1]; // Nx 1 1
4384 }
4385 if(gridDimensions_[0] > 2 and gridDimensions_[1] > 2
4386 and gridDimensions_[2] > 2) {
4387 boundaryRepresentatives[0] = 1 + vshift_[0] + vshift_[1];
4388 }
4389 } else if(dimensionality_ == 2) {
4390 boundaryRepresentatives.resize(9, -1);
4391 boundaryRepresentatives[4] = 0; // 0 0
4392 boundaryRepresentatives[5] = vshift_[0] * (gridDimensions_[1] - 1); // 0 Ny
4393 boundaryRepresentatives[7] = gridDimensions_[0] - 1; // Nx 0
4394 boundaryRepresentatives[8]
4395 = (gridDimensions_[0] - 1)
4396 + vshift_[0] * (gridDimensions_[1] - 1); // Nx Ny
4397
4398 boundaryRepresentatives[1] = 1; // 1 0
4399 boundaryRepresentatives[2]
4400 = 1 + vshift_[0] * (gridDimensions_[1] - 1); // 1 Ny
4401 boundaryRepresentatives[3] = vshift_[0]; // 0 1
4402 boundaryRepresentatives[6] = (gridDimensions_[0] - 1) + vshift_[0]; // Nx 1
4403
4404 boundaryRepresentatives[0] = 1 + vshift_[0]; // 1 1
4405 }
4406 setDecimationLevel(currentDecimationLevel);
4407}
4408
4409bool ttk::MultiresTriangulation::isBoundaryImpacted(SimplexId v) const {
4410 bool ret = false;
4411 if(dimensionality_ == 3) {
4412 std::array<SimplexId, 3> p{};
4413 vertexToPosition(v, p);
4414 if((nbvoxels_[0] % decimation_) and (p[0] + decimation_ > nbvoxels_[0])) {
4415 ret = true;
4416 }
4417 if((nbvoxels_[1] % decimation_) and (p[1] + decimation_ > nbvoxels_[1])) {
4418 ret = true;
4419 }
4420 if((nbvoxels_[2] % decimation_) and (p[2] + decimation_ > nbvoxels_[2])) {
4421 ret = true;
4422 }
4423 }
4424 return ret;
4425}
4426
4427void ttk::MultiresTriangulation::computeCoarsestDecimationLevel() {
4428 int maxDim = std::max(
4429 gridDimensions_[0], std::max(gridDimensions_[1], gridDimensions_[2]));
4430 int dl = 0;
4431 while(maxDim > 2) {
4432 maxDim
4433 = ((maxDim - 1) % 2) ? ((maxDim - 1) / 2 + 2) : ((maxDim - 1) / 2 + 1);
4434 dl++;
4435 }
4436 coarsestDL_ = dl;
4437}
4438
4439int ttk::MultiresTriangulation::RL_to_DL(int rl) {
4440 if(rl < 0) {
4441 return 0;
4442 } else {
4443 return std::max(coarsestDL_ - rl, 0);
4444 }
4445}
4446
4447int ttk::MultiresTriangulation::DL_to_RL(int dl) {
4448 return coarsestDL_ - dl;
4449}
ttk::Debug::debugLevel_
int debugLevel_
Definition: Debug.h:379
ttk::Debug::printWrn
int printWrn(const std::string &msg, const debug::LineMode &lineMode=debug::LineMode::NEW, std::ostream &stream=std::cerr) const
Definition: Debug.h:159
ttk::Debug::setDebugMsgPrefix
void setDebugMsgPrefix(const std::string &prefix)
Definition: Debug.h:364
ttk::Debug::printMsg
int printMsg(const std::string &msg, const debug::Priority &priority=debug::Priority::INFO, const debug::LineMode &lineMode=debug::LineMode::NEW, std::ostream &stream=std::cout) const
Definition: Debug.h:118
ttk::Debug::printErr
int printErr(const std::string &msg, const debug::LineMode &lineMode=debug::LineMode::NEW, std::ostream &stream=std::cerr) const
Definition: Debug.h:149
ttk::MultiresTriangulation::getInvertedLocalNeighborFH
void getInvertedLocalNeighborFH(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2854
ttk::MultiresTriangulation::getImpactedVerticesFH
void getImpactedVerticesFH(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3954
ttk::MultiresTriangulation::getInvertVertexNeighborG
SimplexId getInvertVertexNeighborG(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1183
ttk::MultiresTriangulation::getImpactedVerticesABCDEFGH
void getImpactedVerticesABCDEFGH(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3697
ttk::MultiresTriangulation::vertexToPosition
void vertexToPosition(const SimplexId vertex, std::array< SimplexId, 3 > &p) const
Definition: MultiresTriangulation.cpp:3090
ttk::MultiresTriangulation::getInvertedVertexNeighborABCDEFGH
SimplexId getInvertedVertexNeighborABCDEFGH(const SimplexId v, const int id, const SimplexId shiftX, const SimplexId shiftY, const SimplexId shiftZ, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2330
ttk::MultiresTriangulation::getInvertedLocalNeighborAE
void getInvertedLocalNeighborAE(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2773
ttk::MultiresTriangulation::getInvertedLocalNeighbor2dA
SimplexId getInvertedLocalNeighbor2dA(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3552
ttk::MultiresTriangulation::getImpactedVertices
void getImpactedVertices(SimplexId vertexId, SimplexId v0[3], SimplexId v1[3])
Definition: MultiresTriangulation.cpp:3159
ttk::MultiresTriangulation::getImpactedVerticesAEGC
void getImpactedVerticesAEGC(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3779
ttk::MultiresTriangulation::getInvertVertexNeighborE
SimplexId getInvertVertexNeighborE(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1107
ttk::MultiresTriangulation::getInvertVertexNeighbor2dA
SimplexId getInvertVertexNeighbor2dA(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:572
ttk::MultiresTriangulation::getInvertVertexNeighborBFHD
SimplexId getInvertVertexNeighborBFHD(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2059
ttk::MultiresTriangulation::getInvertedLocalNeighborABDC
void getInvertedLocalNeighborABDC(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2405
ttk::MultiresTriangulation::getVertexNeighborG
SimplexId getVertexNeighborG(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1209
ttk::MultiresTriangulation::getInvertedLocalNeighborAB
void getInvertedLocalNeighborAB(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2617
ttk::MultiresTriangulation::getVertexNeighborC
SimplexId getVertexNeighborC(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1050
ttk::MultiresTriangulation::getInvertedVertexNeighbor2dABCD
SimplexId getInvertedVertexNeighbor2dABCD(const SimplexId v, const int id, const SimplexId shiftX, const SimplexId shiftY, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3516
ttk::MultiresTriangulation::getInvertVertexNeighborAEGC
SimplexId getInvertVertexNeighborAEGC(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1995
ttk::MultiresTriangulation::getInvertedLocalNeighborBFHD
void getInvertedLocalNeighborBFHD(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2582
ttk::MultiresTriangulation::getInvertedLocalNeighborDH
void getInvertedLocalNeighborDH(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2906
ttk::MultiresTriangulation::getInvertVertexNeighborAB
SimplexId getInvertVertexNeighborAB(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1272
ttk::MultiresTriangulation::getInvertVertexNeighborGH
SimplexId getInvertVertexNeighborGH(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1417
ttk::MultiresTriangulation::getVertexNeighborABCDEFGH
SimplexId getVertexNeighborABCDEFGH(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2287
ttk::MultiresTriangulation::getInvertVertexNeighbor2dBD
SimplexId getInvertVertexNeighbor2dBD(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:800
ttk::MultiresTriangulation::getInvertVertexNeighborCG
SimplexId getInvertVertexNeighborCG(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1771
ttk::MultiresTriangulation::getInvertVertexNeighbor2dAB
SimplexId getInvertVertexNeighbor2dAB(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:692
ttk::MultiresTriangulation::getInvertVertexNeighbor2dB
SimplexId getInvertVertexNeighbor2dB(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:600
ttk::MultiresTriangulation::getInvertedLocalNeighborA
void getInvertedLocalNeighborA(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2929
ttk::MultiresTriangulation::getVertexNeighbor2dAB
SimplexId getVertexNeighbor2dAB(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:710
ttk::MultiresTriangulation::getImpactedVerticesAEFB
void getImpactedVerticesAEFB(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3821
ttk::MultiresTriangulation::isInTriangulation
bool isInTriangulation(const SimplexId vertexId) const
Definition: MultiresTriangulation.cpp:3097
ttk::MultiresTriangulation::getInvertVertexNeighborEF
SimplexId getInvertVertexNeighborEF(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1372
ttk::MultiresTriangulation::getInvertedLocalNeighbor2dAB
SimplexId getInvertedLocalNeighbor2dAB(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3610
ttk::MultiresTriangulation::getInvertedLocalNeighborC
void getInvertedLocalNeighborC(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2963
ttk::MultiresTriangulation::getVertexNeighborE
SimplexId getVertexNeighborE(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1126
ttk::MultiresTriangulation::getImpactedVerticesGHDC
void getImpactedVerticesGHDC(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3842
ttk::MultiresTriangulation::preconditionVerticesInternal
int preconditionVerticesInternal()
Precondition vertices.
Definition: MultiresTriangulation.cpp:17
ttk::MultiresTriangulation::getInteriorInvertedVertexNeighbor
int getInteriorInvertedVertexNeighbor(SimplexId, SimplexId, SimplexId &, SimplexId &) const
Definition: MultiresTriangulation.cpp:3331
ttk::MultiresTriangulation::getInvertVertexNeighbor2dAC
SimplexId getInvertVertexNeighbor2dAC(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:764
ttk::MultiresTriangulation::localToGlobalVertexId
SimplexId localToGlobalVertexId(const SimplexId localId) const
Definition: MultiresTriangulation.cpp:3119
ttk::MultiresTriangulation::getImpactedVerticesEG
void getImpactedVerticesEG(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3941
ttk::MultiresTriangulation::getInvertedLocalNeighborEG
void getInvertedLocalNeighborEG(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2744
ttk::MultiresTriangulation::getImpactedVerticesBD
void getImpactedVerticesBD(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3928
ttk::MultiresTriangulation::getInvertedLocalNeighborCD
void getInvertedLocalNeighborCD(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2669
ttk::MultiresTriangulation::getInvertedLocalNeighborCG
void getInvertedLocalNeighborCG(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2796
ttk::MultiresTriangulation::getVertexNeighborBF
SimplexId getVertexNeighborBF(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1744
ttk::MultiresTriangulation::getImpactedVerticesCG
void getImpactedVerticesCG(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3995
ttk::MultiresTriangulation::getImpactedVerticesGH
void getImpactedVerticesGH(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3902
ttk::MultiresTriangulation::getInvertVertexNeighborD
SimplexId getInvertVertexNeighborD(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1069
ttk::MultiresTriangulation::getImpactedVerticesDH
void getImpactedVerticesDH(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:4009
ttk::MultiresTriangulation::getVertexNeighborFH
SimplexId getVertexNeighborFH(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1648
ttk::MultiresTriangulation::getVertexBoundaryIndex
int getVertexBoundaryIndex(const SimplexId) const
Definition: MultiresTriangulation.cpp:4203
ttk::MultiresTriangulation::getInvertedLocalNeighborEF
void getInvertedLocalNeighborEF(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2646
ttk::MultiresTriangulation::getVertexNeighborAC
SimplexId getVertexNeighborAC(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1495
ttk::MultiresTriangulation::getImpactedVerticesEFHG
void getImpactedVerticesEFHG(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3757
ttk::MultiresTriangulation::getInvertVertexNeighborBF
SimplexId getInvertVertexNeighborBF(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1716
ttk::MultiresTriangulation::getVertexNeighbor2dC
SimplexId getVertexNeighbor2dC(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:648
ttk::MultiresTriangulation::getImpactedVerticesError
void getImpactedVerticesError(const int prev_decim, const std::array< SimplexId, 3 > &p) const
Definition: MultiresTriangulation.cpp:3686
ttk::MultiresTriangulation::getExtendedStar
std::vector< SimplexId > getExtendedStar(const SimplexId &vertexId) const
Definition: MultiresTriangulation.cpp:4101
ttk::MultiresTriangulation::getInvertedLocalNeighbor2dAC
SimplexId getInvertedLocalNeighbor2dAC(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3629
ttk::MultiresTriangulation::getImpactedVerticesBFHD
void getImpactedVerticesBFHD(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3800
ttk::MultiresTriangulation::getInvertVertexNeighborABCDEFGH
SimplexId getInvertVertexNeighborABCDEFGH(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2248
ttk::MultiresTriangulation::getVertexNeighborAB
SimplexId getVertexNeighborAB(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1300
ttk::MultiresTriangulation::getInvertVertexNeighborEG
SimplexId getInvertVertexNeighborEG(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1572
ttk::MultiresTriangulation::getInvertedLocalNeighborH
void getInvertedLocalNeighborH(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3066
ttk::MultiresTriangulation::getInvertVertexNeighborC
SimplexId getInvertVertexNeighborC(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1031
ttk::MultiresTriangulation::getInvertedLocalNeighbor2dD
SimplexId getInvertedLocalNeighbor2dD(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3597
ttk::MultiresTriangulation::getVertexNeighborAEGC
SimplexId getVertexNeighborAEGC(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2026
ttk::MultiresTriangulation::getVertexNeighbor2dB
SimplexId getVertexNeighbor2dB(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:616
ttk::MultiresTriangulation::getVertexNeighborEG
SimplexId getVertexNeighborEG(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1599
ttk::MultiresTriangulation::getVertexNeighbor2dA
SimplexId getVertexNeighbor2dA(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:586
ttk::MultiresTriangulation::getInvertedLocalNeighborGHDC
void getInvertedLocalNeighborGHDC(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2512
ttk::MultiresTriangulation::getVertexNeighborCG
SimplexId getVertexNeighborCG(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1798
ttk::MultiresTriangulation::getVertexNeighborH
SimplexId getVertexNeighborH(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1253
ttk::MultiresTriangulation::getVertexNeighborAE
SimplexId getVertexNeighborAE(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1693
ttk::MultiresTriangulation::getInvertedLocalNeighbor2dC
SimplexId getInvertedLocalNeighbor2dC(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3581
ttk::MultiresTriangulation::getInvertVertexNeighborGHDC
SimplexId getInvertVertexNeighborGHDC(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2186
ttk::MultiresTriangulation::getInvertedLocalNeighborGH
void getInvertedLocalNeighborGH(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2692
ttk::MultiresTriangulation::getInvertVertexNeighborFH
SimplexId getInvertVertexNeighborFH(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1626
ttk::MultiresTriangulation::getVertexNeighborD
SimplexId getVertexNeighborD(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1088
ttk::MultiresTriangulation::getInvertedLocalNeighborAEFB
void getInvertedLocalNeighborAEFB(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2477
ttk::MultiresTriangulation::getInvertedLocalNeighborF
void getInvertedLocalNeighborF(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3032
ttk::MultiresTriangulation::vertexToPosition2d
void vertexToPosition2d(const SimplexId vertex, std::array< SimplexId, 3 > &p) const
Definition: MultiresTriangulation.cpp:3084
ttk::MultiresTriangulation::getInvertVertexNeighborBD
SimplexId getInvertVertexNeighborBD(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1518
ttk::MultiresTriangulation::getImpactedVerticesAC
void getImpactedVerticesAC(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3915
ttk::MultiresTriangulation::isBoundaryImpacted
bool isBoundaryImpacted(SimplexId) const
Definition: MultiresTriangulation.cpp:4409
ttk::MultiresTriangulation::getInvertedLocalNeighborB
void getInvertedLocalNeighborB(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3006
ttk::MultiresTriangulation::getInvertVertexNeighborABDC
SimplexId getInvertVertexNeighborABDC(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1870
ttk::MultiresTriangulation::getVertexNeighborBD
SimplexId getVertexNeighborBD(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1545
ttk::MultiresTriangulation::getInvertVertexNeighborAE
SimplexId getInvertVertexNeighborAE(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1671
ttk::MultiresTriangulation::setDecimationLevel
void setDecimationLevel(int decimationLevel)
Definition: MultiresTriangulation.h:882
ttk::MultiresTriangulation::getVertexNeighbor
int getVertexNeighbor(const SimplexId &vertexId, const int &localNeighborId, SimplexId &neighborId) const
Definition: MultiresTriangulation.cpp:403
ttk::MultiresTriangulation::getVertexNeighbor2dAC
SimplexId getVertexNeighbor2dAC(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:782
ttk::MultiresTriangulation::getVertexNeighborAEFB
SimplexId getVertexNeighborAEFB(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2155
ttk::MultiresTriangulation::getImpactedVertices2dCD
void getImpactedVertices2dCD(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:4059
ttk::MultiresTriangulation::getInvertVertexNeighbor2dCD
SimplexId getInvertVertexNeighbor2dCD(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:728
ttk::MultiresTriangulation::getInvertVertexNeighbor2dD
SimplexId getInvertVertexNeighbor2dD(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:664
ttk::MultiresTriangulation::getVertexNeighborDH
SimplexId getVertexNeighborDH(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1847
ttk::MultiresTriangulation::getVertexNeighborA
SimplexId getVertexNeighborA(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:961
ttk::MultiresTriangulation::localNeighborId
char localNeighborId(SimplexId neighborId, SimplexId vertexId)
Definition: MultiresTriangulation.cpp:3270
ttk::MultiresTriangulation::getInvertedLocalNeighborBF
void getInvertedLocalNeighborBF(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2877
ttk::MultiresTriangulation::getInvertedLocalNeighbor2dBD
SimplexId getInvertedLocalNeighbor2dBD(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3648
ttk::MultiresTriangulation::getInvertedLocalNeighborEFHG
void getInvertedLocalNeighborEFHG(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2441
ttk::MultiresTriangulation::getInvertVertexNeighborF
SimplexId getInvertVertexNeighborF(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1145
ttk::MultiresTriangulation::getInvertVertexNeighborA
SimplexId getInvertVertexNeighborA(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:942
ttk::MultiresTriangulation::getVertexNeighborGHDC
SimplexId getVertexNeighborGHDC(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2217
ttk::MultiresTriangulation::getInvertedLocalNeighbor2dB
SimplexId getInvertedLocalNeighbor2dB(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3565
ttk::MultiresTriangulation::getImpactedVerticesABDC
void getImpactedVerticesABDC(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3735
ttk::MultiresTriangulation::getVertexNeighborGH
SimplexId getVertexNeighborGH(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1445
ttk::MultiresTriangulation::getInvertedLocalNeighbor2dCD
SimplexId getInvertedLocalNeighbor2dCD(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3667
ttk::MultiresTriangulation::getVertexNeighbor2dCD
SimplexId getVertexNeighbor2dCD(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:746
ttk::MultiresTriangulation::getVertexNeighborB
SimplexId getVertexNeighborB(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1006
ttk::MultiresTriangulation::getImpactedVerticesCD
void getImpactedVerticesCD(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3876
ttk::MultiresTriangulation::getInvertVertexNeighborAEFB
SimplexId getInvertVertexNeighborAEFB(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2124
ttk::MultiresTriangulation::getVertexNeighborEF
SimplexId getVertexNeighborEF(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1394
ttk::MultiresTriangulation::getInvertVertexNeighbor2dC
SimplexId getInvertVertexNeighbor2dC(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:632
ttk::MultiresTriangulation::getImpactedVertices2dAC
void getImpactedVertices2dAC(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:4073
ttk::MultiresTriangulation::getVertexNeighborBFHD
SimplexId getVertexNeighborBFHD(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:2091
ttk::MultiresTriangulation::getInvertedLocalNeighborBD
void getInvertedLocalNeighborBD(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2825
ttk::MultiresTriangulation::getVertexNeighborNumber
SimplexId getVertexNeighborNumber(const SimplexId &vertexId) const
Definition: MultiresTriangulation.cpp:880
ttk::MultiresTriangulation::getInvertedLocalNeighborG
void getInvertedLocalNeighborG(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2980
ttk::MultiresTriangulation::getInvertVertexNeighborDH
SimplexId getInvertVertexNeighborDH(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1825
ttk::MultiresTriangulation::getInvertedLocalNeighborD
void getInvertedLocalNeighborD(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:3049
ttk::MultiresTriangulation::getImpactedVertices2dAB
void getImpactedVertices2dAB(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:4045
ttk::MultiresTriangulation::getInvertVertexNeighborEFHG
SimplexId getInvertVertexNeighborEFHG(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1933
ttk::MultiresTriangulation::getInvertVertexNeighborCD
SimplexId getInvertVertexNeighborCD(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1327
ttk::MultiresTriangulation::getVertexNeighbor2dABCD
SimplexId getVertexNeighbor2dABCD(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:858
ttk::MultiresTriangulation::getInvertVertexNeighborB
SimplexId getInvertVertexNeighborB(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:980
ttk::MultiresTriangulation::getImpactedVerticesAB
void getImpactedVerticesAB(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3863
ttk::MultiresTriangulation::getImpactedVertices2dABCD
void getImpactedVertices2dABCD(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:4023
ttk::MultiresTriangulation::getVertexNeighborF
SimplexId getVertexNeighborF(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1164
ttk::MultiresTriangulation::findBoundaryRepresentatives
void findBoundaryRepresentatives(std::vector< SimplexId > &boundaryRepresentatives)
Definition: MultiresTriangulation.cpp:4314
ttk::MultiresTriangulation::getVertexNeighborCD
SimplexId getVertexNeighborCD(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1349
ttk::MultiresTriangulation::getInvertVertexNeighbor
int getInvertVertexNeighbor(const SimplexId &vertexId, const SimplexId &neighborId, SimplexId &localNeighborId) const
Definition: MultiresTriangulation.cpp:200
ttk::MultiresTriangulation::getVertexNeighbor2dBD
SimplexId getVertexNeighbor2dBD(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:818
ttk::MultiresTriangulation::getVertexNeighborABDC
SimplexId getVertexNeighborABDC(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1902
ttk::MultiresTriangulation::getInvertedLocalNeighborE
void getInvertedLocalNeighborE(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2946
ttk::MultiresTriangulation::getImpactedVertices2dBD
void getImpactedVertices2dBD(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:4086
ttk::MultiresTriangulation::getInvertVertexNeighborAC
SimplexId getInvertVertexNeighborAC(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1473
ttk::MultiresTriangulation::getImpactedVerticesEF
void getImpactedVerticesEF(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3889
ttk::MultiresTriangulation::getVertexNeighbor2dD
SimplexId getVertexNeighbor2dD(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:678
ttk::MultiresTriangulation::getVertexNeighborEFHG
SimplexId getVertexNeighborEFHG(const SimplexId v, const int id, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1964
ttk::MultiresTriangulation::getInvertedLocalNeighborAEGC
void getInvertedLocalNeighborAEGC(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2547
ttk::MultiresTriangulation::getInvertVertexNeighbor2dABCD
SimplexId getInvertVertexNeighbor2dABCD(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY) const
Definition: MultiresTriangulation.cpp:836
ttk::MultiresTriangulation::getInvertedLocalNeighborAC
void getInvertedLocalNeighborAC(SimplexId id, SimplexId &invertedLocalNeighbor) const
Definition: MultiresTriangulation.cpp:2721
ttk::MultiresTriangulation::getImpactedVerticesBF
void getImpactedVerticesBF(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3981
ttk::MultiresTriangulation::getImpactedVerticesAE
void getImpactedVerticesAE(std::array< SimplexId, 3 > &p, SimplexId &localNeighborId0, SimplexId &localNeighborId1) const
Definition: MultiresTriangulation.cpp:3967
ttk::MultiresTriangulation::getInvertVertexNeighborH
SimplexId getInvertVertexNeighborH(const SimplexId v, const SimplexId neighborId, SimplexId shiftX, SimplexId shiftY, SimplexId shiftZ) const
Definition: MultiresTriangulation.cpp:1234
ttk::SimplexId
int SimplexId
Identifier type for simplices of any dimension.
Definition: DataTypes.h:22
Generated on Tue Jul 11 2023 08:20:54 for TTK by doxygen 1.9.6