"""
Great Ditrigonal Dodecicosidodecahedron
26.05.2021
www.3d-meier.de
http://dmccooey.com/polyhedra/GreatDitrigonalDodecicosidodecahedron.html
"""

import c4d
import math

# Variablen und Konstanten
Titel = 'Great Ditrigonal Dodecicosidodecahedron' # Name

NP = 60    # Anzahl Punkte
N3 = 20    # Anzahl Dreiecke
N5 = 12    # Anzahl Fuenfecke
N6 = 20    # Anzahl Sechsecke
N10D = 12  # Anzahl Dekagramme

Radius = 1.0 # Radius der Eckpunktkugeln    

C0 = (3 - math.sqrt(5)) / 4
C1 = (math.sqrt(5) - 1) / 2
C2 = (1 + math.sqrt(5)) / 4
C3 = math.sqrt(5) / 2


Punkte = [( -C2,  0.5,  -C1),
          ( -C2,  0.5,   C1),
          (  C2,  0.5,  -C1),
          (  C2,  0.5,   C1),
          ( -C2, -0.5,  -C1),
          ( -C2, -0.5,   C1),
          (  C2, -0.5,  -C1),
          (  C2, -0.5,   C1),
          ( 0.5,  -C1,  -C2),
          ( 0.5,  -C1,   C2),
          (-0.5,  -C1,  -C2),
          (-0.5,  -C1,   C2),
          ( 0.5,   C1,  -C2),
          ( 0.5,   C1,   C2),
          (-0.5,   C1,  -C2),
          (-0.5,   C1,   C2),
          ( -C1,  -C2,  0.5),
          ( -C1,  -C2, -0.5),
          (  C1,  -C2,  0.5),
          (  C1,  -C2, -0.5),
          ( -C1,   C2,  0.5),
          ( -C1,   C2, -0.5),
          (  C1,   C2,  0.5),
          (  C1,   C2, -0.5),
          ( -C3,  0.0,   C0),
          ( -C3,  0.0,  -C0),
          (  C3,  0.0,   C0),
          (  C3,  0.0,  -C0),
          ( 0.0,   C0,  -C3),
          ( 0.0,   C0,   C3),
          ( 0.0,  -C0,  -C3),
          ( 0.0,  -C0,   C3),
          (  C0,  -C3,  0.0),
          ( -C0,  -C3,  0.0),
          (  C0,   C3,  0.0),
          ( -C0,   C3,  0.0),
          ( 0.5,  1.0,   C0),
          ( 0.5,  1.0,  -C0),
          (-0.5,  1.0,   C0),
          (-0.5,  1.0,  -C0),
          ( 0.5, -1.0,   C0),
          ( 0.5, -1.0,  -C0),
          (-0.5, -1.0,   C0),
          (-0.5, -1.0,  -C0),
          ( 1.0,   C0,  0.5),
          ( 1.0,   C0, -0.5),
          (-1.0,   C0,  0.5),
          (-1.0,   C0, -0.5),
          ( 1.0,  -C0,  0.5),
          ( 1.0,  -C0, -0.5),
          (-1.0,  -C0,  0.5),
          (-1.0,  -C0, -0.5),
          (  C0,  0.5,  1.0),
          (  C0,  0.5, -1.0),
          ( -C0,  0.5,  1.0),
          ( -C0,  0.5, -1.0),
          (  C0, -0.5,  1.0),
          (  C0, -0.5, -1.0),
          ( -C0, -0.5,  1.0),
          ( -C0, -0.5, -1.0)]

Fuenfecke = [( 24, 20, 52, 56, 16 ),
             ( 25, 17, 57, 53, 21 ),
             ( 26, 18, 58, 54, 22 ),
             ( 27, 23, 55, 59, 19 ),
             ( 28,  2, 36, 38,  0 ),
             ( 29,  1, 39, 37,  3 ),
             ( 30,  4, 42, 40,  6 ),
             ( 31,  7, 41, 43,  5 ),
             ( 32,  9, 44, 45,  8 ),
             ( 33, 10, 47, 46, 11 ),
             ( 34, 12, 49, 48, 13 ),
             ( 35, 15, 50, 51, 14 )]

Dreiecke = [( 24,  4,  0,  0 ),
            ( 25,  1,  5,  5 ),
            ( 26,  2,  6,  6 ),
            ( 27,  7,  3,  3 ),
            ( 28, 10,  8,  8 ),
            ( 29,  9, 11, 11 ),
            ( 30, 12, 14, 14 ),
            ( 31, 15, 13, 13 ),
            ( 32, 17, 16, 16 ),
            ( 33, 18, 19, 19 ),
            ( 34, 20, 21, 21 ),
            ( 35, 23, 22, 22 ),
            ( 36, 44, 52, 52 ),
            ( 37, 53, 45, 45 ),
            ( 38, 54, 46, 46 ),
            ( 39, 47, 55, 55 ),
            ( 40, 56, 48, 48 ),
            ( 41, 49, 57, 57 ),
            ( 42, 50, 58, 58 ),
            ( 43, 59, 51, 51 )]

Dekagramme = [(  0, 14, 55, 28, 30, 59, 10,  4, 51, 47),
              (  0, 47, 25, 24, 46,  1, 20, 38, 39, 21),
              (  2, 23, 37, 36, 22,  3, 44, 26, 27, 45),
              (  2, 45, 49,  6,  8, 57, 30, 28, 53, 12),
              (  5, 11, 58, 31, 29, 54, 15,  1, 46, 50),
              (  5, 50, 24, 25, 51,  4, 17, 43, 42, 16),
              (  7, 18, 40, 41, 19,  6, 49, 27, 26, 48),
              (  7, 48, 44,  3, 13, 52, 29, 31, 56,  9),
              ( 33, 32, 40, 18,  9, 56, 58, 11, 16, 42),
              ( 33, 43, 17, 10, 59, 57,  8, 19, 41, 32),
              ( 34, 35, 38, 20, 15, 54, 52, 13, 22, 36),
              ( 34, 37, 23, 12, 53, 55, 14, 21, 39, 35)]

Sechsecke = [(  0,  4, 42, 58, 54, 38 ),
             (  0, 28,  8, 32, 16, 24 ),
             (  3,  7, 41, 57, 53, 37 ),
             (  3, 29, 11, 33, 19, 27 ),
             ( 17, 32,  9, 29,  1, 25 ),
             ( 17, 57, 49, 48, 56, 16 ),
             ( 18, 33, 10, 28,  2, 26 ),
             ( 18, 58, 50, 51, 59, 19 ),
             ( 34, 12, 30,  4, 24, 20 ),
             ( 34, 21, 25,  5, 31, 13 ),
             ( 35, 15, 31,  7, 27, 23 ),
             ( 35, 22, 26,  6, 30, 14 ),
             ( 40,  6,  2, 36, 52, 56 ),
             ( 40, 48, 13, 15, 50, 42 ),
             ( 43,  5,  1, 39, 55, 59 ),
             ( 43, 51, 14, 12, 49, 41 ),
             ( 44, 36, 38, 46, 11,  9 ),
             ( 44, 45, 53, 21, 20, 52 ),
             ( 47, 39, 37, 45,  8, 10 ),
             ( 47, 46, 54, 22, 23, 55 )]
            
Faktor = 100   # Skalierungsfaktor
k = 1          # Korrekturfaktor fuer Kantenlaenge

ku = 256                                     # Unterteilung der Kugeln             
ru = math.sqrt(2*(17-3*math.sqrt(5)))/4      # Umkugelradius
rk = math.sqrt(6*(5-math.sqrt(5)))/4         # Kantenkugelradius
ri3 = (9*math.sqrt(3)-math.sqrt(15))/12      # Inkugelradius Dreieck
ri5 = math.sqrt(10*(65-19*math.sqrt(5)))/20  # Inkugelradius Fünfeck
ri10 = math.sqrt(2*(5+math.sqrt(5)))/4       # Inkugelradius Dekagramm


#************************************************************************
# Geradengleichung
def Gerade(a, b, r):
    c = b-a
    d = a + r*c
    return d

#************************************************************************
def CreateNullobjekt1():
    obj = c4d.BaseObject(c4d.Onull)
    obj.SetName(Titel)
    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateNullobjekt2():
    obj = c4d.BaseObject(c4d.Onull)
    obj.SetName('Ecken')
    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateNullobjekt3():
    obj = c4d.BaseObject(c4d.Onull)
    obj.SetName('Kanten')
    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateNullobjekt4():
    obj = c4d.BaseObject(c4d.Onull)
    obj.SetName('Polygone')
    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateNullobjekt5():
    obj = c4d.BaseObject(c4d.Onull)
    obj.SetName('Kugeln')
    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateDreiecke():
    obj = c4d.BaseObject(c4d.Opolygon)
    obj.ResizeObject(NP,N3)
    obj.SetName('Dreiecke')
  # Punkte uebergeben
    for i in xrange(NP):
        obj.SetPoint(i, c4d.Vector(Punkte[i][0]*Faktor*k, Punkte[i][1]*Faktor*k, Punkte[i][2]*Faktor*k))
  # Dreiecke setzen
    for i in xrange(N3):
        obj.SetPolygon( i, c4d.CPolygon(Dreiecke[i][0], Dreiecke[i][1], Dreiecke[i][2], Dreiecke[i][3]))

    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateFuenfecke():
    obj = c4d.BaseObject(c4d.Opolygon)
    obj.ResizeObject(NP, N5*2)
    obj.SetName('Fuenfecke')
  # Punkte uebergeben
    for i in xrange(NP):
        obj.SetPoint(i, c4d.Vector(Punkte[i][0]*Faktor*k, Punkte[i][1]*Faktor*k, Punkte[i][2]*Faktor*k))
    zz = 0 # Zähler für Polygone zurücksetzen
    for i in xrange(N5):
        obj.SetPolygon(zz, c4d.CPolygon(Fuenfecke[i][0], Fuenfecke[i][1], Fuenfecke[i][2], Fuenfecke[i][4]))
        zz = zz + 1
        obj.SetPolygon(zz, c4d.CPolygon(Fuenfecke[i][2], Fuenfecke[i][3], Fuenfecke[i][4], Fuenfecke[i][4]))
        zz = zz + 1

    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateSechsecke():
    obj = c4d.BaseObject(c4d.Opolygon)
    obj.ResizeObject(NP, N6*2)
    obj.SetName('Sechsecke')
  # Punkte uebergeben
    for i in xrange(NP):
        obj.SetPoint(i, c4d.Vector(Punkte[i][0]*Faktor*k, Punkte[i][1]*Faktor*k, Punkte[i][2]*Faktor*k))
  # Vierecke setzen
    zz = 0 # Zähler für Polygone zurücksetzen
    for i in xrange(N6):
        obj.SetPolygon(zz, c4d.CPolygon(Sechsecke[i][0], Sechsecke[i][1], Sechsecke[i][2], Sechsecke[i][5]))
        zz = zz + 1
        obj.SetPolygon(zz, c4d.CPolygon(Sechsecke[i][2], Sechsecke[i][3], Sechsecke[i][4], Sechsecke[i][5]))
        zz = zz + 1

    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateDekagramme():
    obj = c4d.BaseObject(c4d.Opolygon)
    obj.ResizeObject(NP + N10D*20, N10D*24)
    obj.SetName('Dekagramme')
    phi = (1+math.sqrt(5))/2.0
    r1 = math.sqrt(5) - 2
    r2 = (3 - math.sqrt(5))/2
    r3 = (math.sqrt(5) - 1)/2
    r4 = 3 - math.sqrt(5)    
  # Punkte uebergeben  
    for i in xrange(NP):
        obj.SetPoint(i, c4d.Vector(Punkte[i][0]*Faktor*k, Punkte[i][1]*Faktor*k, Punkte[i][2]*Faktor*k))
    for i in xrange(N10D):
    # Eckpunkte des Dekagramms in Vektoren umwandeln
        P0 = c4d.Vector(Punkte[Dekagramme[i][0]][0], Punkte[Dekagramme[i][0]][1], Punkte[Dekagramme[i][0]][2])
        P1 = c4d.Vector(Punkte[Dekagramme[i][1]][0], Punkte[Dekagramme[i][1]][1], Punkte[Dekagramme[i][1]][2])
        P2 = c4d.Vector(Punkte[Dekagramme[i][2]][0], Punkte[Dekagramme[i][2]][1], Punkte[Dekagramme[i][2]][2])
        P3 = c4d.Vector(Punkte[Dekagramme[i][3]][0], Punkte[Dekagramme[i][3]][1], Punkte[Dekagramme[i][3]][2])
        P4 = c4d.Vector(Punkte[Dekagramme[i][4]][0], Punkte[Dekagramme[i][4]][1], Punkte[Dekagramme[i][4]][2])
        P5 = c4d.Vector(Punkte[Dekagramme[i][5]][0], Punkte[Dekagramme[i][5]][1], Punkte[Dekagramme[i][5]][2])
        P6 = c4d.Vector(Punkte[Dekagramme[i][6]][0], Punkte[Dekagramme[i][6]][1], Punkte[Dekagramme[i][6]][2])
        P7 = c4d.Vector(Punkte[Dekagramme[i][7]][0], Punkte[Dekagramme[i][7]][1], Punkte[Dekagramme[i][7]][2])
        P8 = c4d.Vector(Punkte[Dekagramme[i][8]][0], Punkte[Dekagramme[i][8]][1], Punkte[Dekagramme[i][8]][2])
        P9 = c4d.Vector(Punkte[Dekagramme[i][9]][0], Punkte[Dekagramme[i][9]][1], Punkte[Dekagramme[i][9]][2])        
    # Neue Punkte
        P10 = Gerade(P0, P3, r1)
        P11 = Gerade(P1, P4, r1)
        P12 = Gerade(P2, P5, r1)
        P13 = Gerade(P3, P6, r1)
        P14 = Gerade(P4, P7, r1)
        P15 = Gerade(P5, P8, r1)
        P16 = Gerade(P6, P9, r1)
        P17 = Gerade(P7, P0, r1)
        P18 = Gerade(P8, P1, r1)
        P19 = Gerade(P9, P2, r1)                  
        P20 = Gerade(P9, P2, r2)        
        P21 = Gerade(P0, P3, r2)
        P22 = Gerade(P1, P4, r2)
        P23 = Gerade(P2, P5, r2)
        P24 = Gerade(P3, P6, r2)
        P25 = Gerade(P4, P7, r2)
        P26 = Gerade(P5, P8, r2)
        P27 = Gerade(P6, P9, r2)
        P28 = Gerade(P7, P0, r2)
        P29 = Gerade(P8, P1, r2)
    # Neue Punkte an Polygonobjekt uebergeben
        obj.SetPoint(20*i+NP   , P10*Faktor*k)
        obj.SetPoint(20*i+NP+1 , P11*Faktor*k)
        obj.SetPoint(20*i+NP+2 , P12*Faktor*k)
        obj.SetPoint(20*i+NP+3 , P13*Faktor*k)
        obj.SetPoint(20*i+NP+4 , P14*Faktor*k)               
        obj.SetPoint(20*i+NP+5 , P15*Faktor*k)               
        obj.SetPoint(20*i+NP+6 , P16*Faktor*k)               
        obj.SetPoint(20*i+NP+7 , P17*Faktor*k)               
        obj.SetPoint(20*i+NP+8 , P18*Faktor*k)               
        obj.SetPoint(20*i+NP+9 , P19*Faktor*k)               
        obj.SetPoint(20*i+NP+10, P20*Faktor*k)               
        obj.SetPoint(20*i+NP+11, P21*Faktor*k)                              
        obj.SetPoint(20*i+NP+12, P22*Faktor*k)               
        obj.SetPoint(20*i+NP+13, P23*Faktor*k)               
        obj.SetPoint(20*i+NP+14, P24*Faktor*k)                               
        obj.SetPoint(20*i+NP+15, P25*Faktor*k)                       
        obj.SetPoint(20*i+NP+16, P26*Faktor*k)                       
        obj.SetPoint(20*i+NP+17, P27*Faktor*k)                       
        obj.SetPoint(20*i+NP+18, P28*Faktor*k)                       
        obj.SetPoint(20*i+NP+19, P29*Faktor*k)                       
        
    # Polygone setzen
        obj.SetPolygon(24*i+0, c4d.CPolygon(Dekagramme[i][1], 20*i+NP+1, 20*i+NP+11, 20*i+NP   ))
        obj.SetPolygon(24*i+1, c4d.CPolygon(Dekagramme[i][2], 20*i+NP+2, 20*i+NP+12, 20*i+NP+1 ))
        obj.SetPolygon(24*i+2, c4d.CPolygon(Dekagramme[i][3], 20*i+NP+3, 20*i+NP+13, 20*i+NP+2 ))
        obj.SetPolygon(24*i+3, c4d.CPolygon(Dekagramme[i][4], 20*i+NP+4, 20*i+NP+14, 20*i+NP+3 ))
        obj.SetPolygon(24*i+4, c4d.CPolygon(Dekagramme[i][5], 20*i+NP+5, 20*i+NP+15, 20*i+NP+4 ))
        obj.SetPolygon(24*i+5, c4d.CPolygon(Dekagramme[i][6], 20*i+NP+6, 20*i+NP+16, 20*i+NP+5 ))
        obj.SetPolygon(24*i+6, c4d.CPolygon(Dekagramme[i][7], 20*i+NP+7, 20*i+NP+17, 20*i+NP+6 ))
        obj.SetPolygon(24*i+7, c4d.CPolygon(Dekagramme[i][8], 20*i+NP+8, 20*i+NP+18, 20*i+NP+7 ))
        obj.SetPolygon(24*i+8, c4d.CPolygon(Dekagramme[i][9], 20*i+NP+9, 20*i+NP+19, 20*i+NP+8 ))
        obj.SetPolygon(24*i+9, c4d.CPolygon(Dekagramme[i][0], 20*i+NP  , 20*i+NP+10, 20*i+NP+9 ))
           
        obj.SetPolygon(24*i+10, c4d.CPolygon(20*i+NP   , 20*i+NP+11, 20*i+NP+10, 20*i+NP+10 ))
        obj.SetPolygon(24*i+11, c4d.CPolygon(20*i+NP+1 , 20*i+NP+12, 20*i+NP+11, 20*i+NP+11 ))            
        obj.SetPolygon(24*i+12, c4d.CPolygon(20*i+NP+2 , 20*i+NP+13, 20*i+NP+12, 20*i+NP+12 ))
        obj.SetPolygon(24*i+13, c4d.CPolygon(20*i+NP+3 , 20*i+NP+14, 20*i+NP+13, 20*i+NP+13 ))
        obj.SetPolygon(24*i+14, c4d.CPolygon(20*i+NP+4 , 20*i+NP+15, 20*i+NP+14, 20*i+NP+14 ))
        obj.SetPolygon(24*i+15, c4d.CPolygon(20*i+NP+5 , 20*i+NP+16, 20*i+NP+15, 20*i+NP+15 ))
        obj.SetPolygon(24*i+16, c4d.CPolygon(20*i+NP+6 , 20*i+NP+17, 20*i+NP+16, 20*i+NP+16 ))
        obj.SetPolygon(24*i+17, c4d.CPolygon(20*i+NP+7 , 20*i+NP+18, 20*i+NP+17, 20*i+NP+17 ))
        obj.SetPolygon(24*i+18, c4d.CPolygon(20*i+NP+8 , 20*i+NP+19, 20*i+NP+18, 20*i+NP+18 ))
        obj.SetPolygon(24*i+19, c4d.CPolygon(20*i+NP+9 , 20*i+NP+10, 20*i+NP+19, 20*i+NP+19 ))
        obj.SetPolygon(24*i+20, c4d.CPolygon(20*i+NP+10, 20*i+NP+11, 20*i+NP+12, 20*i+NP+19 ))
        obj.SetPolygon(24*i+21, c4d.CPolygon(20*i+NP+12, 20*i+NP+13, 20*i+NP+18, 20*i+NP+19 ))
        obj.SetPolygon(24*i+22, c4d.CPolygon(20*i+NP+13, 20*i+NP+14, 20*i+NP+17, 20*i+NP+18 ))
        obj.SetPolygon(24*i+23, c4d.CPolygon(20*i+NP+14, 20*i+NP+15, 20*i+NP+16, 20*i+NP+17 ))

    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateSplineDreiecke():
    obj = c4d.BaseObject(c4d.Ospline)
    obj.SetName("Spline-Dreiecke")
    obj.ResizeObject(N3*3)
    zz = 0
    for i in xrange(N3):
        for j in xrange(3):
            x = Punkte[Dreiecke[i][j]][0]
            y = Punkte[Dreiecke[i][j]][1]
            z = Punkte[Dreiecke[i][j]][2]
            obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
            zz = zz + 1
  # Segmente erzeugen
    obj.MakeVariableTag(c4d.Tsegment, N3)
    for i in range(0, N3):
        obj.SetSegment(i, 3, True)
  # Spline schliessen
    obj[c4d.SPLINEOBJECT_CLOSED] = True

    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateSplineFuenfecke():
    obj = c4d.BaseObject(c4d.Ospline)
    obj.SetName("Spline-Fuenfecke")
    obj.ResizeObject(N5*5)
    zz = 0
    for i in xrange(N5):
        for j in xrange(5):
            x = Punkte[Fuenfecke[i][j]][0]
            y = Punkte[Fuenfecke[i][j]][1]
            z = Punkte[Fuenfecke[i][j]][2]
            obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
            zz = zz + 1
  # Segmente erzeugen
    obj.MakeVariableTag(c4d.Tsegment, N5)
    for i in range(0, N5):
        obj.SetSegment(i, 5, True)
  # Spline schliessen
    obj[c4d.SPLINEOBJECT_CLOSED] = True

    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateSplineSechsecke():
    obj = c4d.BaseObject(c4d.Ospline)
    obj.SetName("Spline-Sechsecke")
    obj.ResizeObject(N6*6)
    zz = 0
    for i in xrange(N6):
        for j in xrange(6):
            x = Punkte[Sechsecke[i][j]][0]
            y = Punkte[Sechsecke[i][j]][1]
            z = Punkte[Sechsecke[i][j]][2]
            obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
            zz = zz + 1
  # Segmente erzeugen
    obj.MakeVariableTag(c4d.Tsegment, N6)
    for i in range(0, N6):
        obj.SetSegment(i, 6, True)
  # Spline schliessen
    obj[c4d.SPLINEOBJECT_CLOSED] = True

    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def CreateSplineDekagramme():
    obj = c4d.BaseObject(c4d.Ospline)
    obj.SetName("Spline-Dekaagramme")
    obj.ResizeObject(N10D*10)
    zz = 0
    for i in xrange(N10D):
        x = Punkte[Dekagramme[i][0]][0]
        y = Punkte[Dekagramme[i][0]][1]
        z = Punkte[Dekagramme[i][0]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][3]][0]
        y = Punkte[Dekagramme[i][3]][1]
        z = Punkte[Dekagramme[i][3]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][6]][0]
        y = Punkte[Dekagramme[i][6]][1]
        z = Punkte[Dekagramme[i][6]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][9]][0]
        y = Punkte[Dekagramme[i][9]][1]
        z = Punkte[Dekagramme[i][9]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][2]][0]
        y = Punkte[Dekagramme[i][2]][1]
        z = Punkte[Dekagramme[i][2]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][5]][0]
        y = Punkte[Dekagramme[i][5]][1]
        z = Punkte[Dekagramme[i][5]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][8]][0]
        y = Punkte[Dekagramme[i][8]][1]
        z = Punkte[Dekagramme[i][8]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][1]][0]
        y = Punkte[Dekagramme[i][1]][1]
        z = Punkte[Dekagramme[i][1]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][4]][0]
        y = Punkte[Dekagramme[i][4]][1]
        z = Punkte[Dekagramme[i][4]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1
        x = Punkte[Dekagramme[i][7]][0]
        y = Punkte[Dekagramme[i][7]][1]
        z = Punkte[Dekagramme[i][7]][2]
        obj.SetPoint(zz, c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        zz = zz + 1

                                        
  # Segmente erzeugen
    obj.MakeVariableTag(c4d.Tsegment, N10D)
    for i in range(0, N10D):
        obj.SetSegment(i, 10, True)
  # Spline schliessen
    obj[c4d.SPLINEOBJECT_CLOSED] = True

    obj.Message(c4d.MSG_UPDATE)
    return obj

#************************************************************************
def main():
    nullobj1 = CreateNullobjekt1()
    nullobj2 = CreateNullobjekt2()   # Ecken
    nullobj3 = CreateNullobjekt3()   # Kanten
    nullobj4 = CreateNullobjekt4()   # Polygone
    nullobj5 = CreateNullobjekt5()   # Umkugel, etc.        
        
#    plyobj1 = CreateSechsecke()     
    plyobj1 = CreateDreiecke()
    plyobj2 = CreateFuenfecke()
    plyobj3 = CreateDekagramme()   
        
#    splobj1 = CreateSplineSechsecke()
    splobj1 = CreateSplineDreiecke()
    splobj2 = CreateSplineFuenfecke()
    splobj3 = CreateSplineDekagramme()   
 
    doc.InsertObject(nullobj1, None, None, True)
    doc.InsertObject(nullobj5, nullobj1, None, True)       
    doc.InsertObject(nullobj4, nullobj1, None, True)
    doc.InsertObject(nullobj3, nullobj1, None, True)
    doc.InsertObject(nullobj2, nullobj1, None, True) 

    doc.InsertObject(splobj3, nullobj3, None, True)    
    doc.InsertObject(splobj2, nullobj3, None, True)    
    doc.InsertObject(splobj1, nullobj3, None, True)    
    
    doc.InsertObject(plyobj3, nullobj4, None, True)     
    doc.InsertObject(plyobj2, nullobj4, None, True) 
    doc.InsertObject(plyobj1, nullobj4, None, True)   
         
  # Kugeln auf Eckpunkte setzen
    for i in range(0, NP):
        obj = c4d.BaseObject(c4d.Osphere)
        obj[c4d.PRIM_SPHERE_RAD] = Radius
        obj.SetName(str(i))            
        x = Punkte[i][0]
        y = Punkte[i][1]
        z = Punkte[i][2]
        obj.SetAbsPos(c4d.Vector(x*Faktor*k, y*Faktor*k, z*Faktor*k))
        doc.InsertObject(obj, nullobj2, None, True)         
         
  # Umkugel erzeugen
    obj = c4d.BaseObject(c4d.Osphere)
    obj[c4d.PRIM_SPHERE_SUB] = ku
    obj[c4d.PRIM_SPHERE_RAD] = ru*Faktor*k
    obj.SetName('Umkugel')
    obj[c4d.ID_BASEOBJECT_VISIBILITY_EDITOR] = 1
    obj[c4d.ID_BASEOBJECT_VISIBILITY_RENDER] = 1        
    doc.InsertObject(obj, nullobj5, None, True)

  # Kantenkugel erzeugen
    obj = c4d.BaseObject(c4d.Osphere)
    obj[c4d.PRIM_SPHERE_SUB] = ku
    obj[c4d.PRIM_SPHERE_RAD] = rk*Faktor*k
    obj.SetName('Kantenkugel')
    obj[c4d.ID_BASEOBJECT_VISIBILITY_EDITOR] = 1
    obj[c4d.ID_BASEOBJECT_VISIBILITY_RENDER] = 1        
    doc.InsertObject(obj, nullobj5, None, True)

  # Inkugel (Dreieck) erzeugen
    obj = c4d.BaseObject(c4d.Osphere)
    obj[c4d.PRIM_SPHERE_SUB] = ku
    obj[c4d.PRIM_SPHERE_RAD] = ri3*Faktor*k
    obj.SetName('Inkugel Dreieck')
    obj[c4d.ID_BASEOBJECT_VISIBILITY_EDITOR] = 1
    obj[c4d.ID_BASEOBJECT_VISIBILITY_RENDER] = 1        
    doc.InsertObject(obj, nullobj5, None, True)

  # Inkugel (Fuenfeck) erzeugen
    obj = c4d.BaseObject(c4d.Osphere)
    obj[c4d.PRIM_SPHERE_SUB] = ku
    obj[c4d.PRIM_SPHERE_RAD] = ri5*Faktor*k
    obj.SetName('Inkugel Fuenfeck')
    obj[c4d.ID_BASEOBJECT_VISIBILITY_EDITOR] = 1
    obj[c4d.ID_BASEOBJECT_VISIBILITY_RENDER] = 1        
    doc.InsertObject(obj, nullobj5, None, True)
    
  # Inkugel (Dekagramm) erzeugen
    obj = c4d.BaseObject(c4d.Osphere)
    obj[c4d.PRIM_SPHERE_SUB] = ku
    obj[c4d.PRIM_SPHERE_RAD] = ri10*Faktor*k
    obj.SetName('Inkugel Dekagramm')
    obj[c4d.ID_BASEOBJECT_VISIBILITY_EDITOR] = 1
    obj[c4d.ID_BASEOBJECT_VISIBILITY_RENDER] = 1        
    doc.InsertObject(obj, nullobj5, None, True)

     
    c4d.EventAdd()

if __name__=='__main__':
    main()