"""
Kachelung 38
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
ruz = 0.5*r*(math.sqrt(6.0) + math.sqrt(2.0)) # Umkreisradius Zwoelfeck
ria = 0.5*r*(1 + math.sqrt(2.0))              # Inkreisradius Achteck
d3z = r*(1 + math.sqrt(3.0))                  # Diagonale Zwoelfeck
d3a = r*(1 + math.sqrt(2.0))                  # Diagonale Achteck

a = r*math.cos(math.pi/4.0)   # Hilfsdaten Raute
b = r*math.sin(math.pi/4.0)   # Hilfsdaten Raute
c = r * math.sqrt(2.0)        # Hilfsdaten Fuenfeck
d = r*math.sin(math.pi/12.0)  # Hilfsdaten Fuenfeck
f = r*math.cos(math.pi/12.0)  # Hilfsdaten Fuenfeck
e = c - 2*d                   # Hilfsdaten Fuenfeck


Abstand_x = 2*riz + 4*ria + r
Abstand_y = riz + 2*ria + 0.5*r
Versatz_x = riz + 2*ria + 0.5*r

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

Faktor = 1000        # Skalierungsfaktor

Zwoelfeck = []
Achteck = []
Viereck = []
Raute1 = []
Raute2 = []
Fuenfeck = []


#Inversion = True
Inversion = False

def Invers(z):
    return 1/z

def CreateNullobjekt():
    obj = c4d.BaseObject(c4d.Onull)   # Nullobjekt erzeugen
    obj.SetName("Kachelung 38")
    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)


# Fuenfecke ****************************************************************************
def CreateSplineObjectF():
    # Splineobjekte erzeugen
    obj = c4d.BaseObject(c4d.Ospline)
    obj.ResizeObject(N*5*(2*NS+1)*(2*NS+1)*4)
    dt= r/N  # Unterteilung Kante
    dte = e/N
    zz = 0   # Zaehler Punkte

    # Fuenfeckdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5*e + i * dte, 0)
        Fuenfeck.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -75) + complex(0.5*e, 0)
        Fuenfeck.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -135) + complex(0.5*e + d, f)
        Fuenfeck.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, 135) + complex(0, f + b)
        Fuenfeck.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, 75) + complex(-0.5*e - d, f)
        Fuenfeck.append(z)
    # Fuenfeck spiegeln
    for i in range(0,5*N):
        z = complex(Fuenfeck[i].real, -Fuenfeck[i].imag)
        Fuenfeck.append(z)
    # Fuenfecke verschieben
    for i in range(0,5*N*2):
        Fuenfeck[i] = Fuenfeck[i] + complex(ruz + r + 0.5*e, 0)
    # Fuenfecke drehen
    for i in range(0,5*N*2):
        Fuenfeck[i] = Drehung(Fuenfeck[i], -45)
    # Fuenfeck spiegeln
    for i in range(0,5*N*2):
        z = complex(-Fuenfeck[i].real, Fuenfeck[i].imag)
        Fuenfeck.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,5*N*4):
                z = Fuenfeck[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)*4)
    for i in range(0, (2*NS+1)*(2*NS+1)*4):
        obj.SetSegment(i, 5*N, True)

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

    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)*4)
    dt= r/N  # Unterteilung Kante
    zz = 0   # Zaehler Punkte

    # Rautendaten erzeugen
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, 30) + complex(0.5*r, riz)
        Raute1.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -45) + complex(0.5*d3z, 0.5*d3z)
        Raute1.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -150) + complex(0.5*d3z + b, 0.5*d3z + a)
        Raute1.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, 135) + complex(0.5*d3a, riz + 0.5*(d3a - r))
        Raute1.append(z)
    # Raute duplizieren und drehen
    for k in range(1,4):
        for j in range(0,4*N):
            z = Drehung(Raute1[j], 90*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*4):
                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)*4)
    for i in range(0, (2*NS+1)*(2*NS+1)*4):
        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)*4)
    dt= r/N  # Unterteilung Kante
    zz = 0   # Zaehler Punkte

    # Rautendaten erzeugen (aus Raute 1)
    for i in range(0,4*N):
        z = Raute1[i]
        Raute2.append(z)
    # Raute drehen
    for i in range(0,4*N):
        Raute2[i] = Drehung(Raute2[i], -45)
    # Raute spiegeln
    for i in range(0,4*N):
        Raute2[i] = complex(-Raute2[i].real, Raute2[i].imag)
    # Raute drehen
    for i in range(0,4*N):
        Raute2[i] = Drehung(Raute2[i], 45)
    # Raute duplizieren und drehen
    for k in range(1,4):
        for j in range(0,4*N):
            z = Drehung(Raute2[j], 90*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*4):
                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)*4)
    for i in range(0, (2*NS+1)*(2*NS+1)*4):
        obj.SetSegment(i, 4*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


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

    # Viereckdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, 0.5*r)
        Viereck.append(z)
    for k in range(1,4):
        for j in range(0,N):
            z = Drehung(Viereck[j], 90*k)
            Viereck.append(z)
    # Viereck verschieben
    for i in range(0,4*N):
        Viereck[i] = Viereck[i] + complex(riz + 2*ria + 0.5*r, 0)

    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):
                z = Viereck[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, 4*N, True)

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

    obj1.Message(c4d.MSG_UPDATE)
    return obj1


# 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("Zwölfecke")

    obj1.Message(c4d.MSG_UPDATE)
    return obj1


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

    # Achteckdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, -ria)
        Achteck.append(z)
    for k in range(1,8):
        for j in range(0,N):
            z = Drehung(Achteck[j], -45*k)
            Achteck.append(z)
    # Achteck verschieben
    for i in range(0,8*N):
        Achteck[i] = Achteck[i] + complex(riz + ria, 0)
    # Achteck duplizieren und drehen
    for k in range(1,4):
        for i in range(0,8*N):
            z = Drehung(Achteck[i], 90*k)
            Achteck.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,8*N*4):
                z = Achteck[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)*4)
    for i in range(0, (2*NS+1)*(2*NS+1)*4):
        obj.SetSegment(i, 8*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


def main():
    nullobj = CreateNullobjekt()
    slinobj1 = CreateSplineObjectZ()
    slinobj2 = CreateSplineObjectA()
    slinobj3 = CreateSplineObjectQ()
    slinobj4 = CreateSplineObjectR1()
    slinobj5 = CreateSplineObjectR2()
    slinobj6 = CreateSplineObjectF()

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

    c4d.EventAdd()

if __name__=='__main__':
    main()