##################################
### DM2_w22 # AGruber@tugraz.at ###
### ue_07 UN_headquaters  NYC   ###
###################################


##############################
import rhinoscriptsyntax as rs      ###
import random, time, sys            ###
sys.path.append("P:/")              ### add LW P:/ to rhino's default search path AND
sys.path.append("P:/WWW/default114/dm2/")     ### add YOUR LW P:/WWW/user/ to rhino's default search path ...
import DM2_lib as dm                ### ... thus DM2_lib.py can be found !
#import OSM_lib as osm               ### "osm" is alias 4 calling defs @ _osm_lib
##############################      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.printDisplay(1)                                      # nomen est omen
rs.EnableRedraw(0) ### MAC >> uncomment !


###_________________________________________# import OSM objects

###_________________________________________#
### basic settings for grid to fit UN_slab  #
###                                         # ! no need 2 change !
floors = H  = dm.H = 40                    # def=40 / incl roof
slabs  = L  = dm.L = 11                    # def=11
depth  = D  = dm.D =  4                    # def= 4 / division in building_depth
floorHeight = fH = dm.fH = 4.0             # def= 4.0 / 4.0*(H-1) = 156 meters
                                            #
#############                               # get gridCoords L*D*H = 1760
#UnoGridCoords     = dm.getUnoGridCoords(L, D, H, fH)
UnoGridCoords = dm.UnoGridCoords           # for the defs @ dm_lib
#################___________________________#




####################################################
#UnoGridCoords = dm.getUnoGridCoords(11, 4, 40, 4.0) ### is executed at the end of DM2_lib
UnoGridCoords = dm.UnoGridCoords
####################################################

dm.newEmptyLayer("UNO::slabs", [20,60,100])
dm.newEmptyLayer("UNO::stair", [250,200,10])
dm.newEmptyLayer("UNO::geo", [150,20,150])

depthVec  = dVec = rs.VectorSubtract( dm.getUnoCoord(0, 0, 0), dm.getUnoCoord(0, 1, 0) )
lengthVec = lVec = rs.VectorSubtract( dm.getUnoCoord(0, 0, 0), dm.getUnoCoord(1, 0, 0) )
heightVec = hVec = rs.VectorSubtract( dm.getUnoCoord(0, 0, 0), dm.getUnoCoord(0, 0, 1) )
rs.AddLine( dm.getUnoCoord(0, 0, 1), dm.getUnoCoord(0, 2, 1) )
rs.AddLine( dm.getUnoCoord(0, 0, 1), dm.getUnoCoord(1, 0, 1) )
rs.AddLine( dm.getUnoCoord(0, 0, 1), dm.getUnoCoord(0, 0, 4) )

pX = dm.getUnoCoord(0, 2, 10)
pY = dm.getUnoCoord(L-1, 0, H-1)
#rs.AddLine(pX,pY)

#rs.AddCircle(pX,30.5)

################################
pXX = dm.getUnoCoord(5, 0, 40-1)
lenx = 50.1
#rs.AddLine( pXX , rs.VectorAdd(pXX, rs.VectorScale( dVec, lenx*-1 ) ) )
#rs.AddLine( pXX , rs.VectorAdd(pXX, rs.VectorScale( lVec, lenx*-5 ) ) )
####################################################################

############################################################
############################################################
############################################################
dm.newEmptyLayer("UNO::veins", [200,0,0])
#rs.AddLine( dm.getUnoCoord(0, 0, 1), dm.getUnoCoord(0, 0, 39) )

inner_top = []
border_top = []
edge_top = []
edge_bottom = []
border_front = []
border_back = []
border_left = []
border_right = []

for l in range(9):
        for d in range(2):
            inner_top.append( dm.getUnoCoord(l+1,d+1,39))

#print len(inner_top)
for l in range(11):
        for d in range(4):
            border_top.append( dm.getUnoCoord(l,d,39))

for d in range(4):
    edge_top.append(dm.getUnoCoord(0,d,39))
    edge_top.append(dm.getUnoCoord(10,d,39))
    edge_bottom.append(dm.getUnoCoord(0,d,0))
    edge_bottom.append(dm.getUnoCoord(10,d,0))


for l in range(11):
    edge_top.append(dm.getUnoCoord(l,0,39))
    edge_top.append(dm.getUnoCoord(l,3,39))
    edge_bottom.append(dm.getUnoCoord(l,0,0))
    edge_bottom.append(dm.getUnoCoord(l,3,0))


for l in range(11):
    for h in range(40):
        border_front.append( dm.getUnoCoord(l,0,h))
        border_back.append( dm.getUnoCoord(l,3,h))

for d in range(4):
    for h in range(40):
        border_left.append( dm.getUnoCoord(0,d,h))
        border_right.append( dm.getUnoCoord(10,d,h))

#rs.AddPoints(border_left)
#rs.AddPoints(border_right)
#rs.SelectObjects(edge)
inner_firsthalf = []
inner_secondhalf = []
for i in range(9):
    inner_firsthalf.append(inner_top[i])
    inner_secondhalf.append(inner_top[i+9])
emerge_pnt = random.choice(inner_firsthalf)
emerge_pnt2 = random.choice(inner_secondhalf)
#dm.getUnoCoord(5,2,39)
#random.choice(border_top)
#print emerge_pnt
ep = []
ep.append(rs.AddPoint(emerge_pnt))
dm.textDots(ep)
ep2 = []
ep2.append(rs.AddPoint(emerge_pnt2))
dm.textDots(ep2)
start_pnts = []
veins = []

def rand_top(emerge_pnt,min_len = 1,max_len = 2):


    for i in range(2):
        sign = random.choice([1,-1])
        D_direc = rs.VectorScale(rs.VectorScale(dVec,sign),round(random.uniform(min_len,max_len)))
        L_direc = rs.VectorScale(rs.VectorScale(lVec,sign),round(random.uniform(min_len,max_len)))
        direc_vec = rs.VectorAdd(D_direc,L_direc)
        end_pnt = rs.VectorAdd(emerge_pnt,direc_vec)
        if end_pnt not in border_top:
            dis_pnts = dm.pntsSortDistancePnt(end_pnt,border_top)
            end_pnt = dis_pnts[0]
        line = rs.AddLine(emerge_pnt,end_pnt)
        veins.append(line)
        start_pnts.append(end_pnt)




def rand_front(emerge_pnt,min_len = 1,max_len = 2,min_vert = 3,max_vert = 5):


    for i in range(2):
       sign = random.choice([1,-1])
       H_direc = rs.VectorScale(hVec,round(random.uniform(min_vert,max_vert)))
       L_direc = rs.VectorScale(rs.VectorScale(lVec,sign),round(random.uniform(min_len,max_len)))
       direc_vec = rs.VectorAdd(H_direc,L_direc)
       end_pnt = rs.VectorAdd(emerge_pnt,direc_vec)
       if end_pnt not in border_front:
           dis_pnts = dm.pntsSortDistancePnt(end_pnt,border_front)
           end_pnt = dis_pnts[0]
       line = rs.AddLine(emerge_pnt,end_pnt)
       veins.append( line )
       start_pnts.append(end_pnt)


def rand_back(emerge_pnt,min_len = 1,max_len = 2,min_vert = 3,max_vert = 5):

    for i in range(2):
       sign = random.choice([1,-1])
       H_direc = rs.VectorScale(hVec,round(random.uniform(min_vert,max_vert)))
       L_direc = rs.VectorScale(rs.VectorScale(lVec,sign),round(random.uniform(min_len,max_len)))
       direc_vec = rs.VectorAdd(H_direc,L_direc)
       end_pnt = rs.VectorAdd(emerge_pnt,direc_vec)
       if end_pnt not in border_back:
           dis_pnts = dm.pntsSortDistancePnt(end_pnt,border_back)
           end_pnt = dis_pnts[0]
       line = rs.AddLine(emerge_pnt,end_pnt)
       veins.append( line )
       start_pnts.append(end_pnt)

def rand_right(emerge_pnt,min_len = 1,max_len = 2,min_vert = 3,max_vert = 5):

    for i in range(2):
       sign = random.choice([1,-1])
       H_direc = rs.VectorScale(hVec,round(random.uniform(min_vert,max_vert)))
       D_direc = rs.VectorScale(rs.VectorScale(dVec,sign),round(random.uniform(min_len,max_len)))
       direc_vec = rs.VectorAdd(H_direc,D_direc)
       end_pnt = rs.VectorAdd(emerge_pnt,direc_vec)
       if end_pnt not in border_right:
           dis_pnts = dm.pntsSortDistancePnt(end_pnt,border_right)
           end_pnt = dis_pnts[0]
       line = rs.AddLine(emerge_pnt,end_pnt)
       veins.append(line)
       start_pnts.append(end_pnt)

def rand_left(emerge_pnt,min_len = 1,max_len = 2,min_vert = 3,max_vert = 5):

    for i in range(2):
       sign = random.choice([1,-1])
       H_direc = rs.VectorScale(hVec,round(random.uniform(min_vert,max_vert)))
       D_direc = rs.VectorScale(rs.VectorScale(dVec,sign),round(random.uniform(min_len,max_len)))
       direc_vec = rs.VectorAdd(H_direc,D_direc)
       end_pnt = rs.VectorAdd(emerge_pnt,direc_vec)
       if end_pnt not in border_left:
           dis_pnts = dm.pntsSortDistancePnt(end_pnt,border_left)
           end_pnt = dis_pnts[0]
       line = rs.AddLine(emerge_pnt,end_pnt)       
       veins.append( line )
       start_pnts.append(end_pnt)


rand_top(emerge_pnt)
rand_top(emerge_pnt2)
#print start_pnts
ver_min = 4
ver_max = 7
#live_counter = 6

for i,pnt in enumerate(start_pnts):
    
    if pnt in border_top and pnt not in border_front and pnt not in border_back and pnt not in border_right and pnt not in border_left:
        rand_top(pnt)
    
    if pnt in border_front and pnt not in border_right and pnt not in border_left:
        rand_front(pnt,min_vert = ver_min, max_vert = ver_max)
        
    if pnt in border_back and pnt not in border_right and pnt not in border_left:
        rand_back(pnt,min_vert = ver_min, max_vert = ver_max)
    
    if pnt in border_right and pnt not in border_front and pnt not in border_back:
        rand_right(pnt,min_vert = ver_min, max_vert = ver_max)
    
    if pnt in border_left  and pnt not in border_front and pnt not in border_back:
        rand_left(pnt,min_vert = ver_min, max_vert = ver_max)
    
    if pnt in border_left  and pnt  in border_front:
        random.choice([rand_left(pnt,min_vert = ver_min, max_vert = ver_max),rand_front(pnt,min_vert = ver_min, max_vert = ver_max)])
    
    if pnt in border_left  and pnt  in border_back:
        random.choice([rand_left(pnt,min_vert = ver_min, max_vert = ver_max),rand_back(pnt,min_vert = ver_min, max_vert = ver_max)])
    
    if pnt in border_right  and pnt  in border_front:
        random.choice([rand_right(pnt,min_vert = ver_min, max_vert = ver_max),rand_front(pnt,min_vert = ver_min, max_vert = ver_max)])
    
    if pnt in border_right  and pnt  in border_back:
        random.choice([rand_right(pnt,min_vert = ver_min, max_vert = ver_max),rand_back(pnt,min_vert = ver_min, max_vert = ver_max)])
    
    
    if i > 128:
        break

vein_list = []
for vein in veins:
    crv = vein
    crv_start = rs.CurveStartPoint(vein)
    vein_list.append([crv,crv_start[2]])
print vein_list
sorted(vein_list, key = lambda k:[1])

for vein in vein_list:
    rs.ObjectColor( vein[0], [ vein[1] / 156 * 255, 0, (1-vein[1] / 156) * 255 ] ) 

#while True:
#    if emerge_pnt == dis_pnts_list[0][0] or emerge_pnt == dis_pnts_list[1][0] :
#        dis_pnts_list = rand_top(emerge_pnt)
#        print "!!!!!"
#    
#    if emerge_pnt != dis_pnts_list[0][0] or emerge_pnt != dis_pnts_list[1][0]:
#        rs.SelectObject(rs.AddPoint(emerge_pnt))
#        crv1 = rs.AddCurve([emerge_pnt,dis_pnts_list[0][0]],1)
#        crv2 = rs.AddCurve([emerge_pnt,dis_pnts_list[1][0]],1)
#        emerge_pnt1 = dis_pnts_list[0][0]
#        emerge_pnt2 = dis_pnts_list[1][0]
#        break


#emerge = [emerge_pnt1,emerge_pnt2]





#    if emerge_pnt1 in border_front and edge_bottom:
#        break

#rs.SelectObject(crv1)




############################################################
############################################################
############################################################

dm.newEmptyLayer("UNO::points", [150,150,150])
rs.AddPoints( UnoGridCoords )

dm.newEmptyLayer("UNO::proj", [250,50,50])
for i in range(64):
    p0 = dm.getUnoCoord( random.randint(0,L-1), random.randint(0,D-1), random.randint(0,H-1) )
    p1 = dm.getUnoCoord( random.randint(0,L-1), random.randint(0,D-1), random.randint(0,H-1) )
    #rs.AddCurve( [p0, p1] )
    #dm.textDots(  [p0, p1] )
    
rs.ZoomExtents()

if 0:
    coords = UnoGridCoords[:]
    random.shuffle( coords )
    rs.AddCurve( coords[0:100] )


#############################
###################################
rs.EnableRedraw(1) ### 4 the MACs
dm.newEmptyLayer("Default")