1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
/**************************************************************************
* *
* Regina - A Normal Surface Theory Calculator *
* Computational Engine *
* *
* Copyright (c) 1999-2025, Ben Burton *
* For further details contact Ben Burton (bab@debian.org). *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
* published by the Free Software Foundation; either version 2 of the *
* License, or (at your option) any later version. *
* *
* As an exception, when this program is distributed through (i) the *
* App Store by Apple Inc.; (ii) the Mac App Store by Apple Inc.; or *
* (iii) Google Play by Google Inc., then that store may impose any *
* digital rights management, device limits and/or redistribution *
* restrictions that are required by its terms of service. *
* *
* This program is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
* *
**************************************************************************/
#include "subcomplex/satblock.h"
#include <sstream>
namespace regina {
SatBlock::SatBlock(const SatBlock& cloneMe) :
nAnnuli_(cloneMe.nAnnuli_),
annulus_(new SatAnnulus[cloneMe.nAnnuli_]),
twistedBoundary_(cloneMe.twistedBoundary_),
adjBlock_(new SatBlock*[cloneMe.nAnnuli_]),
adjAnnulus_(new size_t[cloneMe.nAnnuli_]),
adjReflected_(new bool[cloneMe.nAnnuli_]),
adjBackwards_(new bool[cloneMe.nAnnuli_]) {
for (unsigned i = 0; i < nAnnuli_; i++) {
annulus_[i] = cloneMe.annulus_[i];
adjBlock_[i] = cloneMe.adjBlock_[i];
adjAnnulus_[i] = cloneMe.adjAnnulus_[i];
adjReflected_[i] = cloneMe.adjReflected_[i];
adjBackwards_[i] = cloneMe.adjBackwards_[i];
}
}
void SatBlock::transform(const Triangulation<3>& originalTri,
const Isomorphism<3>& iso, const Triangulation<3>& newTri) {
for (unsigned i = 0; i < nAnnuli_; i++)
annulus_[i].transform(originalTri, iso, newTri);
}
std::tuple<const SatBlock*, size_t, bool, bool>
SatBlock::nextBoundaryAnnulus(size_t thisAnnulus, bool followPrev)
const {
// Don't worry about testing the precondition (this annulus has no
// adjacency) -- things won't break even if it's false.
const SatBlock* nextBlock = this;
size_t nextAnnulus;
if (followPrev)
nextAnnulus = (thisAnnulus == 0 ? nAnnuli_ - 1 : thisAnnulus - 1);
else
nextAnnulus = (thisAnnulus + 1 == nAnnuli_ ? 0 : thisAnnulus + 1);
bool refVert = false;
bool refHoriz = false;
while (nextBlock->hasAdjacentBlock(nextAnnulus)) {
// Push through to the next block...
if (nextBlock->adjReflected_[nextAnnulus])
refVert = ! refVert;
if (! nextBlock->adjBackwards_[nextAnnulus])
refHoriz = ! refHoriz;
size_t tmp = nextBlock->adjAnnulus_[nextAnnulus];
nextBlock = nextBlock->adjBlock_[nextAnnulus];
nextAnnulus = tmp;
// ... and step to the previous/next annulus around.
if (refHoriz == followPrev) {
nextAnnulus = (nextAnnulus + 1 == nextBlock->nAnnuli_ ? 0 :
nextAnnulus + 1);
} else {
nextAnnulus = (nextAnnulus == 0 ? nextBlock->nAnnuli_ - 1 :
nextAnnulus - 1);
}
}
return { nextBlock, nextAnnulus, refVert, refHoriz };
}
std::string SatBlock::abbr(bool tex) const {
std::ostringstream s;
writeAbbr(s, tex);
return s.str();
}
bool SatBlock::isBad(const Tetrahedron<3>* t, const TetList& list) {
if (list.find(t) != list.end())
return true;
return false;
}
} // namespace regina
|
