##############################
###  DM2_w24  hu_03_setUp  ###
###  _diag  /  2024 10 17  ###
##############################
import rhinoscriptsyntax as rs
import random, time, sys   ###                                              
sys.path.append("/Volumes/app/WWW/aeroflot/dm2/")
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(1)
rs.DeleteObjects(rs.AllObjects())


######################################           
number = random.choice( range(16, 256, 4) )
dm.allCoords = dm.setUp_hu_03( number )
circle = dm.allCoords[0]  ### calling def from DM_lib to get *new* set of coords
rectangle = dm.allCoords[1]  ### calling def from DM_lib to get *new* set of coords
######################################

randomVector = [random.uniform(-30,30) for i in range(3)]
rectangle_pts = [rs.VectorRotate(coordinate, randomVector[0], randomVector) for coordinate in rectangle]
circle_pts = [rs.VectorRotate(coordinate, randomVector[0], randomVector) for coordinate in circle]
size = rs.Distance( rectangle[0],  rectangle[1] ) ### edge length of cubus

#dm.textDots( coordsCub )
circle_crv = rs.AddCurve( circle_pts + [circle_pts[0]], 3 )
#rectangle_crv = rs.AddPolyline( rectangle_pts + [rectangle_pts[0]] )
#dm.textDots( coordsCir )

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



### here we go
# defs
def centroid(*points):
    x_values = [p[0] for p in points]
    y_values = [p[1] for p in points]
    z_values = [p[2] for p in points]
    _len = len(points)
    centroid_x = sum(x_values)/_len
    centroid_y = sum(y_values)/_len
    centroid_z = sum(z_values)/_len
    return [centroid_x, centroid_y, centroid_z]
#
def divide_distance(denominator, *points):
    points_out = list(points)
    
    for i in range(len(points_out))[1:]:
        vector = rs.VectorCreate(points[i-1], points[i])
        increment = rs.VectorDivide(vector, denominator)
       
        for step in range(denominator)[1:]:
            location = rs.VectorAdd(points[i], increment*step)
            _index = (i-1)*denominator # new_method
            points_out.insert(_index, location)
    return points_out
#

# move rectangle outwards
## vector
centroid_rectangle = centroid(*rectangle_pts)
centroid_circle = centroid(*circle_pts)
vector = rs.VectorCreate(centroid_rectangle, centroid_circle)
vector[2] = 0
vector = rs.VectorScale(vector, 1.5)

## new points
rectangle_pts = [ rs.VectorAdd(pt, vector) for pt in rectangle_pts ]
circle_pts = [ rs.VectorAdd(pt, vector) for pt in circle_pts ]

# lists
domains = [ (a, a+int(pointcount/4)) for a in range(0,pointcount, int(pointcount/4))]
OG_sides = [rectangle_pts[start:end] for (start,end) in domains]
OG_corners = [side[0] for side in OG_sides] 

#print OG_sides[0]

## test
rectangle_crv = rs.AddPolyline( OG_corners + [OG_corners[0]])

# rotate around circle
copies = 4
connections = []
for i in range(copies):
    #make copy
    #rs.RotateObject(rectangle_crv, centroid_circle, i*360/copies, copy=1)
    xform= rs.XformRotation2(i*360/copies, (0,0,1), centroid_circle)
    sides = [ [rs.VectorTransform(pt, xform) for pt in side ]  for side in OG_sides ]
    ##print len(OG_sides)
    #sides = [ [  for pt in side for side in OG_sides ]
    #
    #print len(sides)
    corners = [side[0] for side in sides]
    #print len(corners)    
    # which 2 sides are closest to circle?
    #print corners
    
    side_midpts = divide_distance(2, *corners ) # + [corners[0]]
    
    distances = []
    for i in range(0, len(side_midpts), 2):
        closest = rs.PointClosestObject( side_midpts[i], circle_crv)[1]
        distances.append(rs.Distance(side_midpts[i], closest))

    #sort them
    distances, closest_sides = zip(*sorted(zip(distances, sides)))
    
    for _list in closest_sides[0:2]:
        # cloest point on curve
        for point in _list:
            closest = rs.PointClosestObject(point, circle_crv)[1]
            rs.AddLine( point, closest)
    
    connections.append(closest_sides[2:4])

    # Create pairs and apply the function
    # Example data and function
    #result = [function(closest_sides[i][1], closest_sides[i + 1][0]) for i in range(len(closest_sides) - 1)]
    
    #print(len(closest_sides[0][3]))
    listpairs = [ zip(closest_sides[i-1], closest_sides[i]) for i in range(len(closest_sides))]
    #print len(listpairs)
    for connection in listpairs:
        for (a,b) in connection:
            rs.AddLine( a, b)

    
zipped = [ zip(connections[i-1][0], connections[i][1]) for i in range(len(connections))]
#print len(connections)
for connection in zipped:
    #print len(connection)
    for (a,b) in connection:
        rs.AddLine(a,b)

                  
        
"""
for list in listpairs:
    print len(list)
    #for (a,b) in list:
     #   rs.AddLine(a,b)
#[[rs.AddLine(a,b) for (a,b) in list] for list in listpairs]

#print(result)
"""



#2 Welche Seiten sind die Nahen?
if 0: #ugly code up until now
    domains = [ (a, a+int(pointcount/4)) for a in range(0,pointcount, int(pointcount/4))]
    sides = [rectangle_pts[start:end] for (start,end) in domains]
    corners = [side[0] for side in sides]
    rectangle_crv = rs.AddPolyline(*corners)
    midpoint = rs.CurveAreaCentroid(rectangle_crv)
    
    
    
    #for pointlist in sides:
        #print pointlist
     #   rs.AddPoints([pointlist[0],pointlist[1]])
        #rs.AddPoint(pointlist[1])
    


    #print len(sides[0]+ sides[1])
    #for point in sides[0] + sides[1]:
     #   closest = rs.AddPoint(rs.PointClosestObject(rs.coerce3dpoint(point), circle_crv)[1])
      #  rs.AddLine(point, closest)


















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