Ich möchte regelmäßige Polyederdaten. Es scheint einfach zu machen, aber wenn man bedenkt, wie man es macht, scheint es nicht einfach zu sein. Ich habe versucht, ein Programm zu erstellen, aber es fühlt sich an wie ein schlammiges Seil.
Erstellt Daten für ein reguläres Polyeder auf einer Kugel mit einem Scheitelpunkt mit dem Radius 1.
Die einzigen Tabellen für reguläre Polyeder ($ M
Der erste Scheitelpunkt sei $ \ left (0,0,1 \ right) $ und soll die Kanten der Tangentenflächen erzeugen.
Suchen Sie den nächsten Scheitelpunkt $ \ left (sin \ \ theta, \ theta, cos \ \ theta \ right) $ und drehen Sie die x-y-Ebene, um ihn in "die Anzahl der Tangentenflächen" zu unterteilen.
Dann ist der dritte $ \ left (sin \ \ theta \ cos \ \ phi, \ sin \ \ theta \ cos \ \ phi, \ cos \ \ theta \ right) $.
$ \ phi $ kann aus "der Anzahl der sich berührenden Gesichter ($ F $)" erhalten werden.
$ \ Theta $ kann aus 3 Scheitelpunkten berechnet werden, muss jedoch vor dem Erstellen der Scheitelpunkte berechnet werden.
\begin{eqnarray}
\phi & = & \frac{2\pi}{F} \\
P_1 & = & (0, 0, 1) \\
P_2 & = & (sin \theta, 0, cos \theta) \\
P_3 & = & (sin \theta\ cos \phi, sin \theta\ sin \phi, cos \theta) \\
L_1 & = & P_2 - P_1 \\
L_2 & = & P_3 - P_1 \\
\frac{L_1 \cdot L_2}{|L_1||L_2|} & = & cos \frac{ \pi \left( N-2 \right) }{N} \\
cos \theta & = & \left( cos^2 \frac{\pi}{F} - cos \frac{ \pi \left( N-2 \right) }{N} \right)\ csc^2 \frac{\pi}{F} \\
\end{eqnarray}
Um $ cos \ \ theta $ aus $ N, F $ zu finden. Wenn Sie die drei Eckpunkte finden, ist die erste "Gesichtsnormale" das äußere Produkt
N_1 = \frac{L_1 \times L_2}{ \left| L_1 \times L_2 \right|}
Wenn daher diese Normallinie um einen Winkel von $ \ phi $ um die x-y-Ebene gedreht wird, kann $ F $ von "Flächennormallinien" erhalten werden.
Da der Abstand von der Mitte des regulären Polyeders zur Fläche das innere Produkt des ersten Scheitelpunkts $ P_1 $ und der Normalen der ersten Fläche $ N_1 $ ist.
\begin{eqnarray}
P_1 & = & \left( 0, 0, 1 \right) \\
N_1 & = & \left( n_x\ , n_y\ , n_z \right) \\
n_z & = & P_1 \cdot N_1 = D \\
\end{eqnarray}
Fragen Sie als. Sie können den Wert von $ \ left (n_z = D \ right) $ für die Normalen verwenden, um einen Gesichtsausdruck zu erstellen.
Da drei oder mehr Normalen erhalten wurden, ist die Beziehung zwischen zwei benachbarten Normalen $ N_1, N_2 $ und der benachbarten Normalen $ N_3 $
\begin{eqnarray}
n_x & = & N_1 \\
n_y & = & \frac{ n_x \times N_2 }{ \left| n_x \times N_2 \right| } \\
n_z & = & \frac{ n_x \times n_y }{ \left| n_x \times n_y \right| } \\
X_{cos} & = & n_x \cdot N_3 \\
Y_{cos} & = & n_y \cdot N_3 \\
Z_{cos} & = & n_z \cdot N_3 \\
\end{eqnarray}
Kann sein. Aus den beiden benachbarten Normalen $ N_1, N_2 $ wird nun eine neue Normalität $ N_3 $ erstellt.
\begin{eqnarray}
n_x & = & N_1 \\
n_y & = & \frac{ n_x \times N_2 }{ \left| n_x \times N_2 \right| } \\
n_z & = & \frac{ n_y \times n_y }{ \left| n_x \times n_y \right| } \\
N_3 & = & X_{cos}\ n_x + Y_{cos}\ n_y + Z_{cos}\ n_z \\
\end{eqnarray}
Wird benötigt bei.
Suchen Sie durch Aufrunden der beiden Normalen nach einer neuen Normalen, beseitigen Sie Doppelarbeit, und wenn sie nicht zunimmt, wird der Zweck erreicht.
Der Schnittpunkt zweier benachbarter Normalen $ N_1, N_2 $ und der Ebene, die durch den Abstand $ D $ vom Zentrum (Ursprung) des regulären Polyeders zur Ebene gebildet wird, verläuft durch die "Seiten des regulären Polyeders". Der Schnittpunkt dieses Schnittpunkts und einer Kugel mit einem Radius von $ 1 $ ist der gewünschte Scheitelpunkt.
Die Richtung des Schnittpunkts ist das äußere Produkt der beiden Normalen
L_V = \frac{ N_1 \times N_2 }{ \left| N_1 \times N_2 \right| }
Es kann von gefunden werden. Da der Basispunkt des Schnittpunkts der "Mittelpunkt der Seite" sein soll, setzen wir die gerade Linie $ L_C $, die zwischen den beiden Normalen verläuft, und den Schnittpunkt $ L_P $ der Oberfläche.
\begin{eqnarray}
L_C & = & \frac{ N_1 + N_2 }{ \left| N_1 + N_2 \right| } \\
cos\ \theta_{L} & = & L_C \cdot N_1 = L_C \cdot N_2 \\
L_P & = & \frac{D}{cos\ \theta_{L}} L_C
\end{eqnarray}
Ich werde danach fragen.
cos\ \theta_P = \left| L_P \right|
Der Abstand von $ L_P $ zum Apex beträgt also
L_D = sin\ \theta_P = \sqrt{1 - cos^2\theta_P} = \sqrt{1 - \left( L_P \cdot L_P \right) }
Es wird sein. Dies ist in "Finden der Normalen der Oberfläche"
L_D = \frac{ \left| L_1 \right| }{2}
Du kannst auch. (Das Programm bleibt das erstere)
Da die gewünschten Eckpunkte gleichmäßig von der Mitte der Seite beabstandet sind
V = L_P \pm L_D L_V
Wird sein.
Finden Sie wie bei "alle Normalen" die Seiten und Eckpunkte, indem Sie die beiden Normalen runden.
Danach werden die Daten vorbereitet und vervollständigt.
import math
flag_debug = False
flag_verbose = False
flag_rotate = False
paren_c = ('{', '}')
paren_vec = ('(', ')')
paren_out = ('(', ')')
paren_list = ('(', ')')
#Regelmäßige Polyederdaten
#Anzahl der Gesichter: (Anzahl der Gesichtswinkel,Anzahl der Kontaktpunkte der Eckpunkte)
RP_TAB = {
+4: (3, 3),
+6: (4, 3),
+8: (3, 4),
12: (5, 3),
20: (3, 5),
}
FP_THR = 1.0 / 1024 #Zulässiger Bereich des Berechnungsfehlers zum Zeitpunkt der Beurteilung
def cos_sin(r): return (math.cos(r), math.sin(r))
def vec_dump(v): return (paren_vec[0] + (' %+8.6f, %+8.6f, %+8.6f ' % tuple(v)) + paren_vec[1])
def vec_add(a, b): return (a[0] + b[0], a[1] + b[1], a[2] + b[2])
def vec_sub(a, b): return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
def vec_mul(a, b): return (a[0] * b, a[1] * b, a[2] * b)
def vec_inner(a, b): #Innenprodukt
return (a[0] * b[0] + a[1] * b[1] + a[2] * b[2])
def vec_cross(a, b): #Äußeres Produkt
c1 = a[1] * b[2] - a[2] * b[1]
c2 = a[2] * b[0] - a[0] * b[2]
c3 = a[0] * b[1] - a[1] * b[0]
return (c1, c2, c3)
def vec_cross_normalize(a, b): #Äußeres Produkt und Normalisierung
return vec_normalize(vec_cross(a, b))
def vec_normalize(a): #Normalisierung
return vec_mul(a, 1.0 / math.sqrt(vec_inner(a, a)))
# X-In Y-Ebene drehen
def vec_rot_xy(v, r):
c, s = cos_sin(r)
x = v[0] * c - v[1] * s
y = v[0] * s + v[1] * c
return (x, y, v[2])
#Vektordaten hinzufügen(Vermeiden Sie Doppelarbeit)
def vec_append(l, v):
r = len(l)
for n in range(r):
c = vec_inner(v, l[n])
if c >= (1.0 - FP_THR):
return n
continue
l.append(v)
return r
#Erstellung regulärer Polyederdaten
def make(F): # F =Anzahl der Gesichter
P = RP_TAB[F][0] # P =Anzahl der Gesichtswinkel
K = RP_TAB[F][1] # K =Anzahl der Kontaktpunkte der Eckpunkte
E = F * P / 2 # E =Anzahl der Seiten
V = E - F + 2 # V =Anzahl der Eckpunkte
if flag_verbose:
print('Anzahl der Gesichter: %d' % F)
print('Anzahl der Seiten: %d' % E)
print('Anzahl der Eckpunkte: %d' % V)
pass
#Eine Runde mit der Anzahl der Kontaktflächen der Eckpunkte
rK1 = math.pi / K # rK1 = π / K
rK2 = math.pi * 2 / K # rK2 = 2π / K
cK1, sK1 = cos_sin(rK1)
cK2, sK2 = cos_sin(rK2)
#Elemente im Zusammenhang mit Polygonen
rP = math.pi * (P - 2) / P # rP = π(P-2) / P
cP, sP = cos_sin(rP)
#Elemente in Bezug auf Seiten und Mittelwinkel
cR = (cK1 * cK1 - cP) / (sK1 * sK1)
sR = math.sqrt(1 - cR * cR)
#Finden Sie die Normalen der drei Gesichter
p1 = (0, 0, 1)
p2 = (sR, 0, cR)
p3 = (sR * cK2, sR * sK2, cR)
l1 = vec_sub(p2, p1)
l2 = vec_sub(p3, p1)
n0 = vec_cross_normalize(l1, l2)
n1 = vec_rot_xy(n0, rK2 * 1)
n2 = vec_rot_xy(n0, rK2 * 2)
cD = n0[2] # cD =Abstand von der Mitte zur Ebene
sD = math.sqrt(1 - cD * cD)
#Suchen Sie das Winkelelement benachbarter Flächen
ny = vec_cross_normalize(n0, n1)
nz = vec_cross_normalize(n0, ny)
N_cos = vec_inner(n0, n1)
X_cos = vec_inner(n0, n2)
Y_cos = vec_inner(ny, n2)
Z_cos = vec_inner(nz, n2)
#Korrigieren Sie die Ausrichtung des regulären Polyeders
if P != 3 and flag_rotate:
n0 = (0, 0, 1)
ny = (cP, -sP, 0)
nz = (sP, cP, 0)
ax = vec_mul(n0, X_cos)
ay = vec_mul(ny, Y_cos)
az = vec_mul(nz, Z_cos)
n1 = vec_add(vec_add(ax, ay), az)
pass
#Finde die Normalen aller Gesichter
nl = [n0, n1]
loop = True
while loop:
CF = len(nl)
for s in range(CF-1):
for e in range(s+1,CF):
n0 = nl[s]
n1 = nl[e]
#Sind n0 und n1 benachbarte Flächen??
nc = vec_inner(n0, n1)
if abs(N_cos - nc) >= FP_THR:
continue
#Benachbarte Flächen von n0 bis n1 hinzugefügt
ny = vec_cross_normalize(n0, n1)
nz = vec_cross_normalize(n0, ny)
ax = vec_mul(n0, X_cos)
ay = vec_mul(ny, Y_cos)
az = vec_mul(nz, Z_cos)
na = vec_add(vec_add(ax, ay), az)
vec_append(nl, na)
continue
continue
loop = (CF != len(nl)) #Es ist vorbei, wenn es nicht zunimmt
continue
#Finde alle Seiten und Eckpunkte
CF = len(nl)
vl = []
fl = {}
for n in range(CF): fl[n] = []
for s in range(CF):
for e in range(s+1, CF):
n0 = nl[s]
n1 = nl[e]
#Sind n0 und n1 benachbarte Flächen??
nc = vec_inner(n0, n1)
if abs(N_cos - nc) >= FP_THR: continue
#Finden Sie den Schnittpunkt von n0 und n1(Gehen Sie durch die Mitte der Seite)
lc = vec_normalize(vec_add(n0, n1))
lv = vec_cross_normalize(n0, n1)
lp = vec_mul(lc, cD / vec_inner(n0, lc))
#Finden Sie den Schnittpunkt des Schnittpunkts und einer Kugel mit einem Radius von 1
t0 = math.sqrt(1 - vec_inner(lp, lp))
q1 = vec_add(vec_mul(lv, -t0), lp)
q2 = vec_add(vec_mul(lv, +t0), lp)
#Fügen Sie Scheitelpunkt- und Kantendaten hinzu
i1 = vec_append(vl, q1)
i2 = vec_append(vl, q2)
fl[s].append((i1, i2))
fl[e].append((i1, i2))
continue
continue
#Daten organisieren
rl = []
el = {}
for f in range(len(fl)):
vd = fl[f]
#Seitendaten für Drahtrahmen
for e in vd: el[e] = None
#Machen Sie disjunkte Seitendaten kontinuierlich(Polygonisierung)
vm = {}
s, e = vd[0]
vm[s] = e
il = vd[1:]
while len(il):
for n in range(len(il)):
p, q = il[n]
if e == p:
vm[e] = q
e = q
elif e == q:
vm[e] = p
e = p
else:
continue
del il[n]
break
continue
s, e = vd[0]
il = [s]
while s != e:
il.append(e)
e = vm[e]
continue
#Polygon normal behoben
nv = nl[f]
p0 = vl[il[0]]
p1 = vl[il[1]]
p2 = vl[il[2]]
v1 = vec_sub(p1, p0)
v2 = vec_sub(p2, p1)
pn = vec_cross(v1, v2)
if vec_inner(nv, pn) < 0: il.reverse()
rl.append((nv, il))
continue
return (vl, rl, el.keys())
#Hauptfunktion
def main(F):
vl, fl, el = make(F)
#Ausgabe von Scheitelpunktdaten
m = ('VERTEX[%d] = ' % len(vl)) + paren_out[0] + '\n'
for n in range(len(vl)):
m = m + (' %s,' % vec_dump(vl[n]))
if not args.uncomment: m = m + (' #%d' % n)
m = m + '\n'
continue
m = m + paren_out[1]
print(m)
#Ausgabe normaler Daten
if args.normal:
m = ('NORMAL[%d] = ' % len(fl)) + paren_out[0] + '\n'
for n in range(len(fl)):
m = m + (' %s,' % vec_dump(fl[n][0]))
if not args.uncomment: m = m + (' #%d' % n)
m = m + '\n'
continue
m = m + paren_out[1]
print(m)
pass
#Ausgabe von Oberflächendaten(Normal,Liste der Eckpunkte)
m = ('FACET[%d] = ' % len(fl)) + paren_out[0] + '\n'
for n in range(len(fl)):
if args.normal: m = m + ' '
else: m = m + ' ' + vec_dump(fl[n][0]) + ','
m = m + ' ' + paren_list[0]
s = ''
for i in fl[n][1]:
m = m + ('%s %2d' % (s, i))
s = ','
continue
m = m + ' ' + paren_list[1] + ','
if not args.uncomment: m = m + (' #%d' % n)
m = m + '\n'
continue
m = m + paren_out[1]
print(m)
#Ausgabe von Kantendaten
el = sorted(el)
m = ('EDGE[%d] = ' % len(el)) + paren_out[0]
for n in range(len(el)):
if ((n & 3) == 0): m = m + '\n '
m = m + (' %s %2d, %2d %s,' % (paren_list[0], el[n][0], el[n][1], paren_list[1]))
continue
m = m + '\n' + paren_out[1]
print(m)
return
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('N', nargs='+', type=int, help='Anzahl der Gesichter={4|6|8|12|20}')
parser.add_argument('-d', '--debug', action='store_true', help='Zum Debuggen')
parser.add_argument('-v', '--verbose', action='store_true', help='Redundante Ausgabe')
parser.add_argument('-r', '--rotate', action='store_true', help='6,Die Ausrichtung der Dodeca wurde korrigiert')
parser.add_argument('-c', '--cparen', action='store_true', help='Ändern Sie die Zeichen in Klammern')
parser.add_argument('-n', '--normal', action='store_true', help='Normale Daten trennen')
parser.add_argument('-u', '--uncomment', action='store_true', help='Index beseitigen')
args = parser.parse_args()
flag_debug = args.debug
flag_verbose = args.verbose
flag_rotate = args.rotate
if args.cparen:
paren_vec = paren_c
paren_out = paren_c
paren_list = paren_c
pass
s = '-' * 72
sep = (len(args.N) > 1)
for N in args.N:
if sep: print(s)
if N in RP_TAB:
main(N)
else:
print('N=%d :Ungültige Anzahl von Seiten' % N)
parser.print_help()
pass
continue
if sep: print(s)
pass
#Nutzloser Pass, continue,Rückkehr ist Emacs Einrückungsschutz
Anzahl der Gesichter: 4
Anzahl der Seiten: 6
Anzahl der Eckpunkte: 4
VERTEX[4] = (
( +0.000000, +0.000000, +1.000000 ), #0
( +0.942809, +0.000000, -0.333333 ), #1
( -0.471405, +0.816497, -0.333333 ), #2
( -0.471405, -0.816497, -0.333333 ), #3
)
FACET[4] = (
( +0.471405, +0.816497, +0.333333 ), ( 2, 0, 1 ), #0
( -0.942809, +0.000000, +0.333333 ), ( 3, 0, 2 ), #1
( +0.471405, -0.816497, +0.333333 ), ( 3, 1, 0 ), #2
( +0.000000, -0.000000, -1.000000 ), ( 3, 2, 1 ), #3
)
EDGE[6] = (
( 0, 1 ), ( 1, 2 ), ( 2, 0 ), ( 2, 3 ),
( 3, 0 ), ( 3, 1 ),
)
Anzahl der Gesichter: 6
Anzahl der Seiten: 12
Anzahl der Eckpunkte: 8
VERTEX[8] = (
( +0.000000, +0.000000, +1.000000 ), #0
( +0.942809, +0.000000, +0.333333 ), #1
( -0.471405, +0.816497, +0.333333 ), #2
( +0.471405, +0.816497, -0.333333 ), #3
( -0.471405, -0.816497, +0.333333 ), #4
( -0.942809, +0.000000, -0.333333 ), #5
( +0.471405, -0.816497, -0.333333 ), #6
( +0.000000, +0.000000, -1.000000 ), #7
)
FACET[6] = (
( +0.408248, +0.707107, +0.577350 ), ( 2, 0, 1, 3 ), #0
( -0.816497, +0.000000, +0.577350 ), ( 5, 4, 0, 2 ), #1
( +0.408248, -0.707107, +0.577350 ), ( 4, 6, 1, 0 ), #2
( +0.816497, -0.000000, -0.577350 ), ( 6, 7, 3, 1 ), #3
( -0.408248, +0.707107, -0.577350 ), ( 7, 5, 2, 3 ), #4
( -0.408248, -0.707107, -0.577350 ), ( 7, 6, 4, 5 ), #5
)
EDGE[12] = (
( 0, 1 ), ( 1, 3 ), ( 2, 0 ), ( 2, 5 ),
( 3, 2 ), ( 4, 0 ), ( 4, 6 ), ( 5, 4 ),
( 6, 1 ), ( 6, 7 ), ( 7, 3 ), ( 7, 5 ),
)
*********Das Folgende hat die gleiche Ausrichtung wie die Raumachse
Anzahl der Gesichter: 6
Anzahl der Seiten: 12
Anzahl der Eckpunkte: 8
VERTEX[8] = (
( -0.577350, -0.577350, +0.577350 ), #0
( +0.577350, -0.577350, +0.577350 ), #1
( +0.577350, +0.577350, +0.577350 ), #2
( -0.577350, +0.577350, +0.577350 ), #3
( +0.577350, -0.577350, -0.577350 ), #4
( -0.577350, -0.577350, -0.577350 ), #5
( +0.577350, +0.577350, -0.577350 ), #6
( -0.577350, +0.577350, -0.577350 ), #7
)
FACET[6] = (
( +0.000000, +0.000000, +1.000000 ), ( 0, 1, 2, 3 ), #0
( -0.000000, -1.000000, +0.000000 ), ( 5, 4, 1, 0 ), #1
( +1.000000, -0.000000, +0.000000 ), ( 4, 6, 2, 1 ), #2
( +0.000000, +1.000000, +0.000000 ), ( 6, 7, 3, 2 ), #3
( -1.000000, +0.000000, +0.000000 ), ( 7, 5, 0, 3 ), #4
( -0.000000, -0.000000, -1.000000 ), ( 7, 6, 4, 5 ), #5
)
EDGE[12] = (
( 0, 1 ), ( 0, 5 ), ( 1, 2 ), ( 2, 3 ),
( 3, 0 ), ( 4, 1 ), ( 4, 6 ), ( 5, 4 ),
( 6, 2 ), ( 6, 7 ), ( 7, 3 ), ( 7, 5 ),
)
Anzahl der Gesichter: 8
Anzahl der Seiten: 12
Anzahl der Eckpunkte: 6
VERTEX[6] = (
( +0.000000, +0.000000, +1.000000 ), #0
( +1.000000, +0.000000, +0.000000 ), #1
( +0.000000, +1.000000, +0.000000 ), #2
( -1.000000, +0.000000, +0.000000 ), #3
( -0.000000, -1.000000, +0.000000 ), #4
( +0.000000, -0.000000, -1.000000 ), #5
)
FACET[8] = (
( +0.577350, +0.577350, +0.577350 ), ( 2, 0, 1 ), #0
( -0.577350, +0.577350, +0.577350 ), ( 3, 0, 2 ), #1
( -0.577350, -0.577350, +0.577350 ), ( 4, 0, 3 ), #2
( +0.577350, -0.577350, +0.577350 ), ( 4, 1, 0 ), #3
( +0.577350, -0.577350, -0.577350 ), ( 5, 1, 4 ), #4
( +0.577350, +0.577350, -0.577350 ), ( 5, 2, 1 ), #5
( -0.577350, +0.577350, -0.577350 ), ( 5, 3, 2 ), #6
( -0.577350, -0.577350, -0.577350 ), ( 5, 4, 3 ), #7
)
EDGE[12] = (
( 0, 1 ), ( 1, 2 ), ( 2, 0 ), ( 2, 3 ),
( 3, 0 ), ( 3, 4 ), ( 4, 0 ), ( 4, 1 ),
( 4, 5 ), ( 5, 1 ), ( 5, 2 ), ( 5, 3 ),
)
Anzahl der Gesichter: 12
Anzahl der Seiten: 30
Anzahl der Eckpunkte: 20
VERTEX[20] = (
( +0.000000, +0.000000, +1.000000 ), #0
( +0.666667, +0.000000, +0.745356 ), #1
( -0.333333, +0.577350, +0.745356 ), #2
( +0.745356, +0.577350, +0.333333 ), #3
( +0.127322, +0.934172, +0.333333 ), #4
( -0.333333, -0.577350, +0.745356 ), #5
( -0.872678, +0.356822, +0.333333 ), #6
( -0.872678, -0.356822, +0.333333 ), #7
( +0.745356, -0.577350, +0.333333 ), #8
( +0.127322, -0.934172, +0.333333 ), #9
( +0.872678, +0.356822, -0.333333 ), #10
( +0.872678, -0.356822, -0.333333 ), #11
( -0.127322, +0.934172, -0.333333 ), #12
( +0.333333, +0.577350, -0.745356 ), #13
( -0.745356, +0.577350, -0.333333 ), #14
( -0.745356, -0.577350, -0.333333 ), #15
( -0.666667, +0.000000, -0.745356 ), #16
( -0.127322, -0.934172, -0.333333 ), #17
( +0.333333, -0.577350, -0.745356 ), #18
( +0.000000, -0.000000, -1.000000 ), #19
)
FACET[12] = (
( +0.303531, +0.525731, +0.794654 ), ( 2, 0, 1, 3, 4 ), #0
( -0.607062, +0.000000, +0.794654 ), ( 6, 7, 5, 0, 2 ), #1
( +0.303531, -0.525731, +0.794654 ), ( 5, 9, 8, 1, 0 ), #2
( +0.982247, -0.000000, +0.187592 ), ( 8, 11, 10, 3, 1 ), #3
( +0.491123, +0.850651, -0.187592 ), ( 10, 13, 12, 4, 3 ), #4
( -0.491123, +0.850651, +0.187592 ), ( 12, 14, 6, 2, 4 ), #5
( -0.982247, +0.000000, -0.187592 ), ( 14, 16, 15, 7, 6 ), #6
( -0.491123, -0.850651, +0.187592 ), ( 15, 17, 9, 5, 7 ), #7
( +0.491123, -0.850651, -0.187592 ), ( 17, 18, 11, 8, 9 ), #8
( +0.607062, -0.000000, -0.794654 ), ( 18, 19, 13, 10, 11 ), #9
( -0.303531, +0.525731, -0.794654 ), ( 19, 16, 14, 12, 13 ), #10
( -0.303531, -0.525731, -0.794654 ), ( 19, 18, 17, 15, 16 ), #11
)
EDGE[30] = (
( 0, 1 ), ( 1, 3 ), ( 2, 0 ), ( 2, 6 ),
( 3, 4 ), ( 4, 2 ), ( 5, 0 ), ( 5, 9 ),
( 6, 7 ), ( 7, 5 ), ( 8, 1 ), ( 8, 11 ),
( 9, 8 ), ( 10, 3 ), ( 10, 13 ), ( 11, 10 ),
( 12, 4 ), ( 12, 14 ), ( 13, 12 ), ( 14, 6 ),
( 14, 16 ), ( 15, 7 ), ( 15, 17 ), ( 16, 15 ),
( 17, 9 ), ( 17, 18 ), ( 18, 11 ), ( 18, 19 ),
( 19, 13 ), ( 19, 16 ),
)
*********Das Folgende hat dieselbe Ebene wie die Ausrichtung der Z-Achse
Anzahl der Gesichter: 12
Anzahl der Seiten: 30
Anzahl der Eckpunkte: 20
VERTEX[20] = (
( -0.577350, -0.187592, +0.794654 ), #0
( -0.000000, -0.607062, +0.794654 ), #1
( +0.577350, -0.187592, +0.794654 ), #2
( +0.356822, +0.491123, +0.794654 ), #3
( -0.356822, +0.491123, +0.794654 ), #4
( -0.000000, -0.982247, +0.187592 ), #5
( -0.934172, -0.303531, +0.187592 ), #6
( -0.577350, -0.794654, -0.187592 ), #7
( +0.934172, -0.303531, +0.187592 ), #8
( +0.577350, -0.794654, -0.187592 ), #9
( +0.577350, +0.794654, +0.187592 ), #10
( +0.934172, +0.303531, -0.187592 ), #11
( -0.577350, +0.794654, +0.187592 ), #12
( +0.000000, +0.982247, -0.187592 ), #13
( -0.934172, +0.303531, -0.187592 ), #14
( -0.356822, -0.491123, -0.794654 ), #15
( -0.577350, +0.187592, -0.794654 ), #16
( +0.356822, -0.491123, -0.794654 ), #17
( +0.577350, +0.187592, -0.794654 ), #18
( +0.000000, +0.607062, -0.794654 ), #19
)
FACET[12] = (
( +0.000000, +0.000000, +1.000000 ), ( 0, 1, 2, 3, 4 ), #0
( -0.525731, -0.723607, +0.447214 ), ( 6, 7, 5, 1, 0 ), #1
( +0.525731, -0.723607, +0.447214 ), ( 5, 9, 8, 2, 1 ), #2
( +0.850651, +0.276393, +0.447214 ), ( 8, 11, 10, 3, 2 ), #3
( +0.000000, +0.894427, +0.447214 ), ( 10, 13, 12, 4, 3 ), #4
( -0.850651, +0.276393, +0.447214 ), ( 12, 14, 6, 0, 4 ), #5
( -0.850651, -0.276393, -0.447214 ), ( 14, 16, 15, 7, 6 ), #6
( -0.000000, -0.894427, -0.447214 ), ( 15, 17, 9, 5, 7 ), #7
( +0.850651, -0.276393, -0.447214 ), ( 17, 18, 11, 8, 9 ), #8
( +0.525731, +0.723607, -0.447214 ), ( 18, 19, 13, 10, 11 ), #9
( -0.525731, +0.723607, -0.447214 ), ( 19, 16, 14, 12, 13 ), #10
( -0.000000, -0.000000, -1.000000 ), ( 19, 18, 17, 15, 16 ), #11
)
EDGE[30] = (
( 0, 1 ), ( 0, 6 ), ( 1, 2 ), ( 2, 3 ),
( 3, 4 ), ( 4, 0 ), ( 5, 1 ), ( 5, 9 ),
( 6, 7 ), ( 7, 5 ), ( 8, 2 ), ( 8, 11 ),
( 9, 8 ), ( 10, 3 ), ( 10, 13 ), ( 11, 10 ),
( 12, 4 ), ( 12, 14 ), ( 13, 12 ), ( 14, 6 ),
( 14, 16 ), ( 15, 7 ), ( 15, 17 ), ( 16, 15 ),
( 17, 9 ), ( 17, 18 ), ( 18, 11 ), ( 18, 19 ),
( 19, 13 ), ( 19, 16 ),
)
Anzahl der Gesichter: 20
Anzahl der Seiten: 30
Anzahl der Eckpunkte: 12
VERTEX[12] = (
( +0.000000, +0.000000, +1.000000 ), #0
( +0.894427, +0.000000, +0.447214 ), #1
( +0.276393, +0.850651, +0.447214 ), #2
( -0.723607, +0.525731, +0.447214 ), #3
( -0.723607, -0.525731, +0.447214 ), #4
( +0.276393, -0.850651, +0.447214 ), #5
( +0.723607, -0.525731, -0.447214 ), #6
( +0.723607, +0.525731, -0.447214 ), #7
( -0.276393, +0.850651, -0.447214 ), #8
( -0.894427, -0.000000, -0.447214 ), #9
( -0.276393, -0.850651, -0.447214 ), #10
( -0.000000, +0.000000, -1.000000 ), #11
)
FACET[20] = (
( +0.491123, +0.356822, +0.794654 ), ( 2, 0, 1 ), #0
( -0.187592, +0.577350, +0.794654 ), ( 3, 0, 2 ), #1
( -0.607062, +0.000000, +0.794654 ), ( 4, 0, 3 ), #2
( -0.187592, -0.577350, +0.794654 ), ( 5, 0, 4 ), #3
( +0.491123, -0.356822, +0.794654 ), ( 5, 1, 0 ), #4
( +0.794654, -0.577350, +0.187592 ), ( 6, 1, 5 ), #5
( +0.982247, -0.000000, -0.187592 ), ( 7, 1, 6 ), #6
( +0.794654, +0.577350, +0.187592 ), ( 7, 2, 1 ), #7
( +0.303531, +0.934172, -0.187592 ), ( 8, 2, 7 ), #8
( -0.303531, +0.934172, +0.187592 ), ( 8, 3, 2 ), #9
( -0.794654, +0.577350, -0.187592 ), ( 9, 3, 8 ), #10
( -0.982247, -0.000000, +0.187592 ), ( 9, 4, 3 ), #11
( -0.794654, -0.577350, -0.187592 ), ( 10, 4, 9 ), #12
( -0.303531, -0.934172, +0.187592 ), ( 10, 5, 4 ), #13
( +0.303531, -0.934172, -0.187592 ), ( 10, 6, 5 ), #14
( +0.187592, -0.577350, -0.794654 ), ( 11, 6, 10 ), #15
( +0.607062, +0.000000, -0.794654 ), ( 11, 7, 6 ), #16
( +0.187592, +0.577350, -0.794654 ), ( 11, 8, 7 ), #17
( -0.491123, +0.356822, -0.794654 ), ( 11, 9, 8 ), #18
( -0.491123, -0.356822, -0.794654 ), ( 11, 10, 9 ), #19
)
EDGE[30] = (
( 0, 1 ), ( 1, 2 ), ( 2, 0 ), ( 2, 3 ),
( 3, 0 ), ( 3, 4 ), ( 4, 0 ), ( 4, 5 ),
( 5, 0 ), ( 5, 1 ), ( 5, 6 ), ( 6, 1 ),
( 6, 7 ), ( 7, 1 ), ( 7, 2 ), ( 7, 8 ),
( 8, 2 ), ( 8, 3 ), ( 8, 9 ), ( 9, 3 ),
( 9, 4 ), ( 9, 10 ), ( 10, 4 ), ( 10, 5 ),
( 10, 6 ), ( 10, 11 ), ( 11, 6 ), ( 11, 7 ),
( 11, 8 ), ( 11, 9 ),
)