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
112
113
114
115
116
117
118
119
120
|
/**************************************************************************
* *
* Regina - A Normal Surface Theory Calculator *
* Computational Engine *
* *
* Copyright (c) 1999-2008, 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. *
* *
* 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, write to the Free *
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
* MA 02110-1301, USA. *
* *
**************************************************************************/
/* end stub */
#include "triangulation/nedge.h"
#include "triangulation/nface.h"
namespace regina {
const int NFace::TRIANGLE = 1;
const int NFace::SCARF = 2;
const int NFace::PARACHUTE = 3;
const int NFace::CONE = 4;
const int NFace::MOBIUS = 5;
const int NFace::HORN = 6;
const int NFace::DUNCEHAT = 7;
const int NFace::L31 = 8;
int NFace::getType() {
if (type)
return type;
subtype = -1;
// Determine the face type.
NVertex* v[3];
NEdge* e[3];
int i;
for (i = 0; i < 3; i++) {
v[i] = getVertex(i);
e[i] = getEdge(i);
}
if (e[0] != e[1] && e[1] != e[2] && e[2] != e[0]) {
// Three distinct edges.
if (v[0] == v[1] && v[1] == v[2])
return (type = PARACHUTE);
for (i = 0; i < 3; i++)
if (v[(i+1)%3] == v[(i+2)%3]) {
subtype = i;
return (type = SCARF);
}
return (type = TRIANGLE);
}
if (e[0] == e[1] && e[1] == e[2]) {
// All edges identified.
if (getEdgeMapping(0).sign() == getEdgeMapping(1).sign() &&
getEdgeMapping(1).sign() == getEdgeMapping(2).sign())
return (type = L31);
for (i = 0; i < 3; i++)
if (getEdgeMapping((i+1)%3).sign() ==
getEdgeMapping((i+2)%3).sign()) {
subtype = i;
return (type = DUNCEHAT);
}
}
// Two edges identified.
for (i = 0; i < 3; i++)
if (e[(i+1)%3] == e[(i+2)%3]) {
subtype = i;
if (getEdgeMapping((i+1)%3).sign() ==
getEdgeMapping((i+2)%3).sign())
return (type = MOBIUS);
if (v[0] == v[1] && v[1] == v[2])
return (type = HORN);
return (type = CONE);
}
// We should never reach this point.
return 0;
}
NEdge* NFace::getEdge(int edge) const {
NPerm p = embeddings[0]->getVertices();
return embeddings[0]->getTetrahedron()->getEdge(
edgeNumber[p[(edge + 1) % 3]][p[(edge + 2) % 3]]);
}
NPerm NFace::getEdgeMapping(int edge) const {
NPerm facePerm = embeddings[0]->getVertices();
// Maps face -> tetrahedron
NPerm edgePerm = embeddings[0]->getTetrahedron()->getEdgeMapping(
edgeNumber[facePerm[(edge + 1) % 3]][facePerm[(edge + 2) % 3]]);
// Maps edge -> tetrahedron
return NPerm(facePerm.preImageOf(edgePerm[0]),
facePerm.preImageOf(edgePerm[1]), edge, 3);
}
} // namespace regina
|
