Je veux des données de polyèdre régulières. Cela semble facile à faire, mais vu comment le faire, cela ne semble pas facile. J'ai essayé de créer un programme, mais cela ressemble à une corde boueuse.
Créez des données pour un polyèdre régulier sur une sphère avec des sommets de rayon 1.
Les seuls tableaux pour les polyèdres réguliers ($ M
Soit le premier sommet $ \ left (0,0,1 \ right) $ et visons à générer les arêtes des faces tangentes.
Trouvez le prochain sommet $ \ left (sin \ \ theta, \ theta, cos \ \ theta \ right) $ et faites pivoter le plan x-y pour le diviser en "le nombre de faces tangentes".
Ensuite, le troisième est $ \ left (sin \ \ theta \ cos \ \ phi, \ sin \ \ theta \ cos \ \ phi, \ cos \ \ theta \ right) $.
$ \ phi $ peut être obtenu à partir du "nombre de faces en contact ($ F $)".
$ \ Theta $ peut être calculé à partir de 3 sommets, mais il doit être calculé avant de créer les sommets.
\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}
Comme, trouvez $ cos \ \ theta $ à partir de $ N, F $. Si vous trouvez les trois sommets, la première "face normale" est le produit extérieur
N_1 = \frac{L_1 \times L_2}{ \left| L_1 \times L_2 \right|}
Par conséquent, si cette ligne normale est tournée autour du plan x-y d'un angle de $ \ phi $, $ F $ de "lignes normales de face" peut être obtenue.
Puisque la distance entre le centre du polyèdre régulier et la face est le produit intérieur du premier sommet $ P_1 $ et de la normale de la première face $ N_1 $.
\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}
Demandez comme. Vous pouvez utiliser la valeur de $ \ left (n_z = D \ right) $ pour la normale pour créer une expression de visage.
Puisque trois normales ou plus ont été obtenues, la relation entre deux normales adjacentes $ N_1, N_2 $ et la normale adjacente $ N_3 $ est
\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}
Peut être. Maintenant, à partir des deux normales adjacentes $ N_1, N_2 $, une nouvelle normale $ N_3 $ est créée.
\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}
Est requis à.
En arrondissant les deux normales, recherchez une nouvelle normale, éliminez la duplication, et si elle n'augmente pas, le but est atteint.
L'intersection de deux normales adjacentes $ N_1, N_2 $ et le plan formé par la distance $ D $ du centre (origine) du polyèdre régulier au plan passe par les "côtés du polyèdre régulier". L'intersection de cette intersection et d'une sphère d'un rayon de $ 1 $ est le sommet souhaité.
La direction de l'intersection est le produit extérieur des deux normales
L_V = \frac{ N_1 \times N_2 }{ \left| N_1 \times N_2 \right| }
Il peut être trouvé par. Puisque nous voulons que le point de base de l'intersection soit le "centre du côté", nous voulons la droite $ L_C $ qui passe entre les deux normales et l'intersection $ L_P $ de la surface
\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}
Je vais le demander.
cos\ \theta_P = \left| L_P \right|
Donc, la distance de $ L_P $ au sommet est
L_D = sin\ \theta_P = \sqrt{1 - cos^2\theta_P} = \sqrt{1 - \left( L_P \cdot L_P \right) }
Ce sera. C'est dans "Trouver la normale de la surface"
L_D = \frac{ \left| L_1 \right| }{2}
Vous pouvez également. (Le programme reste l'ancien)
Étant donné que les sommets souhaités sont régulièrement espacés du centre du côté
V = L_P \pm L_D L_V
Sera.
Comme pour "toutes les normales", trouvez les côtés et les sommets en arrondissant les deux normales.
Après cela, les données sont préparées et terminées.
import math
flag_debug = False
flag_verbose = False
flag_rotate = False
paren_c = ('{', '}')
paren_vec = ('(', ')')
paren_out = ('(', ')')
paren_list = ('(', ')')
#Données de polyèdre régulier
#Nombre de faces: (Nombre d'angles de face,Nombre de points de contact des sommets)
RP_TAB = {
+4: (3, 3),
+6: (4, 3),
+8: (3, 4),
12: (5, 3),
20: (3, 5),
}
FP_THR = 1.0 / 1024 #Plage d'erreur de calcul admissible au moment du jugement
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): #produit intérieur
return (a[0] * b[0] + a[1] * b[1] + a[2] * b[2])
def vec_cross(a, b): #Produit extérieur
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): #Produit extérieur et normalisation
return vec_normalize(vec_cross(a, b))
def vec_normalize(a): #Normalisation
return vec_mul(a, 1.0 / math.sqrt(vec_inner(a, a)))
# X-Rotation dans le plan Y
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])
#Ajouter des données vectorielles(Élimine la duplication)
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
#Création de données polyèdres régulières
def make(F): # F =Nombre de faces
P = RP_TAB[F][0] # P =Nombre d'angles de face
K = RP_TAB[F][1] # K =Nombre de points de contact des sommets
E = F * P / 2 # E =Nombre de côtés
V = E - F + 2 # V =Nombre de sommets
if flag_verbose:
print('Nombre de faces: %d' % F)
print('Nombre de côtés: %d' % E)
print('Nombre de sommets: %d' % V)
pass
#Un tour avec le nombre de surfaces de contact des sommets
rK1 = math.pi / K # rK1 = π / K
rK2 = math.pi * 2 / K # rK2 = 2π / K
cK1, sK1 = cos_sin(rK1)
cK2, sK2 = cos_sin(rK2)
#Éléments liés aux polygones
rP = math.pi * (P - 2) / P # rP = π(P-2) / P
cP, sP = cos_sin(rP)
#Éléments liés aux côtés et aux angles centraux
cR = (cK1 * cK1 - cP) / (sK1 * sK1)
sR = math.sqrt(1 - cR * cR)
#Trouvez les normales des trois faces
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 =Distance du centre au plan
sD = math.sqrt(1 - cD * cD)
#Trouver l'élément d'angle des faces adjacentes
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)
#Corriger l'orientation du polyèdre régulier
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
#Trouvez les normales de tous les visages
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]
#Les faces n0 et n1 sont-elles adjacentes??
nc = vec_inner(n0, n1)
if abs(N_cos - nc) >= FP_THR:
continue
#Ajout de faces adjacentes de n0 à n1
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)) #C'est fini quand ça n'augmente pas
continue
#Trouver tous les côtés et sommets
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]
#Les faces n0 et n1 sont-elles adjacentes??
nc = vec_inner(n0, n1)
if abs(N_cos - nc) >= FP_THR: continue
#Trouvez l'intersection de n0 et n1(Passer par le centre du côté)
lc = vec_normalize(vec_add(n0, n1))
lv = vec_cross_normalize(n0, n1)
lp = vec_mul(lc, cD / vec_inner(n0, lc))
#Trouvez l'intersection de l'intersection et une sphère avec un rayon de 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)
#Ajouter des données de sommet et d'arête
i1 = vec_append(vl, q1)
i2 = vec_append(vl, q2)
fl[s].append((i1, i2))
fl[e].append((i1, i2))
continue
continue
#Organiser les données
rl = []
el = {}
for f in range(len(fl)):
vd = fl[f]
#Données latérales pour le fil de fer
for e in vd: el[e] = None
#Rendre les données latérales disjointes continues(Polygonisation)
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
#Polygone fixe normal
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())
#Fonction principale
def main(F):
vl, fl, el = make(F)
#Sortie des données de sommet
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)
#Sortie des données normales
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
#Sortie des données de surface(Ordinaire,Liste des sommets)
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)
#Sortie des données de bord
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='Nombre de faces={4|6|8|12|20}')
parser.add_argument('-d', '--debug', action='store_true', help='Pour le débogage')
parser.add_argument('-v', '--verbose', action='store_true', help='Sortie redondante')
parser.add_argument('-r', '--rotate', action='store_true', help='6,Correction de l'orientation de la dodéca')
parser.add_argument('-c', '--cparen', action='store_true', help='Changer les caractères entre parenthèses')
parser.add_argument('-n', '--normal', action='store_true', help='Séparer les données normales')
parser.add_argument('-u', '--uncomment', action='store_true', help='Éliminer l'index')
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 :Nombre de pages non valide' % N)
parser.print_help()
pass
continue
if sep: print(s)
pass
#Passe inutile, continue,le retour est la protection contre les indentations d'Emacs
Nombre de faces: 4
Nombre de côtés: 6
Nombre de sommets: 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 ),
)
Nombre de faces: 6
Nombre de côtés: 12
Nombre de sommets: 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 ),
)
*********Ce qui suit a la même orientation que l'axe spatial
Nombre de faces: 6
Nombre de côtés: 12
Nombre de sommets: 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 ),
)
Nombre de faces: 8
Nombre de côtés: 12
Nombre de sommets: 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 ),
)
Nombre de faces: 12
Nombre de côtés: 30
Nombre de sommets: 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 ),
)
*********Ce qui suit a le même plan que l'orientation de l'axe Z
Nombre de faces: 12
Nombre de côtés: 30
Nombre de sommets: 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 ),
)
Nombre de faces: 20
Nombre de côtés: 30
Nombre de sommets: 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 ),
)