##############################
###  DM2_w23  hu_03_setUp  ###
###  _diag  /  2023 10 20  ###
##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###                                              
#sys.path.append("P:/")     ### add path .. setUp_hu_02.py needed !!!                                              
sys.path.append("P:/WWW/flobber27/dm2")     # path for library !!
import DM_lib as dm        ### reload(dm)    
##############################   

rs.UnitSystem(3)                       
rs.ShowGrid(view=None, show=0)
rs.ShowGridAxes(view=None, show=0)
rs.ViewDisplayMode(view=None, mode="Wireframe")
rs.EnableRedraw(0)
dm.PointRadius(displayModeX=0, rad=3, styl=1)
rs.DeleteObjects(rs.AllObjects())


######################################           
anz = random.choice( range(2**4, 2**8, 4) )
coordsCub = dm.setUp_hu_02( anz )[1]  ### calling def from DM_lib to get *new* set of coords
######################################

randomVec = [random.uniform(-30,30) for i in range(3)]
coordsCub = [rs.VectorRotate(cor, randomVec[0], randomVec) for cor in coordsCub]

siz = rs.Distance( coordsCub[0],  coordsCub[1] )
vecX = rs.VectorSubtract( coordsCub[1],  coordsCub[0] )
vecY = rs.VectorSubtract( coordsCub[-1],  coordsCub[0] )
vecZ = dm.normVec3pnts(coordsCub[0], coordsCub[1], coordsCub[-1]) ### unitVector / length = 1.0
vecZ = rs.VectorScale( vecZ, siz )

ptA = coordsCub[0]
ptB = rs.VectorAdd( ptA, rs.VectorScale( vecX, anz/4) )
ptC = rs.VectorAdd( ptB, rs.VectorScale( vecY, anz/4) )
ptD = rs.VectorAdd( ptC, rs.VectorScale( vecX, -anz/4) )

ptE = rs.VectorAdd( ptA, rs.VectorScale( vecZ, anz/4) )
ptF = rs.VectorAdd( ptB, rs.VectorScale( vecZ, anz/4) )
ptG = rs.VectorAdd( ptC, rs.VectorScale( vecZ, anz/4) )
ptH = rs.VectorAdd( ptD, rs.VectorScale( vecZ, anz/4) )

print "*** anz =", anz
print "*** siz =", round(siz, 2), "/ edge lenght =", round(siz, 2),"*",int(anz/4),"=", round(siz*anz/4, 2)
print "*** **********\n"

### just demo ### just demo  >> remove it <<
if 1: 
    baseCrv = rs.AddCurve( [ptA, ptB, ptC, ptD, ptA], 1 ) 
    topCrv  = rs.AddCurve( [ptE, ptF, ptG, ptH, ptE], 1 ) 
    for i,car in enumerate(["A","B","C","D","E","F","G","H"]):
        rs.AddTextDot( car, [ptA, ptB, ptC, ptD,ptE, ptF, ptG, ptH][i] )

    rs.ZoomExtents()
    dirX = rs.CurveArrows (rs.AddLine(ptA, ptB), 2)
    dirY = rs.CurveArrows (rs.AddLine(ptA, ptD), 2)
    dirZ = rs.CurveArrows (rs.AddLine(ptA, ptE), 2)
    rs.ObjectColor(rs.AllObjects()[2], [200,20,20] )
    rs.ObjectColor(rs.AllObjects()[1], [20,200,20] )
    rs.ObjectColor(rs.AllObjects()[0], [20,20,200] )
    
    coords = rs.DivideCurve(baseCrv, anz, 0)
    coords += rs.DivideCurve(topCrv, anz, 0)
    rs.DeleteObjects( [baseCrv, topCrv] )


if 0:
    cen = dm.pntInbetween(ptA, ptG)
    ran = random.uniform(4,16)
    for i,cor in enumerate(coords):
        vec = rs.VectorSubtract( cor, cen )
        unitVec = rs.VectorUnitize( vec )
        scalVec = rs.VectorScale( unitVec, siz*anz/ran)
        circPnt = rs.VectorAdd( cen, scalVec )
        if i%2==0:
            rs.AddLine( cor, circPnt )
        rs.ObjectColor( rs.AddPoint( circPnt ), [200,20,200] )
    
    coords = []
    for i in range(1001):
        scalVec = rs.VectorRotate( scalVec, random.uniform(-90,90), [random.uniform(-1,1) for i in range(3)])
        coords.append( rs.VectorAdd( cen, scalVec ) )
    rs.AddPoints( coords )

### just demo ### just demo  >> remove it <<

### here we go:

anz = 24
abstand = rs.Distance(ptA, ptB)/(anz-1)
vec_x = rs.VectorSubtract(ptB, ptA)
vec_x = rs.VectorUnitize(vec_x)
#vec_x = rs.VectorScale(vec_x, abstand)

vec_y = rs.VectorUnitize(rs.VectorSubtract(ptD, ptA))
vec_z = rs.VectorUnitize(rs.VectorSubtract(ptE, ptA))



pt_x = rs.VectorAdd(ptA, vec_x)
#rs.AddPoint(pt_x)


cubeGrid = []
for x in range(anz):
    vec = rs.VectorScale(vec_x, abstand*x)
    pt_x = rs.VectorAdd(ptA, vec)
    #rs.AddPoint(pt_x)
    for y in range(anz):
        pt_y = rs.VectorAdd(pt_x, rs.VectorScale(vec_y, abstand*y))
        #rs.AddPoint(pt_y)
        for z in range(anz):
            pt_z = rs.VectorAdd(pt_y, rs.VectorScale(vec_z, abstand*z))
            #rs.AddPoint(pt_z)
            cubeGrid.append(pt_z)

#rs.AddPoints(cubeGrid)


center = random.choice(cubeGrid)
radius = random.uniform(rs.Distance(ptA, ptB)*0.25, rs.Distance(ptA, ptB)*0.5)

sphereCoords = []

for cor in cubeGrid:
    if rs.Distance( center, cor ) < radius:
        sphereCoords.append( cor )
        cubeGrid.remove(cor)

#rs.AddPoints(sphereCoords)
random.shuffle(sphereCoords)
rs.AddCurve(sphereCoords, 2)


for i in range (10001):
    pt0 = random.choice(cubeGrid)
    pt1 = random.choice(cubeGrid)
    if rs.Distance(pt0,pt1) < abstand*5:
        rs.AddCurve([pt0,pt1])


################
rs.ZoomExtents()