"""
Kachelung 31
12.10.2015
"""

import c4d
import math

# Variablen und Konstanten
N = 5                                                   # Anzahl Punkte pro Kante
r = 1.0                                                 # Kantenlaenge
riz = 0.5*r*(2 + math.sqrt(3.0))                        # Inkreisradius Zwoelfeck
rin = (r* math.cos(math.pi/9))/(2*math.sin(math.pi/9))  # Inkreisradius Neuneck
d2 = r*math.sin(2*math.pi/9)/math.sin(math.pi/9)        # Diagonale Neuneck
d3 = r*math.sqrt(3.0)/(math.sin(2*math.pi/9))           # Diagonale Neuneck
h1 = 0.5 * math.sqrt(3.0) * (2*riz + d2)                # Hoehe grosses Dreieck
a = r*math.cos(2*math.pi/9)
b = r*math.sin(2*math.pi/9)
c = r*math.sin(math.pi/6)
d = r*math.cos(math.pi/6)
e = r*math.sin(math.pi/18)
f = r + 2*e
ht = r*math.cos(math.pi/18)      # Hoehe Trapez
h = 0.5 * math.sqrt(3.0) * f     # Hoehe Dreieck

Abstand_x = 2*riz + d2
Abstand_y = h1
Versatz_x = riz + 0.5*d2

NS = 5    # Anzahl Wiederholungen in eine Richtung
if NS%2 ==0: # nur ungerade NS zulassen
    NS = NS +1

Faktor = 1000        # Skalierungsfaktor

Zwoelfeck = []
Dreieck = []
Neuneck = []
Raute1 = []
Raute2 = []
Trapez = []

Inversion = True
#Inversion = False

def Invers(z):
    return 1/z

def CreateNullobjekt():
    obj = c4d.BaseObject(c4d.Onull)   # Nullobjekt erzeugen
    obj.SetName("Kachelung 31")
    obj.Message(c4d.MSG_UPDATE)
    return obj

def Drehung(z, Grad):
    Winkel = Grad * math.pi/180
    x = z.real
    y = z.imag
    x1 = math.cos(Winkel) * x + math.sin(Winkel) * y
    y1 = -math.sin(Winkel) * x + math.cos(Winkel) * y
    return complex(x1, y1)


# Trapeze ***************************************************************************
def CreateSplineObjectT():
    obj = c4d.BaseObject(c4d.Ospline)   # Splineobjekt erzeugen
    obj.ResizeObject(N*4*(2*NS+1)*(2*NS+1)*3)
    dt= r/N
    dtf= f/N
    zz = 0   # Zaehler Punkte

    # Trapezdaten erzeugen
    for i in range(0,N):
        z = complex(riz, -0.5 * r + i * dt)
        Trapez.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -10) + complex(riz, 0.5*r)
        Trapez.append(z)
    for i in range(0,N):
        z = complex(riz + ht, 0.5 * f - i * dtf)
        Trapez.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -170) + complex(riz + ht, -0.5*f)
        Trapez.append(z)
    # Trapez drehen
    for i in range(0,4*N):
        Trapez[i] = Drehung(Trapez[i], -30)
    # Trapez duplizieren und drehen
    for k in range(1,3):
        for i in range(0,4*N):
            z = Drehung(Trapez[i], -120*k)
            Trapez.append(z)

    for k in range(0,2*NS+1):
        y0 = -Abstand_y*NS + k*Abstand_y
        for j in range(0,2*NS+1):
            if k%2 == 0.0:
                x0 = -Abstand_x*NS + j*Abstand_x + Versatz_x
            else:
                x0 = -Abstand_x*NS + j*Abstand_x
            for i in range(0,4*N*3):
                z = Trapez[i] + complex(x0, y0)
                if Inversion:
                    z = Invers(z)
                obj.SetPoint(zz, c4d.Vector(z.real*Faktor, z.imag*Faktor, 0.0))
                zz = zz + 1

    obj.MakeVariableTag(c4d.Tsegment, (2*NS+1)*(2*NS+1)*3)
    for i in range(0, (2*NS+1)*(2*NS+1)*3):
        obj.SetSegment(i, 4*N, True)

    obj[c4d.SPLINEOBJECT_CLOSED] = True
    obj.SetName("Trapeze")

    obj.Message(c4d.MSG_UPDATE)
    return obj


# Rauten 1 ****************************************************************************
def CreateSplineObjectR1():
    # Splineobjekte erzeugen
    obj = c4d.BaseObject(c4d.Ospline)
    obj.ResizeObject(N*4*(2*NS+1)*(2*NS+1)*3)
    dt= r/N  # Unterteilung Kante
    zz = 0   # Zaehler Punkte

    # Rautendaten erzeugen (aus den anderen Polygonen)
    for i in range(5*N,6*N):
        z = Zwoelfeck[i]
        Raute1.append(z)
    for i in range(N,2*N):
        z = Neuneck[i]
        Raute1.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, 30) + complex(0.5*r + a, riz + b)
        Raute1.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, 140) + complex(0.5*r + a + d, riz + b - c)
        Raute1.append(z)
    # Raute duplizieren und drehen
    for k in range(1,3):
        for j in range(0,4*N):
            z = Drehung(Raute1[j], 120*k)
            Raute1.append(z)

    for k in range(0,2*NS+1):
        y0 = -Abstand_y*NS + k*Abstand_y
        for j in range(0,2*NS+1):
            if k%2 == 0.0:
                x0 = -Abstand_x*NS + j*Abstand_x + Versatz_x
            else:
                x0 = -Abstand_x*NS + j*Abstand_x
            for i in range(0,4*N*3):
                z = Raute1[i] + complex(x0, y0)
                if Inversion:
                    z = Invers(z)
                obj.SetPoint(zz, c4d.Vector(z.real*Faktor, z.imag*Faktor, 0.0))
                zz = zz + 1

    obj.MakeVariableTag(c4d.Tsegment, (2*NS+1)*(2*NS+1)*3)
    for i in range(0, (2*NS+1)*(2*NS+1)*3):
        obj.SetSegment(i, 4*N, True)

    obj[c4d.SPLINEOBJECT_CLOSED] = True
    obj.SetName("Rauten 1")

    obj.Message(c4d.MSG_UPDATE)
    return obj


# Rauten 2 ****************************************************************************
def CreateSplineObjectR2():
    # Splineobjekte erzeugen
    obj = c4d.BaseObject(c4d.Ospline)
    obj.ResizeObject(N*4*(2*NS+1)*(2*NS+1)*3)
    dt= r/N  # Unterteilung Kante
    zz = 0   # Zaehler Punkte

    # Rautendaten erzeugen durch Spiegelung aus Raute 1
    for i in range(0,4*N):
        z = complex(-Raute1[i].real, Raute1[i].imag)
        Raute2.append(z)
    # Raute duplizieren und drehen
    for k in range(1,3):
        for j in range(0,4*N):
            z = Drehung(Raute2[j], 120*k)
            Raute2.append(z)

    for k in range(0,2*NS+1):
        y0 = -Abstand_y*NS + k*Abstand_y
        for j in range(0,2*NS+1):
            if k%2 == 0.0:
                x0 = -Abstand_x*NS + j*Abstand_x + Versatz_x
            else:
                x0 = -Abstand_x*NS + j*Abstand_x
            for i in range(0,4*N*3):
                z = Raute2[i] + complex(x0, y0)
                if Inversion:
                    z = Invers(z)
                obj.SetPoint(zz, c4d.Vector(z.real*Faktor, z.imag*Faktor, 0.0))
                zz = zz + 1

    obj.MakeVariableTag(c4d.Tsegment, (2*NS+1)*(2*NS+1)*3)
    for i in range(0, (2*NS+1)*(2*NS+1)*3):
        obj.SetSegment(i, 4*N, True)

    obj[c4d.SPLINEOBJECT_CLOSED] = True
    obj.SetName("Rauten 2")

    obj.Message(c4d.MSG_UPDATE)
    return obj


# Neunecke **********************************************************************************
def CreateSplineObjectN():
    # Splineobjekte erzeugen
    obj = c4d.BaseObject(c4d.Ospline)
    obj.ResizeObject(N*9*(2*NS+1)*(2*NS+1))
    dt= r/N  # Unterteilung Kante
    zz = 0   # Zaehler Punkte
    # Neuneckdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, -rin)
        Neuneck.append(z)
    for k in range(1,9):
        for j in range(0,N):
            z = Drehung(Neuneck[j], -40*k)
            Neuneck.append(z)
    # Neuneck verschieben
    for i in range(0,9*N):
        Neuneck[i] = Neuneck[i] + complex(0, riz + rin)

    for k in range(0,2*NS+1):
        y0 = -Abstand_y*NS + k*Abstand_y
        for j in range(0,2*NS+1):
            if k%2 == 0.0:
                x0 = -Abstand_x*NS + j*Abstand_x + Versatz_x
            else:
                x0 = -Abstand_x*NS + j*Abstand_x
            for i in range(0,9*N):
                z = Neuneck[i] + complex(x0, y0)
                if Inversion:
                    z = Invers(z)
                obj.SetPoint(zz, c4d.Vector(z.real*Faktor, z.imag*Faktor, 0.0))
                zz = zz + 1

    obj.MakeVariableTag(c4d.Tsegment, (2*NS+1)*(2*NS+1))
    for i in range(0, (2*NS+1)*(2*NS+1)):
        obj.SetSegment(i, 9*N, True)

    obj[c4d.SPLINEOBJECT_CLOSED] = True
    obj.SetName("Neunecke")

    obj.Message(c4d.MSG_UPDATE)
    return obj


# Zwoelfecke **********************************************************************************
def CreateSplineObjectZ():
    # Splineobjekte erzeugen
    obj1 = c4d.BaseObject(c4d.Ospline)
    obj1.ResizeObject(N*12*(2*NS+1)*(2*NS+1))
    dt= r/N  # Unterteilung Kante
    zz = 0   # Zaehler Punkte

    # Zwoelfeckdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, -riz)
        Zwoelfeck.append(z)
    for k in range(1,12):
        for j in range(0,N):
            z = Drehung(Zwoelfeck[j], -30*k)
            Zwoelfeck.append(z)

    for k in range(0,2*NS+1):
        y0 = -Abstand_y*NS + k*Abstand_y
        for j in range(0,2*NS+1):
            if k%2 == 0.0:
                x0 = -Abstand_x*NS + j*Abstand_x + Versatz_x
            else:
                x0 = -Abstand_x*NS + j*Abstand_x
            for i in range(0,12*N):
                z = Zwoelfeck[i] + complex(x0, y0)
                if Inversion:
                    z = Invers(z)
                obj1.SetPoint(zz, c4d.Vector(z.real*Faktor, z.imag*Faktor, 0.0))
                zz = zz + 1

    obj1.MakeVariableTag(c4d.Tsegment, (2*NS+1)*(2*NS+1))
    for i in range(0, (2*NS+1)*(2*NS+1)):
        obj1.SetSegment(i, 12*N, True)

    obj1[c4d.SPLINEOBJECT_CLOSED] = True
    obj1.SetName("Zwoelfecke")

    obj1.Message(c4d.MSG_UPDATE)
    return obj1


# Dreiecke ******************************************************************************
def CreateSplineObjectD():
    obj = c4d.BaseObject(c4d.Ospline)   # Splineobjekt erzeugen
    obj.ResizeObject(N*3*(2*NS+1)*(2*NS+1))
    dtf= f/N
    zz = 0   # Zaehler Punkte

    # Dreiecksdaten erzeugen
    for i in range(0,N):
        z = complex(riz + ht, -0.5 *f + i * dtf)
        Dreieck.append(z)
    for i in range(0,N):
        z = complex(i * dtf, 0)
        z = Drehung(z, 30) + complex(riz + ht, 0.5*f)
        Dreieck.append(z)
    for i in range(0,N):
        z = complex(i * dtf, 0)
        z = Drehung(z, 150) + complex(riz + ht + h, 0)
        Dreieck.append(z)
    # Dreieck drehen
    for i in range(0,3*N):
        Dreieck[i] = Drehung(Dreieck[i], -30)

    for k in range(0,2*NS+1):
        y0 = -Abstand_y*NS + k*Abstand_y
        for j in range(0,2*NS+1):
            if k%2 == 0.0:
                x0 = -Abstand_x*NS + j*Abstand_x + Versatz_x
            else:
                x0 = -Abstand_x*NS + j*Abstand_x
            for i in range(0,3*N):
                z = Dreieck[i] + complex(x0, y0)
                if Inversion:
                    z = Invers(z)
                obj.SetPoint(zz, c4d.Vector(z.real*Faktor, z.imag*Faktor, 0.0))
                zz = zz + 1

    obj.MakeVariableTag(c4d.Tsegment, (2*NS+1)*(2*NS+1))
    for i in range(0, (2*NS+1)*(2*NS+1)):
        obj.SetSegment(i, 3*N, True)

    obj[c4d.SPLINEOBJECT_CLOSED] = True
    obj.SetName("Dreiecke")

    obj.Message(c4d.MSG_UPDATE)
    return obj

def main():
    nullobj = CreateNullobjekt()
    slinobj1 = CreateSplineObjectZ()
    slinobj2 = CreateSplineObjectN()
    slinobj3 = CreateSplineObjectR1()
    slinobj4 = CreateSplineObjectR2()
    slinobj5 = CreateSplineObjectT()
    slinobj6 = CreateSplineObjectD()

    doc.InsertObject(nullobj, None, None, True)
    doc.InsertObject(slinobj6, nullobj, None, True)
    doc.InsertObject(slinobj5, nullobj, None, True)
    doc.InsertObject(slinobj4, nullobj, None, True)
    doc.InsertObject(slinobj3, nullobj, None, True)
    doc.InsertObject(slinobj2, nullobj, None, True)
    doc.InsertObject(slinobj1, nullobj, None, True)

    c4d.EventAdd()

if __name__=='__main__':
    main()