##################################
###Katharina Lamprecht###
###FINAL-Projekt###
###################################


##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###
sys.path.append("P:/dm2/finale/")  ###
import DM_lib as dm        ### reload( dm )
##############################      

rs.UnitSystem(4)                                        # km = 5, meters = 4, cm = 3 etc
rs.ShowGrid(None, 0)                                    # grid > 0 = off
rs.ShowGridAxes(None, 0)                                # y/y/z axen display > 0/1 = off/on
rs.ViewDisplayMode(rs.CurrentView(), "wireframe")
rs.Command("cplane w t enter", 0)						# cPlane World Top
dm.PointRadius(displayModeX=0, rad=3, styl=3)
dm.printDisplay(0)                                      # nomen est omen
rs.EnableRedraw(0)
dm.eAA()


###_________________________________________#
### basic settings for grid to fit UN_slab  #
###                                         # 
floors = H  = dm.H = 40                     # default=40 / incl roof
slabs  = L  = dm.L = 11                     # default=11
depth  = D  = dm.D =  4                     # default= 4 / division in building_depth
floorHeight = fH = dm.fH = 4.0              # default= 4.0 / 4.0*(H-1) = 156 meters
                                            #
################                            # get from DM_lib as dm:
UnoGridCoords  = dm.UnoGridCoords       # get gridCoords L*D*H = 1760
UnoPanelCoords = dm.UnoPanelCoords      # get panelCoords [frontPanels, backPanels, sidePanels, upSidePanels] / default arguments s.u.
################____________________________#

dm.newEmptyLayer("UNO::setUp", [120,120,140])


################
lengthVec = lVec = rs.VectorUnitize(rs.VectorSubtract( dm.getUnoCoord(0, 0, 0), dm.getUnoCoord(1, 0, 0) )) ## rs.AddPoint( dm.getUnoCoord(1, 0, 0) )
depthVec  = dVec = rs.VectorUnitize(rs.VectorSubtract( dm.getUnoCoord(0, 1, 0), dm.getUnoCoord(0, 0, 0) )) ## rs.AddPoint( dm.getUnoCoord(0, 1, 0) )
heightVec  = hVec = rs.VectorUnitize(rs.VectorSubtract( dm.getUnoCoord(0, 0, 1), dm.getUnoCoord(0, 0, 0) )) ## rs.AddPoint( dm.getUnoCoord(0, 1, 0) )
################

if 0: ### SETUP >> dont' exec @ homework !
    rs.AddCurve( [dm.getUnoCoord(0,0,0), dm.getUnoCoord(0,0,39), dm.getUnoCoord(10,0,39), dm.getUnoCoord(10,0,0), dm.getUnoCoord(10,3,0), dm.getUnoCoord(0,3,0), dm.getUnoCoord(0,3,39), dm.getUnoCoord(10,3,39)], 1)
    rs.ObjectColor(rs.AddLine( dm.getUnoCoord(0, 0, 0), dm.getUnoCoord(0, 1, 0) ), [222, 0, 0] )
    rs.ObjectColor(rs.AddLine( dm.getUnoCoord(0, 0, 0), dm.getUnoCoord(1, 0, 0) ), [0, 222, 0] )
    rs.ObjectColor(rs.AddLine( dm.getUnoCoord(0, 0, 0), dm.getUnoCoord(0, 0, 2) ), [0, 0, 222] )
    rs.ObjectPrintWidth( rs.AllObjects()[0:3], 1.0 )
    #rs.AddPoints( UnoGridCoords )
    rs.ZoomExtents()

frontPanels   = UnoPanelCoords[0]
backPanels    = UnoPanelCoords[1]
sidePanels    = UnoPanelCoords[2]
upSidePanels  = UnoPanelCoords[3]
allPanels     = UnoPanelCoords[4]

#_____________________________here you go:
dm.newEmptyLayer("myPROJ", [100,100,200])

allPanels = []
# front
allPanels  = [[dm.getUnoCoord( 0, 0, 0), dm.getUnoCoord( 0, 0, 39), dm.getUnoCoord(10, 0, 39), dm.getUnoCoord(10, 0, 0)]]
# back:
#allPanels += [[dm.getUnoCoord( 0, 3, 0), dm.getUnoCoord( 0, 3, 39), dm.getUnoCoord(10, 3, 39), dm.getUnoCoord(10, 3, 0)]]
# side:
#allPanels += [[dm.getUnoCoord( 0, 3, 0), dm.getUnoCoord( 0, 3, 39), dm.getUnoCoord( 0, 0, 39), dm.getUnoCoord( 0, 0, 0)]]
#allPanels += [[dm.getUnoCoord(10, 0, 0), dm.getUnoCoord(10, 0, 39), dm.getUnoCoord(10, 3, 39), dm.getUnoCoord(10, 3, 0)]]


############################################################################
######BUCH
if 0:
    col = [0,0,0]
    col_1 = [105,105,105]
    col_2 = [0,0,0] #[14,150,105]

    anz = 10
##Coords
    spine_v = [dm.getUnoCoord( 10, 0, 0), dm.getUnoCoord( 10, 0, 39)]
    spine_h = [dm.getUnoCoord( 10, 3, 0), dm.getUnoCoord( 10, 3, 39)]
    seiten_o = [dm.getUnoCoord( 0, 0, 39), dm.getUnoCoord( 0, 3, 39)]
    seiten_u = [dm.getUnoCoord( 0, 0, 0), dm.getUnoCoord( 0, 3, 0)]
    seiten_oh = [dm.getUnoCoord( 10, 0, 39), dm.getUnoCoord( 10, 3, 39)]
    seiten_uh = [dm.getUnoCoord( 10, 0, 0), dm.getUnoCoord( 10, 3, 0)]
##Curves
    crv_spine_v = rs.AddCurve(spine_v, 1)
    crv_spine_h = rs.AddCurve(spine_h, 1)
    crv_seiten_o = rs.AddCurve(seiten_o, 1)
    crv_seiten_u = rs.AddCurve(seiten_u, 1)
    crv_seiten_oh = rs.AddCurve(seiten_oh, 1)
    crv_seiten_uh = rs.AddCurve(seiten_uh, 1)

    coordsO = rs.DivideCurve( crv_seiten_o, anz , 0)
    coordsU = rs.DivideCurve( crv_seiten_u, anz , 0)
    coordsOh = rs.DivideCurve( crv_seiten_oh, anz , 0)
    coordsUh = rs.DivideCurve( crv_seiten_uh, anz , 0)

##Buchseiten
    for i in range(anz) :
        rs.ObjectColor(crv_seiten_oh, col_2)
        rs.ObjectColor(crv_seiten_uh, col_2)
        seiten_line1 = rs.ObjectColor(rs.AddCurve([coordsU[i], coordsO[i]],2), col_2)
        seiten_line2 = rs.ObjectColor(rs.AddCurve([coordsOh[i], coordsO[i]],2), col_2)
        seiten_line3 = rs.ObjectColor(rs.AddCurve([coordsUh[i], coordsU[i]],2), col_2)
    rs.DeleteObjects([crv_seiten_o, crv_seiten_u])
##Buchruecken
    for z in range (40):
        p5 = dm.getUnoCoord(10,0,z)
        p6 = rs.VectorAdd( p5, rs.VectorScale( lVec, -10 ) )
        p7 = dm.getUnoCoord(10,3,z)
        spine_crv_coords = [p5, p6, p7]
        spine_crvs = rs.ObjectColor((rs.AddCurve(spine_crv_coords, 2)), col_2)
##Punkteumrandung
    for x in range (0, 11):
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 0, 0) ), col_2)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 3, 0) ), col_2)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 0, 39) ), col_2)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 3, 39) ), col_2)
    for z in range (0, 40):
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(10, 0, z) ), col_2)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(10, 3, z) ), col_2)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(0, 0, z) ), col_2)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(0, 3, z) ), col_2)
############################################################################

random.shuffle( allPanels )
def dividePanel( panel=allPanels[0], maxPanels=25, minHig=4.0 ):
        dm.esc()
        if maxPanels>4: maxPanels=4
        if rs.Distance( panel[0], panel[1] ) > minHig*2:
            allPanels.remove( panel )
            pMid = dm.pntInbetween(panel[0],panel[2])
            allPanels.append([panel[0], dm.pntInbetween(panel[0],panel[1]), pMid, dm.pntInbetween(panel[3],panel[0])])
            allPanels.append([dm.pntInbetween(panel[0],panel[1]), panel[1],dm.pntInbetween(panel[1],panel[2]), pMid])
            allPanels.append([pMid, dm.pntInbetween(panel[1],panel[2]), panel[2], dm.pntInbetween(panel[2],panel[3])])
            allPanels.append([dm.pntInbetween(panel[0],panel[3]), pMid, dm.pntInbetween(panel[2],panel[3]), panel[3]])
        if len(allPanels) <= maxPanels :
            dividePanel( panel=random.choice( allPanels[0: int(len(allPanels)*0.666)]), maxPanels=maxPanels )  

dividePanel(panel=allPanels[0], maxPanels=7, minHig=12.0 )
print "::: len(allPanels)",len(allPanels)

##############################################################################
###Symbole###

###Fruehling
def springpanel( panel, normPanel = 1 ):
    p0,p1,p2,p3 = panel
    nVec = dm.normVec3pnts( p0, p1, p2 )
    
    zVal = p0 [2]
    outVal = dm.reMap(zVal, 3, 156-12, 150, 150)
    outValD = dm.reMap(zVal, 0, 156-12, 0.8, 0.8) 
    
    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    nVec1 = rs.VectorScale( nVec, outVal*0.1)#)random.choice([0.1, 0.2])

    col_1 = [203,48,44]
    col_2 = [196,222,180]
    col_3 = [132,118,181]
    col_4 = [222,172,208]

    p0I = dm.pntInbetween(p0, p2, outValD)
    p1I = dm.pntInbetween(p3, p1, outValD)
    p2I = dm.pntInbetween(p2, p0, outValD)
    p3I = dm.pntInbetween(p1, p3, outValD)
    p4I = dm.pntInbetween(p0, p2, outValD)
    
    p0V = rs.VectorAdd( p0I, nVec1 )
    p1V = rs.VectorAdd( p1I, nVec1 )
    p2V = rs.VectorAdd( p2I, nVec1 )
    p3V = rs.VectorAdd( p3I, nVec1 )
    p4V = rs.VectorAdd( p4I, nVec1 )

    circSize=random.choice([0.6, 0.85])#0.9
    cenPt = dm.pntInbetween( p0, p2 )
    planeX = rs.PlaneFromPoints( cenPt, dm.pntInbetween(p0,p1), p1)
    rad = rs.Distance(p0,p3)*0.5*circSize
    circ = rs.AddCircle(planeX, rad)
    
    circSize_kl=random.choice([0.4, 0.6])#0.9
    cenPt_kl = dm.pntInbetween( p0, p2)
    planeX_kl = rs.PlaneFromPoints( cenPt_kl, dm.pntInbetween(p0,p1), p1)
    rad_kl = rs.Distance(p0,p2)*0.3*circSize_kl
    circ_kl = rs.AddCircle(planeX_kl, rad_kl)

    circSize_kl2=random.choice([0.2, 0.5])#0.9
    cenPt_kl2 = dm.pntInbetween( p0, p2)
    planeX_kl2 = rs.PlaneFromPoints( cenPt_kl2, dm.pntInbetween(p0,p1), p1)
    rad_kl2 = rs.Distance(p0,p2)*0.3*circSize_kl2
    circ_kl2 = rs.AddCircle(planeX_kl2, rad_kl2)
    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    anz_2 = int(dm.reMap(zVal, 0, 156-12, 20, 20))

    coordsA = rs.DivideCurve( circ, anz , 0)
    coordsI = rs.DivideCurve( circ_kl, anz , 0)
    coordsO = rs.DivideCurve( circ_kl2, anz_2 , 0)


    for i in range(anz) :
            rs.ObjectColor(circ, random.choice([col_1, col_2, col_3, col_4]))
            rs.ObjectColor(circ_kl, random.choice([col_1, col_2, col_3, col_4]))
            rs.ObjectColor(circ_kl2, random.choice([col_1, col_2, col_3, col_4]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2), col_1)
            rs.ObjectColor(rs.AddCurve( [coordsI[i], coordsO[i]],2),col_4)

###Sommer
def summerpanel( panel, normPanel = 1 ):
    p0,p1,p2,p3 = panel
    nVec = dm.normVec3pnts( p0, p1, p2 )
    
    zVal = p0 [2]
    outVal = dm.reMap(zVal, 3, 156-12, 150, 150)
    outValD = dm.reMap(zVal, 0, 156-12, 0.7, 0.7) 
    
    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    nVec1 = rs.VectorScale( nVec, outVal*0.1)
    
    col_1 = [137,203,191]
    col_2 = [156,194,229]
    col_3 = [236,221,126]
    col_4 = [138,191,89]
    
    p0I = dm.pntInbetween(p0, p2, outValD)
    p1I = dm.pntInbetween(p3, p1, outValD)
    p2I = dm.pntInbetween(p2, p0, outValD)
    p3I = dm.pntInbetween(p1, p3, outValD)
    p4I = dm.pntInbetween(p0, p2, outValD)
    
    p0V = rs.VectorAdd( p0I, nVec1 )
    p1V = rs.VectorAdd( p1I, nVec1 )
    p2V = rs.VectorAdd( p2I, nVec1 )
    p3V = rs.VectorAdd( p3I, nVec1 )
    p4V = rs.VectorAdd( p4I, nVec1 )
    
    coords_wellen = [p0, p1, p2V, p3] #[p0, p1, p2V, p3]
    crv_wellen = rs.AddCurve( coords_wellen, 2 ) 
    
    coords_wellen_2 = [p0, p2, p3] #[p0, p1, p2V, p3]
    crv_wellen_2 = rs.AddCurve( coords_wellen_2, 2 )

    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    coordsA = rs.DivideCurve( crv_wellen, anz , 0)
    coordsI = rs.DivideCurve( crv_wellen_2, anz , 0)

    for i in range(anz) :
            rs.ObjectColor(crv_wellen, random.choice([col_3, col_4]))
            rs.ObjectColor(crv_wellen_2, random.choice([col_3, col_4]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2), random.choice([col_2, col_1]))


    #rs.ObjectPrintWidth([crv_wellen], 1.5)

###Herbst
def autumpanel (panel, normPanel = 1 ):
    p0,p1,p2,p3 = panel
    nVec = dm.normVec3pnts( p0, p1, p2 )
    
    zVal = p0 [2]
    outVal = dm.reMap(zVal, 3, 156-12, 150, 150)
    outValD = dm.reMap(zVal, 0, 156-12, 0.8, 0.8) 
    outValT = dm.reMap(zVal, 0, 156-12, 0.7, 0.7) 

    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    nVec1 = rs.VectorScale( nVec, outVal*random.choice([0.1, 0.2]))#0.05)

    col_1 = [138,31,18]
    col_2 = [197,91,23]
    col_3 = [56,96,41]
    col_4 = [142,103,51]
    col_5 = [180,60,55]
    col_6 = [97,116,61]

    p0I = dm.pntInbetween(p0, p2, outValD)
    p1I = dm.pntInbetween(p3, p1, outValD)
    p2I = dm.pntInbetween(p2, p0, outValD)
    p3I = dm.pntInbetween(p1, p3, outValD)
    p4I = dm.pntInbetween(p0, p2, outValD)
    
    p0T = dm.pntInbetween(p0, p2, outValT)
    p1T = dm.pntInbetween(p3, p1, outValT)
    p2T = dm.pntInbetween(p2, p0, outValT)
    p3T = dm.pntInbetween(p1, p3, outValT)
    p4T = dm.pntInbetween(p0, p2, outValT)

    p0V = rs.VectorAdd( p0I, nVec1 )
    p1V = rs.VectorAdd( p1I, nVec1 )
    p2V = rs.VectorAdd( p2I, nVec1 )
    p3V = rs.VectorAdd( p3I, nVec1 )
    p4V = rs.VectorAdd( p4I, nVec1 )
    coords_blatt = [p1, p3, p0, p2]
    crv_blatt = rs.AddCurve( coords_blatt, 1 )
    coords_blatt_vorne = [p1V, p3V, p0V, p1V]
    crv_blatt_vorne = rs.AddCurve( coords_blatt_vorne, 2 )
    coords_blatt_vorne_2 = [p1V, p0V, p3V, p1V]
    crv_blatt_vorne_2 = rs.AddCurve( coords_blatt_vorne_2, 2 )

    anz = int(dm.reMap(zVal, 0, 156-12, 50, 50))
    coordsA = rs.DivideCurve( crv_blatt, anz , 0)
    coordsI = rs.DivideCurve( crv_blatt_vorne, anz , 0)
    coordsII = rs.DivideCurve( crv_blatt_vorne_2, anz , 0)
    
    for i in range(anz) :
            rs.ObjectColor(crv_blatt, random.choice([col_5, col_2, col_6, col_4]))
            rs.ObjectColor(crv_blatt_vorne, random.choice([col_1, col_3]))
            rs.ObjectColor(crv_blatt_vorne_2, random.choice([col_1, col_3]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2), random.choice([col_5, col_2, col_6, col_4]))
            rs.ObjectColor(rs.AddCurve( [coordsI[i], coordsII[i]],2), random.choice([col_1, col_3]))

###Winter
def winterpanel(panel, anz=50, blende=5, blendeSize=0.9):
    p0,p1,p2,p3 = panel
    nVec = dm.normVec3pnts( p0, p1, p2 )
    zVal = p0 [2]
    outVal = dm.reMap(zVal, 3, 156-12, 150, 150)
    nVec1 = rs.VectorScale( nVec, outVal*0.1)

    col_1 = [82,91,104]
    col_2 = [218,227,243]
    col_3 = [167,184,210]#[98,129,175]
    col_4 = [207,207,207]#[166,165,165]

    coords = [p0,p1,p2,p3, p0]
    #rs.AddCurve( coords, 1 )
    cenPt = dm.pntInbetween( p0, p2 )
    #rs.AddPoint( cenPt )
    planeX = rs.PlaneFromPoints( cenPt, dm.pntInbetween(p0,p1), p1)
    rad = rs.Distance(p0,p3)*0.5*blendeSize
    circ = rs.AddCircle(planeX, rad*random.choice([0.5, 0.8, 1.0]))
    hexaPnts = rs.DivideCurve(circ, 6, 0)
    rs.DeleteObject(circ)
    hexaPnts.append(hexaPnts[0])
    hexagon = rs.AddCurve( hexaPnts, 1 )
    blendenPnts = rs.DivideCurve(hexagon, anz*6, 0)
    blendenPnts = blendenPnts+blendenPnts
    
    rs.ObjectColor(hexagon, col_1)
    for blatt in range(6):
        for i in range(blende):
            pass
            rs.ObjectColor(rs.AddLine( blendenPnts[blatt*anz], blendenPnts[blatt*anz+1+anz+i]), random.choice([col_2, col_3, col_4]))

###Morgen
def dawnpanel (panel, normPanel = 1 ):
    p0,p1,p2,p3 = panel
    nVec = dm.normVec3pnts( p0, p1, p2 )
    
    zVal = p0 [2]
    outVal = dm.reMap(zVal, 3, 156-12, 150, 150)
    outValD = dm.reMap(zVal, 0, 156-12, 0.8, 0.8) 
    outValT = dm.reMap(zVal, 0, 156-12, 0.7, 0.7) 

    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    nVec1 = rs.VectorScale( nVec, outVal*0.05)

    col_1 = [238,162,58]
    col_2 = [238,205,228]
    col_3 = [250,241,153]
    col_4 = [205,234,252]

    p0I = dm.pntInbetween(p0, p2, outValD)
    p1I = dm.pntInbetween(p3, p1, outValD)
    p2I = dm.pntInbetween(p2, p0, outValD)
    p3I = dm.pntInbetween(p1, p3, outValD)
    p4I = dm.pntInbetween(p0, p2, outValD)
    
    p0T = dm.pntInbetween(p0, p2, outValT)
    p1T = dm.pntInbetween(p3, p1, outValT)
    p2T = dm.pntInbetween(p2, p0, outValT)
    p3T = dm.pntInbetween(p1, p3, outValT)
    p4T = dm.pntInbetween(p0, p2, outValT)

    p0V = rs.VectorAdd( p0I, nVec1 )
    p1V = rs.VectorAdd( p1I, nVec1 )
    p2V = rs.VectorAdd( p2I, nVec1 )
    p3V = rs.VectorAdd( p3I, nVec1 )
    p4V = rs.VectorAdd( p4I, nVec1 )

    coords_bogen = [p0, p1, p2, p3]
    coords_bogen1 = [p2I, p1I, p0I, p3I ] #p0, ... p3
    coords_bogen2 = [p2T, p1T, p0T, p3T]  #p0, ... p3

    crv_bogen = rs.AddCurve( coords_bogen, 2 )
    crv_bogen1 = rs.AddCurve(coords_bogen1, 2)
    crv_bogen2 = rs.AddCurve(coords_bogen2, 2)
    
    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    anz_2 = int(dm.reMap(zVal, 0, 156-12, 20, 20))

    coordsA = rs.DivideCurve( crv_bogen, anz , 0)
    coordsI = rs.DivideCurve( crv_bogen1, anz , 0)
    coordsO = rs.DivideCurve( crv_bogen2, anz_2 , 0)


    for i in range(anz) :
            rs.ObjectColor(crv_bogen, random.choice([ col_2, col_4]))
            rs.ObjectColor(crv_bogen1, random.choice([ col_2, col_4]))
            rs.ObjectColor(crv_bogen2, random.choice([ col_2, col_4]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2), col_1)
            rs.ObjectColor(rs.AddCurve( [coordsI[i], coordsO[i]],2),col_3)

###Tag
def daypanel( panel, normPanel = 1 ):
    p0,p1,p2,p3 = panel
    nVec = dm.normVec3pnts( p0, p1, p2 )
    
    zVal = p0 [2]
    outVal = dm.reMap(zVal, 3, 156-12, 150, 150)
    outValD = dm.reMap(zVal, 0, 156-12, 0.8, 1.5) 
    
    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    nVec1 = rs.VectorScale( nVec, outVal*random.choice([0.1, 0.14, 0.2]))#0.1)

    col_1 = [251,206,177]
    col_2 = [165,128,27]
    col_3 = [252,247,205]
    col_4 = [204,189,132]

    p0I = dm.pntInbetween(p0, p2, outValD)
    p1I = dm.pntInbetween(p3, p1, outValD)
    p2I = dm.pntInbetween(p2, p0, outValD)
    p3I = dm.pntInbetween(p1, p3, outValD)
    p4I = dm.pntInbetween(p0, p2, outValD)
    
    p0V = rs.VectorAdd( p0I, nVec1 )
    p1V = rs.VectorAdd( p1I, nVec1 )
    p2V = rs.VectorAdd( p2I, nVec1 )
    p3V = rs.VectorAdd( p3I, nVec1 )
    p4V = rs.VectorAdd( p4I, nVec1 )

    circSize=random.choice([0.65, 0.88])
    cenPt = dm.pntInbetween( p0, p2 )
    planeX = rs.PlaneFromPoints( cenPt, dm.pntInbetween(p0,p1), p1)
    rad = rs.Distance(p0,p3)*0.5*circSize
    circ = rs.AddCircle(planeX, rad)
    
    circSize_kl=random.choice([0.25, 0.48])
    cenPt_kl = dm.pntInbetween( p0, p2)
    planeX_kl = rs.PlaneFromPoints( cenPt_kl, dm.pntInbetween(p0,p1), p1)
    rad_kl = rs.Distance(p0,p2)*0.3*circSize_kl
    circ_kl = rs.AddCircle(planeX_kl, rad_kl)

    circSize_k2= random.choice([0.15, 0.30])
    cenPt_k2 = dm.pntInbetween( p0, p2)
    planeX_k2 = rs.PlaneFromPoints( cenPt_k2, dm.pntInbetween(p0,p1), p1)
    rad_k2 = rs.Distance(p0,p2)*0.3*circSize_k2
    circ_k2 = rs.AddCircle(planeX_k2, rad_k2)

    circSize_k3= random.choice([0.10, 0.25])
    cenPt_k3 = dm.pntInbetween( p0, p2)
    planeX_k3 = rs.PlaneFromPoints( cenPt_k3, dm.pntInbetween(p0,p1), p1)
    rad_k3 = rs.Distance(p0,p2)*0.3*circSize_k3
    circ_k3 = rs.AddCircle(planeX_k3, rad_k3)


    anz = int(dm.reMap(zVal, 0, 156-12, 15, 15))
    coordsA = rs.DivideCurve( circ, anz , 0)
    coordsI = rs.DivideCurve( circ_kl, anz , 0)
    coordsII = rs.DivideCurve( circ_k2, anz , 0)
    coordsIII = rs.DivideCurve( circ_k3, anz , 0)
    
    for i in range(anz) :
            rs.ObjectColor(circ_kl, random.choice([col_2, col_4]))
            rs.ObjectColor(circ_k2, random.choice([col_2, col_4]))
            rs.ObjectColor(circ_k3, random.choice([col_2, col_4]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2),random.choice([col_1, col_3]))
            rs.ObjectColor(rs.AddCurve( [coordsII[i], coordsIII[i]],1),random.choice([col_2, col_4]))

    rs.DeleteObject(circ)

###Nacht
def nightpanel( panel, normPanel = 1 ):
    p0,p1,p2,p3 = panel
    nVec = dm.normVec3pnts( p0, p1, p2 )
    
    zVal = p0 [2]
    outVal = dm.reMap(zVal, 3, 156-12, 150, 150)
    outValD = dm.reMap(zVal, 0, 156-12, 0.8, 0.8) 
    
    anz = int(dm.reMap(zVal, 0, 156-12, 25, 25))
    nVec1 = rs.VectorScale( nVec, outVal*random.choice([0.06, 0.13, 0.2]))#0.1)
    
    col_1 = [31,43,86]#[31,9,10]
    col_2 = [62,100,127]#[39,63,80]
    col_3 = [212,217,222]#[233,234,235]
    col_4 = [120,80,127]#[72,41,77]

    p0I = dm.pntInbetween(p0, p2, outValD)
    p1I = dm.pntInbetween(p3, p1, outValD)
    p2I = dm.pntInbetween(p2, p0, outValD)
    p3I = dm.pntInbetween(p1, p3, outValD)
    p4I = dm.pntInbetween(p0, p2, outValD)
    
    p0V = rs.VectorAdd( p0I, nVec1 )
    p1V = rs.VectorAdd( p1I, nVec1 )
    p2V = rs.VectorAdd( p2I, nVec1 )
    p3V = rs.VectorAdd( p3I, nVec1 )
    p4V = rs.VectorAdd( p4I, nVec1 )
    
    circSize=random.choice([0.6, 0.7, 0.8, 0.88])#0.9
    cenPt = dm.pntInbetween( p0, p2)
    planeX = rs.PlaneFromPoints( cenPt, dm.pntInbetween(p0,p1), p1)
    rad = rs.Distance(p0,p3)*0.5*circSize
    circ = rs.AddCircle(planeX, rad)

    coords_dreieck = [p1V, p3V, p2V, p1V]#[p0V, p2V, p1V, p0V]
    dreieck = rs.AddCurve(coords_dreieck, 1)
    coords_dreieck_2 = [p1V, p2V, p3V, p1V]#[p0V, p2V, p1V, p0V]
    dreieck_2 = rs.AddCurve(coords_dreieck_2, 1)
    point = rs.AddPoint(p1V)

    anz = int(dm.reMap(zVal, 0, 156-12, 22, 22))
    anz_2 = int(dm.reMap(zVal, 0, 156-12, 55, 55))

    coordsA = rs.DivideCurve( circ, anz , 0)
    coordsI = rs.DivideCurve( dreieck, anz , 0)
    coordsII = rs.DivideCurve( dreieck_2, anz_2 , 0)

    for i in range(anz) :
            rs.ObjectColor(circ, random.choice([col_4]))
            rs.ObjectColor(dreieck, random.choice([ col_3]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2),random.choice([col_1, col_2, col_3, col_4]))
            rs.ObjectColor(rs.AddCurve( [coordsI[i], coordsII[i]],2), col_3)
            rs.ObjectColor(rs.AddCurve( [coordsI[i], point],2), col_3)
    rs.DeleteObject(point)


symbols = [springpanel, summerpanel, autumpanel, winterpanel, dawnpanel, daypanel, nightpanel] 

##############################################################################


if 1:
    for i,panel in enumerate(allPanels):
        dm.esc()
        pass
        rs.ObjectColor([rs.AddCurve( panel, 1)], [0,0,0])

        if i%10==0:
            rs.Redraw()
rs.Command("cplane W T enter", 0)


def dividePanel (panel, division = 1):
    p0, p1, p2, p3, = panel
    
    pL = dm.pntInbetween(p2, p3) ###Links
    pR = dm.pntInbetween(p0, p1) ###Rechts
    pM = dm.pntInbetween(dm.pntInbetween(p1, p0), dm.pntInbetween(p2, p3)) ###Mitte
    pZ = dm.pntInbetween(p1, p2) ###Oben
    pS = dm.pntInbetween(p0, p3) ###Unten
    
    if division == 0:
        return [panel]
    if division == 1:
        panel_O = [pR, p1, p2, pL]
        panel_U = [p0, pR, pL, p3]
        return [panel_U, panel_O]
    if division == 2:
        panel_LO = [pM, pZ, p1, pR]
        panel_RO = [pM, p0, p2, pL]
        panel_LU = [pS, pM, pR, p0]
        panel_RU = [pS, pM, pL, p3]
        return [panel_LO, panel_LU, panel_RO, panel_RU]


if 0:
    for i, panel in enumerate(allPanels[0:]):
        if i == 3: 
            panels = dividePanel(panel, division = random.randint(0,1))
            for panel in panels:
                springpanel(panel, normPanel=1)
        if i == 4: 
            panels = dividePanel(panel, division = random.randint(0,1))
            for panel in panels:
                summerpanel(panel, normPanel=1)
        if i == 5: 
            panels = dividePanel(panel, division = random.randint(0,1))
            for panel in panels:
                autumpanel(panel, normPanel=1)
        if i == 2:  
            panels = dividePanel(panel, division = random.randint(0,1))
            for panel in panels:
                if panel[0]:#[2]: #>24
                    anz = 64
                    rnd = random.randint( 6, anz*1 )
                    winterpanel(panel, anz=anz, blende=rnd, blendeSize=0.999)
        if i == 6: 
            panels = dividePanel(panel, division = random.randint(0,1))
            for panel in panels:
                dawnpanel(panel, normPanel=1)
        if i == 0:  
            panels = dividePanel(panel, division = random.randint(0,1))
            for panel in panels:
                daypanel(panel, normPanel=1)
        if i == 1:  
            panels = dividePanel(panel, division = 1)#random.randint(0,1))
            for panel in panels:
                nightpanel(panel, normPanel=1)