"""
Kachelung 39
10.09.2015
"""

import c4d
import math

# Variablen und Konstanten
N = 5                          # Anzahl Punkte pro Kante
r = 1.330                      # Kantenlaenge
h = 0.5 * math.sqrt(3.0) * r   # Hoehe Dreieck

Abstand_x = 4*h + 3*r
Abstand_y = 3*r + 3*h
Versatz_x = 1.5*r + 2*h

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

Faktor = 1000        # Skalierungsfaktor

Viereck1 = []
Viereck2 = []
Viereck3 = []
Sexeck1 = []
Sexeck2 = []
Dreieck1 = []
Dreieck2 = []
Dreieck3 = []

#Inversion = True
Inversion = False

def Invers(z):
    return 1/z

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


# Vierecke 2 ********************************************************************
def CreateSplineObjectQ2():
    obj = c4d.BaseObject(c4d.Ospline)   # Splineobjekt erzeugen
    obj.ResizeObject(N*4*(2*NS+1)*(2*NS+1)*6)
    dt= r/N
    zz = 0   # Zaehler Punkte

    # Viereckssdaten erzeugen (aus Viereck 1)
    for i in range(0,4*N):
        z = Viereck1[i] + complex(r, 0)
        Viereck2.append(z)
    # Viereck drehen
    for i in range(0,4*N):
        Viereck2[i] = Drehung(Viereck2[i], -30)
    # Viereck duplizieren und drehen
    for k in range(1,6):
        for i in range(0,4*N):
            z = Drehung(Viereck2[i], -60*k)
            Viereck2.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*6):
                z = Viereck2[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)*6)
    for i in range(0, (2*NS+1)*(2*NS+1)*6):
        obj.SetSegment(i, 4*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


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

    # Viereckssdaten erzeugen
    for i in range(0,N):
        z = complex(i * dt, )
        Viereck3.append(z)
    for i in range(0,N):
        z = complex(r, i * dt)
        Viereck3.append(z)
    for i in range(0,N):
        z = complex(r - i * dt, r)
        Viereck3.append(z)
    for i in range(0,N):
        z = complex(0, r - i * dt)
        Viereck3.append(z)
    # Viereck verschieben
    for i in range(0,4*N):
        Viereck3[i] = Viereck3[i] + complex(2*h + r, 0)
    # Viereck spiegeln
    for i in range(0,4*N):
        z = complex( Viereck3[i].real, - Viereck3[i].imag)
        Viereck3.append(z)
    # Viereck duplizieren und drehen
    for k in range(1,3):
        for i in range(0,4*N*2):
            z = Drehung(Viereck3[i], -60*k)
            Viereck3.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*6):
                z = Viereck3[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)*6)
    for i in range(0, (2*NS+1)*(2*NS+1)*6):
        obj.SetSegment(i, 4*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


# Vierecke 1 ********************************************************************
def CreateSplineObjectQ1():
    obj = c4d.BaseObject(c4d.Ospline)   # Splineobjekt erzeugen
    obj.ResizeObject(N*4*(2*NS+1)*(2*NS+1)*6)
    dt= r/N
    zz = 0   # Zaehler Punkte

    # Viereckssdaten erzeugen
    for i in range(0,N):
        z = complex(h + i * dt, -0.5 * r)
        Viereck1.append(z)
    for i in range(0,N):
        z = complex(h + r, -0.5 * r + i * dt)
        Viereck1.append(z)
    for i in range(0,N):
        z = complex(h + r - i * dt, 0.5 * r)
        Viereck1.append(z)
    for i in range(0,N):
        z = complex(h, 0.5 * r - i * dt)
        Viereck1.append(z)
    # Viereck duplizieren und drehen
    for k in range(1,6):
        for i in range(0,4*N):
            z = Drehung(Viereck1[i], -60*k)
            Viereck1.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*6):
                z = Viereck1[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)*6)
    for i in range(0, (2*NS+1)*(2*NS+1)*6):
        obj.SetSegment(i, 4*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


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

    # Sechseckdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, -h)
        Sexeck1.append(z)
    for k in range(1,6):
        for j in range(0,N):
            z = Drehung(Sexeck1[j], -60*k)
            Sexeck1.append(z)
    for k in range(0,6*N):
        Sexeck1[k] = Drehung(Sexeck1[k], 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,6*N):
                z = Sexeck1[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, 6*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


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

    # Sechseckdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, -h)
        Sexeck2.append(z)
    for k in range(1,6):
        for j in range(0,N):
            z = Drehung(Sexeck2[j], -60*k)
            Sexeck2.append(z)
    for i in range(0,6*N):
        Sexeck2[i] = Drehung(Sexeck2[i], 30)
    # Sechseck verschieben
    for i in range(0,6*N):
          Sexeck2[i] = Sexeck2[i] + complex(2*r + 2*h, 0)
    # Sechseck drehen
    for i in range(0,6*N):
        Sexeck2[i] = Drehung(Sexeck2[i], -30)
    # Sechseck spiegeln
    for i in range(0,6*N):
        z =  complex(Sexeck2[i].real, -Sexeck2[i].imag)
        Sexeck2.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,6*N*2):
                z = Sexeck2[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)*2)
    for i in range(0, (2*NS+1)*(2*NS+1)*2):
        obj.SetSegment(i, 6*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


# Dreiecke 1 ******************************************************************************
def CreateSplineObjectD1():
    obj = c4d.BaseObject(c4d.Ospline)   # Splineobjekt erzeugen
    obj.ResizeObject(N*3*(2*NS+1)*(2*NS+1)*6)
    dt= r/N
    zz = 0   # Zaehler Punkte

    # Dreiecksdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, 0)
        Dreieck1.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -120) + complex(0.5*r,  0.)
        Dreieck1.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, 120) + complex(0, h)
        Dreieck1.append(z)
    # Dreieck verschieben
    for i in range(0,3*N):
        Dreieck1[i] = Dreieck1[i] + complex(0, -r - h)
    # Dreieck duplizieren und drehen
    for k in range(1,6):
        for i in range(0,3*N):
            z = Drehung(Dreieck1[i], -60*k)
            Dreieck1.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,3*N*6):
                z = Dreieck1[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)*6)
    for i in range(0, (2*NS+1)*(2*NS+1)*6):
        obj.SetSegment(i, 3*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


# Dreiecke 2 ******************************************************************************
def CreateSplineObjectD2():
    obj = c4d.BaseObject(c4d.Ospline)   # Splineobjekt erzeugen
    obj.ResizeObject(N*3*(2*NS+1)*(2*NS+1)*6)
    dt= r/N
    zz = 0   # Zaehler Punkte

    # Dreiecksdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, 0)
        Dreieck2.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -120) + complex(0.5*r,  0)
        Dreieck2.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, 120) + complex(0, h)
        Dreieck2.append(z)
    # Dreieck drehen und verschieben
    for i in range(0,3*N):
        Dreieck2[i] = Drehung(Dreieck2[i], 90) + complex(h + r, 0)
    # Dreieck duplizieren und drehen
    for k in range(1,6):
        for i in range(0,3*N):
            z = Drehung(Dreieck2[i], -60*k)
            Dreieck2.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,3*N*6):
                z = Dreieck2[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)*6)
    for i in range(0, (2*NS+1)*(2*NS+1)*6):
        obj.SetSegment(i, 3*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


# Dreiecke 3 ******************************************************************************
def CreateSplineObjectD3():
    obj = c4d.BaseObject(c4d.Ospline)   # Splineobjekt erzeugen
    obj.ResizeObject(N*3*(2*NS+1)*(2*NS+1)*12)
    dt= r/N
    zz = 0   # Zaehler Punkte

    # Dreiecksdaten erzeugen
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -30)
        Dreieck3.append(z)
    for i in range(0,N):
        z = complex(h, 0.5 * r - i * dt)
        Dreieck3.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)
        z = Drehung(z, -150) + complex(h, -0.5*r)
        Dreieck3.append(z)
    # Dreieck verschieben
    for i in range(0,3*N):
        Dreieck3[i] = Dreieck3[i] + complex(h + r, 0.5*r)
    # Dreieck spiegeln
        z =  complex(Dreieck3[i].real, -Dreieck3[i].imag)
        Dreieck3.append(z)
    # Dreieck duplizieren und drehen
    for k in range(1,6):
        for i in range(0,6*N):
            z = Drehung(Dreieck3[i], -60*k)
            Dreieck3.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,3*N*12):
                z = Dreieck3[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)*12)
    for i in range(0, (2*NS+1)*(2*NS+1)*12):
        obj.SetSegment(i, 3*N, True)

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

    obj.Message(c4d.MSG_UPDATE)
    return obj


def main():
    nullobj = CreateNullobjekt()
    slinobj1 = CreateSplineObjectS1()
    slinobj2 = CreateSplineObjectS2()
    slinobj3 = CreateSplineObjectD1()
    slinobj4 = CreateSplineObjectD2()
    slinobj5 = CreateSplineObjectD3()
    slinobj6 = CreateSplineObjectQ1()
    slinobj7 = CreateSplineObjectQ2()
    slinobj8 = CreateSplineObjectQ3()

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

    c4d.EventAdd()

if __name__=='__main__':
    main()