##Endabgabge#######
##Lorene Seufert###
##Gruber 03########

##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###
sys.path.append("P:/")     ###
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.ViewDisplayMode(rs.CurrentView(), "Pen_UNheadquaters")
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.getCameraTarget()
#dm.setCameraTarget( [1225.59695696, 338.73910091, 71.89443465], [633.13578082, 591.45410233, 65.1470593], lens=50.0, rota=0, upVec=[-0.009635040635226952,0.004109837751097299,0.9999451361077853] ) # ... danke, andi !
#dm.setCameraTarget( [122.49823833, 420.66932771, 418.80497599], [637.04519077, 596.83082374, 73.65398684], lens=50.0, rota=0, upVec=[0.5069426267460451,0.17355806132679627,0.8443262240013062] ) # ... danke, andi !

###_________________________________________#
### 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
dm.UNerror  = 0                             #
                                            #
################                            # 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("Default",)
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) )
################


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



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:4], 1.0 )
    #rs.AddPoints( UnoGridCoords )
    #rs.ZoomExtents()

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

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


### just 4 "dividePanel" == recursive, different sizes 
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)]]

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

def myPanel_V ( panel, anzahl=8 ):
    p0,p1,p2,p3 = panel
    rs.AddCurve( [p0,p1,p2,p3, p0],1)
    #rs.AddCurve( [p0,p1,p2,p3, p0],3)
    crv = rs.AddLine( p0, p3)
    if anzahl==0:
        anzahl = int(rs.Distance( p0, p3 ))
    coords03 = rs.DivideCurve( crv, anzahl)
    rs.DeleteObject(crv)
    #rs.AddPoints( coords03 )
    breite = rs.Distance( coords03[0], coords03[1])
    vecHoehe = rs.VectorSubtract( p1, p0)
    nVec = dm.normVec3pnts( p0, p1, p2 )
    nVec = rs.VectorScale( nVec, breite*2 )
    nVec = rs.VectorRotate( nVec, random.uniform(-30,30), [0,0,1] )
    for pX in coords03:
        pX0 = pX
        pX1 = rs.VectorAdd(pX, nVec)
        pX2 = rs.VectorAdd(pX1, vecHoehe)
        pX3 = rs.VectorAdd(pX, vecHoehe)
        coords = [pX0,pX1,pX2,pX3,pX0] 
        #rs.AddLine( pX, rs.VectorAdd(pX, nVec) )
        rs.AddCurve( coords, 1)
    
def myPanel_H ( panel, anzahl=8 ):
    p0,p1,p2,p3 = panel
    #rs.AddCurve( [p1,p0,p2,p3, p1],2)
    #rs.AddCurve( [p0,p2,p1,p3, p0],2)
    #rs.AddCurve( [p0,p1,p2,p3, p0],3)
    crv = rs.AddLine( p0, p1)
    coords = rs.DivideCurve( crv, anzahl )
    rs.DeleteObject(crv)
    untenVec = rs.VectorSubtract( p3, p0 )
    for cor in coords:
        rs.AddLine( cor, rs.VectorAdd(cor, untenVec))


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


def fancyPanel (panel,cornerVal):
    p0,p1,p2,p3 = panel
    #
    ###length1 = rs.CurveLength(rs.AddCurve([p0,p1]))
    ###length2 = rs.CurveLength(rs.AddCurve([p1,p2]))
    ###rs.AddCurve([p2,p3])
    
    
    #print cornerVal
    if cornerVal == 0:
        corner1 = p0
        corner2 = p2
        verVec = rs.VectorSubtract(p1,p0)
        horVec = rs.VectorSubtract(p3,p0)
        pt6 = p2
        pt7 = p3
        color = [62,117,59]
    
    if cornerVal == 1:
        corner1 = p1
        corner2 = p3
        verVec = rs.VectorSubtract(p0,p1)
        horVec = rs.VectorSubtract(p2,p1)
        pt6 = p3
        pt7 = p2
        color = [180,229,175]
    
    if cornerVal == 2:
        corner1 = p2
        corner2 = p0
        verVec = rs.VectorSubtract(p1,p2)
        horVec = rs.VectorSubtract(p3,p2)
        pt6 = p0
        pt7 = p3
        color = [14,66,67]
    
    if cornerVal == 3:
        corner1 = p3
        corner2 = p1
        verVec = rs.VectorSubtract(p0,p3)
        horVec = rs.VectorSubtract(p2,p3)
        pt6 = p1
        pt7 = p2
        color = [137,172,118]
    
    straightVec = rs.VectorSubtract(corner2,corner1)
    
    pt1 = rs.VectorAdd(rs.VectorAdd(corner1,rs.VectorScale(verVec,random.uniform(0.3,0.5))),rs.VectorScale(horVec,random.uniform(0.1,0.25)))
    pt2 = rs.VectorAdd(pt1,rs.VectorScale(horVec,random.uniform(0.05,0.15)))
    pt3 = rs.VectorAdd(rs.VectorAdd(pt2, rs.VectorScale(-verVec,random.uniform(0.05,0.1))),rs.VectorScale(horVec,random.uniform(0.02,0.08)))
    pt4 = rs.VectorAdd(pt3,rs.VectorScale(horVec,random.uniform(0.05,0.15)))
    pt5 = rs.VectorAdd(corner2,rs.VectorScale(-horVec,random.uniform(0.01,0.05)))
    pt5 = rs.VectorAdd(corner2,rs.VectorScale(-horVec,random.uniform(0.1,0.2)))
    #pt5 = rs.VectorAdd(corner2,rs.VectorScale(-horVec,random.uniform(0.0,0.0)))
    
    #rs.AddCurve( panel, 1)
    allPts =[corner1, pt1, pt2, pt3, pt4, pt5]
    allPts =[corner1, pt1, pt2, pt3, pt4, pt5, pt6, pt7, corner1]
    #rs.AddPoints(allPts)
    #dm.textDots( allPts )
    finalline = rs.AddCurve(allPts, 1)
    #print corner1, corner2
    #rs.AddCurve([corner1,corner2])
    ###rs.ObjectColor(finalline, color)
    #print cornerVal
    return finalline ### ag 


#backPanels = [ reversed(panel) for panel in backPanels ]

allPanels = frontPanels+backPanels
if 1:
    old = 0
    for steps in range(3, 12): ### 10: end with 4 (noGo !); 12: end with 2
        #steps = 1
        UnoPanelCoords = dm.getUNpanelCoords(anzL=20, anzH=20, anzD=3, stepL=steps, stepH=steps*1+0, stepD=1) ### = standard for hu_06
        frontPanels = UnoPanelCoords[0]
        backPanels = UnoPanelCoords[1]
        if 0:
            for i,panel in enumerate(backPanels):
                p0,p1,p2,p3 = panel
                backPanels[i] = [p3,p2,p1,p0]
        allPanels = frontPanels+backPanels
        #print old, len(allPanels)
        if len(allPanels)==old or len(allPanels)==4:
            continue
        old = len(allPanels)
        print steps, "dim:",str(round(rs.Distance(UnoPanelCoords[0][0][0], UnoPanelCoords[0][0][3]), 1))+"/"+str(rs.Distance(UnoPanelCoords[0][0][0], UnoPanelCoords[0][0][1])), " >>", round(rs.Distance(UnoPanelCoords[0][0][0], UnoPanelCoords[0][0][3])/rs.Distance(UnoPanelCoords[0][0][0], UnoPanelCoords[0][0][1]), 2) ,
        print "len(allPanels)", len(allPanels)#, "( = front + back =",len(UnoPanelCoords[0]), "+", len(UnoPanelCoords[1]), ")"

        
        allCrvs = []
        dm.newEmptyLayer("myPROJ::tst")
        for i,panel in enumerate(allPanels[0:0]):
            dm.esc()
            pass
            cornerVal = random.randint(0,3)
            #random.shuffle(panel)
            #crv = rs.AddCurve( panel, 3 )
            #dm.textDots( panel )
            crv = fancyPanel (panel, cornerVal)
            allCrvs.append( crv )
            if 0 and i%100==0:
                rs.Redraw()
        rs.Redraw()
        #rs.Sleep(300)


#print "len(allPanels)", len(allPanels), "( = front + back =",len(frontPanels), "+", len(backPanels), ")"
        if 1:
            haelfte = int(len(allCrvs)*0.5) ### same as len(frontPanels) etc
            anz = 32*steps
            frames = 1
            frames = steps*1
            for f in range(frames):
                dm.newEmptyLayer("myPROJ::tst")
                allCrvs = []
                for i,panel in enumerate(allPanels[0:]):
                    dm.esc()
                    allCrvs.append( fancyPanel (panel, random.randint(0,3)) )
                #rs.Redraw()
                haelfte = int(len(allCrvs)*0.5)
                for i in range(0,haelfte):# haelfte):
                    dm.esc()
                    #rs.SelectObjects( [ allCrvs[i], allCrvs[i+haelfte] ] )
                    fCrv = allCrvs[i]
                    bCrv = allCrvs[i+haelfte]
                    rs.ReverseCurve(bCrv)
                    
                    rs.AddPlanarSrf( [fCrv, bCrv] )
                   
                    if random.randint(0,100) < 30:# or rs.CurveStartPoint(fCrv)[2] > 40:
                        ### TWEEN_Crvs
                        tweens = rs.AddTweenCurves( fCrv, bCrv, number_of_curves=anz*0.5, method=0, sample_number=10)
                        rs.ObjectColor( tweens, [122,143,175])
                    
                    elif random.randint(0,100) < 101:
                        ### DIVI + CONNECT
                        coordsF = rs.DivideCurve( fCrv, anz, 0)
                        coordsB = rs.DivideCurve( bCrv, anz, 0)
                        dist = rs.Distance( coordsF[0], coordsB[0])
                        #print int(rs.Distance( coordsF[0], coordsB[0]))
                        if 1 or dist < 38 or coordsF[0][2]>50:
                            list = zip(coordsF, coordsB)
                            for lis in list:
                                pass
                                rs.ObjectColor( rs.AddCurve( lis ), [47,42,90] )
                        else:
                            ### CONNECT simple
                            coordsF = rs.CurvePoints( fCrv )
                            coordsB = rs.CurvePoints( bCrv )
                            list = zip(coordsF, coordsB)
                            for lis in list:
                                pass
                                rs.ObjectColor( rs.AddCurve( lis ), [106,147,157])
                
                #dm.zA()
                rs.Redraw()
                rs.Sleep(100)
                    #rs.DeleteObjects(allCrvs)



##########################
rs.CurrentLayer("Default")


##########################
if 0:
    for i,panel in enumerate(allPanels[0:]):
        dm.esc()
        pass
        rs.AddCurve( panel, 1)
        if 1 and panel[0][2] > -1:
            if random.uniform(0, 100) < 50:
                myPanel_V ( panel )
            elif random.uniform(0, 100) < 50:
                myPanel_H ( panel, anzahl=8 )
        if i%10==0:
            rs.Redraw()


    coords = rs.DivideCurve(rs.AddCurve( [dm.getUnoCoord(0,0,39),
                    dm.getUnoCoord(10,0,39),
                    dm.getUnoCoord(10,3,39),
                    dm.getUnoCoord(0,3,39),
                    dm.getUnoCoord(0,0,39)
                    ], 1), 11)
    random.shuffle(coords)
    #rs.AddCurve( coords )