###################################
### 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, os   ###
sys.path.append("P:/")     ###
sys.path.append("D:/PY/")
sys.path.append("P:/WWW/mori21/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.ViewDisplayMode(rs.CurrentView(), "rendered")
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=9*1, anzH=39, anzD=3, stepL=1, stepH=2, stepD=1) ### = standard for hu_06
###########################################################################################
##########################################################
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 0: ### 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), [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 )

allPanels  = [[dm.getUnoCoord( 0, 0, 20), dm.getUnoCoord( 0, 0, 39), dm.getUnoCoord(10, 0, 39), dm.getUnoCoord(10, 0, 20)]]
allPanels.append([dm.getUnoCoord( 0, 0, 0), dm.getUnoCoord( 0, 0, 20), dm.getUnoCoord(10, 0, 20), dm.getUnoCoord(10, 0, 0)])
random.shuffle(allPanels)
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), [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) =", len(frontPanels)
    dm.textDots( frontPanels[0] )
    
    for coords in frontPanels[0:20]:
        pass
        rs.AddPoints( coords )
        rs.AddCurve( coords, 1 )
        #rs.AddSrfPt( coords )
    #for coords in sidePanels[0:]:
    #    rs.AddPoints( coords )
    
    for coords in BigPanelCoords[1][5:]:
        pass
        coords[-1]=coords[random.randint(0,3)]
        rs.ObjectColor( rs.AddCurve( coords, degree=random.randint(1,3) ), [0,100,0])
        rs.Redraw()

def dividePanel( panel=allPanels[0], maxPanels=25, minHig=4.0 ):
        dm.esc()
        if maxPanels>500: maxPanels=500
        random.shuffle(allPanels)
        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=128, minHig=6.0 )
print "::: len(allPanels)",len(allPanels)

def gC(L,B,H):
    return dm.getUnoCoord(L,B,H)

#_____________________________here you go:
dm.newEmptyLayer("myPROJ", [100,110,200])
##################################################################
##################################################################
def myPanel_side(panel, basement = 0):

        p0, p1, p2, p3 = panel
        
        nVec = dm.normVec3pnts( p0, p1, p2)
        zCor = p0[2]
        auskrag = dm.reMap(zCor, 0, 156, 1.0, 1.0)         ###tiefen verschieden
        nVec = rs.VectorScale( nVec, auskrag)
        
        p00 = dm.pntInbetween(p0, p1, 0.7 )
        p01 = dm.pntInbetween(p3, p2, 0.7 )
        p02 = dm.pntInbetween(p00, p01, 0.5 )
        
        p02 = rs.VectorAdd ( p02, rs.VectorScale( lVec, 1))
        p02 = rs.VectorAdd ( p02, rs.VectorScale( lVec, 1))
        
        
        coords = [p00, p02, p01]
        
        #base = rs.AddCurve( [p0, p1, p2, p3, p0], 1)
        
        for i,cor in enumerate(coords):
                    cor = rs.VectorAdd(cor, nVec)
                    coords[i] = cor

                    aussen = rs.AddCurve( coords, 1)
        
                    oben = rs.AddCurve( [p1, p2], 1)
                    unten= rs.AddCurve( [p0,p3], 1)
        
                    anz = 25
        
                    coordsA = rs.DivideCurve( oben, anz)
                    coordsB = rs.DivideCurve( unten, anz , 0)
                    coordsC = rs.DivideCurve( aussen, anz , 0)
        
        for i in range( anz) :
            rs.AddCurve( [coordsA [i], coordsC[i]], 1)
                    
        for i in range( anz) :
            rs.AddCurve( [coordsB [i], coordsC[i]], 1)
        
        #linee = rs.AddCurve([p00, p02], 1)
        #linee = rs.AddCurve([p0, p3], 1)
        
        
for i,panel in enumerate(sidePanels[:]):
        pass
        basement = 0
        if i<0 or i>130:
            basement = 1
        myPanel_side( panel, basement = basement)
        
        
for i,panel in enumerate(upSidePanels[:]):
        pass
        basement = 0
        if i<0 or i>130:
            basement = 1
        myPanel_side( panel, basement = basement)

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




p0= gC(10,0,0)
p1= gC(9,0,0)

coords_0 = [gC(0,3,0), gC(0,1,4), gC(0,0,8), gC(0,2,12), gC(0,1,18), gC(0,3,25), gC(0,0,29), gC(0,1,33), gC(0,3,39) ]
coords_1 = [gC(2,3,0), gC(2,2,4), gC(2,1,8), gC(2,0,12), gC(2,1,18), gC(2,2,25), gC(2,1,29), gC(2,2,33), gC(2,3,39) ]
coords_2 = [gC(4,3,0), gC(4,1,4), gC(4,0,8), gC(4,1,12), gC(4,0,18), gC(4,1,25), gC(4,2,29), gC(4,1,33), gC(4,3,39) ]
coords_3 = [gC(6,3,0), gC(6,2,4), gC(6,1,8), gC(6,3,12), gC(6,2,18), gC(6,1,25), gC(6,1,29), gC(6,2,33), gC(6,3,39)]
coords_4 = [gC(8,3,0), gC(8,1,4), gC(8,2,8), gC(8,0,12), gC(8,1,18), gC(8,1,25), gC(8,2,29), gC(8,1,33), gC(8,3,39)]
coords_5 = [gC(10,3,0), gC(10,2,4), gC(10,1,8), gC(10,2,12), gC(10,1,18), gC(10,0,25), gC(10,1,29), gC(10,2,33), gC(10,3,39)]


crv_0 = rs.AddCurve( coords_0, 2)
crv_1 = rs.AddCurve( coords_1, 2)
crv_2 = rs.AddCurve( coords_2, 3)
crv_3 = rs.AddCurve( coords_3, 2)
crv_4 = rs.AddCurve( coords_4, 2)
crv_5 = rs.AddCurve( coords_5, 2)

anz = 16*1
showPts = 0
deg = 1
delIt = 0

frames = 25*1
#path = "L:/animatzi/GD_tst/"
#if not os.path.exists(path): os.makedirs(path)

#coords_1 = makeFigure( pnts=pnts_singt, crv_degree=deg, pos=[50.0, 10.0,0], divis=anz, show=showPts, delIt=delIt, crv_name="MM_singt", obj_color=[0,200,0])
#coords_2 = makeFigure( pnts=pnts_wind, crv_degree=deg, pos=[00.0, 10.0,0], divis=anz, show=showPts, delIt=delIt, crv_name="MM_wind", obj_color=[210,0,120])

#rs.LayerVisible("mori", 1)
#MM_0 = rs.ObjectsByName("MM_schlank")[0]
#MM_1 = rs.ObjectsByName("MM_breit")[0]
#MM_2 = rs.ObjectsByName("MM_arme")[0]
coords_0 = rs.DivideCurve(crv_0, anz, 0)
coords_1 = rs.DivideCurve(crv_1, anz, 0)
coords_2 = rs.DivideCurve(crv_2, anz, 0)
coords_3 = rs.DivideCurve(crv_3, anz, 0)
coords_4 = rs.DivideCurve(crv_4, anz, 0)
coords_5 = rs.DivideCurve(crv_5, anz, 0)
#rs.LayerVisible("mori", 0)

coordsLists = [coords_0, coords_1, coords_2, coords_3, coords_4, coords_5]

#rs.HideObjects([crv_0,crv_1,crv_2,crv_3]) 

dm.getCameraTarget()
#dm.setCameraTarget( [-77.48685689, 11.77273249, 12.05421199], [17.20711797, 25.7546931, 14.05896983], lens=49.99999999, rota=0, upVec=[-0.020714654726424725,-0.003058605226544303,0.999780749971529] ) # ... danke, andi !
## cam 1
#dm.setCameraTarget( [-3151.51513522, -763.71493147, 419.74295749], [-582.27838656, -384.35640237, -47.55628417], lens=49.99999999, rota=0, upVec=[0.17518845445825773,0.02586730648051854,0.9841950456489659] ) # ... danke, andi !
#dm.setCameraTarget( [2282.27449924, -671.8852515, 454.02906213], [-361.78198394, 156.74870715, -257.41642053], lens=49.99999999, rota=0, upVec=[-0.23731190987082756,0.07437235496387741,0.9685823714329036] ) # ... danke, andi !
dm.setCameraTarget( [304.37066938, 600.09470895, 86.15043311], [792.29987168, 587.3116312, 75.92471574], lens=49.99999999, rota=0, upVec=[0.020938410144171304,-0.000548557707655585,0.9997806169680805] ) # ... danke, andi !

if 1:
    if 1:
        framNumber = 0
        fac = 1/frames
        allCoords = []
        for i in range(len(coordsLists)-1):
            for fram in range(0, frames+1):
    #            facX = fac*fram
    #            coords = []
    #            for j in range(anz):
    #                cor = dm.pntInbetween( coords_1[j], coords_2[j], facX )
    #                coords.append(cor)
                coords_0=coordsLists[i]
                coords_1=coordsLists[i+1]
                coords = [ dm.pntInbetween( coords_0[j], coords_1[j], fac*fram ) for j in range(anz+1) ]
                #allCoords.append( coords )
                #rs.AddPoints(coords)
                #rs.AddLine( coords[-1], coords[0] )
                #coords.append(coords[0])
                crv = rs.AddCurve(coords, 2)
                
                #rs.Redraw()
                #rs.Command("isolate -selId "+str(crv)+" enter enter", 0)
                nam = dm.makeName("gD", frameNumber=framNumber, anzahl=4, format='jpg')
                rs.Redraw()
                
                #rs.Command("-viewCaptureToFile Width=960 Height=540 Scale=2 DrawCPlaneAxes=No TransparentBackground=No "+path+nam, 0)
                framNumber +=1
                #print nam
                dm.esc()
                
        


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

import math
import rhinoscriptsyntax as rs
import time

# Startpunkt der Fassade
p0 = [727, 531, 0]    # Unten links vorne
p1 = [787, 640, 0]    # Unten rechts vorne
p2 = [787, 640, 180]  # Oben rechts vorne
p3 = [727, 531, 163]  # Oben links vorne

# Parameter fuer die Wellenform
phase_shift = 0.0  # Startwert der Phasenverschiebung
phase_step = 0.1   # Schrittweite fuer die Bewegung

# Schleife fuer die Bewegung
for frame in range(100):  # Anzahl der Frames
    rs.DeleteObjects(rs.ObjectsByName("wave_curve"))  
    
    # Erstelle die Wellenkurven
    for u in rs.frange(0.0, 1.0, 0.01):  # u-Richtung (Breite der Fassade)
        ptsForCurve = []
        
        # Interpoliere die Punkte entlang der unteren und oberen Kante
        lower_point = [p0[0] + (p1[0] - p0[0]) * u, p0[1] + (p1[1] - p0[1]) * u, p0[2]]
        upper_point = [p3[0] + (p2[0] - p3[0]) * u, p3[1] + (p2[1] - p3[1]) * u, p3[2]]
        
        for v in rs.frange(0.0, 1.0, 0.05):  # v-Richtung (Hoehe der Fassade)
            # Interpoliere den Punkt zwischen unterer und oberer Kante
            x = lower_point[0] + (upper_point[0] - lower_point[0]) * v
            y = lower_point[1] + (upper_point[1] - lower_point[1]) * v
            z = lower_point[2] + (upper_point[2] - lower_point[2]) * v
            
            # Berechne die Wellenform mit Phasenverschiebung
            wave = math.sin((u + phase_shift) * 2 * math.pi) * math.sin(v * 2 * math.pi)
            y += wave * 10  # Amplitude der Welle
            
            ptsForCurve.append([x, y, z])  # Punkt im 3D-Raum
        
        # Erstelle eine Kurve aus den Punkten
        curve = rs.AddCurve(ptsForCurve)
        rs.ObjectName(curve, "wave_curve")  # Benenne die Kurve
    
    # Aktualisiere die Phasenverschiebung
    phase_shift += phase_step
    
    # Zeichne die Szene neu
    rs.Redraw()
    time.sleep(0.1)  # Kurze Pause fuer die Animation

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