#rectangles.py

from random import randint
from ezgraphics import GraphicsWindow

def is_any_overlap(rect,rectangles):
    '''return True if rect overlaps any of the rectangles'''
    for r in rectangles:
        if not (r[0][0]+r[1]/2 < rect[0][0]-rect[1]/2 or\
                r[0][0]-r[1]/2 > rect[0][0]+rect[1]/2 or\
                r[0][1]-r[2]/2 > rect[0][1]+rect[2]/2 or\
                r[0][1]+r[2]/2 < rect[0][1]-rect[2]/2):
            if r != rect:   #not itself
                return True
    return False


def is_rect_in_rect(rect,rectangles):
    '''return True if rect is inside any of the rectangles'''
    for r in rectangles:
        if rect[0][0]-rect[1]/2>r[0][0]-r[1]/2 and rect[0][0]+rect[1]/2<r[0][0]+r[1]/2 and\
           rect[0][1]-rect[2]/2>r[0][1]-r[2]/2 and rect[0][1]+rect[2]/2<r[0][1]+r[2]/2:
            if r != rect:   #not itself
                return True
    return False


def is_interior(point,rectangles):
    '''return True if the point is inside any of the rectangles'''
    for r in rectangles:
        if r[0][0]-r[1]/2 <= point[0] <= r[0][0]+r[1]/2 and \
           r[0][1]-r[2]/2 <= point[1] <= r[0][1]+r[2]/2:
               return True
    return False

inp = input("Enter width of world: [1000] ")
world_width = int(inp) if inp!="" else 1000
inp = input("Enter height of world: [555] ")
world_height = int(inp) if inp!="" else 555

inp = input("Input rectangles from a file? (y or n) [n]: ")
if inp!="" and inp.lower()[0]=='y':
    is_input_file = True
    fname = input(" Name of input file? ")
    ifile = open(fname, mode="r")
else:    
    is_input_file = False
    min_rect_d = int(input("Enter min size of rectangles: "))
    inp = input("Enter max size of rectangles: [%d] "%min_rect_d)
    max_rect_d = int(inp) if inp!="" else min_rect_d
    num_rects = int(input("Enter number of rectangles: "))
    is_non_overlapping = True if input("Non-overlapping? (y or n): ").lower()=='y' else False

inp = input("Enter number of points: [200] ")
num_points = int(inp) if inp!="" else 200

inp = input("Show areas? [Y/y] ")
is_show_areas = True if inp=="" or inp.lower()[0]=='y' else False

win = GraphicsWindow(world_width,world_height)
canvas = win.canvas()
canvas.setTextFont(size=6)

rectangles = []
if is_input_file:
    lines = ifile.readlines()
    import re
    for line in lines:
        l2 = [int(i) for i in re.sub("[^0-9,]",'',line).split(',')]
        rectangles.append(((l2[0],l2[1]),l2[2],l2[3]))
else:    
    MAX_ATTEMPTS = 1000
    for r_i in range(num_rects):
        if not is_non_overlapping:
            width = randint(min_rect_d,max_rect_d)
            height = randint(min_rect_d,max_rect_d)
            x_c = randint(width//2+1,world_width-width//2-1)
            y_c = randint(height//2+1,world_height-height//2-1)
            rectangles.append(((x_c,y_c),width,height)) #((x,y),width,height)

        else:    # non-overlapping  Try to get as many as wanted 
            width = randint(min_rect_d,max_rect_d)
            height = randint(min_rect_d,max_rect_d)
            x_c = randint(width//2+1,world_width-width//2-1)
            y_c = randint(height//2+1,world_height-height//2-1)
            #x_c = randint(min_rect_d//2+1,world_width-min_rect_d//2-1)
            #y_c = randint(min_rect_d//2+1,world_height-min_rect_d//2-1)
                
            attempts = 0
            while attempts<MAX_ATTEMPTS and \
                  (is_interior((x_c,y_c),rectangles) or \
                   is_any_overlap(((x_c,y_c),width,height),rectangles)):
                attempts += 1
                width = randint(min_rect_d,max_rect_d)
                height = randint(min_rect_d,max_rect_d)
                x_c = randint(width//2+1,world_width-width//2-1)
                y_c = randint(height//2+1,world_height-height//2-1)
               
            if attempts < MAX_ATTEMPTS:
                rectangles.append(((x_c,y_c),width,height)) #((x,y),width,height)

print("Number of rectangles:",len(rectangles))
sum_areas = sum([r[1]*r[2] for r in rectangles])
print("sum_areas",sum_areas)
min_width = min(rectangles,key=lambda t: t[1])
min_height = min(rectangles,key=lambda t: t[2])
if min_width < min_height:
    print("minimum dimension rectangle",min_width)
else:
    print("minimum dimension rectangle",min_height)
max_width = max(rectangles,key=lambda t: t[1])
max_height = max(rectangles,key=lambda t: t[2])
if max_width > max_height:
    print("maximum dimension rectangle",max_width)
else:
    print("maximum dimension rectangle",max_height)
rectangles.sort(key=lambda t: t[1]*t[2])
print("minimum area rectangle",rectangles[0])
print("maximum area rectangle",rectangles[-1])

#print(rectangles)
canvas.setOutline("yellow")
num_equal_areas = 0
for i in range(len(rectangles)-1):    #must be sorted in area order
    i_area = rectangles[i][1]*rectangles[i][2]   #width*height
    j = i+1
    while j<len(rectangles) and i_area == rectangles[j][1]*rectangles[j][2]:
        #    don't know min_rect_d and max_ if read from file, so skip if read from file...
        if not is_input_file and min_rect_d != max_rect_d:  #if all same-sized squares there are too many, will hang
            canvas.drawLine(rectangles[i][0][0],rectangles[i][0][1],rectangles[j][0][0],rectangles[j][0][1])
        
        j += 1
        num_equal_areas += 1
print("num_equal_areas pairs",num_equal_areas,"  (yellow line connects each pair)")


    
# draw the rectangles   all in BLACK
canvas.setOutline("black")
for r in rectangles:
    canvas.drawRectangle(r[0][0]-r[1]/2, r[0][1]-r[2]/2, r[1], r[2])
    if is_show_areas:
        canvas.drawText(r[0][0],r[0][1], str(r[1]*r[2]))
    

points = []          # draw them last, see below
num_inside_points = 0
for p in range(num_points):
    x_p = randint(1,world_width-1)
    y_p = randint(1,world_height-1)
    if is_interior((x_p,y_p),rectangles):
        num_inside_points += 1
    points.append((x_p,y_p))
print("num_inside_points",num_inside_points, "  (red points)")

    

# interior rectangles   GREEN rectangles
canvas.setOutline("green")
num_interiors = 0
for r in rectangles:
    if is_rect_in_rect(r,rectangles):
        canvas.drawRectangle(r[0][0]-r[1]/2, r[0][1]-r[2]/2, r[1], r[2])
        if is_show_areas:
            canvas.drawText(r[0][0],r[0][1],str(r[1]*r[2]))
        num_interiors += 1
print("num_interiors",num_interiors,"  (green rectangles)")





    
canvas.setOutline("red")
num_isolates = 0
for r in rectangles:
    if not is_any_overlap(r,rectangles):
        canvas.drawRectangle(r[0][0]-r[1]/2, r[0][1]-r[2]/2, r[1], r[2])
        if is_show_areas:
            canvas.drawText(r[0][0],r[0][1],str(r[1]*r[2]))
        num_isolates += 1
print("num_isolates",num_isolates,"  (red rectangles)")


       
# maximum overlap of rectangles    CYAN rectangles
overlaps = []
for i in range(len(rectangles)):
    overlaps.append(0)
    ri = rectangles[i]
    for j in range(len(rectangles)):
        rj = rectangles[j]
        if  ri!=rj and\
            ri[0][0]-ri[1]/2 <= rj[0][0]+rj[1]/2 and\
            ri[0][0]+ri[1]/2 >= rj[0][0]-rj[1]/2 and\
            ri[0][1]-ri[2]/2 <= rj[0][1]+rj[2]/2 and\
            ri[0][1]+ri[2]/2 >= rj[0][1]-rj[2]/2:
            overlaps[i] += 1
            
max_overlaps = max(overlaps)
print("max_overlaps",max_overlaps,"  (cyan rectangles)")
#if not is_non_overlapping:
if max_overlaps > 0:    # at least one non-overlapping
    canvas.setOutline("cyan")
    for i in range(len(overlaps)):
        if overlaps[i]==max_overlaps:
            print("  rectangle of max overlaps",rectangles[i])
            r = rectangles[i]
            canvas.drawRect(r[0][0]-r[1]/2, r[0][1]-r[2]/2, r[1], r[2])
            if is_show_areas:
                canvas.drawText(r[0][0],r[0][1],str(r[1]*r[2]))


# maximum #points inside any rectangle   MAGENTA rectangles
num_points_inside = []
i = 0
for r in rectangles:    #3-tuple of: 2-tuple of x,y, width, height
    num_points_inside.append(0)
    for p in points:   #2-tuple of x,y
        if r[0][0]-r[1]/2 <= p[0] <= r[0][0]+r[1]/2 and \
           r[0][1]-r[2]/2 <= p[1] <= r[0][1]+r[2]/2:
            num_points_inside[i] += 1
    i += 1
    
max_num_pts_inside = max(num_points_inside)
print("max num_points_inside",max_num_pts_inside,"  (magenta rectangles)")
canvas.setOutline("magenta")
for i in range(len(num_points_inside)):
    if num_points_inside[i]==max_num_pts_inside:
        print("  rectangle of max pts",rectangles[i])
        r = rectangles[i]
        canvas.drawRect(r[0][0]-r[1]/2, r[0][1]-r[2]/2, r[1], r[2])
        if is_show_areas:
            canvas.drawText(r[0][0],r[0][1],str(r[1]*r[2]))


#weighted centroid    BROWN disc
x_prod_sum = sum([r[0][0]*r[1]*r[2] for r in rectangles])  #sum has no key!!!
y_prod_sum = sum([r[0][1]*r[1]*r[2] for r in rectangles])
x_w_centroid = x_prod_sum / sum_areas
y_w_centroid = y_prod_sum / sum_areas
print("(x_w_centroid,y_w_centroid): (%4.1f,%4.1f)"%(x_w_centroid,y_w_centroid),"  (brown dot)")
canvas.setColor("brown")
canvas.drawOval(x_w_centroid-1,y_w_centroid-1,3,3)

#centroid             ORANGE disc
x_sum = sum([r[0][0] for r in rectangles])
y_sum = sum([r[0][1] for r in rectangles])
x_centroid = x_sum / len(rectangles)
y_centroid = y_sum / len(rectangles)
print("(x_centroid,y_centroid): (%4.1f,%4.1f)"%(x_centroid,y_centroid),"  (orange dot)")
canvas.setColor("orange")
canvas.drawOval(x_centroid-1,y_centroid-1,3,3)
canvas.setFill()


# draw the points last
for p in points:
    if is_interior(p,rectangles):
        canvas.setOutline("red")
    else:
        canvas.setOutline("blue")
    canvas.drawPoint(p[0],p[1])


from math import sqrt
def distance(pt1, pt2):
    '''return distance between two points (two 2-tuples)'''
    return sqrt((pt1[0]-pt2[0])**2+(pt1[1]-pt2[1])**2)


print("Click points with mouse. (Click the upperleft corner blue box to Quit)")
canvas.setColor("blue")
canvas.drawRect(0,0,5,5)  #quitting 
x,y = win.getMouse()    #gets a point as a 2-tuple
while x>5 or y>5:
    print(" ("+str(x)+","+str(y)+")", end=" ")
    canvas.setColor("blue")
    canvas.drawOval(x-1,y-1, 3,3)
    min_d = world_width*world_height
    for r in rectangles:   #find min distance [border] or corner
        for corner_offset_x in [-1,1]:
            for corner_offset_y in [-1,1]:
                d = distance((x,y),(r[0][0]+corner_offset_x*(r[1]/2),r[0][1]+corner_offset_y*(r[2]/2)))
                if d < min_d :
                    min_d = d
                    min_d_rect = r
                    min_corner_x = corner_offset_x
                    min_corner_y = corner_offset_y
    canvas.drawLine(x,y, min_d_rect[0][0]+min_corner_x*(min_d_rect[1]/2), min_d_rect[0][1]+min_corner_y*(min_d_rect[2]/2))
    print("bl:%4.1f"%(min_d), end=" ")
    
    canvas.setColor("green")
    for r in rectangles:      #is inside this rectangle
        if r[0][0]-r[1]/2 <= x <= r[0][0]+r[1]/2 and \
           r[0][1]-r[2]/2 <= y <= r[0][1]+r[2]/2:
            min_in_d = 10000   # pos. inf.
            for corner_offset_x in [-1,1]:
                for corner_offset_y in [-1,1]:
                    d = distance((x,y),(r[0][0]+corner_offset_x*(r[1]/2),r[0][1]+corner_offset_y*(r[2]/2)))
                    if d < min_in_d :
                        min_in_d = d
                        min_in_d_rect = r
                        min_in_corner_x = corner_offset_x
                        min_in_corner_y = corner_offset_y
            canvas.drawLine(x,y, min_in_d_rect[0][0]+min_in_corner_x*(min_in_d_rect[1]/2), min_in_d_rect[0][1]+min_in_corner_y*(min_in_d_rect[2]/2))
            print("gr:%4.1f"%(min_in_d), end=" ")
    print()
    x,y = win.getMouse()    #get next point


inp = input("Save rectangles to a file? (y or n) [n]: ")
if inp!="" and inp.lower()[0]=='y':
    fname = input(" Name of file? ")
    outfile = open(fname, mode="w")
    for r in rectangles:
        outfile.write(str(r)+"\n")  
    
    outfile.close()