###################################
### DM2_w24 # AGruber@tugraz.at ###
### hu_06 UN_headquaters  NYC   ### ######################################################
### paneling  / new dimensions  ### 87.5 x 22.0 meters (was lenY = 116.56 / lenX =  28.18)
################################### ######################################################


##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###
sys.path.append("P:/dm2")     ###
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, 1)                                # 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(1)                                      # nomen est omen
rs.EnableRedraw(0)



###_________________________________________#
### 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.
################____________________________#
################
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) )
################
###########################################################################################
UnoPanelCoords = dm.getUNpanelCoords(anzL=10*7, anzH=39, anzD=3, stepL=1, stepH=1, stepD=1) ### = all ~windows_panels
BigPanelCoords = dm.getUNpanelCoords(anzL=10*1, anzH=39, anzD=3, stepL=2, stepH=6, stepD=2) ### = all ~windows_panels
UnoPanelCoords = dm.getUNpanelCoords(anzL=10*1, anzH=39, anzD=3, stepL=1, stepH=3, stepD=1) ### = standard for hu_06 ######mal .. (bsp. 7) um linien in breite zu schmaelern#######
###########################################################################################
##########################################################
frontPanels   = UnoPanelCoords[0] ### list of coordLists !
backPanels    = UnoPanelCoords[1]
sidePanels    = UnoPanelCoords[2]
upSidePanels  = UnoPanelCoords[3]
allPanels     = UnoPanelCoords[4]
#################################

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

if 1: ### SETUP >> dont' exec @ homework !
    rs.ObjectColor(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), [0,0,0])#[100,0,200])
#    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:4], 1.0 )
    rs.ZoomExtents()
    #for coords in BigPanelCoords[4]: rs.AddCurve( coords, 1 )

if 0: ### DEMO  >> dont' exec @ homework !
    print len(frontPanels)
    dm.textDots( frontPanels[0] )
    
    for coords in frontPanels[0:10]+sidePanels:
        pass
        rs.AddPoints( coords )
        rs.AddCurve( coords, 1 )
        #rs.AddSrfPt( coords )
    #for coords in sidePanels[0:]:
    #    rs.AddPoints( coords )
    
    for coords in BigPanelCoords[4]:
        pass
        rs.AddCurve( coords, 1 )

if 0: ### DEMO  >> dont' exec @ homework !!!!!!############

#############:
### panel_DEF:
    def myPanel( panel, basement = 0 ):
        p0, p1, p2, p3 = panel ### get items (==coords) from list
        rs.AddLine( p0, p2 )
        if basement:
            crv = rs.AddCurve( [p0, p1, dm.pntInbetween(p1, p3), p2, p3], 1 )
            rs.ObjectPrintWidth( crv, 1 )
            rs.ObjectColor( crv, [200,0,0])
        else:
            rs.AddCurve( panel )

    for i,panel in enumerate(frontPanels[:]):
        pass
        panNr = 0
        if i<10 or i>119:
            panNr = 1
        myPanel( panel, basement = panNr ) ### basement = (i<20 or i>109)
        #rs.Redraw()

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

def panelAG( 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.1)
    
    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 )

#######################################################################
######BUCH
if 1:
    col = [0,0,0]
    col_1 = [105,105,105]
    for x in range (0, 11):
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 0, 0) ), col)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 3, 0) ), col)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 0, 39) ), col)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 3, 39) ), col)
    for x in range (1, 10):
        for z in range (1,39):
            rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(x, 3, z) ), col_1)
    for y in range (0, 4):
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(10, y, 0)), col)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(10, y, 39)), col)
    for y in range (1, 3):
        for z in range (1, 39):
            rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(10, y, z) ), col_1)
    for z in range (0, 40):
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(10, 0, z) ), col)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(10, 3, z) ), col)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(0, 0, z) ), col)
        rs.ObjectColor(rs.AddPoint( dm.getUnoCoord(0, 3, z) ), col)
##Buchseiten
    rs.ObjectColor(rs.AddCurve([dm.getUnoCoord(10, 1, 39),dm.getUnoCoord(0, 1,  39),dm.getUnoCoord(0, 1, 0), dm.getUnoCoord(10, 1,  0)],   1), col)
    rs.ObjectColor(rs.AddCurve([dm.getUnoCoord(10, 2, 39),dm.getUnoCoord(0, 2,  39),dm.getUnoCoord(0, 2, 0), dm.getUnoCoord(10, 2,  0)  ], 1), col)


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


###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.95])#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.5, 0.7])#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.6])#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.8, 0.8) 
    
    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]
    crv_wellen = rs.AddCurve( coords_wellen, 2 )  ###wellen

    if i > -1:
        rs.ObjectColor(crv_wellen, col_1)
    if i > 29:
        rs.ObjectColor(crv_wellen, col_2)
    if i > 59:
        rs.ObjectColor(crv_wellen, col_3)
    if i > 89:
        rs.ObjectColor(crv_wellen, col_4)

###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]

    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, 1 )
    
    anz = int(dm.reMap(zVal, 0, 156-12, 5, 5))
    coordsA = rs.DivideCurve( crv_blatt, anz , 0)
    coordsI = rs.DivideCurve( crv_blatt_vorne, anz , 0)
    for i in range(anz) :
            rs.ObjectColor(crv_blatt, random.choice([col_1, col_2, col_3, col_4]))
            rs.ObjectColor(crv_blatt_vorne, random.choice([col_1, col_2, col_3, col_4]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2), random.choice([col_1, col_2, col_3, col_4]))

###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.2]))
    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.8, 1.2])#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.3, 0.55])#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)

    anz = int(dm.reMap(zVal, 0, 156-12, 15, 15))
    coordsA = rs.DivideCurve( circ, anz , 0)
    coordsI = rs.DivideCurve( circ_kl, anz , 0)
    
    for i in range(anz) :
            rs.ObjectColor(circ_kl, random.choice([col_2, col_4]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2),random.choice([col_1, col_3]))
    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.01, 0.1, 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.8, 1.1])#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_halbkreis = [p0V, p1V, p2V, p3V]
    halbkreis = rs.AddCurve(coords_halbkreis, 2)
    halbkreis_ = rs.AddLine(p0V, p3V)

    anz = int(dm.reMap(zVal, 0, 156-12, 20, 20))
    coordsA = rs.DivideCurve( circ, anz , 0)
    coordsI = rs.DivideCurve( halbkreis, anz , 0)
    
    for i in range(anz) :
            rs.ObjectColor(circ, random.choice([col_4]))
            rs.ObjectColor(halbkreis, random.choice([ col_3]))
            rs.ObjectColor(halbkreis_, random.choice([ col_3]))
            rs.ObjectColor(rs.AddCurve( [coordsA[i], coordsI[i]],2),random.choice([col_1, col_2, col_3, col_4]))
            
            crv_2_col = [rs.AddCurve( [p3V, p1V, p2V, p3V, p0V, p1V, p2V, p0V, p3V], 2 ), rs.AddCurve( [p1V, p2V, p3V, p1V, p2V, p1V, p0V, p2V, p3V, p1V], 5 ), rs.AddCurve( [p0V, p1V, p2V, p3V, p0V, p1V, p2V, p3V, p4V], 4 )]
            rs.ObjectColor(crv_2_col, col_3) #[0, 0, 0]




for i,panel in enumerate(frontPanels):
    pass
    #rs.AddCurve( panel, 1)
    goOut = 1
#    if i:                   
#        goOut = 0
#    if i<30:
#        goOut = 0
    panelAG( panel, normPanel = goOut )
###fruehling
    springpanel (panel, normPanel = 1)
###sommer
#    summerpanel (panel, normPanel = 1)
###herbst
#    autumpanel (panel, normPanel = 1)
###winter
#    if panel[0]:#[2]: #>24
#        anz = 64
#        rnd = random.randint( 6, anz*1 )
#        winterpanel(panel, anz=anz, blende=rnd, blendeSize=0.999)
###morgen
#    dawnpanel (panel, normPanel = 1)
###tag
#    daypanel (panel, normPanel = 1)
###night
#    nightpanel (panel, normPanel = 1)



#____________________________:here you end

#################################
#rs.ZoomExtents()
rs.EnableRedraw(1) ### 4 the MACs
dm.printDisplay(1)
dm.newEmptyLayer("Default")