"""
Kachelung 9
12.02.2014
"""

import c4d
import math

# Variablen und Konstanten
N = 32      # Anzahl Punkte pro Kante
r = 1.0    # Kantenlänge 
ri = 0.5*r*(2 + math.sqrt(3.0)) # Inkreisradius Zwölfeck
h = 0.5 * math.sqrt(3.0) *r     # Höhe Dreieck

Abstand_x = 2*ri
Abstand_y = 2*ri

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

  

Faktor = 1000        # Skalierungsfaktor


Zwoelfeck = []
Dreieck = []
Quadrat = []

Inversion = True
#Inversion = False

def Invers(z):
    return 1/z

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


# Quadrate **************************************************************************
def CreateSplineObjectQ():    
    # Splineobjekte erzeugen
    obj3 = c4d.BaseObject(c4d.Ospline)   
    obj3.ResizeObject(N*4*(2*NS)*(2*NS))      
    dt= r/N  # Unterteilung Kante
    zz = 0   # Zähler Punkte        
    
    # Quadratdaten erzeugen 
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, -0.5 * r)              
        Quadrat.append(z)
    for i in range(0,N):
        z = complex(0.5 * r, -0.5 * r + i * dt)            
        Quadrat.append(z)
    for i in range(0,N):
        z = complex(0.5 * r - i * dt, 0.5 * r)             
        Quadrat.append(z)
    for i in range(0,N):
        z = complex(-0.5 * r, 0.5 * r - i * dt)               
        Quadrat.append(z)

    for k in range(0,2*NS):                  
        y0 = -Abstand_y*NS + k*Abstand_y + ri
        for j in range(0,2*NS):                                       
            x0 = -Abstand_x*NS + j*Abstand_x + ri           
            for i in range(0,4*N):
                z = Quadrat[i] + complex(0, 0) + complex(x0, y0)   
                if Inversion:
                    z = Invers(z)
                obj3.SetPoint(zz, c4d.Vector(z.real*Faktor, z.imag*Faktor, 0.0))            
                zz = zz + 1
    obj3.MakeVariableTag(c4d.Tsegment, (2*NS)*(2*NS))     
    for i in range(0, (2*NS)*(2*NS)):
        obj3.SetSegment(i, 4*N, True)  

    obj3[c4d.SPLINEOBJECT_CLOSED] = True
    obj3.SetName("Quadrate")
       
    obj3.Message(c4d.MSG_UPDATE)
    return obj3



# Zwölfecke **********************************************************************************
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   # Zähler Punkte        
    # Zwölfeckdaten erzeugen
    for i in range(0,N):
        z = complex(-0.5 * r + i * dt, -ri)              
        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):                    
            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


# Dreiecke ******************************************************************************
def CreateSplineObjectD():    
    obj = c4d.BaseObject(c4d.Ospline)   # Splineobjekt erzeugen
    obj.ResizeObject(N*12*(2*NS)*(2*NS))      
    dt= r/N

    zz = 0   # Zähler Punkte    

    # Dreiecksdaten erzeugen
    for i in range(0,N):
        z = complex(0.5 * r, -0.5 *r + i * dt)              
        Dreieck.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)          
        z = Drehung(z, 30) + complex(0.5*r, 0.5*r)    
        Dreieck.append(z)
    for i in range(0,N):
        z = complex(i * dt, 0)    
        z = Drehung(z, 150) + complex(0.5*r + h, 0)
        Dreieck.append(z)
    for k in range(1,4):        
        for j in range(0,3*N):
            z = Drehung(Dreieck[j], -90*k)              
            Dreieck.append(z)    
        
    for k in range(0,2*NS):        
        y0 = -Abstand_y*NS + k*Abstand_y + ri
        for j in range(0,2*NS):              
            x0 = -Abstand_x*NS + j*Abstand_x + ri
            for i in range(0,12*N):
                z = Dreieck[i] + complex(0, 0) + 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)*(2*NS)*4)     
    for i in range(0, (2*NS)*(2*NS)*4):
        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 = CreateSplineObjectD()  
    slinobj3 = CreateSplineObjectQ()  
           
    doc.InsertObject(nullobj, None, None, True)
    doc.InsertObject(slinobj2, nullobj, None, True)
    doc.InsertObject(slinobj3, nullobj, None, True)   
    doc.InsertObject(slinobj1, nullobj, None, True)       

    
    c4d.EventAdd()



if __name__=='__main__':
    main()