### https://iam.tugraz.at/diag/dm2/ue_02/ue_02_startUp_01.py
### https://iam.tugraz.at/diag/dm2/ue_02/ue_02_endUp.py
### grabbed:  2021-10-21 15:13:40
#################################


import rhinoscriptsyntax as rs
import time
import random
#############
'''
timStart = time.time()
print "start", timStart
'''

rs.UnitSystem(4) # meters = 4, cm = 3
rs.EnableRedraw(0)
rs.DeleteObjects( rs.AllObjects() )

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


lenX = 15       
lenY = 25             #random.randint(lenX, lenX*2)
lenZ = 30         #random.randint(lenX, lenX*5)

'''
print "\t _____________/################"
print "\t my randomized para.llel.epiped"
print "\t X/Y/Z =", str(lenX)+"/"+str(lenY)+"/"+str(lenZ)+" _____________"
print "\t ################/  \n"
'''

#______base vectors
vecX = [1, 2, 0]
vecY = [2, 1, 0]
vecZ = [0, 0, 1]
#vecY = rs.VectorUnitize([ random.uniform(1,0.5), random.uniform(0.5,1), 0 ])
#vecZ = rs.VectorUnitize([ random.uniform(-0.5,1.5), random.uniform(-0.5,0.5), 1 ])

rs.ObjectColor( rs.AddCurve([ [0,0,0], rs.VectorScale(vecX, lenX) ] ), [200,0,0] )
rs.ObjectColor( rs.AddCurve([ [0,0,0], rs.VectorScale(vecY, lenY) ] ), [0,200,0] )
rs.ObjectColor( rs.AddCurve([ [0,0,0], rs.VectorScale(vecZ, lenZ) ] ), [0,0,200] )
rs.AddPoints( [rs.VectorScale(vecX, lenX), rs.VectorScale(vecY, lenY), rs.VectorScale(vecZ, lenZ)] )

#______here comes my para.llel.epiped:


ptA = [0,0,0]
ptB = rs.VectorScale(vecX, lenX)
ptC = rs.VectorAdd( ptB, rs.VectorScale(vecY, lenY) )
ptD = rs.VectorScale(vecY, lenY)

#rs.DeleteObjects( rs.AllObjects() )

rs.AddCurve( [ptA, ptB, ptC, ptD, ptA], 1) 
rs.AddCurve( [ptB, rs.VectorAdd(ptB, rs.VectorScale(vecZ, lenZ))], 1) 
rs.AddCurve( [ptC, rs.VectorAdd(ptC, rs.VectorScale(vecZ, lenZ))], 1) 
rs.AddCurve( [ptD, rs.VectorAdd(ptD, rs.VectorScale(vecZ, lenZ))], 1) 



if 1:
    face_base =  [ ptA, ptB, ptC, ptD, ptA] 
    #random.shuffle( face_base )
    #rs.AddCurve( face_base, 3 )
    face_top = []
    for pt in face_base:
        face_top.append( rs.VectorAdd(pt, rs.VectorScale(vecZ, lenZ)) )
    #rs.AddCurve( face_top, 2 )
#rs.AddCurve( face_top, 1 )
    face_b_t = face_base + face_top         # list + list / better list.extend(..)
    random.shuffle( face_b_t )
#    rs.AddCurve( face_b_t, 1 )
#    rs.AddCurve( face_b_t, 2 )
if 1:
    for i in range(4**3):
        ptX_rnd = rs.VectorScale( vecX, random.uniform(0, lenX) )
        ptY_rnd = rs.VectorScale( vecY, random.uniform(0, lenY) )
        ptZ_rnd = rs.VectorScale( vecZ, random.uniform(0, lenZ) )

        rs.AddPoint( ptX_rnd )
        rs.AddPoint( ptY_rnd )
        rs.AddPoint( ptZ_rnd )
        rs.AddPoint( rs.VectorAdd( rs.VectorAdd(ptX_rnd, ptY_rnd), ptZ_rnd) )
        #ptRnd = rs.VectorAdd( rs.VectorAdd( ptX_rnd, ptY_rnd), ptZ_rnd )
        #rs.AddPoint (ptRnd)
if 1:
    ptList = []
    for i in range(8**3):
        ptX_rnd = rs.VectorScale( vecX, random.randint(0, int(lenX) ) )
        ptY_rnd = rs.VectorScale( vecY, random.randint(0, int(lenY) ) )
        ptZ_rnd = rs.VectorScale( vecZ, random.randint(0, int(lenZ) ) )
        ptRnd = rs.VectorAdd( ptX_rnd, ptY_rnd )
        ptRnd = rs.VectorAdd( rs.VectorAdd(ptX_rnd, ptY_rnd), ptZ_rnd)
        if ptRnd not in ptList:
            ptList.append( ptRnd )
    
    rs.AddPoints (ptList)

if 1:
    #rs.DeleteObjects( rs.AllObjects() )
    ptList = []
    for x in range(lenX+1):
        for y in range(lenY+1):
            for z in range(lenZ+1):
                if (x==0 or x==lenX) and ((y==0 or y==lenY) or (z==0 or z==lenZ)) or ((y==0 or y==lenY) and (z==0 or z==lenZ)):
                    cor = rs.VectorAdd(rs.VectorAdd(rs.VectorScale(vecX, x), rs.VectorScale(vecY, y)), rs.VectorScale(vecZ, z))
                    ptList.append(cor)
    rs.AddPoints( ptList )

### smart ??
#ptList = [rs.VectorAdd(rs.VectorAdd(rs.VectorScale(vecX, x), rs.VectorScale(vecY, y)), rs.VectorScale(vecZ, z)) for x in range(lenX+1) for y in range(lenY+1) for z in range(lenZ+1) if (x==0 or x==lenX) and ((y==0 or y==lenY) or (z==0 or z==lenZ)) or ((y==0 or y==lenY) and (z==0 or z==lenZ)) ]
#rs.AddPoints( [rs.VectorAdd(rs.VectorAdd(rs.VectorScale(vecX, x), rs.VectorScale(vecY, y)), rs.VectorScale(vecZ, z)) for x in range(lenX+1) for y in range(lenY+1) for z in range(lenZ+1) if (x==0 or x==lenX) and ((y==0 or y==lenY) or (z==0 or z==lenZ)) or ((y==0 or y==lenY) and (z==0 or z==lenZ)) ] )

if 1:
    rs.DeleteObjects( rs.AllObjects() )
    ptList = []
    ptListX = []
    ptListY = []
    for x in range(lenX+1):
        for y in range(lenY+1):
            for z in range(lenZ+1):
                cor = rs.VectorAdd(rs.VectorAdd(rs.VectorScale(vecX, x), rs.VectorScale(vecY, y)), rs.VectorScale(vecZ, z))
                if (x < 5) or (x >10):
                #if (x==0 or x==lenX) and ((y==0 or y==lenY) or (z==0 or z==lenZ)) or ((y==0 or y==lenY) and (z==0 or z==lenZ)):
                 ptList.append(cor)
                 
                if (y < 10) or (y > 15):
                #if x==0 and z<y*(lenZ/lenY) and random.uniform(0, 100)<150:
                    ptListX.append( cor )
                    
                #if y==lenY and z>int(x*(lenZ/lenX)) and random.uniform(0, 100)<150:
                    #ptListX.append( cor )
                    
                if (z < 10) or (z > 20):
                #if z==11110 or z%3==0 or x%3==0 or y%5 == 11110:
                    ptListY.append( cor )
    rs.AddPoints( ptList )
    rs.AddPoints( ptListX )
    rs.AddPoints( ptListY )
    
    random.shuffle(ptListX)
    rs.AddCurve( ptListX, 2 )
    rs.SelectObject( rs.AllObjects()[0] )


if 0:
    #rs.DeleteObjects( rs.ObjectsByType( 1 ) )
    ptList = []
    ptListXY0 = []
    ptListA = []
    ptListB = ptListC = ptListD = []
    for x in range(lenX+1):
        print x
        ptX = rs.VectorScale(vecX_uni, x)
        #rs.AddPoint( ptX )
        for y in range( lenY+1):
            ptY = rs.VectorScale(vecY_uni, y)
            ptXY0 = rs.VectorAdd(ptX, ptY)
            #rs.AddPoint( ptXV )
            #rs.Redraw()
            ptListXY0.append( ptXY0  )
            for z in range( lenZ+1):
                ptZ = rs.VectorScale(vecZ_uni, z)
                ptXYZ = rs.VectorAdd(ptXY0, ptZ)
                ptList.append( ptXYZ  )
                if x%4==1110 or (z%8==0 and z > 4) or y%3==11110:
                    ptListB.append(ptXYZ)
                    rs.AddPoint( ptXYZ )
                if x == 0:
                    #rs.AddPoint( ptXVW )
                    ptListA.append(ptXYZ)
                #rs.Redraw()
    
    #rs.AddPoints (ptList)
    #rs.AddPoints (ptListXY0)
    
    for pt in ptListA:
        pass        # the pass statement does nothing
        pt0YZ = [-1, pt[1], pt[2]]
        rs.AddLine( pt, pt0YZ)
    
    random.shuffle(ptListA)
    rs.AddCurve( ptListA, 2 )
    #random.shuffle(ptListB)
    if 0 and ptListB:
        rs.AddCurve( ptListB, 1 )
rs.ZoomExtents()
######################
#______4_lazy_experts:
if 1:

    rs.ZoomExtents()
    rs.Command("-zoom Factor 0.95 enter", 0)
    rs.Redraw()

if 0:
    path = "P:/ue_02/images/"
    name = "tst.png"
    rs.Command("-viewCaptureToFile Width=480  Height=360 Scale=2 TransparentBackground=Yes "+path+name, 0)
    name = "tst_"+str(int(time.time()))+".jpg"
    #rs.Command("-viewCaptureToFile Width=480  Height=360  Scale=2 TransparentBackground=No  "+path+name, 0)

'''
timEnd = time.time()
print "\n****\ndura", round(timEnd-timStart, 2), "secs"
'''