"""
Antiprismaring
01.04.2021
www.3d-meier.de
"""

import c4d
import math

# Variablen und Konstanten
Titel = 'Antiprismaring' # Name

NP = 72     # Anzahl Punkte
N3 = 60     # Anzahl Dreiecke 6 Eck Antiprisma
N3a = 36    # Anzahl Dreiecke 3 Eck Antiprisma
N6 = 12     # Anzahl Sechsecke
Radius = 2  # Radius der Eckpunktkugeln

a = 1                  # Kantenlänge
N = 6
sec = 1/math.cos(math.pi/(2*N))
h1 = math.sqrt(1-(sec**2)/4)      # Hoehe Antiprisma
hD = math.sqrt(3)/2               # Hoehe Dreieck = Inkreisradius Sechseck  


beta = math.acos(-1/3.0)
gamma =  math.asin((2-math.sqrt(3))/math.sqrt(3))
delta = math.pi -  math.acos(-1/3.0) - math.asin((2-math.sqrt(3))/math.sqrt(3))
d = math.sqrt(3)*math.cos(delta)/2
e = math.sqrt(3)*math.sin(delta)/2

Punkte = []

R = a/(2*math.sin(math.pi/N))  # Umkreisradius Sechseck
w = math.pi/N                  # Winkel für Sechseck

dx1 = 1 + e + hD 
dx2 = dx1/2
dz1 = dx1*math.sqrt(3)/2

# Antiprisma 1
for i in xrange(N):
    Punkte.append(c4d.Vector(-dx2+R*math.cos(w+2*math.pi*i/N),-h1/2, dz1+R*math.sin(w+2*math.pi*i/N)))    
for i in xrange(N):
    Punkte.append(c4d.Vector(-dx2+R*math.cos(2*math.pi*i/N), h1/2, dz1+R*math.sin(2*math.pi*i/N)))

# Antiprisma 2
for i in xrange(N):
    Punkte.append(c4d.Vector(dx2+R*math.cos(2*math.pi*i/N), -d-h1/2, dz1+R*math.sin(2*math.pi*i/N)))
for i in xrange(N):
    Punkte.append(c4d.Vector(dx2+R*math.cos(w+2*math.pi*i/N),-d+h1/2, dz1+R*math.sin(w+2*math.pi*i/N)))    

# Antiprisma 3
for i in xrange(N):
    Punkte.append(c4d.Vector(dx1+R*math.cos(w+2*math.pi*i/N),-h1/2, R*math.sin(w+2*math.pi*i/N)))    
for i in xrange(N):
    Punkte.append(c4d.Vector(dx1+R*math.cos(2*math.pi*i/N), h1/2, R*math.sin(2*math.pi*i/N)))

# Antiprisma 4
for i in xrange(N):
    Punkte.append(c4d.Vector(dx2+R*math.cos(2*math.pi*i/N), -d-h1/2, -dz1+R*math.sin(2*math.pi*i/N)))
for i in xrange(N):
    Punkte.append(c4d.Vector(dx2+R*math.cos(w+2*math.pi*i/N),-d+h1/2, -dz1+R*math.sin(w+2*math.pi*i/N)))    

# Antiprisma 5
for i in xrange(N):
    Punkte.append(c4d.Vector(-dx2+R*math.cos(w+2*math.pi*i/N),-h1/2, -dz1+R*math.sin(w+2*math.pi*i/N)))    
for i in xrange(N):
    Punkte.append(c4d.Vector(-dx2+R*math.cos(2*math.pi*i/N), h1/2, -dz1+R*math.sin(2*math.pi*i/N)))

# Antiprisma 6
for i in xrange(N):
    Punkte.append(c4d.Vector(-dx1+R*math.cos(2*math.pi*i/N), -d-h1/2, R*math.sin(2*math.pi*i/N)))
for i in xrange(N):
    Punkte.append(c4d.Vector(-dx1+R*math.cos(w+2*math.pi*i/N),-d+h1/2, R*math.sin(w+2*math.pi*i/N)))    

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

Dreiecke1 = [(43, 34, 42, 42),
             (28, 42, 34, 34),
             (42, 28, 37, 37),
             (27, 37, 28, 28),
             (37, 27, 43, 43),
             (34, 43, 27, 27),
             (17, 26, 25, 25),
             (17, 25, 23, 23),
             (32, 23, 25, 25),
             (23, 32, 22, 22),
             (26, 22, 32, 32),
             (22, 26, 17, 17),
             ( 5, 15,  0,  0),
             (20,  0, 15, 15),
             ( 0, 20,  6,  6),
             (21,  6, 20, 20),
             ( 6, 21,  5,  5),
             (15,  5, 21, 21),
             (45, 54, 44, 44),
             (48, 44, 54, 54),
             (44, 48, 39, 39),
             (53, 39, 48, 48),
             (45, 39, 53, 53),
             (54, 45, 53, 53),
             (71, 56, 70, 70),
             (50, 70, 56, 56),
             (70, 50, 65, 65),
             (49, 65, 50, 50),
             (65, 49, 71, 71),
             (56, 71, 49, 49),
             (61,  4,  3,  3),
             (61,  3, 67, 67),
             (10, 67,  3,  3),
             (67, 10, 66, 66),
             ( 4, 66, 10, 10),
             (66,  4, 61, 61)]

Sechsecke = [(    0,     1,    2,    3,    4,    5),
             (   11,    10,    9,    8,    7,    6),
             ( 0+12,  1+12, 2+12, 3+12, 4+12, 5+12),
             (11+12, 10+12, 9+12, 8+12, 7+12, 6+12),            
             ( 0+24,  1+24, 2+24, 3+24, 4+24, 5+24),
             (11+24, 10+24, 9+24, 8+24, 7+24, 6+24),     
             ( 0+36,  1+36, 2+36, 3+36, 4+36, 5+36),
             (11+36, 10+36, 9+36, 8+36, 7+36, 6+36),     
             ( 0+48,  1+48, 2+48, 3+48, 4+48, 5+48),
             (11+48, 10+48, 9+48, 8+48, 7+48, 6+48),  
             ( 0+60,  1+60, 2+60, 3+60, 4+60, 5+60),
             (11+60, 10+60, 9+60, 8+60, 7+60, 6+60)]

Faktor = 100    # Skalierungsfaktor
k = 1           # Korrekturfaktor


#************************************************************************
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 CreateDreiecke():
    obj = c4d.BaseObject(c4d.Opolygon)
    obj.ResizeObject(NP,N3)
    obj.SetName('Dreiecke 1')
  # 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 CreateDreiecke1():
    obj = c4d.BaseObject(c4d.Opolygon)
    obj.ResizeObject(NP,N3a)
    obj.SetName('Dreiecke 2')
  # 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(N3a):
        obj.SetPolygon( i, c4d.CPolygon(Dreiecke1[i][0], Dreiecke1[i][1], Dreiecke1[i][2], Dreiecke1[i][3]))

    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 CreateSplineDreiecke():
    obj = c4d.BaseObject(c4d.Ospline)
    obj.SetName("Spline-Dreiecke 1")
    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 CreateSplineDreiecke1():
    obj = c4d.BaseObject(c4d.Ospline)
    obj.SetName("Spline-Dreiecke 2")
    obj.ResizeObject(N3a*3)
    zz = 0
    for i in xrange(N3a):
        for j in xrange(3):
            x = Punkte[Dreiecke1[i][j]][0]
            y = Punkte[Dreiecke1[i][j]][1]
            z = Punkte[Dreiecke1[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, N3a)
    for i in range(0, N3a):
        obj.SetSegment(i, 3, 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 main():
    nullobj1 = CreateNullobjekt1()
    nullobj2 = CreateNullobjekt2()   # Ecken
    nullobj3 = CreateNullobjekt3()   # Kanten
    nullobj4 = CreateNullobjekt4()   # Polygone

    plyobj1 = CreateDreiecke()
    plyobj2 = CreateSechsecke()
    plyobj3 = CreateDreiecke1()

    splobj1 = CreateSplineDreiecke()
    splobj2 = CreateSplineSechsecke()
    splobj3 = CreateSplineDreiecke1()

    doc.InsertObject(nullobj1, None, 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)
    c4d.EventAdd()


if __name__=='__main__':
    main()