00001: HW01
bytecount: {'code': 324, 'const': 200, 'code+const': 524}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x, y, w, h = r
    return [x + w / 2, y - h / 2]
#======================================
def distance(r1, r2):
    x1, y1 = center(r1)
    x2, y2 = center(r2)
    return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
#======================================
def intersection(r1, r2):
    x1, y1, w1, h1 = r1
    x2, y2, w2, h2 = r2
    x = max(x1, x2)
    y = min(y1, y2)
    w = min(x1 + w1, x2 + w2) - x
    h = y - max(y1 - h1, y2 - h2)
    return max(w, 0) * max(h, 0)
#======================================
def union(r1, r2):
    x1, y1, w1, h1 = r1
    x2, y2, w2, h2 = r2
    return w1 * h1 + w2 * h2 - intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2) / union(r1, r2)
#======================================

00002: HW01
bytecount: {'code': 348, 'const': 200, 'code+const': 548}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x,y,w,h = r
  xc = x + w/2
  yc = y - h/2
  return [xc, yc]
#======================================
def distance(r1, r2):
  x1,y1 = center(r1)
  x2,y2 = center(r2)
  d = ((x1-x2)**2 + (y1-y2)**2)**0.5
  return d
#======================================
def intersection(r1, r2):
  x1,y1,w1,h1 = r1
  x2,y2,w2,h2 = r2
  dx = max( min(x1+w1, x2+w2) - max(x1, x2) , 0)
  dy = max( min(y1, y2) - max(y1-h1, y2-h2) , 0)
  i = dx*dy
  return i
#======================================
def union(r1, r2):
  x1,y1,h1,w1 = r1
  x2,y2,h2,w2 = r2
  a1 = h1*w1
  a2 = h2*w2
  u = a1 + a2 - intersection(r1, r2)
  return u
#======================================
def iou(r1, r2):
  ratio = intersection(r1, r2) / union(r1, r2)
  return ratio
#======================================

00003: HW01
bytecount: {'code': 352, 'const': 204, 'code+const': 556}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x, y, w, h = r
  return [x + w / 2, y - h / 2]
#======================================
def distance(r1, r2):
  x1, y1 = center(r1)
  x2, y2 = center(r2)
  return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** (1 / 2)
#======================================
def intersection(r1, r2):
  x1, y1, w1, h1 = r1
  x2, y2, w2, h2 = r2
  x1max = x1 + w1
  y1min = y1 - h1
  x2max = x2 + w2
  y2min = y2 - h2
  dx = min(x1max, x2max) - max(x1, x2)
  dy = min(y1, y2) - max(y1min, y2min)
  dx = (abs(dx) + dx) / 2
  dy = (abs(dy) + dy) / 2
  return dx * dy
#======================================
def union(r1, r2):
  x1, y1, w1, h1 = r1
  x2, y2, w2, h2 = r2
  return (w1 * h1) + (w2 * h2) - intersection(r1, r2)
#======================================
def iou(r1, r2):
  return intersection(r1, r2) / union(r1, r2)
#======================================

00004: HW01
bytecount: {'code': 364, 'const': 196, 'code+const': 560}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x,y,w,h = r
  xr = x+(w*0.5)
  yr = y-(h*0.5)
  return [xr,yr]
#======================================
def distance(r1, r2):
  xr1,yr1 = center(r1)
  xr2,yr2 = center(r2)
  dist = (((xr2-xr1)**2) +((yr2-yr1)**2))**0.5
  return dist
#======================================
def intersection(r1, r2):
  x1,y1,w1,h1 = r1
  x2,y2,w2,h2 = r2
  left = max(x1,x2)
  right = min(x1+w1 , x2+w2)
  upper = min(y1,y2)
  under = max(y1-h1 , y2-h2)
  width = max(right-left,0)
  height = max(upper-under,0)
  area = width*height
  return area
#======================================
def union(r1, r2):
  x1,y2,w1,h1 = r1
  x2,y2,w2,h2 = r2
  area_1 = w1*h1
  area_2 = w2*h2
  union = (area_1 + area_2) - intersection(r1,r2)
  return union
#======================================
def iou(r1, r2):
  r = intersection(r1,r2) /union(r1,r2)
  return r
#======================================

00005: HW01
bytecount: {'code': 368, 'const': 204, 'code+const': 572}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x,y,w,h=r
  a=x+w/2
  b=y-h/2
  return [a,b]
#======================================
def distance(r1, r2):
  x1,y1=center(r1)
  x2,y2=center(r2)
  return ((x1-x2)**2+(y1-y2)**2)**.5
#======================================
def intersection(r1, r2):
  x1,y1,w1,h1=r1
  x2,y2,w2,h2=r2
  w1+=x1
  w2+=x2
  h1=y1-h1
  h2=y2-h2
  x=min(w1,w2)-max(x1,x2)
  y=min(y1,y2)-max(h1,h2)
  x=(x+abs(x))/2
  y=(y+abs(y))/2
  return x*y
#======================================
def union(r1, r2):
  x1,y1,w1,h1=r1
  x2,y2,w2,h2=r2
  a1=w1*h1
  a2=w2*h2
  return a1+a2-intersection(r1,r2)
#======================================
def iou(r1, r2):
 return intersection(r1,r2)/union(r1,r2)

00006: HW01
bytecount: {'code': 382, 'const': 200, 'code+const': 582}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    [i,j,di,dj] = r
    x = (i+(di+i))/2
    y = (j+(j-dj))/2
    return [x,y]
#======================================
def distance(r1, r2):
    [x1,y1] = center(r1)
    [x2,y2] = center(r2)
    dx = max(x1,x2)-min(x1,x2)
    dy = max(y1,y2)-min(y1,y2)
    distance = (dx**2+dy**2)**0.5
    return distance
#======================================
def intersection(r1, r2):
    [i1,j1,di1,dj1] = r1
    [i2,j2,di2,dj2] = r2
    dwidth = max((min((i1+di1),(i2+di2))-max(i1,i2)),0)
    dlength = min(j1,j2)-max((j1-dj1),(j2-dj2))
    intersection = dwidth*dlength
    return intersection
#======================================
def union(r1, r2):
    [i1,j1,di1,dj1] = r1
    [i2,j2,di2,dj2] = r2
    area1 = di1*dj1
    area2 = di2*dj2
    union = area1 +area2 - intersection(r1,r2)
    return union
#======================================
def iou(r1, r2):
    iou = intersection(r1, r2) / union(r1,r2)
    return iou
#======================================

00007: HW01
bytecount: {'code': 368, 'const': 252, 'code+const': 620}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x, y, w, h = r
    cente = [x+w/2, y-h/2]
    return cente
#======================================
def distance(r1, r2):
    rc1 = center(r1)
    rc2 = center(r2)
    distanc = ((rc1[0]-rc2[0])**2 +(rc1[1]-rc2[1])**2)**(1/2)
    return distanc
#======================================
def intersection(r1, r2):
    x1, y1, w1, h1 = r1
    x2, y2, w2, h2 = r2
    XX = max(min((x1+w1),(x2+w2))-max(x1,x2),0)
    YY = max(min(y1,y2)-max((y2-h2),(y1-h1)),0)
    inter = float(XX*YY)
    return inter
#======================================
def union(r1, r2):
    riA = intersection(r1, r2)
    x1, y1, w1, h1 = r1
    x2, y2, w2, h2 = r2
    r1A = w1*h1
    r2A = w2*h2
    unio = r1A +r2A -riA
    return unio
#======================================
def iou(r1, r2):
    riA = intersection(r1, r2)
    ruA = union(r1, r2)
    io = riA/ruA
    return io
#======================================

00008: HW01
bytecount: {'code': 428, 'const': 200, 'code+const': 628}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x,y,w,h = r[:]
  midx = x+w/2
  midy = y-h/2
  return [midx,midy]
#======================================
def distance(rd1,rd2):
    x1,y1=center(rd1)
    x2,y2=center(rd2)
    disx=(x2-x1)**2
    disy=(y2-y1)**2
    dis=(disx+disy)**0.5
    return dis
#======================================
def intersection(ri1,ri2):
    x1,y1,w1,h1=ri1[:]
    x2,y2,w2,h2=ri2[:]
    x1m=x1+w1
    x2m=x2+w2
    xi=max(x1,x2)
    xm=min(x1m,x2m)
    xf=max(0.0,xm-xi)
    y1m=y1-h1
    y2m=y2-h2
    yi=max(y1m,y2m)
    ym=min(y1,y2)
    yf=max(0.0,ym-yi)
    iarea=xf*yf
    return iarea
#======================================
def union(ru1,ru2):
    x1,y1,w1,h1=ru1[:]
    x2,y2,w2,h2=ru2[:]
    r1area=w1*h1
    r2area=w2*h2
    sarea=r1area+r2area-intersection(ru1,ru2)
    return sarea
#======================================
def iou(ro1,ro2):
    iu= intersection(ro1,ro2)/union(ro1,ro2)
    return iu
#======================================

00009: HW01
bytecount: {'code': 442, 'const': 200, 'code+const': 642}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x1,y1,w,h = r
  x2 = x1 + w
  y2 = y1
  m1 = (-h/w)
  m2 = (h/w)
  c1 = y1-(m1*x1)
  xc = round(((y2-y1+(m1*x1)-(m2*x2))/(m1-m2)),2)
  yc = round((c1 + (m1*xc)),2)
  return [xc,yc]
#======================================
def distance(r1, r2):
    pc1,pc2 = [center(r1),center(r2)]
    x1,y1 = pc1
    x2,y2 = pc2
    d1 = ((x2-x1)**(2))+((y2-y1)**(2))
    return d1**0.5
#======================================
def intersection(r1, r2):
    xl1,yu1,w1,h1 = r1
    xl2,yu2,w2,h2 = r2
    xr1 = xl1 + w1 
    xr2 = xl2 + w2
    yd1 = yu1 - h1
    yd2 = yu2 - h2
    xinter = max((min(xr1,xr2)-max(xl1,xl2)),0)
    yinter = max((min(yu1,yu2)-max(yd1,yd2)),0)
    return xinter*yinter
#======================================
def union(r1, r2):
    xl1,yu1,w1,h1 = r1
    xl2,yu2,w2,h2 = r2
    areainter = intersection(r1,r2)
    return (w1*h1) + (w2*h2) - areainter
#======================================
def iou(r1, r2):
    areainter = intersection(r1,r2)
    areaunion = union(r1,r2)
    return areainter/areaunion
#======================================

00010: HW01
bytecount: {'code': 408, 'const': 252, 'code+const': 660}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x,y,w,h=r
    xcenter=(x+w/2)
    ycenter=(y-h/2)
    a=[xcenter,ycenter]
    return a
#======================================
def distance (r1, r2):
    l1=center(r1)
    l2=center(r2)
    l1x=l1[0] ; l1y=l1[1]
    l2x=l2[0] ; l2y=l2[1]
    diffx=(l1x-l2x)**2
    diffy=(l1y-l2y)**2
    diff=(diffx+diffy)**0.5
    return diff
#======================================
def intersection(r1, r2):
    x1,y1,w1,h1=r1
    x2,y2,w2,h2=r2
    left=max(x1,x2); right=min(x1+w1,x2+w2)
    down=max(y1-h1,y2-h2);up=min(y1,y2)
    w3 = max(0, right - left)
    h3 = max(0, up - down)
    area = w3*h3    
    return area
#======================================
def union(r1, r2):
    x1,y1,w1,h1=r1
    x2,y2,w2,h2=r2
    area1=h1*w1
    area2=h2*w2
    inter=intersection(r1, r2)
    areaunion=(area1+area2)-inter
    return areaunion
#======================================
def iou(r1, r2):
    inter=intersection(r1, r2)
    un=union(r1, r2)
    return inter/un
#======================================

00011: HW01
bytecount: {'code': 430, 'const': 276, 'code+const': 706}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  left, top, width, height = r
  return [left + (width / 2), top - (height / 2)]
#======================================
def distance(r1, r2):
  c1 = center(r1)
  c2 = center(r2)
  return ((c1[0] - c2[0]) ** 2 + (c1[1] - c2[1]) ** 2) ** 0.5
#======================================
def intersection(r1, r2):
  left1, top1, width1, height1 = r1
  left2, top2, width2, height2 = r2
  left = max(left1, left2)
  top = min(top1, top2)
  right = min(left1 + width1, left2 + width2)
  bottom = max(top1 - height1, top2 - height2)
  width = max(0, right - left)
  height = max(0, top - bottom)
  return width * height
#======================================
def union(r1, r2):
  left1, top1, width1, height1 = r1
  left2, top2, width2, height2 = r2
  left = max(left1, left2)
  top = min(top1, top2)
  right = min(left1 + width1, left2 + width2)
  bottom = max(top1 - height1, top2 - height2)
  width = max(0, right - left)
  height = max(0, top - bottom)
  intersect = width * height
  area1 = width1 * height1
  area2 = width2 * height2
  return area1 + area2 - intersect
#======================================
def iou(r1, r2):
  return intersection(r1, r2) / union(r1, r2)
#======================================

00012: HW01
bytecount: {'code': 320, 'const': 412, 'code+const': 732}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return ([(r[0]+r[2]*0.5),(r[1]-r[3]*0.5)])
#======================================
def distance(r1, r2):
    a=center(r1)
    b=center(r2)
    return( ((a[0]-b[0])**2+(a[1]-b[1])**2)**0.5)
#======================================
def intersection(r1, r2):
    x1, y1, w1, h1 = r1 
    x2, y2, w2, h2 = r2 
    nx = max(0,min(x1 + w1, x2 + w2) - max(x1, x2))
    ny = max(0,min(y1, y2) -max(y1-h1, y2 - h2))
    return (nx*ny)
#======================================
def union(r1, r2):
    return r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1, r2)
#======================================
def iou(r1, r2):
    return(intersection(r1, r2)/union(r1,r2))
#======================================

00013: HW01
bytecount: {'code': 404, 'const': 334, 'code+const': 738}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x, y, w, h = r
    cx = x + w/2
    cy = y - h/2
    return [cx, cy]
#======================================
def distance(r1, r2):
    cx1, cy1 = center(r1)
    cx2, cy2 = center(r2)
    return ((cx1 - cx2)**2 + (cy1 - cy2)**2)**(0.5)    
#======================================
def intersection(r1, r2):
    x1, y1, w1, h1 = r1
    x2, y2, w2, h2 = r2
    x_left = max(x1, x2)
    y_top = min(y1, y2)
    x_right = min(x1 + w1, x2 + w2)
    y_bottom = max(y1 - h1, y2 - h2)
    interx = (len(str(x_right - x_left).split('-'))-2)**(2)
    intery = (len(str(y_top - y_bottom).split('-'))-2)**(2) 
    return (((x_right - x_left)* (y_top - y_bottom)*interx*intery)**(2))**(0.5)
#======================================
def union(r1, r2):
    i = intersection(r1, r2)
    u = (r1[2] * r1[3]) + (r2[2] * r2[3]) - i
    return u    
#======================================
def iou(r1, r2):
    i = intersection(r1, r2)
    u = union(r1, r2)
    return i / u    
#======================================

00014: HW01
bytecount: {'code': 360, 'const': 392, 'code+const': 752}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    [x,y,w,h] = r
    return [x+w/2, y-h/2]
#======================================
def distance(r1, r2):
    c1 = center(r1)
    c2 = center(r2)
    dist = ((c1[0]-c2[0])**2 + (c1[1]-c2[1])**2)**0.5
    return dist
#======================================
def intersection(r1, r2):
    x1 = max(r1[0], r2[0])
    y1 = min(r1[1], r2[1])
    x2 = min(r1[0]+r1[2], r2[0]+r2[2])
    y2 = max(r1[1]-r1[3], r2[1]-r2[3])
    return max((x2-x1),0)*max((y1-y2),0)
#======================================
def union(r1, r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    return area1 + area2 - intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00015: HW01
bytecount: {'code': 400, 'const': 388, 'code+const': 788}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]
  y = r[1]
  w = r[2]
  h = r[3]
  centerdot = [x+(w/2),y-(h/2)]
  return centerdot
#======================================
def distance(r1, r2):
  center_1 = center(r1)
  center_2 = center(r2)
  x1 = center_1[0]
  y1 = center_1[1]
  x2 = center_2[0]
  y2 = center_2[1]
  distance1to2 = ((x2-x1)**2+(y2-y1)**2)**(1/2)
  return distance1to2
#======================================
def intersection(r1, r2):
    x1, y1, w1, h1 = r1
    x2, y2, w2, h2 = r2
    left = max(x1, x2) 
    right = min(x1 + w1, x2 + w2)
    top = min(y1, y2)
    bottom = max(y1 - h1, y2 - h2)
    #print(left,right,bottom,top)
    return max(0, right - left) * max(0, top - bottom)
#======================================
def union(r1, r2):
    w1 , h1 = r1[2] , r1[3]
    w2 , h2 = r2[2] , r2[3]
    area1 = w1*h1
    area2 = w2*h2
    total = area1+area2-intersection(r1 , r2)
    return total
#======================================
def iou(r1, r2):
  return intersection(r1, r2) / union(r1, r2)    
#======================================
#r1 = [1.0, 4.0, 1.5, 2.0]
#r2 = [2.0, 5.0, 2.5, 2.0]
#r3 = [4.0, 5.5, 1.5, 3.5]
#r4 = [6.0, 4.5, 1.5, 2.0]
#r5 = [5.75, 7.0, 2.0, 5.0] 
#print(center(r1))
#print(center(r2))
#print(round(distance(r1,r2),2))
#print(round(distance(r3,r4),2))
#print(intersection(r1,r2)) 
#print(intersection(r2,r3))
#print(intersection(r4,r5))
#print(intersection(r1,r5))
#print(union(r1,r2))
#print(union(r2,r3))
#print(union(r4,r5))
#print(round(iou(r1,r2),2))
#print(round(iou(r2,r3),2))
#print(round(iou(r4,r5),2))

00016: HW01
bytecount: {'code': 368, 'const': 420, 'code+const': 788}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  centerX = r[0] + r[2]/2
  centerY = r[1] - r[3]/2
  return [centerX,centerY]
#======================================
def distance(r1, r2):
  centerX1,centerY1 = center(r1)
  centerX2,centerY2 = center(r2)
  difX = centerX2 - centerX1
  difY = centerY2 - centerY1
  return (difX**2 + difY**2)**(1/2)
#======================================
def intersection(r1, r2):
    intersectionArea = max(0, min(r1[0] + r1[2], r2[0] + r2[2]) - max(r1[0], r2[0])) * max(0, min(r1[1], r2[1]) - max(r1[1] - r1[3], r2[1] - r2[3]))
    return intersectionArea
#======================================
def union(r1, r2):
    r1Area = r1[2] * r1[3]
    r2Area = r2[2] * r2[3]
    intersect = intersection(r1,r2)
    return r1Area + r2Area - intersect
#======================================
def iou(r1, r2):
    total = union(r1,r2)
    intersect = intersection(r1,r2)
    return intersect / total
#======================================

00017: HW01
bytecount: {'code': 416, 'const': 388, 'code+const': 804}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center_r = [(r[0] + r[2]/2), (r[1] - r[3]/2)]
    return center_r
#======================================
def distance(r1, r2):
    cr1 = center(r1)
    cr2 = center(r2)
    x1, y1, x2, y2 = cr1[0], cr1[1], cr2[0], cr2[1]
    dstc_2c = (((x2-x1)**2)+((y2-y1)**2))**(1/2)
    return dstc_2c  
#======================================
def intersection(r1, r2):
    x1, y1, xin2, yin2 = r1
    x3, y3, xin4, yin4 = r2
    x2 = x1 + xin2
    y2 = y1 - yin2
    x4 = x3 + xin4
    y4 = y3 - yin4
    itsx1 = max(x1, x3)
    itsy1 = min(y1, y3)
    itsx2 = min(x2, x4)
    itsy2 = max(y2, y4)
    its_wid = max(0, itsx2 - itsx1)
    its_hei = max(0, itsy1 - itsy2)
    its_area = its_hei * its_wid
    return its_area
#======================================
def union(r1, r2):
    widr1 = r1[2]
    heir1 = r1[3]
    widr2 = r2[2]
    heir2 = r2[3]
    area_r1 = widr1 * heir1
    area_r2 = widr2 * heir2
    union_r12 = area_r1 + area_r2 - intersection(r1, r2)
    return union_r12
#======================================
def iou(r1, r2):
    iou = intersection(r1, r2) / union(r1, r2)
    return iou
#======================================

00018: HW01
bytecount: {'code': 388, 'const': 420, 'code+const': 808}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + (r[2]/2)
  y = r[1] - (r[3]/2)
  result = [x, y]
  return result
#======================================
def distance(r1, r2):
  x1, y1 = center(r1)
  x2, y2 = center(r2)
  result = ((x1-x2)**2 + (y1-y2)**2)**0.5
  return result
#======================================
def intersection(r1, r2):
  x1 = max(r1[0], r2[0])
  y1 = min(r1[1], r2[1])
  x2 = min(r1[0] + r1[2], r2[0] + r2[2])
  y2 = max(r1[1] - r1[3], r2[1] - r2[3])
  result = max(0, (x2-x1)) * max(0, (y1-y2))
  return result
#======================================
def union(r1, r2):
  area1 = r1[2] * r1[3]
  area2 = r2[2] * r2[3]
  intersec = intersection(r1, r2)
  result = area1 + area2 - intersec
  return result
#======================================
def iou(r1, r2):
  intersec = intersection(r1, r2)
  uni = union(r1, r2)
  return intersec/uni
#======================================

00019: HW01
bytecount: {'code': 336, 'const': 472, 'code+const': 808}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+(r[2]/2),r[1]-(r[3]/2)]
#======================================
def distance(r1, r2):
    return (((center(r1)[0]-center(r2)[0])**2)+((center(r1)[1]-center(r2)[1])**2))**0.5
#======================================
def intersection(r1, r2):
    return max(0,min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0]))*max(0,min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3]))
#======================================
def union(r1, r2):
    return (r1[2]*r1[3])+(r2[2]*r2[3])-(intersection(r1, r2))
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00020: HW01
bytecount: {'code': 336, 'const': 472, 'code+const': 808}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
    return ((center(r1)[0]-center(r2)[0])**2+(center(r1)[1]-center(r2)[1])**2)**0.5
#======================================
def intersection(r1, r2):
    return max( min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0]),0 )*max( min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3]),0 )
#======================================
def union(r1, r2):
    return r1[2]*r1[3]+r2[2]*r2[3]-(intersection(r1, r2))
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00021: HW01
bytecount: {'code': 338, 'const': 472, 'code+const': 810}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0] + (r[2]/2), r[1] - (r[3]/2)]
#======================================
def distance(r1, r2):
    c1, c2 = center(r1), center(r2)
    return ((c2[0] - c1[0]) ** 2 + (c2[1] - c1[1]) ** 2) ** 0.5    
#======================================
def intersection(r1, r2):
    return max(0, min(r1[0] + r1[2], r2[0] + r2[2]) - max(r1[0], r2[0])) * max(0, min(r1[1], r2[1]) - max(r1[1] - r1[3], r2[1] - r2[3]))
#======================================
def union(r1, r2):
    return (r1[2]*r1[3]) + (r2[2]*r2[3]) - intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2) / union(r1, r2) 
#======================================

00022: HW01
bytecount: {'code': 392, 'const': 420, 'code+const': 812}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = (2*r[0] + r[2]) / 2
    y = (2*r[1] - r[3]) / 2
    return [x, y]
#======================================
def distance(r1, r2):
    x1, y1 = center(r1)
    x2, y2 = center(r2)
    dist = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
    return dist
#======================================
def intersection(r1, r2):
    left = max(r1[0], r2[0])
    right = min(r1[0] + r1[2], r2[0] + r2[2])
    up = min(r1[1], r2[1])
    down = max(r1[1] - r1[3], r2[1] - r2[3])
    #if left < right and down < up
        #intersect_area = (right - left)*(up - down)
    #else intersect_area = 0
    w_intersect = max(0, (right - left))
    h_intersect = max(0, (up - down))
    intersect_area = w_intersect * h_intersect
    return intersect_area
#======================================
def union(r1, r2):
    area1 = r1[2] * r1[3]
    area2 = r2[2] * r2[3]
    union_area = area1 + area2 - intersection(r1, r2)
    return union_area
#======================================
def iou(r1, r2):
    iou = intersection(r1, r2) / union(r1, r2)
    return iou
#======================================

00023: HW01
bytecount: {'code': 344, 'const': 472, 'code+const': 816}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+r[2]/2, r[1]-r[3]/2]
#======================================
def distance(r1, r2):
    c1 = center(r1)
    c2 = center(r2)
    return ((c1[0]-c2[0])**2+(c1[1]-c2[1])**2)**0.5
#======================================
def intersection(r1, r2):
    x =  max(0, min(r1[0]+r1[2], r2[0]+r2[2]) - max(r1[0], r2[0]))
    y =  max(0, min(r1[1], r2[1]) - max(r1[1]-r1[3], r2[1]-r2[3]))
    return x*y
#======================================
def union(r1, r2):
  return r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00024: HW01
bytecount: {'code': 344, 'const': 472, 'code+const': 816}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [(r[0]+(r[2]/2)), (r[1]-(r[3]/2))]
#======================================
def distance(r1, r2):
  a = center(r1)
  b = center(r2)
  return ((a[0]-b[0])**2 + (a[1]-b[1])**2)**0.5  
#======================================
def intersection(r1, r2):
  x = min((r1[0]+r1[2]),(r2[0]+r2[2])) - max(r1[0],r2[0])
  y = min(r1[1],r2[1]) - max((r1[1]-r1[3]), (r2[1]-r2[3]))
  return max(0,x)*max(0,y)
#======================================
def union(r1, r2):
  return (r1[2]*r1[3]) + (r2[2]*r2[3]) - intersection(r1,r2)    
#======================================
def iou(r1, r2):
  return intersection(r1,r2)/union(r1,r2)
#======================================

00025: HW01
bytecount: {'code': 400, 'const': 420, 'code+const': 820}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] + r[2]/2
    y = r[1] - r[3]/2
    return [x, y]
#======================================
def distance(r1, r2):
    [x1,y1] = center(r1)
    [x2,y2] = center(r2)
    d = ( (x1 - x2)**2 + (y1 - y2)**2 )**(0.5)
    return d
#======================================
def intersection(r1, r2):
    x1 = r1[0] ; x2 = r1[0] + r1[2] ; x3 = r2[0] ; x4 = r2[0] + r2[2]
    y1 = r1[1] ; y2 = r1[1] - r1[3] ; y3 = r2[1] ; y4 = r2[1] - r2[3]
    w = max((min([x2,x4]) - max([x3,x1])),0)
    h = max((min([y1,y3]) - max([y2,y4])),0)
    intersection =  w*h
    return intersection
#======================================
def union(r1, r2):
    union = (r1[2]*r1[3]) + (r2[2]*r2[3]) - intersection(r1, r2)
    return union
#======================================
def iou(r1, r2):
    iou = (intersection(r1, r2))/(union(r1, r2))
    return iou
#======================================

00026: HW01
bytecount: {'code': 352, 'const': 472, 'code+const': 824}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r): 
    return [r[0]+(r[2]/2), r[1]-(r[3]/2)]
def distance(r1, r2):
    return (((center(r1)[0]-center(r2)[0])**2)+((center(r1)[1]-center(r2)[1])**2))**0.5
def intersection(r1, r2):
    width = max(0, min(r1[0]+r1[2], r2[0]+r2[2]) - max(r1[0], r2[0]))
    height = max(0, min(r1[1], r2[1]) - max(r1[1]-r1[3], r2[1]-r2[3]))
    return width*height
def union(r1, r2):
    area_r1 = r1[2]*r1[3]
    area_r2 = r2[2]*r2[3]
    return area_r1 + area_r2 - intersection(r1, r2)
def iou(r1, r2):
    return intersection(r1, r2) / union(r1, r2)

00027: HW01
bytecount: {'code': 436, 'const': 392, 'code+const': 828}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + (r[2] / 2)
  y = r[1] - (r[3] / 2)
  return [x, y]
#======================================
def distance(r1, r2):
  x1, y1 = center(r1)
  x2, y2 = center(r2)
  return ((x2 - x1)**2 + (y2 - y1)**2)**0.5
#======================================
def intersection(r1, r2):
  x1, y1 = center(r1)
  x2, y2 = center(r2)
  w1, h1 = r1[2], r1[3]
  w2, h2 = r2[2], r2[3]
  dx = min(x1 + w1/2, x2 + w2/2) - max(x1 - w1/2, x2 - w2/2)
  dy = min(y1 + h1/2, y2 + h2/2) - max(y1 - h1/2, y2 - h2/2)
  return abs((dx*dy)*(dx>0)*(dy>0))
#======================================
def union(r1, r2):
  inter = intersection(r1, r2)
  area1 = r1[2] * r1[3]
  area2 = r2[2] * r2[3]
  return area1 + area2 - inter
#======================================
def iou(r1, r2):
  inter = intersection(r1, r2)
  union_area = union(r1, r2)
  return inter / union_area
#======================================

00028: HW01
bytecount: {'code': 408, 'const': 420, 'code+const': 828}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + r[2]/2 
  y = r[1] - r[3]/2
  return [x,y]
#======================================
def distance(r1, r2):  
  x1,y1 = center(r1)
  x2,y2 = center(r2)
  return ((x1-x2)**2+(y1-y2)**2)**(0.5) 
#======================================
def intersection(r1, r2):
  x_cor = [r1[0], r1[0]+r1[2],r2[0], r2[0]+r2[2]] 
  y_cor = [r1[1], r1[1]-r1[3],r2[1], r2[1]-r2[3]]
  del_x = min(x_cor[1],x_cor[3]) - max(x_cor[0],x_cor[2]) 
  del_y = min(y_cor[0],y_cor[2]) - max(y_cor[1],y_cor[3])
  return max(0,del_x)*max(0,del_y)
#======================================
def union(r1, r2):
  areaA = r1[2] * r1[3] 
  areaB =  r2[2] * r2[3]
  return areaA+areaB-intersection(r1,r2)
#======================================
def iou(r1, r2):
  return intersection(r1,r2) / union(r1,r2)
#======================================

00029: HW01
bytecount: {'code': 356, 'const': 472, 'code+const': 828}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
  xy1 = center(r1)
  xy2 = center(r2)
  return ((xy1[0]-xy2[0])**2+(xy1[1]-xy2[1])**2)**0.5
#======================================
def intersection(r1, r2):
  xmin = max(r1[0],r2[0])
  xmax = min(r1[0]+r1[2],r2[0]+r2[2])
  ymax = min(r1[1],r2[1])
  ymin = max(r1[1]-r1[3],r2[1]-r2[3])
  return max(0,xmax-xmin)*max(0,ymax-ymin)
#======================================
def union(r1, r2):
  unionarea = r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1, r2)
  return unionarea
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1, r2)
#======================================

00030: HW01
bytecount: {'code': 360, 'const': 472, 'code+const': 832}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r): 
  xcenter=r[0]+r[2]/2
  ycenter=r[1]-r[3]/2
  return [xcenter,ycenter]
#======================================
def distance(r1, r2):
  center_r1=center(r1)
  center_r2=center(r2)
  return(((center_r2[0]-center_r1[0])**2+(center_r2[1]-center_r1[1])**2)**0.5)
#======================================
def intersection(r1, r2):
  xintersect=max(min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0]),0)
  yintersect=max(min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3]),0)
  return(xintersect*yintersect)
#======================================
def union(r1, r2):
  area_r1=r1[2]*r1[3]
  area_r2=r2[2]*r2[3]
  return(area_r1+area_r2-intersection(r1, r2))
#======================================
def iou(r1, r2):
  return(intersection(r1, r2)/union(r1, r2))
#======================================

00031: HW01
bytecount: {'code': 360, 'const': 472, 'code+const': 832}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
  c1=center(r1)
  c2=center(r2)
  return ((c1[0]-c2[0])**2+(c1[1]-c2[1])**2)**(1/2)
#======================================
def intersection(r1, r2):
  x_right_near=min(r1[0]+r1[2],r2[0]+r2[2])
  x_left_far=max(r1[0],r2[0])
  y_up_lower=min(r1[1],r2[1])
  y_down_higher=max(r1[1]-r1[3],r2[1]-r2[3])
  W=max(x_right_near-x_left_far,0)
  H=max(y_up_lower-y_down_higher,0)
  return W*H 
#======================================
def union(r1, r2):
  return (r1[2]*r1[3])+(r2[2]*r2[3])-intersection(r1, r2)
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1, r2)
#======================================

00032: HW01
bytecount: {'code': 364, 'const': 472, 'code+const': 836}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  cp = [r[0]+(r[2]/2),r[1]-(r[3]/2)]
  return cp
#======================================
def distance(r1, r2):
  d = (((center(r1)[0]-center(r2)[0])**2)+((center(r1)[1]-center(r2)[1])**2))**0.5
  return d
#======================================
def intersection(r1, r2):
    x = max((min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0])),0)
    y = max((min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3])),0)
    area = x*y
    return area
#======================================
def union(r1, r2):
    area = ((r1[2]*r1[3])+(r2[2]*r2[3]))-intersection(r1,r2)
    return area
#======================================
def iou(r1, r2):
    iou = intersection(r1,r2)/union(r1,r2)
    return iou
#======================================

00033: HW01
bytecount: {'code': 368, 'const': 472, 'code+const': 840}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0] + r[2] / 2, r[1] - r[3] / 2]
#======================================
def distance(r1, r2):
    cr1 = center(r1)
    cr2 = center(r2)
    return ((cr1[0] - cr2[0])**2 + (cr1[1] - cr2[1])**2)**.5
#======================================
def intersection(r1, r2):
    x1 = max(r1[0], r2[0])
    x2 = min(r1[0]+r1[2], r2[0]+r2[2])
    y1 = min(r1[1], r2[1])
    y2 = max(r1[1]-r1[3], r2[1]-r2[3])
    w = x2 - x1
    h = y1 - y2
    return abs(w * h * (h >= 0) * (w >= 0))
#======================================
def union(r1, r2):
    return r1[2] * r1[3] + r2[2] * r2[3] - intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2) / union(r1, r2)
#======================================

00034: HW01
bytecount: {'code': 456, 'const': 384, 'code+const': 840}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0] + r[2]/2, r[1] - r[3]/2]
#======================================
def distance(r1, r2):
  d1 = center(r1)
  d2 = center(r2)
  return ( (d1[0]-d2[0])**2 + (d1[1]-d2[1])**2 )**0.5
#======================================
def intersection(r1, r2):
  x1, y1, w1, h1 = r1
  x2, y2, w2, h2 = r2
  mn_u = min(y1, y2)
  mx_d = max(y1 - h1, y2 - h2)
  mx_l = max(x1, x2)
  mn_r = min(x1 + w1, x2 + w2)
  return max(0.0, mn_r-mx_l) * max(0.0, mn_u-mx_d)
#======================================
def union(r1, r2):
  x1, y1, w1, h1 = r1
  x2, y2, w2, h2 = r2
  a1 = [x1, y1]
  c1 = [x1+w1, y1-h1]
  a2 = [x2, y2]
  c2 = [x2+w2, y2-h2]
  area = ( abs(a1[0]-c1[0]) * abs(a1[1]-c1[1]) ) + ( abs(a2[0]-c2[0]) * abs(a2[1]-c2[1]) )
  area -= intersection(r1, r2)
  return area
#======================================
def iou(r1, r2):
  return intersection(r1, r2) / union(r1, r2)
#======================================

00035: HW01
bytecount: {'code': 372, 'const': 472, 'code+const': 844}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  c1=(r[2]/2)+r[0]
  c2=r[1]-(r[3]/2)
  return [c1, c2]
#======================================
def distance(r1, r2):
  p1 = center(r1)
  p2 = center(r2)
  d=(((p1[0]-p2[0])**2)+((p1[1]-p2[1])**2))**(1/2)
  return d
#======================================
def intersection(r1, r2):
  x = max((min((r1[0]+r1[2]), (r2[0]+r2[2]))-(max(r2[0], r1[0]))), 0)
  y = max((min(r2[1], r1[1])-max((r1[1]-r1[3]), (r2[1]-r2[3]))), 0)
  a = x*y
  return a
#======================================
def union(r1, r2):
  area_1 = r1[2]*r1[3]
  area_2 = r2[2]*r2[3]
  u = (area_1+area_2)-intersection(r1, r2)
  return u
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00036: HW01
bytecount: {'code': 374, 'const': 472, 'code+const': 846}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
  x = ((center(r1)[0]-center(r2)[0])**2+((center(r1)[1]-center(r2)[1])**2))**0.5
  return x
#======================================
def intersection(r1, r2):
  xleft = max(r1[0],r2[0])
  yleft = min(r1[1],r2[1])
  xright = min(r1[0]+r1[2],r2[0]+r2[2])
  yright = max(r1[1]-r1[3],r2[1]-r2[3])
  area = max(xright-xleft, 0)*max(yleft-yright, 0)
  return max(0,area)
#======================================
def union(r1, r2):
  area = (r1[2]*r1[3])+(r2[2]*r2[3])-(intersection(r1, r2))
  return area
#======================================
def iou(r1, r2):
  percent = intersection(r1, r2)/union(r1, r2)
  return percent
#======================================

00037: HW01
bytecount: {'code': 352, 'const': 496, 'code+const': 848}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+r[2]/2, r[1]-r[3]/2]
#======================================
def distance(r1, r2):
    A = center(r1)
    B = center(r2)
    return ((A[0]-B[0])**2 + (A[1]-B[1])**2)**(1/2)
#======================================
def intersection(r1, r2):
    R = min(r1[0]+r1[2], r2[0]+r2[2])
    L = max(r1[0], r2[0])
    U = min(r1[1], r2[1])
    D = max(r1[1]-r1[3], r2[1]-r2[3])
    return max(0.0, R-L)*max(0.0, U-D)
#======================================
def union(r1, r2):
    return (r1[2]*r1[3])+(r2[2]*r2[3])-intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)

00038: HW01
bytecount: {'code': 376, 'const': 472, 'code+const': 848}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=r[0]+r[2]/2
  y=r[1]-r[3]/2
  c=[x,y]
  return(c)
#======================================
def distance(r1, r2):
  a=center(r1)
  b=center(r2)
  dis=(((b[0]-a[0])**2)+((b[1]-a[1])**2))**(1/2)
  return(dis)
#======================================
def intersection(r1, r2):
  p1=max(r1[0],r2[0])
  p2=min(r1[0]+r1[2],r2[0]+r2[2])
  p3=max(r1[1]-r1[3],r2[1]-r2[3])
  p4=min(r1[1],r2[1])
  its=max(0,p2-p1)*max(0,p4-p3)
  return(its)
#======================================
def union(r1, r2):
  u=(r1[2]*r1[3])+(r2[2]*r2[3])-intersection(r1,r2)
  return(u)   
#======================================
def iou(r1, r2):
  return(intersection(r1,r2)/union(r1,r2))
#======================================

00039: HW01
bytecount: {'code': 376, 'const': 472, 'code+const': 848}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+(r[2]/2),r[1]-(r[3]/2)]
#======================================
def distance(r1, r2):
    p1 = center(r1)
    p2 = center(r2)
    return ((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2)**0.5
#======================================
def intersection(r1, r2):
    x1,xd1 = r1[0],r1[0]+r1[2]
    x2,xd2 = r2[0],r2[0]+r2[2]
    y1,yd1 = r1[1]-r1[3],r1[1]
    y2,yd2 = r2[1]-r2[3],r2[1]
    return max(min(xd1,xd2)-max(x1,x2),0)*max(min(yd1,yd2)-max(y1,y2),0)
#======================================
def union(r1, r2):
    return (r1[2]*r1[3]) + (r2[2]*r2[3]) - intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00040: HW01
bytecount: {'code': 380, 'const': 472, 'code+const': 852}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  center = [r[0]+r[2]/2,r[1]-r[3]/2]
  return center
#======================================
def distance(r1, r2):
  pox = center(r1)
  poy = center(r2)
  distance= ((pox[0]-poy[0])**2+(pox[1]-poy[1])**2)**0.5
  return distance
#======================================
def intersection(r1, r2):
  xleft = max(r1[0],r2[0])
  xright = min(r1[0]+r1[2],r2[0]+r2[2])
  ymax = min(r1[1],r2[1])
  ymin = max(r1[1]-r1[3],r2[1]-r2[3])     
  w = max(0,xright - xleft)
  h = max(0,ymax - ymin)
  intersection = w*h
  return intersection  
#======================================
def union(r1, r2):
  x = intersection(r1,r2)
  union = (r1[2]*r1[3]+r2[2]*r2[3])-x
  return union
#======================================
def iou(r1, r2):
  return intersection(r1,r2)/union(r1,r2)    
#======================================

00041: HW01
bytecount: {'code': 380, 'const': 472, 'code+const': 852}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] + r[2]/2
    y = r[1] - r[3]/2
    cen = [x,y]
    return cen
#======================================
def distance(r1, r2):
    r1 = center(r1)
    r2 = center(r2)
    dis = ((r1[0]-r2[0])**2 + (r1[1]-r2[1])**2)**0.5
    return dis
#======================================
def intersection(r1, r2):
    x1 = max(r1[0],r2[0])
    y1 = max(r1[1]-r1[3],r2[1]-r2[3])
    x2 = min(r1[0]+r1[2],r2[0]+r2[2])
    y2 = min(r1[1],r2[1])
    inter = max(0,x2-x1) * max(0,y2-y1)
    return inter
#======================================
def union(r1, r2):
    uni = r1[2]*r1[3] + r2[2]*r2[3] - intersection(r1,r2)
    return uni 
#======================================
def iou(r1, r2):
    i = intersection(r1,r2) / union(r1,r2)
    return i
#======================================

00042: HW01
bytecount: {'code': 380, 'const': 472, 'code+const': 852}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    xcenter = r[0] + r[2]/2
    ycenter = r[1] - r[3]/2
    return [xcenter,ycenter]
#======================================
def distance(r1, r2):
    center_r1 = center(r1)
    center_r2 = center(r2)
    Distance = (((center_r1[0] - center_r2[0])**2) + ((center_r1[1] - center_r2[1])**2))**(1/2)
    return Distance
#======================================
def intersection(r1, r2):
    wide = min(r1[0] + r1[2] , r2[0] + r2[2]) - max(r1[0] , r2[0])
    height = min(r1[1] , r2[1]) - max(r1[1] - r1[3] , r2[1] - r2[3])
    area = max(wide, 0) * max(height, 0)
    return area
#======================================
def union(r1, r2):
    intersec = intersection(r1, r2)
    Area = ((r1[2] * r1[3]) + (r2[2] * r2[3])) - intersec
    return Area
#======================================
def iou(r1, r2):
    intersec = intersection(r1, r2)
    Union = union(r1, r2)
    IOU = intersec / Union
    return IOU
#======================================

00043: HW01
bytecount: {'code': 384, 'const': 472, 'code+const': 856}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    c = [r[0]+r[2]/2,r[1]-r[3]/2]
    return c
#======================================
def distance(r1, r2):
    c1 = center(r1) ; c2 = center(r2)
    d = ((c1[0]-c2[0])**2+(c1[1]-c2[1])**2)**(0.5)
    return d
#======================================
def intersection(r1, r2):
    rf = min(r1[0]+r1[2],r2[0]+r2[2])
    lf = max(r1[0],r2[0])
    w = max(rf-lf,0)
    s = max(r1[1]-r1[3],r2[1]-r2[3]) ; f = min(r1[1],r2[1])
    h = max(f-s,0)
    return w*h
#======================================
def union(r1, r2):
    area_in = intersection(r1,r2)
    area_u = r1[2]*r1[3]+r2[2]*r2[3]-area_in
    return area_u
#======================================
def iou(r1, r2):
    area_in = intersection(r1,r2)
    area_u = union(r1,r2)
    return area_in/area_u
#======================================

00044: HW01
bytecount: {'code': 384, 'const': 472, 'code+const': 856}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + r[2]/2
  y =  r[1] - r[3]/2
  return [x,y]
#======================================
def distance(r1, r2):
  x1 = center(r1)[0] ; y1 = center(r1)[1]
  x2 = center(r2)[0] ; y2 = center(r2)[1]
  distance = ((x1-x2)**2 + (y1-y2)**2)**0.5
  return distance
#======================================
def intersection(r1, r2):
  wid = min(r1[0]+r1[2],r2[0]+r2[2]) - max(r1[0],r2[0]) ; wid = max(wid,0)
  hight = min(r1[1],r2[1]) - max((r1[1]-r1[3] ), (r2[1] - r2[3]))  ; hight = max(hight,0)
  return wid*hight
#======================================
def union(r1, r2):
  area = r1[2]*r1[3] + r2[2]*r2[3] - (intersection(r1, r2))
  return area
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1, r2)
#======================================

00045: HW01
bytecount: {'code': 384, 'const': 472, 'code+const': 856}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + r[2]/2
  y = r[1] - r[3]/2
  return [x,y]
#======================================
def distance(r1, r2):
  a1 = center(r1)
  a2 = center(r2)
  return ((a1[0]-a2[0])**2+(a1[1]-a2[1])**2)**0.5
#======================================
def intersection(r1, r2):
  b1 = [r1[0]+r1[2],r1[1]-r1[3]]
  b2 = [r2[0]+r2[2],r2[1]-r2[3]]
  x = min(b1[0],b2[0])-max(r1[0],r2[0])
  y = min(r1[1],r2[1])-max(b1[1],b2[1])
  return max(x,0)*max(y,0)
#======================================
def union(r1, r2):
  return r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1, r2)
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1,r2)
#======================================

00046: HW01
bytecount: {'code': 386, 'const': 472, 'code+const': 858}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + r[2]/2
  y = r[1] - r[3]/2
  return [x, y]
#======================================
def distance(r1, r2):
  c1 = center(r1)
  c2 = center(r2)
  return ((c1[0]-c2[0])**2 + (c1[1]-c2[1])**2)**0.5
#======================================
def intersection(r1, r2):
    left = max(r1[0], r2[0])
    right = min(r1[0]+r1[2], r2[0]+r2[2])
    bottom = max(r1[1]-r1[3], r2[1]-r2[3])
    top = min(r1[1], r2[1])
    width = right - left
    height = top - bottom
    return (width * height + (width <= 0 or height <= 0) * -(width * height))
#======================================
def union(r1, r2):
    i = intersection(r1, r2)
    return (r1[2] * r1[3] + r2[2] * r2[3] - i)
#======================================
def iou(r1, r2):
    return intersection(r1, r2) / union(r1, r2)

00047: HW01
bytecount: {'code': 388, 'const': 472, 'code+const': 860}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x , y = r[0] ,r[1]
  return [x+r[2]/2,y-r[3]/2]
#======================================
def distance(r1, r2):
    x,y = center(r1),center(r2)
    return ((x[0]-y[0])**2+(x[1]-y[1])**2)**(1/2)
#======================================
def intersection(r1, r2):
    x_right = min(r1[0]+r1[2], r2[0]+r2[2])
    x_left  = max(r1[0], r2[0])
    y_top  = min(r1[1], r2[1])
    y_bottom= max(r1[1]-r1[3], r2[1]-r2[3])
    one = x_right-x_left
    two = y_top - y_bottom
    one = max(one ,0)
    two = max(two, 0)
    return one*two
#======================================
def union(r1, r2):
  area1 = r1[2]*r1[3]
  area2 = r2[2]*r2[3]
  return area1 + area2 - intersection(r1, r2)
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1, r2)
#======================================

00048: HW01
bytecount: {'code': 388, 'const': 472, 'code+const': 860}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r): 
    x = r[0] + (r[2]/2)
    y = r[1] - (r[3]/2)
    return [x, y]
#======================================
def distance(r1, r2):
    a = center(r1)
    b = center(r2)
    c = ((b[0]-a[0])**2 + (b[1]-a[1])**2)**(1/2)
    return c
#======================================
def intersection(r1, r2):
    a = max(r1[0],r2[0])
    b = min(r1[0]+r1[2],r2[0]+r2[2])
    width = max((b-a),0)
    c = max(r1[1]-r1[3],r2[1]-r2[3])
    d = min(r1[1],r2[1])
    length = max((d-c),0)
    area = width*length
    return area
#======================================
def union(r1, r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    area3 = area1+area2-intersection(r1,r2)
    return area3
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00049: HW01
bytecount: {'code': 388, 'const': 472, 'code+const': 860}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+(r[2]/2), r[1]-(r[3]/2)]
# #======================================
def distance(r1, r2):
  p=center(r1)
  a=center(r2)
  return  (((p[0]-a[0])**2)+((p[1]-a[1]))**2)**0.5
# #======================================
def intersection(r1, r2):
  newxr1=r1[0]+r1[2]
  newxr2=r2[0]+r2[2]
  maxl=max(r1[0],r2[0])
  minr=min(newxr1,newxr2)
  ansx=max(minr-maxl,0)
  newyr1=r1[1]-r1[3]
  newyr2=r2[1]-r2[3]
  maxt=max(newyr1,newyr2)
  minu=min(r1[1],r2[1])
  ansy=max(minu-maxt,0)
  return ansx*ansy
# #======================================
def union(r1, r2):
  a1=r1[2]*r1[3]
  a2=r2[2]*r2[3]
  ans=(a1+a2)-intersection(r1, r2)
  return ans
# #======================================
def iou(r1, r2):
  return (intersection(r1, r2))/union(r1, r2)
#======================================

00050: HW01
bytecount: {'code': 388, 'const': 472, 'code+const': 860}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=r[0]+r[2]/2
  y=r[1]-r[3]/2
  return [x,y]
#======================================
def distance(r1, r2):
  c1 = center(r1)
  c2 = center(r2)
  return ((c1[0]-c2[0])**2+(c1[1]-c2[1])**2)**0.5
#======================================
def intersection(r1, r2):
  xmin1 = r1[0]
  xmin2 = r2[0]
  ymin1 = r1[1]-r1[3]
  ymin2 = r2[1]-r2[3]
  xmax1 = r1[0]+r1[2]
  xmax2 = r2[0]+r2[2]
  ymax1 = r1[1]
  ymax2 = r2[1]
  w = max((min(xmax1,xmax2)-max(xmin1,xmin2)),0)
  h = max((min(ymax1,ymax2)-max(ymin1,ymin2)),0)
  return h*w
#======================================
def union(r1, r2):
  s = r1[2]*r1[3]+r2[2]*r2[3]
  return s-intersection(r1,r2)
#======================================
def iou(r1, r2):
  return intersection(r1,r2)/union(r1,r2)
#======================================

00051: HW01
bytecount: {'code': 392, 'const': 472, 'code+const': 864}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] + (r[2]/2)
    y = r[1] - (r[3]/2)
    return [x, y]
#======================================
def distance(r1, r2):
    p = center(r1)
    q = center(r2)
    d = (((p[0]) - (q[0]))**2 + ((p[1]) - (q[1]))**2)**0.5
    return d
#======================================
def intersection(r1, r2):
    a = min(r1[0] + r1[2], r2[0] + r2[2]) - max(r1[0], r2[0])
    b = min(r1[1], r2[1])  - max(r1[1] - r1[3], r2[1] - r2[3])
    a = max(a, 0)
    b = max(b, 0)
    area_in = a*b
    return area_in
#======================================
def union(r1, r2):
    area_in = intersection(r1, r2)
    area_all = (r1[2]*r1[3]) + (r2[2]*r2[3])
    area_u = area_all - area_in
    return area_u
#======================================
def iou(r1, r2):
    m = intersection(r1, r2)
    n = union(r1, r2)
    ratio_iou = m/n
    return ratio_iou
#======================================

00052: HW01
bytecount: {'code': 444, 'const': 420, 'code+const': 864}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x,y,w,h = r[0],r[1],r[2],r[3]
    return [x+w/2,y-h/2]
#======================================
def distance(r1, r2):
    x1,y1 = center(r1)
    x2,y2 = center(r2)
    return (abs(x1-x2)**2+abs(y1-y2)**2)**(1/2)
#======================================
def intersection(r1, r2):
    x1_1,y1_1,w1,h1 = r1[0],r1[1],r1[2],r1[3]
    x2_1,y2_1,w2,h2 = r2[0],r2[1],r2[2],r2[3]
    x1_2,y1_2 = x1_1+w1,y1_1-h1
    x2_2,y2_2 = x2_1+w2,y2_1-h2
    x = max((w1+w2)-(max(x1_2,x2_2)-min(x1_1,x2_1)),0)
    y = max((h1+h2)-(max(y1_1,y2_1)-min(y1_2,y2_2)),0)
    return x*y
#======================================
def union(r1, r2):
    w1,h1 = r1[2],r1[3]
    w2,h2 = r2[2],r2[3]
    return w1*h1+w2*h2-intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00053: HW01
bytecount: {'code': 392, 'const': 472, 'code+const': 864}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    cenx = r[0]+((r[2])/2)
    ceny = r[1]-((r[3])/2)
    cen =[cenx,ceny]
    return cen
#======================================
def distance(r1,r2):
    a=center(r1)
    b=center(r2)
    d= (((a[0]-b[0])**2)+((a[1]-b[1])**2))**0.5
    return d
#======================================
def intersection(r1,r2):
    xr1=r1[0]+r1[2]
    xr2=r2[0]+r2[2]
    xd1=r1[1]-r1[3]
    xd2=r2[1]-r2[3]
    width = max(min(xr1,xr2) - max(r1[0],r2[0]),0)
    high  = max(min(r1[1],r2[1])-max(xd1,xd2),0)
    area = width*high
    return area
#======================================
def union(r1,r2):
    area1_2union = (r1[2]*r1[3])+(r2[2]*r2[3])-intersection(r1,r2)
    u=area1_2union
    return u
#======================================
def iou(r1,r2):
    rt=intersection(r1,r2)/union(r1,r2)
    return rt
#======================================

00054: HW01
bytecount: {'code': 392, 'const': 472, 'code+const': 864}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
    cen1 = center(r1)
    cen2 = center(r2)
    return ((cen1[0]-cen2[0])**2+(cen1[1]-cen2[1])**2)**0.5
#======================================
def intersection(r1, r2):
    x1 =r1[0] ; x1_ =r1[0]+r1[2]
    x2 =r2[0] ; x2_ =r2[0]+r2[2]
    y1 =r1[1] ; y1_ =r1[1]-r1[3]
    y2 =r2[1] ; y2_ =r2[1]-r2[3]
    width = min(x1_,x2_)-max(x1,x2)
    width = max(width,0)
    length = min(y1,y2)-max(y1_,y2_)
    length = max(length,0)
    return width*length
#======================================
def union(r1, r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    return area1+area2-intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00055: HW01
bytecount: {'code': 396, 'const': 472, 'code+const': 868}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center_x=r[0]+(r[2]/2)
    center_y=r[1]-(r[3]/2)
    return [center_x, center_y]
#============================================================================
def distance(r1, r2):
    center_1 = center(r1)
    center_2 = center(r2)
    distant = ((center_1[0]-center_2[0])**2 + (center_1[1]-center_2[1])**2)**0.5
    return distant
#============================================================================
def intersection(r1, r2):
    point_x1 = r1[0]+r1[2]
    point_y1 = r1[1]-r1[3]
    point_x2 = r2[0]+r2[2]
    point_y2 = r2[1]-r2[3]
    length_x = abs(max(0, min(point_x1, point_x2) - max(r1[0], r2[0])))
    length_y = abs(max(0, min(r1[1], r2[1]) - max(point_y1, point_y2)))
    intersect_area = length_x * length_y
    return intersect_area
#============================================================================
def union(r1, r2):
    area_1 = r1[2] * r1[3]
    area_2 = r2[2] * r2[3]
    total_area = area_1 + area_2 - intersection(r1 ,r2)
    return total_area
#============================================================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#============================================================================

00056: HW01
bytecount: {'code': 396, 'const': 472, 'code+const': 868}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  cenx = r[0] + r[2]/2
  ceny = r[1] - r[3]/2
  center = [cenx, ceny]
  return center
def distance(r1, r2):
  dix = center(r1)[0] - center(r2)[0]
  diy = center(r1)[1] - center(r2)[1]
  distance = (dix**2 + diy**2)**0.5
  return distance
def intersection(r1, r2):
  x1 = min(r1[0] + r1[2], r2[0] + r2[2])
  width = max(x1 - max(r1[0],r2[0]), 0)
  y1 = max(r2[1] - r2[3], r1[1] - r1[3])
  height = max(min(r1[1],r2[1]) - y1, 0)
  intersection = width*height
  return intersection
def union(r1, r2):
  area1 = r1[2]*r1[3]
  area2 = r2[2]*r2[3]
  union = area1 + area2 - intersection(r1,r2)
  return union
def iou(r1, r2):
  iou = intersection(r1,r2) / union(r1,r2)
  return iou

00057: HW01
bytecount: {'code': 396, 'const': 472, 'code+const': 868}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]+r[2]/2
  y = r[1]-r[3]/2
  return[x,y]        
#======================================
def distance(r1, r2):
  a = center(r1)
  b = center(r2)
  distances = ((a[0]-b[0])**2+(a[1]-b[1])**2)**0.5
  return distances
#======================================
def intersection(r1, r2):
  a1 = r1[0]
  b1 = r1[0]+r1[2]
  a2 = r2[0]
  b2 = r2[0]+r2[2]
  x = min(b1,b2)-max(a1,a2)
  a3 = r1[1]-r1[3]
  b3 = r1[1]
  a4 = r2[1]-r2[3]
  b4 = r2[1]
  y = min(b3,b4)-max(a3,a4)
  area = max(x,0)*max(y,0)
  return area
#======================================
def union(r1, r2):
  areas = (r1[2]*r1[3] + r2[2]*r2[3]) - intersection(r1, r2)
  return areas
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1, r2)
#======================================

00058: HW01
bytecount: {'code': 396, 'const': 472, 'code+const': 868}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  mid_x = r[0]+(r[2]/2)
  mid_y = r[1]-(r[3]/2)
  mid = [mid_x,mid_y]
  return mid 
#======================================
def distance(r1, r2):
    dis1 = center(r1)
    dis2 = center(r2)
    dis=((dis1[0]-dis2[0])**2 + (dis1[1]-dis2[1])**2)**(1/2)
    return dis
#======================================
def intersection(r1, r2):
    x_left = max(r1[0],r2[0])
    x_right = min(r1[0]+r1[2],r2[0]+r2[2])
    y_top = min(r1[1],r2[1])
    y_bottom = max(r1[1]-r1[3],r2[1]-r2[3])
    delta_x = max(0,x_right-x_left)
    delta_y = max(0,y_top-y_bottom)
    intersec = delta_x*delta_y 
    return intersec
#======================================
def union(r1, r2):
  inter = intersection(r1,r2)
  A1 = r1[2]*r1[3]
  A2 = r2[2]*r2[3]
  u = A1+A2- inter
  return u
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1,r2)
#exec(input())
#======================================

00059: HW01
bytecount: {'code': 400, 'const': 472, 'code+const': 872}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+r[2]/2, r[1]-r[3]/2]
#======================================
def distance(r1, r2):
  return ((center(r1)[0] - center(r2)[0])**2 + (center(r1)[1] - center(r2)[1])**2)**(1/2)
#======================================
def intersection(r1, r2):
  temp1 = [r1[0],r1[1]-r1[3],r1[0]+r1[2],r1[1]]  
  temp2 = [r2[0],r2[1]-r2[3],r2[0]+r2[2],r2[1]]
  dx = min(temp1[2], temp2[2]) - max(temp1[0], temp2[0])
  dy = min(temp1[3], temp2[3]) - max(temp1[1], temp2[1])
  return max(dx, 0)*max(dy, 0)
#======================================
def union(r1, r2):
  return r1[2]*r1[3] + r2[2]*r2[3] - intersection(r1, r2)
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1, r2)
#======================================

00060: HW01
bytecount: {'code': 400, 'const': 472, 'code+const': 872}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0]
    y = r[1]
    w = r[2]
    h = r[3]
    return [float(x+w/2),float(y-h/2)]
#======================================
def distance(r1, r2):
    x1 = center(r1)[0] ; y1 = center(r1)[1]
    x2 = center(r2)[0] ; y2 = center(r2)[1]
    return ((x2-x1)**2+(y2-y1)**2)**(1/2)
#======================================
def intersection(r1, r2):
    w = max((min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0])),0)
    h = max(min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3]),0)
    return w*h
#======================================
def union(r1, r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    area = area1+area2-intersection(r1,r2)
    return area
#======================================
def iou(r1, r2):
    ratio = intersection(r1,r2)/union(r1,r2)
    return ratio
#======================================

00061: HW01
bytecount: {'code': 376, 'const': 496, 'code+const': 872}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  center_x = r[0] + (r[2] / 2)
  center_y = r[1] - (r[3] / 2)
  return [center_x, center_y]
#======================================
def distance(r1, r2):
  cen_r1 = center(r1)
  cen_r2 = center(r2)
  a = (cen_r1[0] - cen_r2[0]) ** 2
  b = (cen_r1[1] - cen_r2[1]) ** 2
  return (a + b) ** (1/2)
#======================================
def intersection(r1, r2):
  x1 = max(r1[0], r2[0])
  y1 = min(r1[1], r2[1])
  x2 = min(r1[0] + r1[2], r2[0] + r2[2])
  y2 = max(r1[1] - r1[3], r2[1] - r2[3])
  width = max(x2 - x1, 0.0)
  higth = max(y1 - y2, 0.0)
  return width * higth
#======================================
def union(r1, r2):
  return (r1[2] * r1[3]) + (r2[2] * r2[3]) - intersection(r1, r2)
#======================================
def iou(r1, r2):
  return (intersection(r1, r2) / union(r1, r2))
#======================================

00062: HW01
bytecount: {'code': 400, 'const': 472, 'code+const': 872}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    a=[r[0]+r[2]/2,r[1]-r[3]/2]
    return a
#print(center(r2))
#======================================
def distance(r1, r2):
    ab=center(r1)
    ac=center(r2)
    dista=(((ab[0]-ac[0])**2)+((ab[1]-ac[1])**2))**(1/2)    
    return dista
#print(round(distance(r1,r2),2))
#======================================
def intersection(r1, r2):
    a=max(r1[1]-r1[3],r2[1]-r2[3])
    b=min(r1[1],r2[1])
    c=(b-a)
    x=max(c,0)
    d=min(r1[0]+r1[2],r2[0]+r2[2])
    e=max(r1[0],r2[0])
    f=(d-e)
    y=max(f,0)
    g=x*y
    return g
#print (intersection(r4,r5))
#======================================
def union(r1, r2):
    i=intersection(r1, r2)
    x=(r1[2]*r1[3])+(r2[2]*r2[3])-i
    return x
#print (union(r4, r5))
#======================================
def iou(r1, r2):
    p=intersection(r1, r2)
    u=union(r1, r2)
    t=p/u
    return t
#print (round(iou(r4, r5),2))
#======================================

00063: HW01
bytecount: {'code': 400, 'const': 472, 'code+const': 872}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
    c1 = center(r1)
    c2 = center(r2)
    return (((c2[0]-c1[0])**2)+((c2[1]-c1[1])**2))**(1/2)
#======================================
def intersection(r1, r2):
    r1 = [r1[0],r1[1]-r1[3],r1[0]+r1[2],r1[1]] #[xmin,ymin,xmax,ymax]
    r2 = [r2[0],r2[1]-r2[3],r2[0]+r2[2],r2[1]]
    a = max(0,min(r1[2],r2[2])-max(r1[0],r2[0]))
    b = max(0,min(r1[3],r2[3])-max(r1[1],r2[1]))
    return a*b
#======================================
def union(r1, r2):
    return (r1[2]*r1[3]+r2[2]*r2[3]) - intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00064: HW01
bytecount: {'code': 402, 'const': 472, 'code+const': 874}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    ans = list()
    ans.append(r[0] + r[2] / 2)
    ans.append(r[1] - r[3] / 2)
    return ans
#======================================
def distance(r1, r2):
    pointr1 = center(r1)
    pointr2 = center(r2)
    distance = (pointr1[0] - pointr2[0])**2 + (pointr1[1] - pointr2[1])**2
    return distance**0.5
#======================================
def intersection(r1, r2):
    r1_bottom_right = [r1[0]+r1[2],r1[1]-r1[3]]
    r2_bottom_right = [r2[0]+r2[2],r2[1]-r2[3]]
    #  ที่ max เทียบกะ 0 เพราะว่าถ้าค่าที่ได้น้อยกว่า 0  จะไม่มีพื้นที่ๆ inter กัน
    width = max(min(r1_bottom_right[0],r2_bottom_right[0])-max(r1[0],r2[0]),0)
    height = max((min(r1[1],r2[1])-max(r1_bottom_right[1],r2_bottom_right[1])),0)
    return width * height
#======================================
def union(r1, r2):
    return r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00065: HW01
bytecount: {'code': 402, 'const': 472, 'code+const': 874}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+r[2]/2, r[1]-r[3]/2]
#======================================
def distance(r1, r2):
#  c1,c2 = center(r1), center(r2)  # IndentationError
    c1,c2 = center(r1), center(r2)
    return ((c1[0]-c2[0])**2+(c1[1]-c2[1])**2)**0.5  
#======================================
def intersection(r1, r2):
#   rec1 = [r1[0],r1[1]-r1[3],r1[0]+r1[2],r1[1]]  # IndentationError
    rec1 = [r1[0],r1[1]-r1[3],r1[0]+r1[2],r1[1]]
    rec2 = [r2[0],r2[1]-r2[3],r2[0]+r2[2],r2[1]]
    x = max(0,min(rec1[2],rec2[2])-max(rec1[0],rec2[0]))
    y = max(0,min(rec1[3],rec2[3])-max(rec1[1],rec2[1]))
    return x*y
#======================================
def union(r1, r2):
    return r1[2]*r1[3] + r2[2]*r2[3] - intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00066: HW01
bytecount: {'code': 404, 'const': 472, 'code+const': 876}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    centerx = (r[0]+(r[2]/2))
    centery = (r[1]-(r[3]/2))
    return([centerx , centery])
#======================================
def distance(r1, r2):
    center1 = center(r1)
    center2 = center(r2)
    xtotal = (center1[0]-center2[0])**2
    ytotal = (center1[1]-center2[1])**2
    return(( xtotal + ytotal)**0.5)
#======================================
def intersection(r1, r2):
    ขอบซ้ายx = max(r1[0] , r2[0])
    ขอบขวาx = min(r1[0]+r1[2] , r2[0]+r2[2])
    ขอบบนy = min(r1[1] , r2[1])
    ขอบล่างy = max(r1[1]-r1[3] , r2[1]-r2[3])
    ความยาว = ขอบขวาx - ขอบซ้ายx
    ความกว้าง = ขอบบนy - ขอบล่างy
    ความยาว = max(0,ความยาว)
    ความกว้าง = max(0,ความกว้าง)
    return(ความยาว*ความกว้าง)   
#======================================
def union(r1, r2):
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    a3 = intersection(r1 , r2)
    return(a1+a2-a3) 
#======================================
def iou(r1, r2):
    inter = intersection(r1 , r2)
    uni = union(r1 , r2)
    return(inter/uni) 
#======================================

00067: HW01
bytecount: {'code': 404, 'const': 472, 'code+const': 876}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    r = [(r[0]+r[0]+r[2])/2,(r[1]+r[1]-r[3])/2]
    return(r)
#======================================
def distance(r1, r2): 
    r1 = center(r1)
    r2 = center(r2)
    d = ((r1[0]-r2[0])**2+(r1[1]-r2[1])**2)**(0.5)
    return(d)
#======================================
def intersection(r1, r2):
    ขอบขวาmin = min(r1[0]+r1[2],r2[0]+r2[2])
    ขอบซ้ายmax = max(r1[0],r2[0])
    x = ขอบขวาmin - ขอบซ้ายmax
    ขอบบนmin = min(r1[1],r2[1])
    ขอบล่างmax = max(r1[1]-r1[3],r2[1]-r2[3])
    y =  ขอบบนmin - ขอบล่างmax
    x = max(0,x)
    y = max(0,y)
    intersec = x*y
    return(intersec)
#======================================
def union(r1, r2):
    u = r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1, r2)
    return(u)
#======================================
def iou(r1, r2):
    i = intersection(r1, r2)/union(r1, r2)
    return(i)
#======================================

00068: HW01
bytecount: {'code': 404, 'const': 472, 'code+const': 876}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + r[2]/2
  y = r[1] - r[3]/2
  return [x, y]
#======================================
def distance(r1, r2):
  c1 = center(r1)
  c2 = center(r2)
  d = (  (c2[0]-c1[0])**2 + (c2[1]-c1[1])**2  )**0.5
  return d
#======================================
def intersection(r1, r2):
  x = r1[2]+r2[2]-( max(r1[0]+r1[2], r2[0]+r2[2])-min(r1[0], r2[0]) )
  y = r1[3]+r2[3]-( max(r1[1], r2[1])-min(r1[1]-r1[3], r2[1]-r2[3]) )
  a = max(x, 0)
  b = max(y, 0)
  return a*b
#======================================
def union(r1, r2):
  a1 = r1[2]*r1[3]
  a2 = r2[2]*r2[3]
  return a1+a2-intersection(r1, r2)
#======================================
def iou(r1, r2):
  return intersection(r1, r2) / union(r1, r2)
#======================================

00069: HW01
bytecount: {'code': 404, 'const': 472, 'code+const': 876}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+(r[2]/2),r[1]-(r[3]/2)]
#======================================
def distance(r1, r2):
  centerR1 = center(r1)
  centerR2 = center(r2)
  xDistance = centerR1[0]-centerR2[0]
  yDistance = centerR1[1]-centerR2[1]
  distance = (xDistance**2+yDistance**2)**(1/2)
  return distance
#======================================
def intersection(r1, r2):
  LeftR1Boundary = r1[0]
  TopR1Boundary =  r1[1]
  RightR1Boundary = r1[0]+r1[2]
  BottomR1Boundary =  r1[1]-r1[3]
  LeftR2Boundary = r2[0]
  TopR2Boundary =  r2[1]
  RightR2Boundary = r2[0]+r2[2]
  BottomR2Boundary =  r2[1]-r2[3]
  leftIntersectBoundary = max(LeftR1Boundary,LeftR2Boundary )
  rightIntersectBoundary  = min(RightR1Boundary,RightR2Boundary)
  topIntersectBoundary = min(TopR1Boundary,TopR2Boundary)
  bottomIntersectBoundary = max(BottomR1Boundary,BottomR2Boundary)
  height = max(topIntersectBoundary - bottomIntersectBoundary,0)
  width = max(rightIntersectBoundary - leftIntersectBoundary,0)
  return height*width
#======================================
def union(r1, r2):
  return (r1[2]*r1[3]+r2[2]*r2[3])-intersection(r1, r2)
#======================================
def iou(r1, r2):
  return intersection(r1,r2)/union(r1,r2)   
#======================================

00070: HW01
bytecount: {'code': 404, 'const': 472, 'code+const': 876}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x =r[0]+(r[2]/2)
    y =r[1]-(r[3]/2)
    c_point =[x,y]
    return c_point
#======================================
def distance(r1, r2):
    x = (center(r1)[0]-center(r2)[0])**2
    y =(center(r1)[1]-center(r2)[1])**2
    distance =(x+y)**(1/2)
    return distance
#======================================
def intersection(r1, r2):
    xl_max = max(r1[0],r2[0])
    len_x_min = min(r1[0]+r1[2]-xl_max,r2[0]+r2[2]-xl_max)
    len_x =max(len_x_min,0)
    yl_max = max(r1[1]-r1[3],r2[1]-r2[3])
    len_y_min = min(r1[1]-yl_max,r2[1]-yl_max)
    len_y =max(len_y_min,0)
    intersecspace = len_x*len_y
    return intersecspace
#======================================
def union(r1, r2):
    union_space =(r1[2]*r1[3])+(r2[2]*r2[3])-intersection(r1,r2)
    return union_space
#======================================
def iou(r1, r2):
    ratio =intersection(r1,r2)/union(r1,r2)
    return ratio
#======================================

00071: HW01
bytecount: {'code': 382, 'const': 496, 'code+const': 878}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] +r[2]/2
    y = r[1] - r[3]/2
    center = [x,y]
    return center
#======================================
def distance(r1, r2):
    r1 = center(r1)
    r2 = center(r2)
    x = (r2[0] - r1[0])**2
    y = (r2[1] - r1[1])**2
    distance = (x + y)**0.5
    return distance
#======================================
def intersection(r1, r2):
    H = abs(min(r1[1],r2[1]) - max(r1[1]-r1[3],r2[1]-r2[3]))
    W = min(r2[0]+r2[2],r1[0]+r1[2]) - max(r1[0],r2[0])
    area_intersection = H*W
    area_intersection = max(0.0,area_intersection)
    return area_intersection
#======================================
def union(r1, r2):
    area_union = r1[2]*r1[3] + r2[2]*r2[3] - intersection(r1,r2)
    return area_union
#======================================
def iou(r1, r2):
    iou = intersection(r1,r2) / union(r1,r2)
    return iou
#======================================

00072: HW01
bytecount: {'code': 384, 'const': 496, 'code+const': 880}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=r[0]+(r[2]/2)
  y=r[1]-(r[3]/2)
  return [x,y]
#======================================
def distance(r1, r2):
  d1=center(r1)
  d2=center(r2)
  d=((d1[0]-d2[0])**2+(d1[1]-d2[1])**2)**(1/2)
  return d
#======================================
def intersection(r1, r2):
    x=min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0])
    x=max(0.0,x)
    y=min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3])
    a=max(0.0,y)
    a=x*y
    return a
#======================================
def union(r1, r2):
    a1=r1[2]*r1[3]
    a2=r2[2]*r2[3]
    a=a1+a2-intersection(r1,r2)
    return a
#======================================
def iou(r1, r2):
    a=intersection(r1,r2)/union(r1,r2)
    return a
#======================================

00073: HW01
bytecount: {'code': 408, 'const': 472, 'code+const': 880}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    w_2 = r[2]/2
    h_2 = r[3]/2
    return [r[0] + w_2, r[1]- h_2]
#======================================
def distance(r1, r2):
    c1 = center(r1)
    c2 = center(r2)
    return ( ((c1[0] - c2[0])**2) + ((c1[1] - c2[1])**2) )**.5
#======================================
def intersection(r1, r2):
    R1 = r1[0] + r1[2]
    L1 = r1[0] 
    R2 = r2[0] + r2[2]
    L2 = r2[0] 
    min_R = min(R1,R2)
    max_L = max(L1,L2)
    dX = max(0,min_R - max_L)
    T1 = r1[1]
    B1 = r1[1] - r1[3]
    T2 = r2[1]
    B2 = r2[1] - r2[3]
    min_T = min(T1,T2)
    max_B = max(B1,B2)
    dY = max(0,min_T - max_B)
    return dX * dY
#======================================
def union(r1, r2):
    a1 = r1[3] * r1[2]
    a2 = r2[3] * r2[2]
    return a1 + a2 - intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1,r2) / union(r1,r2)
#======================================

00074: HW01
bytecount: {'code': 410, 'const': 472, 'code+const': 882}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  a=r[0]+r[2]/2
  b=r[1]-r[3]/2
  x=[a,b]
  return x
#======================================
def distance(r1, r2):
  center1=center(r1)
  center2=center(r2)
  a=abs(center1[0]-center2[0])
  b=abs(center1[1]-center2[1])
  r=(a**2+b**2)**(1/2)
  return r
#======================================
def intersection(r1, r2):
  d1=min(r1[0]+r1[2],r2[0]+r2[2])
  d2=max(r1[0],r2[0])
  d=d1-d2
  d=max(0,d)
  e1=min(r1[1],r2[1])
  e2=max(r1[1]-r1[3],r2[1]-r2[3])
  e=e1-e2
  a=abs(d*e)
  return a
#======================================
def union(r1, r2):
  a=r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1,r2)
  return a
#======================================
def iou(r1, r2):
    a=intersection(r1,r2)
    b=union(r1,r2)
    return a/b
#======================================

00075: HW01
bytecount: {'code': 438, 'const': 444, 'code+const': 882}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    r[0] = float(r[0])
    r[1] = float(r[1])
    r[2] = float(r[2])
    r[3] = float(r[3])
    x = r[2]/2
    y = r[3]/2
    x += r[0]
    y = r[1] - y 
    return [x,y]
def distance(r1, r2):
    dx1,dy1 = center(r1)
    dx2,dy2 = center(r2)
    t = ((dx1-dx2)**2+(dy1-dy2)**2)**0.5
    return (t)
def intersection(r1, r2):
    x = min(r1[0]+r1[2],r2[0]+r2[2])-max(r2[0],r1[0])
    y = abs(max(r1[1]-r1[3],r2[1]-r2[3])-min(r2[1],r1[1]))
    z = x*y
    return (max(0.0,z))
def union(r1, r2):
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    x = a1 + a2 - intersection(r1,r2)
    return x
def iou(r1, r2):
    x = intersection(r1,r2)/union(r1, r2)
    return (x)

00076: HW01
bytecount: {'code': 412, 'const': 472, 'code+const': 884}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]
  y = r[1]
  w = r[2]
  h = r[3]
  center = [x+w/2, y-h/2]
  return(center)
#======================================
def distance(r1, r2):
    distance = ((center(r1)[0]-center(r2)[0])**2+(center(r1)[1]-center(r2)[1])**2)**0.5
    return(distance)
#======================================
def intersection(r1, r2):
    x1 = r1[0]
    y1 = r1[1]
    w1 = r1[2]
    h1 = r1[3]
    x2 = r2[0]
    y2 = r2[1]
    w2 = r2[2]
    h2 = r2[3]
    a = max(0,min(x1+w1,x2+w2)-max(x1,x2))
    b = max(0,min(y1,y2)-max(y1-h1,y2-h2))
    return(a*b)
#======================================
def union(r1, r2):
    w1 = r1[2]
    h1 = r1[3]
    w2 = r2[2]
    h2 = r2[3]
    intersect = intersection(r1,r2)
    area = w1*h1 + w2*h2 - intersect
    return(area)
#======================================
def iou(r1, r2):
    ratio = intersection(r1,r2)/union(r1,r2)
    return(ratio)
#======================================

00077: HW01
bytecount: {'code': 412, 'const': 472, 'code+const': 884}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    cen =[]
    x = cen.append(r[0] + r[2]/2)
    y = cen.append(r[1] - r[3]/2)
    return(cen)
#======================================
def distance(r1, r2):
    cr1 = center(r1)
    cr2 = center(r2)
    dis =((cr2[0]-cr1[0])**2 + (cr2[1]-cr1[1])**2)**(1/2)
    return(dis)
#======================================
def intersection(r1, r2):
    a = min(r1[0] + r1[2], r2[0] +  r2[2])
    b = max(r1[0], r2[0])
    x = max(0, a - b)
    c = max(r1[1] - r1[3], r2[1] - r2[3])
    d = min(r1[1], r2[1])
    y = max(0, d - c)
    intersect = x*y
    return(intersect)
#======================================
def union(r1, r2):
    union = float(r1[2])*float(r1[3]) + float(r2[2])*float(r2[3]) - intersection(r1, r2)
    return(union)
#======================================
def iou(r1, r2):
    iou = intersection(r1,r2) / union(r1,r2)
    return(iou)
#======================================

00078: HW01
bytecount: {'code': 412, 'const': 472, 'code+const': 884}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] + r[2]/2
    y = r[1] - r[3]/2
    return [x,y]
#======================================
def distance(r1, r2):
    c1 = center(r1)
    c2 = center(r2)
    dx = abs(c1[0]-c2[0])
    dy = abs(c1[1]-c2[1])
    return (dx**2 + dy**2)**(0.5)
#======================================
def intersection(r1, r2):
    ax1 = r1[0]
    bx1 = r2[0]
    ay1 = r1[1]
    by1 = r2[1]
    ax2 = ax1 + r1[2]
    bx2 = bx1 + r2[2]
    ay2 = ay1 - r1[3]
    by2 = by1 - r2[3]
    x1 = max(ax1,bx1)
    y1 = min(ay1,by1)
    x2 = min(ax2,bx2)
    y2 = max(ay2,by2)
    dx = x2-x1
    dy = y1-y2
    return max(dx,0)*max(dy,0)
#======================================
def union(r1, r2):
    inter = intersection(r1,r2)
    areaA = r1[2]*r1[3]
    areaB = r2[2]*r2[3]
    return areaA + areaB - inter
#======================================
def iou(r1, r2):
    return intersection(r1, r2) / union(r1, r2)
#======================================

00079: HW01
bytecount: {'code': 386, 'const': 500, 'code+const': 886}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=((4*r[0])+(2*r[2]))/4
  y=((4*r[1])-(2*r[3]))/4
  return [x,y] 
#======================================
def distance(r1, r2):
  centre1=center(r1) #[x1,y1]
  centre2=center(r2) #[x2,y2]
  return ((centre1[0]-centre2[0])**2+(centre1[1]-centre2[1])**2)**0.5    
#======================================
def intersection(r1, r2):    
  width=max(0,min(((r1[0]+r1[2]),(r2[0]+r2[2])))-max(r1[0],r2[0]))
  height=max(0,min(r1[1],r2[1])-max(abs(r2[1]-r2[3]),abs(r1[1]-r1[3])))
  return width*height
#======================================
def union(r1, r2):
  area = (r1[2]*r1[3])+(r2[2]*r2[3])-intersection(r1,r2)
  return area
#======================================
def iou(r1, r2):
  ratio = intersection(r1,r2)/union(r1,r2)
  return ratio
#======================================

00080: HW01
bytecount: {'code': 416, 'const': 472, 'code+const': 888}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
    c1 = center(r1)
    c2 = center(r2)
    return ((c1[0]-c2[0])**2+(c1[1]-c2[1])**2)**(1/2)
#======================================
def intersection(r1, r2):
    cn2r1 = [r1[0]+r1[2],r1[1]-r1[3]]
    cn2r2 = [r2[0]+r2[2],r2[1]-r2[3]]
    x1 = [max(r1[0],r2[0]),min(r1[1],r2[1])]
    x2 = [min(cn2r1[0],cn2r2[0]),max(cn2r1[1],cn2r2[1])]
    inA = max((x2[0]-x1[0]),0)*max((x1[1]-x2[1]),0)
    return inA
#======================================
def union(r1, r2):
    A1 = r1[2]*r1[3]
    A2 = r2[2]*r2[3]
    uA = A1 + A2 - intersection(r1,r2)
    return uA
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================
#r1=[1.0, 4.0, 1.5, 2.0]
#r2=[2.0, 5.0, 2.5, 2.0]
#r3=[4.0, 5.5, 1.5, 3.5]
#r4=[6.0, 4.5, 1.5, 2.0]
#r5=[5.75, 7.0, 2.0, 5.0]
#print(center(r1))
#print(center(r2))
#print(round(distance(r1,r2),2))
#print(round(distance(r3,r4),2))
#print(intersection(r1,r2)) 
#print(intersection(r2,r3))
#print(intersection(r4,r5))
#print(intersection(r1,r5)) # กรณีโบนัส
#print(union(r1,r2))
#print(union(r2,r3))
#print(union(r4,r5))
#print(round(iou(r1,r2),2))
#print(round(iou(r2,r3),2))
#print(round(iou(r4,r5),2))

00081: HW01
bytecount: {'code': 392, 'const': 496, 'code+const': 888}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
      a=r[0] + r[2]/2
      b=r[1] - r[3]/2
      x=[a,b]
      return(x)
#======================================
def distance(r1, r2):
      a=center(r1)[0]-center(r2)[0]
      b=center(r1)[1]-center(r2)[1]
      return((a**2+b**2)**0.5)
#======================================
def intersection(r1, r2):
      a=max(r1[0], r2[0])
      b=min(r1[0]+r1[2], r2[0]+r2[2])
      c=max(r1[1]-r1[3], r2[1]-r2[3])
      d=min(r1[1], r2[1])
      e=b-a
      f=(e+((e)**2)**0.5)/2
      return(f*(d-c))
#======================================
def union(r1, r2):
      a=r1[2]*r1[3]
      b=r2[2]*r2[3]
      return((a+b)-intersection(r1,r2))
#======================================
def iou(r1, r2):
      return(intersection(r1,r2)/union(r1, r2))
#======================================

00082: HW01
bytecount: {'code': 416, 'const': 472, 'code+const': 888}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [(r[0]+r[2]+r[0])/2,((2*r[1]-r[3])/2)]
#======================================
def distance(r1, r2):
  x=center(r1)
  y=center(r2)
  return (((x[0]-y[0])**2)+((x[1]-y[1])**2))**0.5
#======================================
def intersection(r1, r2):
  xleft_side=max(r1[0],r2[0])
  xright_side=min(r1[0]+r1[2],r2[0]+r2[2])
  y_up=min(r1[1],r2[1])
  y_down=max(r1[1]-r1[3],r2[1]-r2[3])
  yfinal=y_up-y_down
  yfinal=max(y_up-y_down,0)
  xfinal=xright_side-xleft_side
  xfinal=max(xright_side-xleft_side,0)
  area=(xfinal)*(yfinal)
  out=[area,0]
  return float(max(out))
#======================================
def union(r1, r2):
  areau=(r1[2]*r1[3])+(r2[2]*r2[3])-(intersection(r1,r2))
  return float(areau)
#======================================
def iou(r1, r2):
  return intersection(r1,r2)/union(r1,r2)
#======================================

00083: HW01
bytecount: {'code': 416, 'const': 472, 'code+const': 888}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0]+(r[2]/2)
    y = r[1]-(r[3]/2)
    return [x,y]
#======================================
def distance(r1, r2):
    x = max(center(r1)[0],center(r2)[0])-min(center(r1)[0],center(r2)[0])
    y = max(center(r1)[1],center(r2)[1])-min(center(r1)[1],center(r2)[1])
    return ((x**2)+(y**2))**(1/2)
#======================================
def intersection(r1, r2):
    x = max(0,min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0]))
    y = max(0,min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3]))
    return x*y
#======================================
def union(r1, r2):
    return (r1[2]*r1[3]+r2[2]*r2[3])-intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00084: HW01
bytecount: {'code': 416, 'const': 472, 'code+const': 888}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    a=r[0]+r[2]/2
    b=r[1]-r[3]/2
    return([a,b])
#======================================
def distance(r1, r2):
    c1=center(r1)
    c2=center(r2)
    dx=(c1[0]-c2[0])**2
    dy=(c1[1]-c2[1])**2
    d=(dx+dy)**(1/2)
    return d
#======================================
def intersection(r1, r2):
    x1=r1[0]
    x2=r2[0]
    y1=r1[1]
    y2=r2[1]
    w1=r1[2]
    w2=r2[2]
    h1=r1[3]
    h2=r2[3]
    h_intersect= min(y1,y2) - max(y1-h1,y2-h2)
    w_intersect= min(x2+w2,x1+w1) - max(x2,x1)
    area_intersect= max(h_intersect,0) * max(w_intersect,0)
    return area_intersect
#======================================
def union(r1, r2):
    w1=r1[2]
    w2=r2[2]
    h1=r1[3]
    h2=r2[3]
    area1= h1 * w1
    area2= h2 * w2
    area_union= area1 + area2 - intersection(r1,r2)
    return area_union
#======================================
def iou(r1, r2):
    ratio = intersection(r1,r2) / union(r1,r2)
    return ratio
#======================================

00085: HW01
bytecount: {'code': 416, 'const': 472, 'code+const': 888}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=r[0]
  y=r[1]
  w=r[2]
  h=r[3]
  a=x+(w/2)
  b=y-(h/2)
  return [a,b]
#======================================
def distance(r1, r2):
  c1=center(r1)
  c2=center(r2)
  d=((c1[0]-c2[0])**2 + (c1[1]-c2[1])**2)**(1/2)
  return d
#======================================
def intersection(r1, r2):
  a=r1[0] + r1[2]
  b=r2[0] + r2[2]
  c=r2[0]
  d=r1[0]
  dx=max(0,min(a,b) - max(c,d))
  e=r1[1]
  f=r2[1]
  g=r2[1] - r2[3]
  i=r1[1] - r1[3]
  dy=max(min(e,f) - max (g,i),0)
  return dx*dy
#======================================
def union(r1, r2):
  a1=r1[2] * r1[3]
  a2=r2[2] * r2[3]
  area=(a1 + a2) - intersection(r1, r2)
  return area
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1, r2)
#======================================

00086: HW01
bytecount: {'code': 420, 'const': 472, 'code+const': 892}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none


00087: HW01
bytecount: {'code': 420, 'const': 472, 'code+const': 892}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + r[2]/2
  y = r[1] - r[3]/2
  return [x, y]
#======================================
def distance(r1, r2):
  ct1 = center(r1)
  ct2 = center(r2)
  d = (((ct1[0]-ct2[0])**2)+((ct1[1]-ct2[1])**2))**(0.5)
  return d
#======================================
def intersection(r1, r2):
  l = [r1[0],r2[0]]
  r = [(r1[0]+r1[2]),(r2[0]+r2[2])]
  up = [r1[1],r2[1]]
  lo = [(r1[1]-r1[3]),(r2[1]-r2[3])]
  x = min(r)-max(l)
  x = max(x,0)
  y = min(up)-max(lo)
  y = max(y,0)
  Area = x*y
  return Area
#======================================
def union(r1, r2):
  In = intersection(r1, r2)
  A1 = (r1[2]*r1[3])
  A2 = (r2[2]*r2[3])
  U = A1+A2-In
  return U
#======================================
def iou(r1, r2):
  In = intersection(r1, r2)
  U = union(r1, r2)
  at = In/U
  return at
#======================================

00088: HW01
bytecount: {'code': 420, 'const': 472, 'code+const': 892}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  p2 = [(r[0]+r[2]),(r[1]-r[3])]
  pc = [(r[0]+p2[0])/2 , (r[1]+p2[1])/2]
  return pc
#======================================
def distance(r1, r2):
  pc1 = center(r1)
  pc2 = center(r2)
  d = (((pc1[0] - pc2[0])**2) + ((pc1[1] - pc2[1])**2))**0.5
  return d
#======================================
def intersection(r1, r2):
  x1 = min(r1[0]+r1[2], r2[0]+r2[2])
  y1 = min(r1[1], r2[1])
  x2 = max(r1[0], r2[0])
  y2 = max(r1[1]-r1[3], r2[1]-r2[3])
  s1 = max(0, x1-x2)
  s2 = max(0, y1-y2)
  inter = s1 * s2
  return inter
#======================================
def union(r1, r2):
  inter = intersection(r1, r2)
  uni = (r1[2] * r1[3]) + (r2[2] * r2[3]) - inter
  return uni
#======================================
def iou(r1, r2):
  inter = intersection(r1, r2)
  uni = union(r1, r2)
  return inter/uni
#======================================

00089: HW01
bytecount: {'code': 420, 'const': 472, 'code+const': 892}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    Xc = r[0] + r[2]/2
    Yc = r[1] - r[3]/2
    return [Xc,Yc]
#======================================
def distance(r1, r2):
    c1 = center(r1)
    c2 = center(r2)
    dx = c2[0]-c1[0]
    dy = c2[1]-c1[1]
    d = (dx**2 + dy**2)**(1/2)
    return(d)
#======================================
def intersection(r1, r2):
    x1 = min(r1[0]+r1[2],r2[0]+r2[2])
    x2 = max(r1[0],r2[0])
    x3 = max(x1,x2)
    dx = x3-x2
    y1 = min(r1[1],r2[1])
    y2 = max(r1[1]-r1[3],r2[1]-r2[3])
    y3 = max(y1,y2)
    dy = y3-y2
    ints = dx*dy
    return(ints)
#======================================
def union(r1, r2):
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    a3 = intersection(r1, r2)
    uni = a1 + a2 - a3
    return(uni)
#======================================
def iou(r1, r2):
    a1 = intersection(r1, r2)
    a2 = union(r1, r2)
    iou = a1/a2
    return(iou)
#======================================

00090: HW01
bytecount: {'code': 396, 'const': 496, 'code+const': 892}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]+0.5*r[2]
  y = r[1]-0.5*r[3]
  return [x,y]
#======================================
def distance(r1, r2):
  a = center(r1)
  b = center(r2)
  return (((a[0]-b[0])**2)+((a[1]-b[1])**2))**0.5
#======================================
def intersection(r1, r2):
  sqm_x1 = max(r1[0],r2[0])
  sqm_x2 = min(r1[0]+r1[2],r2[0]+r2[2])
  sqm_w  = max(0,sqm_x2-sqm_x1)
  sqm_y1 = max(r1[1]-r1[3],r2[1]-r2[3])
  sqm_y2 = min(r1[1],r2[1])
  sqm_l = max(0,sqm_y2-sqm_y1)
  inter_ = sqm_w*sqm_l
  return inter_
#======================================
def union(r1, r2):
  sq_1 = r1[2]*r1[3]
  sq_2 = r2[2]*r2[3]
  all_area = sq_1 + sq_2
  union_ = sq_1 + sq_2 - intersection(r1,r2)
  return union_
#======================================
def iou(r1, r2):
    iou_ = intersection(r1,r2)/union(r1,r2)
    return iou_
#======================================

00091: HW01
bytecount: {'code': 420, 'const': 472, 'code+const': 892}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    c = []
    x = r[0] + r[2]/2
    y = r[1] - r[3]/2
    c.append(x)
    c.append(y)
    return c
#======================================
def distance(r1, r2):
    x = (center(r1)[0]-center(r2)[0])
    y = (center(r1)[1]-center(r2)[1])
    d = (x**2 + y**2)**0.5
    return d    
#======================================
def intersection(r1, r2):
    x1 = min(r1[0] + r1[2], r2[0] + r2[2])
    x2 = max(r1[0], r2[0])
    dx = x1 - x2
    sx = (dx + abs(dx))/2
    y1 = min(r1[1], r2[1])
    y2 = max(r1[1] - r1[3], r2[1] - r2[3])
    dy = y1-y2
    return sx*dy    
#======================================
def union(r1, r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    total = area1 + area2 - intersection(r1, r2)
    return total    
#======================================
def iou(r1, r2):
    x = intersection(r1, r2)/union(r1, r2)
    return x    
#======================================

00092: HW01
bytecount: {'code': 424, 'const': 472, 'code+const': 896}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1,r2):
    c1 = center(r1)
    c2 = center(r2)
    return ((c1[0]-c2[0])**2+(c1[1]-c2[1])**2)**(1/2)
#======================================
def intersection(r1,r2):
    x1 = abs(r1[0]-r2[0])
    x2 = abs(r1[2]+r1[0]-(r2[0]+r2[2]))
    x_inter = max(0,(abs(r1[2]+r2[2])-x1-x2)/2)
    y1 = abs(r1[1]-r2[1])
    y2 = abs(r1[1]-r1[3]-(r2[1]-r2[3]))
    y_inter = max(0,(abs(r1[3]+r2[3])-y1-y2)/2)
    return x_inter*y_inter
#======================================
def union(r1,r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    return area1+area2-intersection(r1,r2)
#======================================
def iou(r1,r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00093: HW01
bytecount: {'code': 428, 'const': 472, 'code+const': 900}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]
  y = r[1]
  w = r[2]
  h = r[3]
  return [x+w/2, y-h/2]
#======================================
def distance(r1, r2):
  c1 = center(r1)
  c2 = center(r2)
  x1 = c1[0]
  y1 = c1[1]
  x2 = c2[0]
  y2 = c2[1]
  d = ((x1-x2)**2 + (y1-y2)**2)**0.5
  return d
#======================================
def intersection(r1, r2):
  x1 = r1[0]
  y1 = r1[1]
  w1 = r1[2]
  h1 = r1[3]
  x2 = r2[0]
  y2 = r2[1]
  w2 = r2[2]
  h2 = r2[3]
  dw = min(x1+w1,x2+w2) - max(x1,x2)
  dh = min(y1,y2) - max(y1-h1,y2-h2)
  area_i = max(dw, 0) * max(dh, 0)
  return area_i
#======================================
def union(r1, r2):
  area_1 = r1[2]*r1[3]
  area_2 = r2[2]*r2[3]
  area_i = intersection(r1, r2)
  area_u = area_1 + area_2 - area_i
  return area_u
#======================================
def iou(r1, r2):
  area_i = intersection(r1, r2)
  area_u = union(r1, r2)
  ratio = area_i/area_u
  return ratio
#======================================

00094: HW01
bytecount: {'code': 430, 'const': 472, 'code+const': 902}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0]+r[2]/2
    y = r[1]-r[3]/2
    xy = [x,y]
    return xy
#======================================
def distance(r1, r2):
    c1,c2 = center(r1),center(r2)
    x = ((c1[0]-c2[0])**2 + (c1[1]-c2[1])**2)**(1/2)
    return x
#======================================
def intersection(r1, r2):
    x1 = [r1[0], r2[0]]
    x2 = [r1[0]+r1[2], r2[0]+r2[2]]
    y1 = [r1[1], r2[1]]
    y2 = [r1[1]-r1[3], r2[1]-r2[3]]
    dx = min(x2) - max(x1)
    dy = min(y1) - max(y2)
    a = ((abs(dx)+dx)/2)*((abs(dy)+dy)/2)
    return a
#======================================
def union(r1, r2):
    a1 = r1[2] * r1[3]
    a2 = r2[2] * r2[3]
    i = intersection(r1, r2)
    u = a1+a2-i
    return u
#======================================
def iou(r1, r2):
    i = intersection(r1, r2)
    u = union(r1, r2)
    iou = i/u
    return iou
#======================================

00095: HW01
bytecount: {'code': 432, 'const': 472, 'code+const': 904}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x2 = r[0] + ( r[2] / 2 )
  y2 = r[1] - ( r[3] / 2 )
  return [ x2 , y2 ]
#======================================
def distance(r1, r2):
  c1 = center(r1)
  c2 = center(r2)
  xn = abs( c1[0] - c2[0] )
  yn = abs( c1[1] - c2[1] )
  rn = ((xn**2) + (yn**2))**0.5
  return rn
#======================================
def intersection(r1, r2):
  x1n = r1[0] + r1[2]
  y1n = r1[1] - r1[3]
  x2n = r2[0] + r2[2]
  y2n = r2[1] - r2[3]
  xl = max( r1[0] , r2[0] )
  xr = min( x1n , x2n )
  wn = max( 0 , xr - xl )
  yu = min( r1[1] , r2[1] )
  yd = max( y1n , y2n )
  hn = max( 0 , yu - yd )
  return wn * hn
#======================================
def union(r1, r2):
    a = intersection(r1,r2)
    a1 = r1[2] * r1[3]
    a2 = r2[2] * r2[3]
    aa = a1 + a2 - a
    return aa
#======================================
def iou(r1, r2):
    rn1 = intersection(r1,r2)
    rn2 = union(r1, r2)
    rn = rn1 / rn2
    return rn
#======================================

00096: HW01
bytecount: {'code': 434, 'const': 472, 'code+const': 906}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
     x = r[0]+r[2]/2 ; y = r[1]-r[3]/2
     return [x,y]
def distance(r1, r2):
     x1 = center(r1)[0] ; x2 = center(r2)[0] ;x = x2-x1
     y1 = center(r1)[1] ; y2 = center(r2)[1] ;y = y2-y1
     distance = (x**2+y**2)**(1/2)
     return distance
def intersection(r1, r2):
    y1 = r1[1] ; y2 = r2[1]
    x1 = r1[0] ; x2 =r2[0]
    h1 = r1[-1]; h2 = r2[-1]
    w1 = r1[2] ; w2 = r2[2]
    x_left  = max(x1,x2) 
    x_right = min(x1+w1,x2+w2) ; w = max(x_right-x_left,0)
    h_on    = min(y1,y2)
    h_under = max(y1-h1,y2-h2) ; h = max(h_on - h_under,0)
    return max(h*w,0)
def union(r1, r2):
    sq1 = abs(r1[2]*r1[3])
    sq2 = abs(r2[2]*r2[3])
    return (sq1+sq2) - intersection(r1,r2)
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)

00097: HW01
bytecount: {'code': 436, 'const': 472, 'code+const': 908}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] ; y = r[1] ; w = r[2] ; h = r[3]
    a = x + w/2
    b = y - h/2
    ans = [a,b]
    return ans
#======================================
def distance(r1, r2):
    a = center(r1)
    b = center(r2)
    dist = (((a[0]-b[0])**2)+((a[1]-b[1])**2))**0.5
    return dist
#======================================
def intersection(r1, r2):
    left1 = r1[0] ; top1 = r1[1] ; right1= r1[0]+r1[2] ; bottom1 = r1[1]-r1[3]
    left2 = r2[0] ; top2 = r2[1]; right2= r2[0]+r2[2] ; bottom2 = r2[1]-r2[3]
    xlap = max(0, min(right1,right2)-max(left1,left2))
    ylap = max(0, min(top1,top2)-max(bottom1,bottom2))
    return xlap*ylap
#======================================
def union(r1, r2):
    w1 = r1[2] ; h1 = r1[3]
    w2 = r2[2] ; h2 = r2[3]
    area1 = w1*h1
    area2 = w2*h2
    ans = area1+area2-intersection(r1,r2)
    return ans
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00098: HW01
bytecount: {'code': 436, 'const': 472, 'code+const': 908}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    height = (r[3])/2
    a = (r[1])-height
    width  = (r[2])/2
    b = (r[0])+width
    z = [b,a]
    return z
def distance(r1,r2):
    a = center(r1)
    b = center(r2)
    differ_x = a[0]-b[0]
    differ_y = a[1]-b[1]
    distance = (((differ_x)**2)+((differ_y)**2))**0.5
    return distance
def intersection(r1,r2):
    wide_x1 = r1[0]+r1[2]
    wide_x2 = r2[0]+r2[2]
    high_y1 = r1[1]-r1[3]
    high_y2 = r2[1]-r2[3]
    differ_length = max(max(min(wide_x1,wide_x2),0)-max(r1[0],r2[0]),0)
    differ_height = max(min(r1[1],r2[1]) -max(max(high_y1,high_y2),0),0)
    intersection_area = differ_height*differ_length
    return intersection_area
def union(r1,r2):
    intersection_area = intersection(r1,r2)
    area_r1 = r1[2]*r1[3]
    area_r2 = r2[2]*r2[3]
    total_area = (area_r1+area_r2)-intersection_area
    return total_area
def iou(r1,r2):
    intersection_area = intersection(r1,r2)
    union_area = union(r1,r2)
    ratio_area = intersection_area/union_area
    return ratio_area
#======================================

00099: HW01
bytecount: {'code': 408, 'const': 500, 'code+const': 908}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  center=[r[0]+r[2]/2, r[1]-r[3]/2]
  return center
def distance(r1, r2):
  distance=(((r1[0]+r1[2]/2-r2[0]-r2[2]/2)**2)+((r1[1]-r1[3]/2-r2[1]+r2[3]/2)**2))**0.5
  return distance
def intersection(r1, r2):
  a=min(r1[1], r2[1])
  b=max(r1[1]-r1[3], r2[1]-r2[3])
  c=max(r1[0], r2[0])
  d=min(r1[0]+r1[2], r2[0]+r2[2])
  e=max(a-b, 0)
  f=max(d-c, 0)
  intersection=e*f
  return intersection
def union(r1, r2):
  union=r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1, r2)
  return union
def iou(r1, r2):
  iou=intersection(r1, r2)/union(r1, r2)
  return iou

00100: HW01
bytecount: {'code': 416, 'const': 496, 'code+const': 912}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    a=(((r[2])/2)+(r[0]))
    b=(((r[1])-(r[3])/2))
    return[a,b]
#======================================
def distance(r1, r2):
    x=center(r1)
    y=center(r2)
    c=(((((y[0])-(x[0]))**2)+(((y[1])-(x[1]))**2))**(1/2))
    return(c)
#======================================
def intersection(r1, r2):
    mx=min(((r1[0])+(r1[2])),((r2[0])+(r2[2])))
    my=min((r1[1]),(r2[1]))
    xx=max((r1[0]),(r2[0]))
    xy=max(((r1[1])-(r1[3])),((r2[1])-(r2[3])))
    nx=(mx)-(xx)
    ny=(my)-(xy)
    sx=max(0.0,nx)
    sy=max(0.0,ny)
    ins=(sx*sy)
    return(ins) 
#======================================
def union(r1, r2):
    w1=((r1[2]))*((r1[3]))
    w2=((r2[2]))*((r2[3]))
    w=(w1+w2)
    ins=intersection(r1,r2)
    wa=w-ins
    return(wa)
#======================================
def iou(r1, r2):
    ins=intersection(r1,r2)
    uni=union(r1,r2)
    i=(ins/uni)
    return(i)
#=====================================

00101: HW01
bytecount: {'code': 444, 'const': 472, 'code+const': 916}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    c=[(r[0]+(r[0]+r[2]))/2,((r[1]-r[3])+r[1])/2]
    return c
#======================================
def distance(r1, r2):
    s1=center(r1)
    s2=center(r2)
    dc=(((s1[0]-s2[0])**2)+((s1[1]-s2[1])**2))**0.5
    return dc
#======================================
def intersection(r1, r2):
    r6=[r1[0],r1[1],r1[2]+r1[0],r1[1]-r1[3]]
    r7=[r2[0],r2[1],r2[2]+r2[0],r2[1]-r2[3]]
    x=max(0,min(r6[2],r7[2])-max(r6[0],r7[0]))
    y=max(0,min(r6[1],r7[1])-max(r6[3],r7[3]))
    area=x*y
    return area
#======================================
def union(r1, r2):
    a=r1[2]*r1[3]
    b=r2[2]*r2[3]
    c=(a+b)-intersection(r1,r2)
    return c
#======================================
def iou(r1, r2):
    a=intersection(r1,r2)/union(r1,r2)
    return a
#======================================

00102: HW01
bytecount: {'code': 448, 'const': 472, 'code+const': 920}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]+(r[2]/2)
  y = r[1]-(r[3]/2)
  center = [x,y]
  return center
#======================================
def distance(r1, r2):
  r1 = center(r1)      
  r2 = center(r2)
  distance = (((r1[0]-r2[0])**2)+((r1[1]-r2[1])**2))**(1/2)
  return distance
#======================================
def intersection(r1, r2):
  list_x = [r1[0],r2[0],r1[0]+r1[2],r2[0]+r2[2]]    
  list_y = [r1[1],r2[1],r1[1]-r1[3],r2[1]-r2[3]]
  list_x.sort()
  list_y.sort()
  x = list_x[2]-max(r1[0],r2[0])
  y = list_y[2]-max(r1[1]-r1[3],r2[1]-r2[3])
  intersection = x*y
  return intersection
#======================================
def union(r1, r2):
  a1 = r1[2]*r1[3]    
  a2 = r2[2]*r2[3]  
  subinter = intersection(r1, r2)
  union = a1+a2-subinter
  return union
#======================================
def iou(r1, r2):
  a = intersection(r1, r2)  
  b = union(r1, r2)
  iou = a/b
  return iou
#======================================

00103: HW01
bytecount: {'code': 452, 'const': 472, 'code+const': 924}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  rec = r
  cent = [(r[0]+(r[2]/2))] + [(r[1]-(r[3]/2))]
  return cent
# ======================================
def distance(r1, r2):
    cent1 = center(r1)
    cent2 = center(r2)
    dist = (((cent2[1]-cent1[1])**2)+((cent2[0]-cent1[0])**2))**(1/2)
    return dist
  # ======================================
def intersection(r1, r2):
    rec1 = r1
    rec2 = r2
    min1 = min(rec1[0]+rec1[2],rec2[0]+rec2[2])
    min2 = min(rec1[1],rec2[1])
    A = [min1] + [min2]
    max1 = max(rec1[0], rec2[0])
    max2 = max(rec1[1]-rec1[3], rec2[1]- rec2[3])
    B = [max1] + [max2]
    sec_area = max(0,A[0]-B[0]) * max(0,A[1]-B[1])
    return sec_area
  # ======================================
def union(r1, r2):
    rec1 = r1
    rec2 = r2 
    a = rec1[2]*rec1[3]
    a2 = rec2[2]*rec2[3]
    uni = a + a2 - intersection(r1,r2)
    return uni
  # ======================================
def iou(r1, r2):
    rec1 = r1
    rec2 = r2
    iouu = intersection(rec1,rec2)/union(rec1,rec2)
    return iouu
  # ======================================

00104: HW01
bytecount: {'code': 504, 'const': 420, 'code+const': 924}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r) :
    x = float(r[0])
    y = float(r[1])
    w = float(r[2])
    h = float(r[3])
    x += w/2
    y -= h/2
    return [x,y]
#======================================
def distance(r1, r2) :
    [x1,y1] = center(r1)
    [x2,y2] = center(r2)
    d = ((x1 - x2)**2 + (y1 - y2)**2)**(1/2)
    return d
#======================================
def intersection(r1, r2) :
    x1 = float(r1[0]) ; y1 = float(r1[1]) ; w1 = float(r1[2]) ; h1 = float(r1[3])
    x2 = float(r2[0]) ; y2 = float(r2[1]) ; w2 = float(r2[2]) ; h2 = float(r2[3])
    xL = max(x1,x2)
    xR = min(x1+w1,x2+w2)
    yU = min(y1,y2)
    yD = max(y1-h1,y2-h2)
    xL = min(xL,xR)
    yD = min(yU,yD)
    Area_intersection = (xR-xL)*(yU-yD)
    return Area_intersection
#======================================
def union(r1, r2) :
    w1 = float(r1[2]) ; h1 = float(r1[3])
    w2 = float(r2[2]) ; h2 = float(r2[3])
    A1 = w1*h1
    A2 = w2*h2
    Area_union = A1 + A2 - intersection(r1, r2)
    return Area_union
#======================================
def iou(r1, r2) :
    Area_intersection = intersection(r1, r2)
    Area_union = union(r1, r2)
    iou = Area_intersection / Area_union
    return iou
#======================================

00105: HW01
bytecount: {'code': 508, 'const': 420, 'code+const': 928}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
   x = (2*r[0] + r[2])/2
   y = (2*r[1] - r[3])/2
   return [x,y]
#======================================
def distance(r1, r2):
  x1,y1 = center(r1)
  x2,y2 = center(r2)
  d = ((x2-x1)**2 + (y2-y1)**2)**0.5 
  return d
#======================================
def intersection(r1, r2):
  a = abs(r1[0]-r2[0])
  b = abs(r1[0]+r1[2]-r2[0]-r2[2])
  x = abs(min(r1[0],r2[0])-max(r1[0]+r1[2],r2[0]+r2[2]))
  w = max(x-(a+b),0)
  c = abs(r2[1]-r1[1])
  d = abs(r2[1]-r2[3]-r1[1]+r1[3])
  y = abs(max(r1[1],r2[1])-min(r1[1]-r1[3],r2[1]-r2[3]))
  h = max(y-(c+d),0)
  return w*h
#======================================
def union(r1, r2):
  q = r1[2] * r1[3] + r2[2] * r2[3] - intersection(r1, r2)
  return q
#======================================
def iou(r1, r2):
  p = intersection(r1, r2)/union(r1, r2)
  return p
#======================================

00106: HW01
bytecount: {'code': 456, 'const': 472, 'code+const': 928}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=r[0]
  y=r[1]
  w=r[2]
  h=r[3]
  a=r[0]+(r[2]/2)
  b=r[1]-(r[3]/2)
  return [a,b]
#======================================
def distance(r1, r2):
  xy1=center(r1)
  xy2=center(r2)
  dis = ( ((xy1[0]-xy2[0])**2)+((xy1[1]-xy2[1])**2) )**(1/2)
  return dis
#======================================
def intersection(r1, r2):
  x1=r1[0]
  y1=r1[1]
  w1=r1[2]
  h1=r1[3]
  x2=r2[0]
  y2=r2[1]
  w2=r2[2]
  h2=r2[3]
  xr1=x1+w1
  yr1=y1-h1
  xr2=x2+w2
  yr2=y2-h2
  a=max(x1,x2)
  b=min(xr1,xr2)
  c=min(y1,y2)
  d=max(yr1,yr2)
  e=b-a
  e=max(0,e)
  f=c-d
  f=max(0,f)
  return e*f
#======================================
def union(r1, r2):
  area = (r1[2]*r1[3])+(r2[2]*r2[3])-(intersection(r1, r2))
  return area
#======================================
def iou(r1, r2):
  a=intersection(r1, r2)
  b=union(r1, r2)
  return a/b
#======================================

00107: HW01
bytecount: {'code': 460, 'const': 472, 'code+const': 932}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = float(r[0])
    y = float(r[1])
    w = float(r[2])
    h = float(r[3])
    centerx = x + (w / 2)
    centery = y - (h / 2)
    center = [centerx, centery]
    return center
#======================================
def distance(r1, r2):
    x1 = float(center(r1)[0])
    x2 = float(center(r2)[0])
    y1 = float(center(r1)[1])
    y2 = float(center(r2)[1])
    dx = ((x1)-(x2))**2
    dy = ((y1)-(y2))**2
    distance = (dx + dy)**(1/2)
    return distance
#======================================
def intersection(r1, r2):
    w = min(r1[0] + r1[2], r2[0] + r2[2]) - max(r1[0], r2[0])
    w = max(w, 0)
    h = min(r1[1], r2[1]) - max(r1[1] - r1[3], r2[1] - r2[3])
    h = max(h, 0)
    intersection = w*h
    return intersection 
#======================================
def union(r1, r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    union = (area1 + area2) - intersection(r1, r2)
    return union    
#======================================
def iou(r1, r2):
    iou = intersection(r1, r2)/ union(r1, r2)
    return iou

00108: HW01
bytecount: {'code': 464, 'const': 472, 'code+const': 936}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = float(r[0])+float(r[2])/2
    y = float(r[1])-float(r[3])/2
    return [x,y]
#======================================
def distance(r1, r2):
    x=(center(r1)[0]-center(r2)[0])**2
    y=(center(r1)[1]-center(r2)[1])**2
    z = (x+y)**0.5
    return z
#======================================
def intersection(r1, r2):
    xma = min(float(r1[0])+float(r1[2]),float(r2[0])+float(r2[2]))
    xmi = max(float(r1[0]),float(r2[0]))
    yma = min(float(r1[1]),float(r2[1]))
    ymi = max(float(r1[1])-float(r1[3]),float(r2[1])-float(r2[3]))
    area = max(xma-xmi,0)*max(yma-ymi,0)
    return area
#======================================
def union(r1, r2):
    area = (float(r1[2])*float(r1[3]))+(float(r2[2])*float(r2[3]))-intersection(r1, r2)
    return area
#======================================
def iou(r1, r2):
    ratio = intersection(r1, r2)/union(r1, r2)
    return ratio
#======================================

00109: HW01
bytecount: {'code': 464, 'const': 472, 'code+const': 936}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
     float(r[0]) #คู่อันดับ x
     float(r[1]) #คู่อันดับ y
     float(r[2]) #ความกว้าง
     float(r[3]) #ความยาว
     c1 = (r[2]/2+r[0])
     c2 = (r[1]-r[3]/2)
     c = [c1,c2]
     return(c)
#======================================
def distance(r1, r2):
     a = center(r1)
     b = center(r2)
     c = a[0]-b[0]
     d = a[1]-b[1]
     e = ((c**2)+(d**2))**0.5
     return(e)
#======================================
def intersection(r1, r2):
    m1 = max(r1[0],r2[0])
    m2 = min(r1[0]+r1[2],r2[0]+r2[2])
    m3 = max(r1[1]-r1[3],r2[1]-r2[3])
    m4 = min(r1[1],r2[1])
    a = max(0,m2-m1)
    b = max(0,m4-m3)
    c = (b)*(a)
    return(c)
#======================================
def union(r1, r2):
    a = intersection(r1,r2)
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    u = a1+a2-a
    return(u)
#======================================
def iou(r1, r2):
    p = intersection(r1,r2)
    u = union(r1,r2)
    o = (p/u)
    return(o)
#======================================

00110: HW01
bytecount: {'code': 516, 'const': 420, 'code+const': 936}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x1 = float(r[0]) + float(r[2])/2
    y1 = float(r[1]) - float(r[3])/2
    return [x1,y1]
#======================================
def distance(r1, r2):
    x1,y1 = center(r1)
    x2,y2 = center(r2)
    dis_tance = (x2-x1)**2 + (y2-y1)**2
    return (dis_tance)**(1/2)
#======================================
def intersection(r1, r2):
    x1_fic = [r1[0],r1[0]+r1[2]]
    y1_fic = [r1[1],r1[1]-r1[3]]
    x2_fic = [r2[0],r2[0]+r2[2]]
    y2_fic = [r2[1],r2[1]-r2[3]]
    x_total = sorted(x1_fic+x2_fic)
    y_total = sorted(y1_fic+y2_fic)
    x_roof = min(max(x1_fic),max(x2_fic))
    y_roof = min(max(y1_fic),max(y2_fic))
    x_low = max(min(x1_fic),min(x2_fic))
    y_low = max(min(y1_fic),min(y2_fic))
    x_useful = abs(x_roof - x_total[0]) - abs(x_low - x_total[0])
    y_useful = abs(y_roof - y_total[0]) - abs(y_low - y_total[0])
    return max(x_useful,0)*max(y_useful,0)    
#======================================
def union(r1, r2):
    return r1[2]*r1[3] + r2[2]*r2[3] - intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00111: HW01
bytecount: {'code': 444, 'const': 496, 'code+const': 940}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center = [(r[0])+((r[2])/2),(r[1])-((r[3])/2)] 
    return center
#======================================
def distance(r1, r2):
    distance = ((center(r1)[0]-center(r2)[0])**2 + (center(r1)[1]-center(r2)[1])**2)**(1/2)
    return distance
#======================================
def intersection(r1, r2):
    w_1 = min(r1[0]+r1[2]-r2[0],r2[0]+r2[2]-r1[0])
    w_2 = max(w_1,0.0)
    y1 = min(r2[1],r1[1])
    y2 = max((r2[1]-r2[3]),(r1[1]-r1[3]))
    y = y1-y2
    x2 = min(r1[0],r2[0])
    x3 = max(r1[0],r2[0])
    w_3 = min(r2[2],r1[2])
    w = min(w_2,w_3) 
    intersection = y*w
    return intersection
#======================================
def union(r1, r2):
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    union = (a1+a2)-intersection(r1,r2)
    return union
#======================================
def iou(r1, r2):
    i_1 = intersection(r1, r2)
    iou = i_1 / (union(r1, r2))
    return iou
#======================================

00112: HW01
bytecount: {'code': 468, 'const': 472, 'code+const': 940}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0]
    y = r[1]
    w = r[2]
    h = r[3]
    a = (x+(x+w))/2
    b = (y+(y-h))/2
    return [a,b]
#======================================
def distance(r1, r2):
    x = center(r1)
    y = center(r2)
    a = x[0]
    a1 = x[1]
    b = y[0]
    b1 = y[1]
    dis = ((a-b)**2+(a1-b1)**2)**0.5
    return dis
#======================================
def intersection(r1, r2):
    x1 = r1[0]
    y1 = r1[1]
    w1 = r1[2]
    h1 = r1[3]
    x2 = r2[0]
    y2 = r2[1]
    w2 = r2[2]
    h2 = r2[3]
    xl = max(x1, x2)
    yt = min(y1, y2)
    xr = min(x1 + w1, x2 + w2)
    yb = max(y1 - h1, y2 - h2)
    width = max(0,xr-xl)
    height = max(0,yt-yb)
    intersect = width*height
    return intersect
#======================================
def union (r1,r2):
    a = intersection(r1,r2)
    w1 = r1[2]
    h1 = r1[3]
    w2 = r2[2]
    h2 = r2[3]
    ar1 = w1*h1
    ar2 = w2*h2
    return (ar1+ar2)-a
#======================================
def iou(r1, r2):
    x = intersection(r1, r2)
    y = union(r1,r2)
    return x/y
#======================================

00113: HW01
bytecount: {'code': 468, 'const': 472, 'code+const': 940}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=float((2*r[0]+r[2])/2)
  y=float((2*r[1]-r[3])/2)
  a=[x,y]
  return a
#======================================
def distance(r1, r2):
  b=center(r1)
  c=center(r2)
  dist=((b[0]-c[0])**2 + (b[1]-c[1])**2)**(1/2)
  return dist
#======================================
def intersection(r1, r2):
  a=float(r1[0])
  b=float(r1[1])
  c=a+float(r1[2])
  d=b-float(r1[3])
  e=float(r2[0])
  f=float(r2[1])
  g=e+float(r2[2])
  h=f-float(r2[3])
  a=max(a,e)
  c=min(c,g)
  a=c-a
  a=max(0,a)
  b=min(b,f)
  d=max(h,d)
  b=b-d
  b=max(0,b)
  return a*b
#======================================
def union(r1, r2):
   areau=float(r1[2])*float(r1[3])+float(r2[2])*float(r2[3])-intersection(r1, r2)
   return areau
#======================================
def iou(r1, r2):
  return intersection(r1, r2)/union(r1, r2)
#======================================

00114: HW01
bytecount: {'code': 440, 'const': 500, 'code+const': 940}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0]+r[2]/2
    y = r[1]-r[3]/2
    return [x , y]
def distance(r1, r2):
    x1 = r1[0]+r1[2]/2
    y1 = r1[1]-r1[3]/2
    x2 = r2[0]+r2[2]/2
    y2 = r2[1]-r2[3]/2
    return ((x1-x2)**2 + (y1-y2)**2)**0.5
def intersection(r1,r2):
    x1 = min(r1[0]+r1[2],r2[0]+r2[2])
    x2 = max(r1[0],r2[0])
    x3 = x1-x2
    x = max(x3,0)
    y1 = min(r1[1],r2[1])
    y2 = max(r1[1]-r1[3],r2[1]-r2[3])
    y3 = y1-y2
    y = max(y3,0)
    return x * y
def union(r1, r2):
    area_r1 = r1[2] * r1[3]
    area_r2 = r2[2] * r2[3]
    union_area = area_r1 + area_r2 - intersection(r1,r2)
    return union_area
def iou(r1, r2):
    area_sec = intersection(r1,r2)
    area_uni = union(r1, r2)
    return area_sec/area_uni
#======================================
#======================================

00115: HW01
bytecount: {'code': 520, 'const': 420, 'code+const': 940}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [(((r[0] * 2) + r[2]) / 2), (((r[1] * 2) - r[3]) / 2)]
#======================================
def distance(r1, r2):
    x1, y1 = center(r1)
    x2, y2 = center(r2)
    return ((((x2-x1)**2)+((y2-y1)**2))**.5)
#======================================
def intersection(r1, r2):
    true_top_1 = max(r1[1], r1[1] - r1[3])
    true_down_1 = min(r1[1], r1[1] - r1[3])
    true_left_1 = min(r1[0], r1[0] + r1[2]) 
    true_right_1 = max(r1[0], r1[0] + r1[2])
    true_top_2 = max(r2[1], r2[1] - r2[3])
    true_down_2 = min(r2[1], r2[1] - r2[3])
    true_left_2 = min(r2[0], r2[0] + r2[2]) 
    true_right_2 = max(r2[0], r2[0] + r2[2])
    top = min(true_top_1, true_top_2)
    down = max(true_down_1, true_down_2)
    left = max(true_left_1, true_left_2)
    right = min(true_right_1, true_right_2)
    h = max(top - down, 0)
    w = max(right - left, 0)
    return (h * w)
#======================================
def union(r1, r2):
    a1 = abs(r1[2] * r1[3])
    a2 = abs(r2[2] * r2[3])
    return ((a1 + a2) - intersection(r1, r2))
#======================================
def iou(r1, r2):
    return (intersection(r1, r2) / union(r1, r2))
#======================================

00116: HW01
bytecount: {'code': 444, 'const': 496, 'code+const': 940}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center = [r[0]+(r[2]/2), r[1]-(r[3]/2)]
    return center
#======================================
def distance(r1, r2):
    x1 = (center(r1))[0]
    y1 = (center(r1))[1]
    x2 = (center(r2))[0]
    y2 = (center(r2))[1]
    distance = (((x2-x1)**2)+((y2-y1)**2))**(1/2)
    return distance
#======================================
def intersection(r1, r2):
    hor1 = [r1[0],(r1[0]+r1[2])]
    vert1 = [(r1[1]-r1[3]),r1[1]]
    hor2 = [r2[0],(r2[0]+r2[2])]
    vert2 = [(r2[1]-r2[3]),r2[1]]
    width = max(0.0, min(hor1[1],hor2[1]) - max(hor1[0],hor2[0]))
    height = max(0.0, min(vert1[1],vert2[1]) - max(vert1[0],vert2[0]))
    intersection = width*height
    return intersection
#======================================
def union(r1, r2):
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    return a1+a2-intersection(r1, r2)
#======================================
def iou(r1, r2):
    return (intersection(r1, r2))/(union(r1, r2))
#======================================

00117: HW01
bytecount: {'code': 472, 'const': 472, 'code+const': 944}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] + r[2]/2
    y = r[1] - r[3]/2
    return [x, y]
#======================================
def distance(r1, r2):
    x1 = center(r1)[0]
    x2 = center(r2)[0]
    y1 = center(r1)[1]
    y2 = center(r2)[1]
    d = ((x2-x1)**2+(y2-y1)**2)**(1/2)
    return d
#======================================
def intersection(r1, r2):
    x1 = r1[2]
    x2 = r2[2]
    y1 = r1[3]
    y2 = r2[3]
    d1 = abs((r1[0] + r1[2]) - (r2[0] + r2[2]))
    d2 = abs(r1[0] - r2[0])
    l1 = abs(r1[1] - r2[1])
    l2 = abs((r1[1] - r1[3]) - (r2[1] - r2[3]))
    m = max(x1 + x2 - d1 - d2 , 0)
    n = max(y1 + y2 - l1 -l2 , 0)
    A  = ((m)/2) * ((n)/2)
    return A
#======================================
def union(r1, r2):
    a1 = r1[2] * r1[3]
    a2 = r2[2] * r2[3]
    U = a1 + a2 - intersection(r1, r2)
    return U
#======================================
def iou(r1, r2):
    R = intersection(r1, r2) / union(r1, r2)
    return R
#======================================

00118: HW01
bytecount: {'code': 472, 'const': 472, 'code+const': 944}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    float(r[0]) 
    float(r[1])
    float(r[2])
    float(r[3])
    c1 = (r[2]+(2*r[0]))/2
    c2 = ((2*r[1])-r[3])/2
    c = [c1,c2]
    return(c)
#======================================
def distance(r1, r2):
    a = center(r1)
    b = center(r2)
    a0 = a[0]-b[0]
    a1 = a[1]-b[1]
    c = ((a0**2)+(a1**2))**0.5
    return(c)
#======================================
def intersection(r1, r2):
    mx0 = max(r1[0],r2[0])
    mx1 = min(r1[0]+r1[2],r2[0]+r2[2])
    mx2 = max(r1[1]-r1[3],r2[1]-r2[3])
    mx3 = min(r1[1],r2[1])
    m0 = max(0,mx1-mx0)
    m1 = max(0,mx3-mx2)
    i = (m0)*(m1)
    return(i)
#======================================
def union(r1, r2):
    a = intersection(r1, r2)
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    s = a1+a2-a
    return(s)
#======================================
def iou(r1, r2):
    i = intersection(r1, r2)
    u = union(r1, r2)
    r = (i/u)
    return(r)
#======================================

00119: HW01
bytecount: {'code': 452, 'const': 496, 'code+const': 948}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+r[2]/2, r[1]-r[3]/2]
#======================================
def distance(r1, r2):
    return ((center(r1)[0]-center(r2)[0])**2+(center(r1)[1]-center(r2)[1])**2)**0.5
#======================================
def intersection(r1, r2):
    return (((min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0]))+(((min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0]))**2)**0.5))/2)*(((min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3]))+(((min(r1[1],r2[1])-max(r1[1]-r1[3],r2[1]-r2[3]))**2)**0.5))/2)
#======================================
def union(r1, r2):
    return (r1[2]*r1[3])+(r2[2]*r2[3])-intersection(r1, r2)
#======================================
def iou(r1, r2):
    return ((intersection(r1, r2))/(union(r1, r2)))  
#======================================

00120: HW01
bytecount: {'code': 428, 'const': 524, 'code+const': 952}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    diagonal_inter = [r[0]+(r[2]/2),r[1]-(r[3]/2)]
    return diagonal_inter
#======================================
def distance(r1, r2):
    dis = ((((r2[0]+(r2[2]/2))-(r1[0]+(r1[2]/2)))**2)+(((r2[1]-(r2[3]/2))-(r1[1]-(r1[3]/2)))**2))**(1/2)
    return dis
#======================================
def intersection(r1, r2):
    a = min(r1[0]+r1[2],r2[0]+r2[2])
    b = min(r1[1],r2[1])
    c = max(r1[0],r2[0])
    d = max(r1[1]-r1[3],r2[1]-r2[3])
    s1 = a - c
    s2 = b - d
    side1 = max(0.0,s1)
    side2 = max(0.0,s2)
    intersection_area = side1 * side2
    return intersection_area
#======================================
def union(r1, r2):
    intersection_area = intersection(r1, r2)
    union_area = ((r1[2]*r1[3])+(r2[2]*r2[3])) - (intersection_area)
    return union_area
#======================================
def iou(r1, r2):
    intersection_area = intersection(r1, r2)
    union_area = union(r1, r2)
    ratio = intersection_area / union_area
    return ratio
#======================================

00121: HW01
bytecount: {'code': 432, 'const': 524, 'code+const': 956}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + r[2]/2
  y = r[1] - r[3]/2
  r = [x, y]
  return r
#======================================
def distance(r1, r2):
  dtx = ((r1[0] + r1[2]/2) - (r2[0] + r2[2]/2))**2
  dty = ((r1[1] - r1[3]/2) - (r2[1] - r2[3]/2))**2
  distance = ( dtx + dty )**0.5
  return distance
#======================================
def intersection(r1, r2):
  x1 = max( r1[0], r2[0] )
  x2 = min( r1[0]+r1[2], r2[0]+r2[2] )
  w = x2 - x1
  w1 = max(0.0, w)
  y1 = min( r1[1], r2[1] )
  y2 = max( r1[1]-r1[3] , r2[1]-r2[3] )
  h = y1 - y2
  h1 = max(0.0, h)
  area = w1 * h1
  return area
#======================================
def union(r1, r2):
  u = r1[2]*r1[3] + r2[2]*r2[3] - intersection(r1, r2)
  return u
#======================================
def iou(r1, r2):
  iou = intersection(r1, r2)/union(r1, r2)
  return iou
#======================================

00122: HW01
bytecount: {'code': 464, 'const': 496, 'code+const': 960}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
    cr1 = center(r1)
    cr2 = center(r2)
    dx = cr1[0]-cr2[0]
    dy = cr1[1]-cr2[1]
    return (dx**2+dy**2)**(1/2)  
#======================================
def intersection(r1, r2):
    nw = max(0.0,max(r1[0]+r1[2],r2[0]+r2[2])-min(r1[0],r2[0])-abs(r1[0]+r1[2]-(r2[0]+r2[2]))-abs(r1[0]-r2[0]))
    nh = max(0.0,max(r1[1],r2[1])-min(r1[1]-r1[3],r2[1]-r2[3])-abs(r1[1]-r1[3]-(r2[1]-r2[3]))-abs(r1[1]-r2[1]))
    return nh*nw
#======================================
def union(r1, r2):
    return (r1[2]*r1[3]+r2[2]*r2[3])-intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00123: HW01
bytecount: {'code': 462, 'const': 500, 'code+const': 962}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r) :
  r=[(r[2]/2)+r[0],(+r[1]-r[3]/2)]
  return r
#======================================
def distance(r1,r2):
  r1=[(r1[2]/2)+r1[0],(r1[1]-r1[3]/2)]
  r2=[(r2[2]/2)+r2[0],(r2[1]-r2[3]/2)]
  x1=r1[0]-r2[0]
  y1=r1[1]-r2[1]
  d=((x1**2)+(y1**2))**(1/2)
  return d
#======================================
def intersection(r1,r2):
  x1=max(r1[0],r2[0])
  x2=min(r1[0]+r1[2],r2[0]+r2[2])
  w=max(x2-x1,0)
  y1=min(r1[1],r2[1])
  y2=max(r1[1]-r1[3],r2[1]-r2[3])
  h=max(y1-y2,0)
  area=w*h
  return area
#======================================
def union(r1,r2):
  x=intersection(r1,r2)
  a1=(r1[2])*(r1[3])
  a2=(r2[2])*(r2[3])
  au=a1+a2-x
  return au
#======================================
def iou(r1,r2):
  p=intersection(r1,r2)/union(r1,r2)
  return p
#======================================

00124: HW01
bytecount: {'code': 492, 'const': 472, 'code+const': 964}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  br = [r[0]+r[2],r[1]-r[3]]
  center = [(r[0]+br[0])/2,(r[1]+br[1])/2]
  return center
#======================================
def distance(r1, r2):
  c1 = center(r1)
  c2 = center(r2)
  d = ((c1[0]-c2[0])**2 + (c1[1]-c2[1])**2)**0.5
  return d
#======================================
def intersection(r1, r2):
  bl1 = [r1[0], r1[1]-r1[3]]
  bl2 = [r2[0], r2[1]-r2[3]]
  tr1 = [r1[0]+r1[2], r1[1]]
  tr2 = [r2[0]+r2[2], r2[1]]
  xbl = max(bl1[0],bl2[0])
  ybl = max(bl1[1],bl2[1])
  xtr = min(tr1[0],tr2[0])
  ytr = min(tr1[1],tr2[1])
  dx = xtr-xbl
  dy = ytr-ybl
  c1 = max(0,dx)
  c2 = max(0,dy)
  A = c1 * c2
  return A
#======================================
def union(r1, r2):
  A1 = r1[2]*r1[3]
  A2 = r2[2]*r2[3]
  sA = A1 + A2 - intersection(r1, r2)
  return sA
#======================================
def iou(r1, r2):
  r = intersection(r1, r2) / union(r1, r2)
  return r   
#======================================

00125: HW01
bytecount: {'code': 492, 'const': 472, 'code+const': 964}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = float(r[0]) + (float(r[2]))/2
  y = float(r[1]) - (float(r[3]))/2
  return ([x,y])
#======================================
def distance(r1, r2):
    a = float((center(r1))[0]) - float((center(r2))[0])
    b = float((center(r1))[1]) - float((center(r2))[1])
    c = ((a**2)+(b**2))**(1/2)
    return(c)
#======================================
def intersection(r1, r2):
    ax = max(float(r1[0]),float(r2[0]))
    bx = min((float(r1[0]))+(float(r1[2])),(float(r2[0]))+(float(r2[2])))
    top = max((bx-ax),0)
    ay = min(float(r1[1]),float(r2[1]))
    by = max((float(r1[1]))-(float(r1[3])),(float(r2[1]))-(float(r2[3])))
    side = max((ay-by),0)
    return top*side
#======================================
def union(r1, r2):
    pt1 = (float(r1[2]))*(float(r1[3]))
    pt2 = (float(r2[2]))*(float(r2[3]))
    ruam = pt1 + pt2 - intersection(r1,r2)
    return (ruam)
#======================================
def iou(r1, r2):
    tor = intersection(r1,r2)/union(r1,r2)
    return(tor)
#======================================

00126: HW01
bytecount: {'code': 468, 'const': 500, 'code+const': 968}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0]+ (r[2]/2)
    y = r[1]- (r[3]/2)
    r = [x,y]
    return r
#======================================
def distance(r1, r2):
    x1 = r1[0]+ (r1[2]/2)
    y1 = r1[1]- (r1[3]/2)
    rone = [x1,y1] 
    x2 = r2[0]+ (r2[2]/2)
    y2 = r2[1]- (r2[3]/2)
    rtwo = [x2,y2]
    d = ((rone[0]-rtwo[0])**2+(rone[1]-rtwo[1])**2)**0.5
    return d
#======================================
def intersection(r1, r2):
    lenx = min(r1[0]+r1[2],r2[0]+r2[2])-max(r1[0],r2[0])
    leny = min(r2[1],r1[1])-max(r1[1]-r1[3],r2[1]-r2[3])
    lenx = abs(lenx) + lenx and lenx 
    area = lenx * leny
    return area
#======================================
def union(r1, r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    union = area1 + area2 - intersection(r1,r2)
    return union
#======================================
def iou(r1, r2):
    i = intersection(r1,r2)
    u = union(r1,r2)
    ratio = i/u
    return ratio
#======================================

00127: HW01
bytecount: {'code': 496, 'const': 472, 'code+const': 968}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  return [r[0]+r[2]/2,r[1]-r[3]/2]
#======================================
def distance(r1, r2):
  diff=[center(r1)[0]-center(r2)[0],center(r1)[1]-center(r2)[1]]
  return (diff[0]**2+diff[1]**2)**(1/2)
#======================================
def intersection(r1, r2):
    a1=r1[0];wa=r1[2];a2=r1[0]+wa
    b1=r2[0];wb=r2[2];b2=r2[0]+wb 
    ha=r1[3];aa1=r1[1]-ha;aa2=r1[1] 
    hb=r2[3];bb1=r2[1]-hb;bb2=r2[1]
    s1=(min(a1-b2,0),min(aa1-bb2,0)) 
    s2=(min(wb,-s1[0]),min(hb,-s1[1]))
    s3=(min(a2-b1,s2[0],wa),min(aa2-bb1,s2[1],ha))
    s4=(max(s3[0],0),max(s3[1],0))
    return s4[0]*s4[1]
#======================================
def union(r1, r2):
  sum_area=r1[2]*r1[3]+r2[2]*r2[3]
  return sum_area-intersection(r1,r2) 
#======================================
def iou(r1, r2):
  return intersection(r1,r2)/union(r1,r2)
#======================================

00128: HW01
bytecount: {'code': 500, 'const': 472, 'code+const': 972}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center_x = r[0]+r[2]/2
    center_y = r[1]-r[3]/2
    ans = [center_x, center_y]
    return ans 
#======================================
def distance(r1, r2):
    center_x1 = center(r1)[0]
    center_y1 = center(r1)[1]
    center_x2 = center(r2)[0]
    center_y2 = center(r2)[1]
    d = ((center_x1-center_x2)**2+(center_y1-center_y2)**2)**0.5
    return d
#======================================
def intersection(r1, r2):
    width_intersect = max(0,min(max(r1[0], r1[0]+r1[2]), max(r2[0], r2[0]+r2[2])) - max(min(r1[0], r1[0]+r1[2]), min(r2[0], r2[0]+r2[2])))
    len_intersect = max(0,min(max(r1[1], r1[1]-r1[3]), max(r2[1], r2[1]-r2[3])) - max(min(r1[1], r1[1]-r1[3]), min(r2[1], r2[1]-r2[3])))
    area_intersect = width_intersect * len_intersect
    return area_intersect
#======================================
def union(r1, r2):
    area_u = (r1[2]*r1[3])+(r2[2]*r2[3])-intersection(r1, r2)
    return area_u
#======================================
def iou(r1, r2):
    ratio = intersection(r1, r2)/union(r1, r2)
    return ratio
#======================================

00129: HW01
bytecount: {'code': 476, 'const': 496, 'code+const': 972}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x=r[0]+r[2]/2
    y=r[1]-r[3]/2
    return [x,y]
#======================================
def distance(r1,r2):
    x1=center(r1)[0]
    x2=center(r2)[0]
    y1=center(r1)[1]
    y2=center(r2)[1]
    p=((x2-x1)**2+(y2-y1)**2)**(1/2)
    return p
#======================================
def intersection(r1, r2):
    l1,l2,t1,t2 = r1[0],r2[0],r1[1],r2[1]
    p1,p2,b1,b2 = r1[0]+r1[2],r2[0]+r2[2],r1[1]-r1[3],r2[1]-r2[3]
    w = max(r1[2]+r2[2]-max(p1-l2,p2-l1,r1[2],r2[2]),0.0)
    h = max(r1[3]+r2[3]-max(t1-b2,t2-b1,r1[3],r2[3]),0.0)
    return w*h
#======================================
def union(r1, r2):
    a1=r1[2]*r1[3]
    a2=r2[2]*r2[3]
    area=a1+a2-intersection(r1,r2)
    return area
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00130: HW01
bytecount: {'code': 460, 'const': 516, 'code+const': 976}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center_x = r[0] + r[2]/2
    center_y = r[1] - r[3]/2
    return [center_x, center_y]
#======================================
def distance(r1, r2):
    x1 = center(r1)[0]
    y1 = center(r1)[1]
    x2 = center(r2)[0]
    y2 = center(r2)[1]
    d = ((x1-x2)**2 + (y1-y2)**2)**(1/2)
    return d
#======================================
def intersection(r1, r2):
    def find_mid(p1,p2,p3,p4):
        lower_value = [p1,p3]
        higher_value = [p2,p4]
        length = (min(higher_value)-max(lower_value) + abs(min(higher_value)-max(lower_value))) / 2
        return length
    x1 = r1[0]
    x2 = r1[0] + r1[2]
    x3 = r2[0]
    x4 = r2[0] + r2[2]
    y1 = r1[1] - r1[3]
    y2 = r1[1]
    y3 = r2[1] - r2[3]
    y4 = r2[1]
    length_x = find_mid(x1,x2,x3,x4)
    length_y = find_mid(y1,y2,y3,y4)
    return length_x*length_y
#======================================
def union(r1, r2):
    area_r1 = r1[2]*r1[3]
    area_r2 = r2[2]*r2[3]
    area_intersect = intersection(r1,r2)
    return area_r1 + area_r2 - area_intersect
#======================================
def iou(r1, r2):
    return intersection(r1,r2) / union(r1,r2)
#======================================

00131: HW01
bytecount: {'code': 504, 'const': 472, 'code+const': 976}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r) :
    x = r[0] + r[2]/2
    y = r[1] - r[3]/2
    return [x,y]
def distance(r1,r2) :
    CM1 = center(r1)
    CM2 = center(r2)
    D = ((CM1[0]-CM2[0])**2+(CM1[1]-CM2[1])**2)**0.5
    return D
def intersection(r1,r2) :
    X_max = max(r1[0],r1[0]+r1[2],r2[0],r2[0]+r2[2])
    X_min = min(r1[0],r1[0]+r1[2],r2[0],r2[0]+r2[2])
    Y_max = max(r1[1],r1[1]-r1[3],r2[1],r2[1]-r2[3])
    Y_min = min(r1[1],r1[1]-r1[3],r2[1],r2[1]-r2[3])
    w = abs(min((X_max - X_min - r1[2] - r2[2]),0))
    h = abs(min((Y_max - Y_min - r1[3] - r2[3]),0))
    return h*w
def union(r1,r2) :
    Area_1 = r1[2]*r1[3]
    Area_2 = r2[2]*r2[3]
    intersect_Area = intersection(r1,r2)
    return Area_1+Area_2-intersect_Area
def iou(r1,r2) :
    return intersection(r1,r2)/union(r1,r2)

00132: HW01
bytecount: {'code': 484, 'const': 496, 'code+const': 980}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    xc = float(r[0]) + float(r[2])/2
    yc = float(r[1]) - float(r[3])/2
    return [xc,yc]
#======================================
def distance(r1, r2):
    dx = float(center(r2)[0])-float(center(r1)[0])
    dy = float(center(r2)[1])-float(center(r1)[1])
    d = (dx**2+dy**2)**0.5
    return d
#======================================
def intersection(r1, r2):
    x11 = x14 = r1[0]
    x12 = x13 = r1[0] + r1[2]
    y11 = y12 = r1[1]
    y13 = y14 = r1[1] - r1[3]
    x21 = x24 = r2[0]
    x22 = x23 = r2[0] + r2[2]
    y21 = y22 = r2[1]
    y23 = y24 = r2[1] - r2[3]
    dx = min(x12,x22) - max(x11,x21)
    dy = min(y11,y21) - max(y13,y23)
    dx2 = max(0.0,dx)
    dy2 = max(0.0,dy)
    ina = dx2*dy2
    return ina
#======================================
def union(r1, r2):
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    u = a1 + a2 - intersection(r1, r2)
    return u
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00133: HW01
bytecount: {'code': 512, 'const': 472, 'code+const': 984}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    c = [float(r[0])+float(r[2])/2 , float(r[1])-float(r[3])/2]
    return c
#======================================
def distance(r1, r2):
    a = abs(float(center(r1)[0])-float(center(r2)[0]))
    b = abs(float(center(r1)[1])-float(center(r2)[1]))
    d = (a**2+b**2)**0.5
    return d
#======================================
def intersection(r1, r2):
    r1_l = float(r1[0])
    r2_l = float(r2[0])
    r1_r = float(r1[0])+float(r1[2])
    r2_r = float(r2[0])+float(r2[2])
    r1_t = float(r1[1])
    r2_t = float(r2[1])
    r1_b = float(r1[1])-float(r1[3])
    r2_b = float(r2[1])-float(r2[3])
    w = max(min(r1_r,r2_r) - max(r1_l,r2_l) ,0)
    h = max(min(r1_t,r2_t) - max(r1_b,r2_b) ,0)
    area = w*h
    return area
#======================================
def union(r1, r2):
    a_r1r2 = (float(r1[2])*float(r1[3]))+(float(r2[2])*float(r2[3]))
    u = a_r1r2 - intersection(r1, r2)
    return u
#======================================
def iou(r1, r2):
    e = intersection(r1, r2) / union(r1, r2)
    return e
#======================================

00134: HW01
bytecount: {'code': 516, 'const': 472, 'code+const': 988}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center_x = float(r[0]) + (float(r[2]) / 2)
    center_y = float(r[1]) - (float(r[3]) / 2)
    return [center_x, center_y]
#======================================
def distance(r1, r2):
    a = center(r1)
    b = center(r2)
    distance = ((float(b[0])-float(a[0]))**2 + (float(b[1])-float(a[1]))**2)**0.5
    return distance
#======================================
def intersection(r1, r2):
    a = float(r1[0]) + float(r1[2])
    b = float(r2[0]) + float(r2[2])
    c = float(r1[0])
    d = float(r2[0])
    e = float(r1[1])
    f = float(r2[1])
    g = float(r1[1]) - float(r1[3])
    j = float(r2[1]) - float(r2[3])
    right = min(a, b)
    left = max(c, d)
    width = right - left
    top = min(e, f)
    bottom = max(g, j)
    height = top - bottom
    area = max(width, 0) * max(height, 0)
    return area
#======================================
def union(r1, r2):
    a1 = float(r1[2]) * float(r1[3])
    a2 = float(r2[2]) * float(r2[3])
    union = a1 + a2 - intersection(r1, r2)
    return union
#======================================
def iou(r1, r2):
    return intersection(r1, r2) / union(r1, r2)
#======================================

00135: HW01
bytecount: {'code': 516, 'const': 472, 'code+const': 988}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
   ctx = (r[0]+r[2]/2)
   cty = (r[1]-r[3]/2)
   return [ctx,cty]
#======================================
def distance(r1, r2):
    x2 = center(r2)[0]
    x1 = center(r1)[0]
    y1 = center(r1)[1]
    y2 = center(r2)[1]
    d = ((x2-x1)**2+(y2-y1)**2)**(1/2)
    return d
#======================================
def intersection(r1, r2):
    w1 = r1[2]
    w2 = r2[2]
    h1 = r1[3]
    h2 = r2[3]
    u1 = (max(r1[0],r1[0]+r1[2],r2[0],r2[0]+r2[2])-min(r1[0],r1[0]+r1[2],r2[0],r2[0]+r2[2]))
    u2 = (max(r1[1],r1[1]-r1[3],r2[1],r2[1]-r2[3])-min(r1[1],r1[1]-r1[3],r2[1],r2[1]-r2[3]))
    ux = w1+w2-u1
    uy = h1+h2-u2
    return (max(ux,0)*max(uy,0))
#======================================
def union(r1, r2):
    a1 = r1[2]*r1[3]
    a2 = r2[2]*r2[3]
    return a1 + a2 - intersection(r1, r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00136: HW01
bytecount: {'code': 516, 'const': 472, 'code+const': 988}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  nx = float(r[0])+(float(r[2])/2)
  ny = float(r[1])-(float(r[3])/2)
  nxy = [nx,ny]
  return nxy
def distance(r1, r2):
  A = center(r1)
  B = center(r2)
  C = ((float(B[0])-float(A[0]))**2)+((float(B[1])-float(A[1]))**2)
  C = C**0.5
  return C
def intersection(r1, r2):
    MinT = min((float(r1[1])),(float(r2[1])))
    MaxL = max((float(r1[0])),(float(r2[0])))
    MinR = min((float(r1[0])+float(r1[2])),(float(r2[0])+float(r2[2])))
    MaxB = max((float(r1[1])-float(r1[3])),(float(r2[1])-float(r2[3])))
    DX = MinR - MaxL
    DY = MinT - MaxB
    ZDX = max(DX,0)
    ZDY = max(DY,0)
    Area = ZDY * ZDX
    return Area
def union(r1, r2):
    Inters = intersection(r1, r2)
    areaA = float(r1[2])*float(r1[3])
    areaB = float(r2[2])*float(r2[3])
    Un = areaB+areaA-Inters
    return Un
def iou(r1, r2):
    Inters = intersection(r1, r2)
    Uni = union(r1, r2)
    IOU = Inters/Uni
    return IOU

00137: HW01
bytecount: {'code': 466, 'const': 523, 'code+const': 989}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  center = [""] * 2
  center[0] = r[0] + r[2] / 2
  center[1] = r[1] - r[3] / 2
  return center
#======================================
def distance(r1, r2):
  center1 = center(r1)
  center2 = center(r2)
  x1, y1, x2, y2 = center1[0], center1[1], center2[0], center2[1]
  distance = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** (1/2)
  return distance
#======================================
def intersection(r1, r2):
  left = max(r1[0], r2[0])
  top = min(r1[1], r2[1])
  right = min(r1[0] + r1[2], r2[0] + r2[2])
  bottom = max(r1[1] - r1[3], r2[1] - r2[3])
  h = top - bottom
  w = right - left
  area_intersection = ((h + abs(h)) / 2) * ((w + abs(w)) / 2)
  return area_intersection
#======================================
def union(r1, r2):
  w1 = r1[2]
  h1 = r1[3]
  w2 = r2[2]
  h2 = r2[3]
  area1 = h1 * w1
  area2 = h2 * w2
  area_intersection = intersection(r1, r2)
  area_union = area1 + area2 - area_intersection
  return area_union
#======================================
def iou(r1, r2):
  area_intersection = intersection(r1, r2)
  area_union = union(r1, r2)
  iou = area_intersection / area_union
  return iou
#======================================

00138: HW01
bytecount: {'code': 496, 'const': 496, 'code+const': 992}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center = [float(r[2])/2 + float(r[0]),                (float(r[1])-float(r[3])) +                (float(r[3])/2)]
    return center
#======================================
def distance(r1, r2):
    a1 = float(center(r1)[0])
    b1 = float(center(r1)[1])
    a2 = float(center(r2)[0])
    b2 = float(center(r2)[1])
    distance = (((a1-a2)**2)+((b1-b2)**2))**0.5
    return distance
#======================================
def intersection(r1, r2):
    m1 = max((float(r1[0])),(float(r2[0])))
    n1 = max((float(r1[1])-(float(r1[3]))),              (float(r2[1])-(float(r2[3]))))
    m2 = min((float(r1[0])+(float(r1[2]))),              (float(r2[0])+(float(r2[2]))))
    n2 = min((float(r1[1])),(float(r2[1])))
    intersection = max((m2-m1),0.0)*max((n2-n1),0.0)
    return intersection
#======================================
def union(r1, r2):
    union = ((float(r1[2]))*(float(r1[3])))+             ((float(r2[2]))*(float(r2[3])))-             intersection(r1, r2)
    return union
#======================================
def iou(r1, r2):
    iou = intersection(r1, r2)/union(r1, r2)
    return iou
#======================================

00139: HW01
bytecount: {'code': 492, 'const': 500, 'code+const': 992}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
 x = r[0]+r[2]/2
 y = r[1]-r[3]/2
 a = [x,y]
 return a
#======================================
def distance(r1, r2):
 x1 = r1[0]+r1[2]/2
 y1 = r1[1]-r1[3]/2
 x2 = r2[0]+r2[2]/2
 y2 = r2[1]-r2[3]/2
 dx = (max(x1,x2)-min(x1,x2))**2
 dy = (max(y1,y2)-min(y1,y2))**2
 d = (dx + dy)**(1/2)
 return d    
#======================================
def intersection(r1, r2):
 x = r1[2]+r2[2]-(max(r1[0]+r1[2],r2[0]+r2[2])-min(r1[0],r2[0]))
 x1 = max(x,0)
 y = r1[3]+r2[3]-(max(r1[1],r2[1])-min(r1[1]-r1[3],r2[1]-r2[3]))
 y1 = max(y,0)
 area = x1*y1
 return area    
#======================================
def union(r1, r2):
 a = r1[2]*r1[3]
 b = r2[2]*r2[3]
 c = a+b-intersection(r1,r2)
 return c
#======================================
def iou(r1, r2):
 return intersection(r1,r2)/union(r1,r2)
#======================================

00140: HW01
bytecount: {'code': 526, 'const': 472, 'code+const': 998}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  pos = list()
  pos.append(float(r[0]) + ((float(r[2]))/2))
  pos.append(float(r[1]) - (float(r[3])/2))
  return pos
#======================================
def distance(r1, r2):
  a = center(r1)
  b = center(r2)
  d = (((a[0]-b[0])**2)+((a[1]-b[1])**2))**0.5
  return d
#======================================
def intersection(r1, r2):
    x1_min = float( r1[0] )
    x1_max = float(r1[0])+float(r1[2])
    y1_min = float(r1[1])-float(r1[3])
    y1_max = float(r1[1])
    x2_min = float(r2[0])
    x2_max = float(r2[0])+float(r2[2])
    y2_min = float(r2[1])-float(r2[3])
    y2_max = float(r2[1])
    x_intersect1 = max(x1_min,x2_min)
    x_intersect2 = min(x1_max,x2_max)
    w = x_intersect2 - x_intersect1
    #check intersect area
    w = max(w,0)
    y_intersect1 = max(y1_min,y2_min)
    y_intersect2 = min(y1_max,y2_max)
    h = y_intersect2 - y_intersect1
    #check intersect area
    h = max(h,0)
    return w*h
#======================================
def union(r1, r2):
    area1 = float(r1[2])*float(r1[3])
    area2 = float(r2[2])*float(r2[3])
    intersect = intersection(r1,r2)
    return area1+area2-intersect
#======================================
def iou(r1, r2):
    all_area = union(r1,r2)
    intersect = intersection(r1,r2)
    return intersect/all_area
#======================================

00141: HW01
bytecount: {'code': 528, 'const': 472, 'code+const': 1000}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r1):
    cx = r1[0]+(r1[2]/2)
    cy = r1[1]-(r1[3]/2)
    x = [cx,cy]
    return x
def distance(r1, r2):
    a1 = center(r1)
    a2 = center(r2)
    x = (((a1[0] - a2[0])**2) + (a1[1] - a2[1])**2)**0.5
    return x
def intersection(r1, r2):
    x1=abs(r1[0]-r2[0])
    x2=abs((r1[0]+r1[2])-(r2[0]+r2[2]))
    x3=abs(min(r1[0],r2[0])-max((r1[0]+r1[2]),(r2[0]+r2[2])))
    x4=max(0,x3-x2-x1)
    y1=abs(r1[1]-r2[1])
    y2=abs((r1[1]-r1[3])-(r2[1]-r2[3]))
    y3=abs(min((r1[1]-r1[3]),(r2[1]-r2[3]))-max(r1[1],r2[1]))
    y4=max(0,y3-y2-y1)
    ar=x4*y4
    return ar
def union(r1, r2):
    z1 = r1[2]*r1[3]
    z2 = r2[2]*r2[3]
    inter = intersection(r1, r2)
    z3 = z1+z2- inter
    return z3
def iou(r1, r2):   
    x = intersection(r1, r2)/union(r1, r2)
    return x

00142: HW01
bytecount: {'code': 532, 'const': 472, 'code+const': 1004}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r): 
    x = float(r[0])
    y = float(r[1])
    w = float(r[2])
    h = float(r[3])
    sx = x+w
    sy = y-h
    c = [(x+sx)/2,(y+sy)/2]
    return c
#======================================
def distance(r1, r2):
    cr1 = center(r1)
    cr2 = center(r2)
    x1 = float(cr1[0])
    x2 = float(cr2[0])
    y1 = float(cr1[1])
    y2 = float(cr2[1])
    dx = abs(x1-x2)**2
    dy = abs(y1-y2)**2
    d = (dx+dy)**0.5
    return d
#======================================
def intersection(r1, r2):
    xl1 = float(r1[0])
    xl2 = float(r2[0])
    xr1 = xl1+r1[2]
    xr2 = xl2+r2[2]
    yt1 = float(r1[1])
    yt2 = float(r2[1])
    yb1 = yt1-r1[3]
    yb2 = yt2-r2[3]
    lx = max(xl1,xl2)
    rx = min(xr1,xr2)
    ty = min(yt1,yt2)
    by = max(yb1,yb2)
    dx = rx-lx
    dy = abs(ty-by)
    i = dx*dy
    check = (i+abs(i))/2
    return check
#======================================
def union(r1, r2):
    u = float(r1[2])*float(r1[3])+float(r2[2])*float(r2[3])-intersection(r1,r2)
    return u
#======================================
def iou(r1, r2):
    io = intersection(r1,r2)/union(r1,r2)
    return io
#======================================

00143: HW01
bytecount: {'code': 486, 'const': 524, 'code+const': 1010}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]
  y = r[1]
  w = r[2]
  h = r[3]
  ct_x = x + (w/2)
  ct_y = y - (h/2)
  ct = [ct_x , ct_y]
  return ct
#======================================
def distance(r1, r2):
  dis_x = center(r1)[0] - center(r2)[0]
  dis_y = center(r1)[1] - center(r2)[1]
  dist = ((dis_x)**2 + (dis_y)**2)**0.5
  return dist
#======================================
def intersection(r1, r2):
  x1 = r1[0]
  y1 = r1[1]
  w1 = r1[2]
  h1 = r1[3]
  x2 = r2[0]
  y2 = r2[1]
  w2 = r2[2]
  h2 = r2[3]
  len_inter_x = max(min( x1 + w1 , x2 + w2 ) - max( x1 , x2 ) , 0)
  len_inter_y = max(min(y1 , y2) - max(y1 - h1 , y2 - h2) , 0)
  inter = len_inter_x * len_inter_y
  return inter
#======================================
def union(r1, r2):
  x1 = r1[0]
  y1 = r1[1]
  w1 = r1[2]
  h1 = r1[3]
  x2 = r2[0]
  y2 = r2[1]
  w2 = r2[2]
  h2 = r2[3]
  uni =  min((w1*h1) + (w2*h2) - intersection(r1, r2) , (w1*h1) + (w2*h2))
  return uni
#======================================
def iou(r1, r2):
  inter = intersection(r1, r2)
  uni = union(r1,r2)
  io = inter/uni
  return io
#======================================

00144: HW01
bytecount: {'code': 524, 'const': 496, 'code+const': 1020}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  m = float(r[0])+(float(r[2])*0.5)
  n = float(r[1])-(float(r[3])*0.5)
  return[m, n]
#======================================
def distance(r1, r2):
  d = ((float(center(r2)[1])-float(center(r1)[1]))**2+(float(center(r2)[0])-float(center(r1)[0]))**2)**0.5
  return d
#======================================
def intersection(r1, r2):
    a = min(float(r1[0])+float(r1[2]), float(r2[0])+float(r2[2]))
    b = max(float(r1[0]), float(r2[0]))
    c = min(float(r1[1]), float(r2[1]))
    g = max(float(r1[1])-float(r1[3]), float(r2[1])-float(r2[3]))
    A1 = float(a)-float(b)
    A2 = float(c)-float(g)
    area = max(A1,0)*max(A2,0)
    return area
#======================================
def union(r1, r2):
    area1 = float(r1[2])*float(r1[3])
    area2 = float(r2[2])*float(r2[3])
    U = float(area1)+float(area2)-float(intersection(r1, r2))
    return U
#======================================
def iou(r1, r2):
    t = float(intersection(r1, r2))/float(union(r1, r2))
    return t
#======================================

00145: HW01
bytecount: {'code': 554, 'const': 472, 'code+const': 1026}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    r = [ float(i) for i in r]
    px = ((2*r[0])+r[2])/2                           
    py = ((2*r[1])-r[3])/2
    return [px,py]
#======================================
def distance(r1, r2):
    r1 = center(r1)    
    r2 = center(r2)
    d = ((r1[0]-r2[0])**2+(r1[1]-r2[1])**2)**(1/2)
    return d    
#======================================
def intersection(r1, r2):
   r1 = [float(i) for i in r1]                        
   r2 = [float(i) for i in r2] 
   w = min(r1[1],r2[1]) - max((r1[1]-r1[3]),(r2[1]-                                               r2[3]))
   l = min((r1[0]+r1[2]),(r2[0]+r2[2]))-max(r1[0],r2[0])
   return max(w,0)*max(l,0)
#======================================
def union(r1, r2):
    r1 = [float(i) for i in r1]                        
    r2 = [float(i) for i in r2]            
    A1 = r1[2]*r1[3]
    A2 = r2[2]*r2[3] 
    A12 = intersection(r1, r2)
    return A1+A2-A12
#======================================
def iou(r1, r2):
    intersec = intersection(r1, r2)
    uni = union(r1, r2)
    return intersec/uni
#======================================

00146: HW01
bytecount: {'code': 548, 'const': 500, 'code+const': 1048}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    centerx = (float(r[0])+float(r[2])/2)
    centery = (float(r[1])-float(r[3])/2)
    Cen = [centerx,centery]
    return Cen
#======================================
def distance(r1, r2):
    Cenr1X = (float(r1[0])+float(r1[2])/2)
    Cenr1Y = (float(r1[1])-float(r1[3])/2)
    Cenr2X = (float(r2[0])+float(r2[2])/2)
    Cenr2Y = (float(r2[1])-float(r2[3])/2)
    distance = (((Cenr1X-Cenr2X)**2)+((Cenr1Y-Cenr2Y)**2))**0.5
    return distance
#======================================
def intersection(r1, r2):
    x = min(float(r1[0])+float(r1[2]),float(r2[0])+float(r2[2]))          - max(float(r1[0]),float(r2[0]))
    y = min(float(r1[1]),float(r2[1])) - max(float(r1[1])-float(r1[3]),                               float(r2[1])-float(r2[3]))
    xx = float(max(0,x))
    yy = float(max(0,y))
    intersect_area = xx*yy
    return intersect_area
#======================================
def union(r1, r2):
    area_r1 = (float(r1[2])*float(r1[3]))
    area_r2 = (float(r2[2])*float(r2[3]))
    union_area = area_r1 + area_r2
    return union_area - intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00147: HW01
bytecount: {'code': 548, 'const': 500, 'code+const': 1048}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = ((r[0]+r[2])+r[0])/2
  y = ((r[1])+(r[1]-r[3]))/2
  center =[x,y]
  return center
#======================================
def distance(r1, r2):
  x1 = ((r1[0]+r1[2])+r1[0])/2
  y1 = ((r1[1])+(r1[1]-r1[3]))/2
  x2 = ((r2[0]+r2[2])+r2[0])/2
  y2 = ((r2[1])+(r2[1]-r2[3]))/2
  x = x1-x2
  y = y1-y2
  d = ((x**2)+(y**2))**0.5
  return d
#======================================
def intersection(r1, r2):
  x1L = r1[0]
  x1R = r1[0]+r1[2]
  x2L = r2[0]
  x2R = r2[0]+r2[2]
  min_XR = min(x1R,x2R)
  max_XL = max(x1L,x2L)
  y1U = r1[1]
  y1D = r1[1]-r1[3]
  y2U = r2[1]
  y2D = r2[1]-r2[3]
  min_YU = min(y1U,y2U)
  max_YD = max(y1D,y2D)
  w = min_XR - max_XL
  h = min_YU - max_YD
  w = max(w,0)
  h = max(h,0)
  area = w*h
  return area
#======================================
def union(r1, r2):
  d1 = r1[2]
  h1 = r1[3]
  d2 = r2[2]
  h2 = r2[3]
  area1_2 = (d1*h1)+(d2*h2)
  area = area1_2 - intersection(r1, r2)
  return area
#======================================
def iou(r1, r2):
  iou = intersection(r1, r2) / union(r1, r2)
  return iou
#======================================

00148: HW01
bytecount: {'code': 580, 'const': 472, 'code+const': 1052}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  a = float(r[0])+float(r[2])/2
  b = float(r[1])-float(r[3])/2
  c = [a,b]
  return c
#======================================
def distance(r1, r2):
  a = center(r1)
  b = center(r2)
  l = ((float(a[0])-float(b[0]))**2+(float(a[1])-float(b[1]))**2)**0.5
  return l
#======================================
def intersection(r1, r2):
  a2 = float(r2[0])+float(r2[2])
  b2 = float(r1[0])+float(r1[2])
  a1 = float(r2[0])
  b1 = float(r1[0])
  c1 = float(r1[1])
  c2 = float(r1[1])-float(r1[3])
  n1 = float(r2[1])
  n2 = float(r2[1])-float(r2[3])
  j = min(a2,b2)-max(a1,b1)
  t = min(n1,c1)-max(c2,n2)
  p1 = min(j , float(r1[2]), float(r2[2]))
  p2 = min(t , float(r1[3]), float(r2[3]))
  m1 = max(0,p1)
  m2 = max(0,p2)
  return m1*m2
#======================================
def union(r1, r2):
  a1 = float(r1[2])*float(r1[3])
  a2 = float(r2[2])*float(r2[3])
  a3 = intersection(r1, r2)
  t = (a1+a2)-a3
  return t
#======================================
def iou(r1, r2):
  u = union(r1, r2)
  v = intersection(r1, r2)
  c = v / u
  return c
#======================================

00149: HW01
bytecount: {'code': 432, 'const': 628, 'code+const': 1060}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [(r[0]+r[0]+r[2])/2,(r[1]+r[1]-r[3])/2]
#======================================
def distance(r1, r2):
    return ((center(r1)[0]-center(r2)[0])**2+(center(r1)[1]-center(r2)[1])**2)**0.5
#======================================
def intersection(r1, r2):
    def rs(r): #พิกัด x ด้านขวาของ r
        return r[0]+r[2]
    def ls(r): #พิกัด x ด้านซ้ายของ r
        return r[0]
    def ts(r): #พิกัด y ด้านบนของ r
        return r[1]
    def bs(r): #พิกัด y ด้านล่างของ r
        return r[1] - r[3]
    wantedr = min(rs(r1),rs(r2))
    wantedl = max(ls(r1),ls(r2))
    wantedt = min(ts(r1),ts(r2))
    wantedb = max(bs(r1),bs(r2))
    width =  max(0,wantedr - wantedl) # giv me bonus pls. I'm tired :[
    height = max(0,wantedt - wantedb)
    return width*height
#======================================
def union(r1, r2):
    def area(r):
        return r[2]*r[3]
    return area(r1) + area(r2) - intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1, r2)/union(r1, r2)
#======================================

00150: HW01
bytecount: {'code': 508, 'const': 552, 'code+const': 1060}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0] + (r[2]/2)
  y = r[1] - (r[3]/2)
  return [x,y]
#======================================
def distance(r1, r2):
  x1 = r1[0] + (r1[2]/2)
  y1 = r1[1] - (r1[3]/2)
  x2 = r2[0] + (r2[2]/2)
  y2 = r2[1] - (r2[3]/2)
  return ((x1-x2)**2 + (y1-y2)**2)**(0.5)
#======================================
def intersection(r1, r2):
  x1,x2 = r1[0],r2[0]
  y1,y2 = r1[1],r2[1]
  w1,w2 = r1[2],r2[2]
  h1,h2 = r1[3],r2[3]
  xl,yl = max(x1,x2),min(y1,y2)
  xr = min(x1+w1,x2+w2)
  yr = max(y1-h1,y2-h2)
  Area = (xr-xl)*abs(yr-yl)
  answer = max(Area,0)
  return answer
#======================================
def union(r1, r2):
  x1,x2 = r1[0],r2[0]
  y1,y2 = r1[1],r2[1]
  w1,w2 = r1[2],r2[2]
  h1,h2 = r1[3],r2[3]
  I = intersection(r1, r2)
  U = ((w1*h1) + (w2*h2)) - I
  return U
#======================================
def iou(r1, r2):
  U = union(r1, r2)
  I = intersection(r1, r2)
  return (I/U)
#======================================

00151: HW01
bytecount: {'code': 644, 'const': 420, 'code+const': 1064}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]+(r[2]/2)
  y = r[1]-(r[3]/2)
  return [x, y]
#======================================
def distance(r1, r2):
    x1, y1 = center(r1)
    x2, y2 = center(r2)
    dis = (((x1-x2)**2)+((y1-y2)**2))**0.5
    return dis
#======================================
def intersection(r1, r2):
    left_top_1 = [r1[0], r1[1]]
    right_top_1 = [r1[0]+r1[2], r1[1]]
    left_bottom_1 = [r1[0], r1[1]-r1[3]]
    right_bottom_1 = [r1[0]+r1[2],  r1[1]-r1[3]]
    left_top_2 = [r2[0], r2[1]]
    right_top_2 = [r2[0]+r2[2], r2[1]]
    left_bottom_2 = [r2[0], r2[1]-r2[3]]
    right_bottom_2 = [r2[0]+r1[2],  r2[1]-r2[3]]
    ## find edge points
    left_top = [max(left_top_1[0], left_top_2[0]), min(left_top_1[1], left_top_2[1])]
    right_top = [min(right_top_1[0], right_top_2[0]), min(right_top_1[1], right_top_2[1])]
    left_bottom = [max(left_bottom_1[0], left_bottom_2[0]), max(left_bottom_1[1], left_bottom_2[1])]
    right_bottom = [min(right_bottom_1[0], right_bottom_2[0]), max(right_bottom_1[1], right_bottom_2[1])]
    width = max(0,right_top[0] - left_top[0])  #abs
    high = max(0,right_top[1] - right_bottom[1]) #abs
    area = width*high
    return  area
#======================================
def union(r1, r2):
  area_r1 = r1[2]*r1[3]
  area_r2 = r2[2]*r2[3]
  area_intersect = intersection(r1, r2)
  r1_union_r2 = area_r1+area_r2-area_intersect
  return r1_union_r2
#======================================
def iou(r1, r2):
  area_intersect = intersection(r1, r2)
  area_union = union(r1, r2)
  intersect_o_union =   area_intersect/area_union
  return intersect_o_union
#======================================

00152: HW01
bytecount: {'code': 596, 'const': 472, 'code+const': 1068}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x2 = [r[0]+r[2],r[1]-r[3]]
    half = [(x2[0]+r[0])/2,(x2[1]+r[1])/2]
    return half
#======================================
def distance(r1, r2):
    x = center(r1)
    y = center(r2)
    dis = (((x[0]-y[0])**2)+((x[1]-y[1])**2))**0.5
    return dis
#======================================
def intersection(r1, r2):
    a = [r1[0],r1[1]]
    b = [r2[0],r2[1]]
    x1 = max(a[0],b[0])
    y1 = min(a[1],b[1])
    r1low = [r1[0]+r1[2],r1[1]-r1[3]]
    r2low = [r2[0]+r2[2],r2[1]-r2[3]]
    c = [r1low[0],r1low[1]]
    d = [r2low[0],r2low[1]]
    x2 = min(c[0],d[0])
    y2 = max(c[1],d[1])
    i = max(x1,x2)
    j = min(x1,x2)
    j = max(r1[0],r2[0],j)
    k = max(y1,y2)
    k = min(k,r1[1],r2[1])
    l = min(y1,y2)
    wide = i-j
    height = k-l
    area = wide*height
    return area
#======================================
def union(r1, r2):
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    intersec = intersection(r1,r2)
    areacomb = area1+area2-intersec
    return areacomb
#======================================
def iou(r1, r2):
    x = intersection(r1,r2)
    y = union(r1,r2)
    ans = x/y
    return ans
#======================================

00153: HW01
bytecount: {'code': 596, 'const': 472, 'code+const': 1068}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x1 = float(r[0])
  y1 = float(r[1])
  w1 = float(r[2])
  h1 = float(r[3])
  cen_x = (x1) + ((w1)/2)
  cen_y = (y1) - ((h1)/2)
  return([cen_x, cen_y])
#======================================
def distance(r1, r2):
  x1,y1 = center(r1)
  x2,y2 = center(r2)
  x = float(x1) - float(x2)
  y = float(y1) - float(y2) 
  dis = float(((x**2) + (y**2))**(1/2))
  return(dis)
#======================================
def intersection(r1, r2):
  x1,y1,w1,h1 = float(r1[0]),float(r1[1]),float(r1[2]),float(r1[3])
  x2,y2,w2,h2 = float(r2[0]),float(r2[1]),float(r2[2]),float(r2[3])
  xx1 = min(x1+w1, x2+w2)
  xx2 = max(x1, x2) 
  x = xx1-xx2
  x = max(0, x)
  yy1 = max(y1-h1, y2-h2)
  yy2 = min(y1 , y2)
  y = yy2-yy1
  y = max(0, y)
  inter = x*y
  return(inter)
#======================================
def union(r1, r2):
  x1,y1,w1,h1 = float(r1[0]),float(r1[1]),float(r1[2]),float(r1[3])
  x2,y2,w2,h2 = float(r2[0]),float(r2[1]),float(r2[2]),float(r2[3])
  area_1 = w1*h1
  area_2 = w2*h2
  uni = area_1 + area_2 - intersection(r1, r2)
  return(uni)
#======================================
def iou(r1, r2):
  iu = intersection(r1, r2) / union(r1, r2)
  return(iu)    
#======================================

00154: HW01
bytecount: {'code': 544, 'const': 524, 'code+const': 1068}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x1 = r[0]
  y1 = r[1]
  x2 = r[0]+r[2]
  y2 = r[1]-r[3]
  rx = (x1+x2)/2
  ry = (y1+y2)/2
  return [rx,ry]
#======================================
def distance(r1, r2):
  d=((center(r1)[0]-center(r2)[0])**2+(center(r1)[1]-center(r2)[1])**2)**(1/2)
  return d
#======================================
def intersection(r1, r2):
  x1 = r1[0]
  y1 = r1[1]
  x2 = r1[0]+r1[2]
  y2 = r1[1]-r1[3]
  x3 = r2[0]
  y3 = r2[1]
  x4 = r2[0]+r2[2]
  y4 = r2[1]-r2[3]
  xt = max(x1, x3)
  yt = min(y1, y3)
  xb = min(x2, x4)
  yb = max(y2, y4)
  intersect = max(0,(xb - xt)) * max(0,(yt - yb))
  return intersect
#======================================
def union(r1, r2):
  x1 = r1[0]
  y1 = r1[1]
  x2 = r1[0]+r1[2]
  y2 = r1[1]-r1[3]
  x3 = r2[0]
  y3 = r2[1]
  x4 = r2[0]+r2[2]
  y4 = r2[1]-r2[3]
  a1 = (x2-x1)*(y1-y2)
  a2 = (x4-x3)*(y3-y4)
  union = (a1+a2)-intersection(r1, r2)
  return union   
#======================================
def iou(r1, r2):
  iou = intersection(r1, r2)/union(r1, r2)
  return iou    
#======================================

00155: HW01
bytecount: {'code': 604, 'const': 472, 'code+const': 1076}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=float(r[0])
  y=float(r[1])
  w=float(r[2])
  h=float(r[3])
  a=x+w/2
  b=y-h/2
  return [a,b]
#======================================
def distance(r1, r2):
  c=center(r1)
  d=center(r2)
  e=float(c[0])
  f=float(c[1])
  g=float(d[0])
  h=float(d[1])
  s=((e-g)**2+(f-h)**2)**0.5
  return s
#======================================
def intersection(r1, r2):
  right1=float(float(r1[0])+float(r1[2]))
  left1=float(r1[0])
  top1=float(r1[1])
  bottom1=float(float(r1[1])-float(r1[3]))
  right2=float(float(r2[0])+float(r2[2]))
  left2=float(r2[0])
  top2=float(r2[1])
  bottom2=float(float(r2[1])-float(r2[3]))
  a=float(min(right1,right2))
  b=float(max(left1,left2))
  w=float(max(a-b,0))
  c=float(min(top1,top2))
  d=float(max(bottom1,bottom2))
  h=float(max(c-d,0))
  return w*h
#======================================
def union(r1, r2):
  a=abs(float(r1[2])*float(r1[3]))
  b=abs(float(r2[2])*float(r2[3]))
  c=float(intersection(r1,r2))
  return a+b-c
#======================================
def iou(r1, r2):
  a=intersection(r1,r2)
  b=union(r1,r2)
  return a/b
#======================================

00156: HW01
bytecount: {'code': 588, 'const': 496, 'code+const': 1084}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    X = [(r[0]*2+r[2])/2,(r[1]*2-r[3])/2]
    return X
#======================================
def distance(R1, R2):
    x1 = center(R1)[0]
    x2 = center(R2)[0]
    y1 = center(R1)[1] 
    y2 = center(R2)[1] 
    d = (((x1-x2)**2)+((y1-y2)**2))**0.5
    return d
#======================================
def intersection(R1, R2):
    Ax = sorted([R1[0],R1[2]+R1[0],R2[0],R2[2]+R2[0]])
    Ay = sorted([R1[1],R1[1]-R1[3],R2[1],R2[1]-R2[3]])
    xd = (Ax[2]-Ax[1])  
    yd = (Ay[2]-Ay[1])
    Xt = min(1,((Ax[3]-Ax[0])/((1e-10)+abs((R1[0]+R1[2])-(R2[0]+R2[2]))+abs(R1[0]-R2[0])))//1)
    Yt = min(1,((Ay[3]-Ay[0])/((1e-10)+abs((R1[1]-R1[3])-(R2[1]-R2[3]))+abs(R1[1]-R2[1])))//1)
    I = (xd*yd)*(Xt*Yt)
    return I
#======================================
def union(R1, R2):
    A1 = R1[2]*R1[3]
    A2 = R2[2]*R2[3]
    U = A1+A2-intersection(R1, R2) 
    return U
#======================================
def iou(R1, R2):
    IOU = intersection(R1, R2)/union(R1, R2)
    return IOU
#======================================

00157: HW01
bytecount: {'code': 616, 'const': 472, 'code+const': 1088}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
 return [r[0]+(r[2]/2),r[1]-(r[3]/2)]
#======================================
def distance(r1, r2):
 mx1 = center(r1)[0]
 my1 = center(r1)[1]
 mx2 = center(r2)[0]
 my2 = center(r2)[1]
 dis = ((mx1-mx2)**2+(my1-my2)**2)**(1/2)
 return dis
#======================================
def intersection(r1, r2):
 cxn = int(r2[0]+r2[2]>r1[0]+r1[2])
 cxl = int(r1[0]<r2[0])
 yawruam = ((r2[0]+r2[2])*(cxn)-(r1[0]+r1[2])*(cxn-1))-(r1[0]*cxl-(r2[0]*(cxl-1)))
 interx = - yawruam + r1[2] + r2[2]
 cyb = int(r2[1]>r1[1])
 cyl = int(r2[1]-r2[3]<r1[1]-r1[3])
 soongruam = (r2[1]*cyb - r1[1]*(cyb-1)) - ((r2[1]-r2[3])*cyl - (r1[1]-r1[3])*(cyl-1))
 intery = - soongruam + r1[3] + r2[3]
 cbnx = int(yawruam < (r1[2] + r2[2]))
 cbny = int(soongruam < (r1[3] + r2[3]))
 cbn = (cbnx)*(cbny)
 return (interx*intery*cbn)+1-1
#======================================
def union(r1, r2):
 return (r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1, r2))
#======================================
def iou(r1, r2):
 return intersection(r1, r2)/union(r1, r2)

00158: HW01
bytecount: {'code': 624, 'const': 472, 'code+const': 1096}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x=(float(r[2])/2)+float(r[0])
  y=float(r[1])-float(r[3])/2
  center=[x,y]
  return center
#======================================
def distance(r1, r2):
    dx=abs(float(center(r1)[0])-float(center(r2)[0]))
    dy=abs(float(center(r1)[1])-float(center(r2)[1]))
    distance=((dx**2)+(dy**2))**(1/2)
    return distance
#======================================
def intersection(r1,r2): 
    y1=float(r1[1])
    y2=float(r2[1])
    h1=float(r1[3])
    h2=float(r2[3])
    r1_y_edge=[y1,y1-h1]
    r2_y_edge=[y2,y2-h2]
    all_ry=[y1,y1-h1,y2,y2-h2]
    intersect_y=max(all_ry)-min(all_ry)-abs(min(r1_y_edge)-min(r2_y_edge))-abs(max(r1_y_edge)-max(r2_y_edge))
    x1=float(r1[0])
    x2=float(r2[0])
    w1=float(r1[2])
    w2=float(r2[2])
    r1_x_edge=[x1,x1+w1]
    r2_x_edge=[x2,x2+w2]
    all_rx=[x1,x1+w1,x2,x2+w2]
    intersect_x=max(all_rx)-min(all_rx)-abs(min(r1_x_edge)-min(r2_x_edge))-abs(max(r1_x_edge)-max(r2_x_edge))
    make_sure_intersectx=max(intersect_x,0)
    make_sure_intersecty=max(intersect_y,0)
    return make_sure_intersecty*make_sure_intersectx
#======================================
def union(r1, r2):
    A1=r1[2]*r1[3]
    A2=r2[2]*r2[3]
    union=A1+A2-intersection(r1,r2)
    return union
#======================================
def iou(r1, r2):
    iou=intersection(r1,r2)/union(r1,r2)
    return iou
#======================================

00159: HW01
bytecount: {'code': 616, 'const': 496, 'code+const': 1112}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] + (r[2]/2)
    y = r[1] - (r[3]/2)
    return [x, y]
#======================================
def distance(r1, r2):
    m1 = center(r1)
    m2 = center(r2)
    del_y = abs(m1[1] - m2[1])
    del_x = abs(m1[0] - m2[0])
    dist = (del_y**2 + del_x**2)**(1/2)
    return dist
#======================================
def intersection(r1, r2):
    ybot_corn = [r1[1]-r1[3],r2[1]-r2[3]]
    xbot_corn = [r1[0],r2[0]]
    ytop_corn = [r1[1],r2[1]]
    xtop_corn = [r1[0]+r1[2],r2[0]+r2[2]]
    ybot_max = max(ybot_corn)
    xbot_max = max(xbot_corn)
    ytop_min = min(ytop_corn)
    xtop_min = min(xtop_corn)
    x_dif = abs(xtop_min - xbot_max)
    y_dif = abs(ytop_min - ybot_max)
    x_chck = [r1[0]+r1[2],r2[0]]
    chck = x_chck[1] - (x_chck[0]) + (1/10000000)**(r1[3] / r1[2])
    nchk = chck / abs(chck)
    var_chck = (1 - nchk)/2
    x_chck2 = [r2[0]+r2[2],r1[0]]
    chck2 = x_chck2[1] - (x_chck2[0]) + (1/10000000)**(r2[3] / r2[2])
    nchk2 = chck2 / abs(chck2)
    var_chck2 = (1 - nchk2)/2
    insec_a = x_dif*y_dif*var_chck*var_chck2
    return insec_a
#======================================
def union(r1, r2):
    insec = intersection(r1, r2)
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    un_area = area1 + area2 - insec
    return un_area
#======================================
def iou(r1, r2):
    un_area = union(r1, r2)
    sec_area = intersection(r1, r2)
    ratio = sec_area / un_area
    return ratio
#======================================

00160: HW01
bytecount: {'code': 644, 'const': 472, 'code+const': 1116}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  kx=(r[0]+r[2]+r[0])/2
  ky=(r[1]-r[3]+r[1])/2
  k=[kx,ky]
  return k
#======================================
def distance(r1, r2):
  r1=center(r1)
  r2=center(r2)
  r1=[float(r1[0]),float(r1[1])]
  r2=[float(r2[0]),float(r2[1])]
  d=((r1[0]-r2[0])**2+(r1[1]-r2[1])**2)**0.5
  return d
#======================================
def intersection(r1, r2):
  w=max((max(r1[0]+r1[2],r2[0]+r2[2])-min(r1[0],r2[0]))-(max(r1[0],r2[0])-min(r1[0],r2[0]))-(max(r1[0]+r1[2],r2[0]+r2[2])-min(r1[0]+r1[2],r2[0]+r2[2])),0)
  h=max((max(r1[1],r2[1])-min(r1[1]-r1[3],r2[1]-r2[3]))-(max(r1[1]-r1[3],r2[1]-r2[3])-min(r1[1]-r1[3],r2[1]-r2[3]))-(max(r1[1],r2[1])-min(r1[1],r2[1])),0)
  a=w*h
  return a    
#======================================
def union(r1, r2):
  a1=r1[2]*r1[3]+r2[2]*r2[3]-intersection(r1, r2)
  return a1
#======================================
def iou(r1, r2):
  x=intersection(r1, r2)/union(r1, r2)
  return x
#======================================

00161: HW01
bytecount: {'code': 648, 'const': 472, 'code+const': 1120}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = r[0]+r[2]/2
  y = r[1]-r[3]/2
  return [x, y]
#======================================
def distance(r1, r2):
  d = ((center(r1)[0] - center(r2)[0])**2 + (center(r1)[1] - center(r2)[1])**2)**0.5
  return d
#======================================
def intersection(r1, r2):
  xmax = max(float(r1[0]), float(r1[0])+float(r1[2]), float(r2[0]), float(r2[0])+float(r2[2]))
  xmin = min(float(r1[0]), float(r1[0])+float(r1[2]), float(r2[0]), float(r2[0])+float(r2[2]))
  width = xmax - xmin
  sumx = float(r1[2]) + float(r2[2])
  widthx = min(width, sumx)
  x = sumx - widthx
  ymax = max(float(r1[1]), float(r1[1])-float(r1[3]), float(r2[1]), float(r2[1])-float(r2[3]))
  ymin = min(float(r1[1]), float(r1[1])-float(r1[3]), float(r2[1]), float(r2[1])-float(r2[3]))
  height = ymax - ymin
  sumy = float(r1[3]) + float(r2[3])
  heighty = min(sumy, height)
  y = sumy - heighty
  A = x*y
  return A
#======================================
def union(r1, r2):
  A = (float(r1[2])*float(r1[3])) + (float(r2[2])*float(r2[3])) - intersection(r1, r2)
  return A
#======================================
def iou(r1, r2):
  A = intersection(r1, r2)/union(r1, r2)
  return A
#======================================

00162: HW01
bytecount: {'code': 626, 'const': 496, 'code+const': 1122}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = [float(e) for e in r]
    a = x[0] + (x[2]/2)
    b = x[1] - (x[3]/2)  
    c = [a, b]
    return c
#======================================
def distance(r1, r2):
    x1 = [float(e) for e in center(r1)]
    x2 = [float(e) for e in center(r2)]
    d = (((x1[0]-x2[0])**2) + ((x1[1]-x2[1])**2))**(1/2)
    return d
#======================================
def intersection(r1, r2):
    p1 = [float(e) for e in r1]
    p2 = [float(e) for e in r2]
    x = max(p1[0], p2[0])
    x1 = min(p1[0]+p1[2], p2[0]+p2[2])
    xl = max(x1-x, 0.0)
    y = min(p1[1], p2[1])
    y1 = max(p1[1]-p1[3], p2[1]-p2[3])
    yl = max(y-y1, 0.0)
    ai = xl*yl
    return ai
#======================================
def union(r1, r2):
    p1 = [float(e) for e in r1]
    p2 = [float(e) for e in r2]
    a1 = p1[2]*p1[3]
    a2 = p2[2]*p2[3]
    u = a1 + a2 - intersection(r1, r2)
    return u
#======================================
def iou(r1, r2):
    ii = intersection(r1, r2) / union(r1, r2)
    return ii
#======================================

00163: HW01
bytecount: {'code': 592, 'const': 548, 'code+const': 1140}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0]
    y = r[1]
    w = r[2]
    h = r[3]
    x1 = x+w
    y1 = y-h
    a = (x+x1)/2
    b = (y+y1)/2
    return [a,b]
#======================================
def distance(r1, r2):
    R1 = center(r1)
    R2 = center(r2)
    d = (((R1[0]-R2[0])**2)+((R1[1]-R2[1])**2))**0.5
    return d    
#======================================
def intersection(r1, r2):
    x1 = r1[0]
    y1 = r1[1]
    w1 = r1[2]
    h1 = r1[3]
    x2 = r2[0]
    y2 = r2[1]
    w2 = r2[2]
    h2 = r2[3]
    x = [x1,x1+w1,x2,x2+w2]
    y = [y1,y1-h1,y2,y2-h2]
    w = [w1,w2]
    h = [h1,h2]
    secw = abs(min(w))-(abs(max(x)-min(x))-abs(max(w)))
    sech = abs(min(h))-(abs(max(y)-min(y))-abs(max(h)))
    ch1 = [0,secw]
    ch2 = [0,sech]
    A = max(ch1)*max(ch2)
    check = [0.0,A]
    return max(check)
#======================================
def union(r1, r2):
    x1 = r1[0]
    y1 = r1[1]
    w1 = abs(r1[2])
    h1 = abs(r1[3])
    x2 = r2[0]
    y2 = r2[1]
    w2 = abs(r2[2])
    h2 = abs(r2[3])
    sum_area = ((w1*h1)+(w2*h2))-intersection(r1,r2)
    return sum_area     
#======================================
def iou(r1, r2):
    ra = intersection(r1,r2)/union(r1,r2)
    return ra
#======================================

00164: HW01
bytecount: {'code': 670, 'const': 472, 'code+const': 1142}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0]
    y = r[1]
    w = r[2]
    h = r[3]
    xr = x+(w/2)
    yr = y-(h/2)
    ct = [xr,yr]
    return ct
def distance(r1, r2):
    ct1 = center(r1)
    ct2 = center(r2)
    x = abs(float(ct1[0])-float(ct2[0]))
    y = abs(float(ct1[1])-float(ct2[1]))
    dt = ((x**2)+(y**2))**0.5
    return dt
def intersection(r1, r2):
    dxmax = abs((r1[0]+r1[2])-(r2[0]+r2[2]))
    dxmin = abs((r1[0])-(r2[0]))
    dxall = max(r1[0],(r1[0]+r1[2]),r2[0],(r2[0]+r2[2]))              - min(r1[0],(r1[0]+r1[2]),r2[0],(r2[0]+r2[2]))
    xits = dxall-dxmax-dxmin
    w = max(0,xits)
    dymax = abs(r1[1]-r2[1])
    dymin = abs((r1[1]-r1[3])-(r2[1]-r2[3]))
    dyall = max(r1[1],(r1[1]-r1[3]),r2[1],(r2[1]-r2[3]))              - min(r1[1],(r1[1]-r1[3]),r2[1],(r2[1]-r2[3]))
    h = dyall-dymax-dymin
    area = w*h
    return area
def union(r1, r2):
    ar1 = float(r1[2])*float(r1[3])
    ar2 = float(r2[2])*float(r2[3])
    its = intersection(r1, r2)
    un = ar1+ar2-its
    return un
def iou(r1, r2):
    n1 = intersection(r1, r2)
    n2 = union(r1, r2)
    io = n1/n2
    return io

00165: HW01
bytecount: {'code': 550, 'const': 604, 'code+const': 1154}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [(r[0]+(r[0]+r[2]))/2, ((r[1]-r[-1])+r[1])/2]
#======================================
def distance(r1, r2):
    r1 = center(r1)
    r2 = center(r2)
    return pow((r1[0]-r2[0])**2 + (r1[1]-r2[1])**2, 1/2)
#======================================
def intersection(r1, r2):
    r1 = [r1[0], r1[1]-r1[-1], r1[0]+r1[2], r1[1]]
    r2 = [r2[0], r2[1]-r2[-1], r2[0]+r2[2], r2[1]]
    x = max(min(r1[2], r2[2]) - max(r1[0], r2[0]), 0.0)
    y = max(min(r1[3], r2[3]) - max(r1[1], r2[1]), 0.0)
    return x*y
#======================================
def union(r1, r2):
    intersect_area = intersection(r1, r2)
    r1 = [r1[0], r1[1]-r1[-1], r1[0]+r1[2], r1[1]]
    r2 = [r2[0], r2[1]-r2[-1], r2[0]+r2[2], r2[1]]
    area_r1 = (r1[2] - r1[0]) * (r1[3] - r1[1])
    area_r2 = (r2[2] - r2[0]) * (r2[3] - r2[1])
    return (area_r1 + area_r2) - intersect_area
#======================================
def iou(r1, r2):
    return intersection(r1, r2) / union(r1, r2)
#======================================
# r1=[1.0, 4.0, 1.5, 2.0]
# r2=[2.0, 5.0, 2.5, 2.0]
# r3=[4.0, 5.5, 1.5, 3.5]
# r4=[6.0, 4.5, 1.5, 2.0]
# r5=[5.75, 7.0, 2.0, 5.0]
# print(center(r1))
# print(center(r2))
# print(round(distance(r1,r2),2))
# print(round(distance(r3,r4),2))
# print(intersection(r1,r2)) 
# print(intersection(r2,r3))
# print(intersection(r4,r5))
# print(intersection(r1,r5)) # กรณีโบนัส
# print(union(r1,r2))
# print(union(r2,r3))
# print(union(r4,r5))
# print(union(r1,r5)) # bonus
# print(round(iou(r1,r2),2))
# print(round(iou(r2,r3),2))
# print(round(iou(r4,r5),2))
# """
# OUTPUT
# [1.75, 3.0]
# [3.25, 4.0]
# 1.8
# 2.02
# 0.5
# 1.0
# 3.0
# 0.0
# 7.5
# 9.25
# 10.0
# 0.07
# 0.11
# 0.3
# EXPECT
# [1.75, 3.0]
# [3.25, 4.0]
# 1.8
# 2.02
# 0.5
# 1.0
# 3.0
# 0.0 # กรณีโบนัส
# 7.5
# 9.25
# 10.0
# 0.07
# 0.11
# 0.3
# """

00166: HW01
bytecount: {'code': 666, 'const': 496, 'code+const': 1162}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    c=[0,1]
    c[0]=r[0]+(r[2]/2)
    c[1]=r[1]-(r[3]/2)
    return c
#======================================
def distance(r1, r2):
    c1,c2=center(r1),center(r2)
    return (((c2[0]-c1[0])**2)+((c2[1]-c1[1])**2))**0.5
#======================================
def intersection(r1, r2):
    new_corner1=[max(r1[0],r2[0]),min(r1[1],r2[1])]
    new_corner2=[min(r1[0]+r1[2],r2[0]+r2[2]),max(r1[1]-r1[3],r2[1]-r2[3])]
    c1=center(r1)
    c2=center(r2)
    #c2[0]>r1[0]-(r2[2]/2)
    joint_x_min=min(round(min(max(c2[0]-(r1[0]-(r2[2]/2)),0),1)+0.5),1)
    #c2[0]<r1[0]+r1[2]+(r2[2]/2)
    joint_x_max=min(round(min(max((r1[0]+r1[2]+(r2[2]/2))-c2[0],0),1)+0.5),1)
    #c2[1]>r1[1]-r1[3]-(r2[3]/2)
    joint_y_min=min(round(min(max(c2[1]-(r1[1]-r1[3]-(r2[3]/2)),0),1)+0.5),1)
    #c2[1]<r1[1]+(r2[3]/2)
    joint_y_max=min(round(min(max((r1[1]+(r2[3]/2))-c2[1],0),1)+0.5),1)
    joint_index=joint_x_min*joint_x_max*joint_y_min*joint_y_max
    return abs(new_corner1[0]-new_corner2[0])*abs(new_corner1[1]-new_corner2[1])*joint_index
#======================================
def union(r1, r2):
    area_r1=r1[2]*r1[3]
    area_r2=r2[2]*r2[3]
    return area_r1+area_r2-intersection(r1,r2)
#======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
#======================================

00167: HW01
bytecount: {'code': 636, 'const': 548, 'code+const': 1184}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    center_x = [(r[2]/2)+r[0]]
    center_y = [r[1]-(r[3]/2)]
    center_xy = center_x + center_y
    return center_xy
#======================================
def distance(r1, r2):
    point_r1 = center(r1)
    point_r2 = center(r2)
    distance = ((point_r2[0]-point_r1[0])**2 + (point_r2[1]-point_r1[1])**2)**0.5
    return distance
#======================================
def intersection(r1, r2):
    top_1 = [r1[0]+r1[2],r1[1]]
    top_2 = [r2[0]+r2[2],r2[1]]
    bottom_1 = [r1[0],r1[1]-r1[3]]
    bottom_2 = [r2[0],r2[1]-r2[3]]
    x_min = min(top_1[0],top_2[0])
    y_min = min(top_1[1],top_2[1])
    x_max = max(bottom_1[0],bottom_2[0])
    y_max = max(bottom_1[1],bottom_2[1])
    x_axis = x_min - x_max
    y_axis = y_min - y_max
    intersec = [0.0,abs(x_axis*y_axis)][x_axis > 0 and y_axis > 0]
    return intersec
#======================================
def union(r1, r2):
    top_1 = [r1[0],r1[1]]
    top_2 = [r2[0],r2[1]]
    bottom_1 = [r1[0]+r1[2],r1[1]-r1[3]]
    bottom_2 = [r2[0]+r2[2],r2[1]-r2[3]]
    r1_x = abs(top_1[0]-bottom_1[0])
    r1_y = abs(top_1[1]-bottom_1[1])
    r2_x = abs(top_2[0]-bottom_2[0])
    r2_y = abs(top_2[1]-bottom_2[1])
    area_1 = r1_x*r1_y
    area_2 = r2_x*r2_y
    union_12 = (area_1 + area_2) - intersection(r1, r2)
    return union_12
#======================================
def iou(r1, r2):
    iou_12 = intersection(r1, r2) / union(r1, r2)
    return iou_12

00168: HW01
bytecount: {'code': 716, 'const': 472, 'code+const': 1188}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
import math
def center(r):
 x = r[0]
 y = r[1]
 w = r[2]
 h = r[3]
 r = [x+w/2, y-h/2]
 return r
#======================================
def distance(r1, r2):
  pos1 = center(r1)
  pos2 = center(r2)
  diffX = math.pow(pos1[0]-pos2[0],2)
  diffY = math.pow(pos1[1]-pos2[1],2)
  dis = math.sqrt(diffX + diffY)
  return dis
#======================================
def intersection(r1, r2):
  posr1 = [r1[0]+r1[2], r1[1]-r1[3] ] #มุมขวาล่างสี่เหลี่ยมแรก 
  posr1_1 = [r1[0], r1[1]-r1[3] ] #มุมซ้ายล่างสี่เหลี่ยมแรก
  posr1_2 = [r1[0]+r1[2], r1[1] ] #มุมขวาบนสี่เหลี่ยมแรก 
  posr2 = [r2[0]+r2[2], r2[1]-r2[3] ] #มุมขวาล่างสี่เหลี่ยมสอง
  posr2_1 = [r2[0], r2[1]-r2[3] ] #มุมซ้ายล่างสี่เหลี่ยมสอง
  posr2_2 = [r2[0]+r2[2], r2[1] ] #มุมขวาบนสี่เหลี่ยมสอง
  tL = [max(r1[0],r2[0]), min(r1[1],r2[1])]
  bL = [max(posr1_1[0],posr2_1[0]), max(posr1_1[1],posr2_1[1])]
  tR = [min(posr1_2[0],posr2_2[0]), min(posr1_2[1],posr2_2[1])]
  bR = [min(posr1[0],posr2[0]), max(posr1[1],posr2[1])]  
  TF = r2[0]<posr1[0] and r2[1]>posr1[1] and r1[0]<posr2[0] and r1[1]>posr2[1] #check ซ้อนทับ
  area1 = abs((tL[1]-bL[1]))*abs((tR[0]-tL[0])) * TF
  return area1
#======================================
def union(r1, r2):
  area1 = r1[2]*r1[3]
  area2 = r2[2]*r2[3]
  areaintersec = intersection(r1,r2)
  areaReal = area1+area2-areaintersec
  return areaReal
#======================================
def iou(r1, r2):
  areaintersec = intersection(r1,r2)
  areaU = union(r1,r2)
  ratio = areaintersec/areaU
  return ratio
#======================================

00169: HW01
bytecount: {'code': 568, 'const': 640, 'code+const': 1208}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x_center = r[0] + r[2]/2
  y_center = r[1] - r[3]/2
  return [x_center,y_center]
#======================================
def distance(r1, r2):
  a = center(r1)
  b = center(r2)
  l = ((a[0]-b[0])**2+(a[1]-b[1])**2)**0.5
  return l
#======================================
def intersection(r1, r2):
  rec_x_right = max(r1[0], r2[0])
  rec_y_down = min(r1[1], r2[1])
  rec_x_plus_w_left = min(r1[0] + r1[2], r2[0] + r2[2])
  rec_y_minus_h_up = max(r1[1] - r1[3], r2[1] - r2[3])
  area = abs(rec_x_right - rec_x_plus_w_left) * abs(rec_y_down - rec_y_minus_h_up)
  rec_right = max(r1, r2)
  rec_left = min(r1, r2) 
  c1 = min([0,0,0,0,0,0], [rec_right[0] - (rec_left[0]+rec_left[2]),area,r1[1],r1[3],r2[1],r2[3]])
  rec_up = max([c1[2],c1[3]], [c1[4],c1[5]])
  rec_down = min([c1[2],c1[3]], [c1[4],c1[5]])
  c2 = min([0.0,0.0], [rec_up[0] - rec_up[1] - rec_down[0],c1[1]])
  return  c2[1]
#======================================
def union(r1, r2):
  area = (r1[2]*r1[3]) + (r2[2]*r2[3]) - intersection(r1,r2)
  return area
#======================================
def iou(r1, r2):
  ratio = intersection(r1,r2)/union(r1,r2)
  return ratio
#======================================

00170: HW01
bytecount: {'code': 630, 'const': 584, 'code+const': 1214}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    xcen = r[0] + r[2]/2
    ycen = r[1] - r[3]/2
    return [xcen, ycen]
#===============================================================#
def distance(r1, r2):
    x1, y1 = center(r1)
    x2, y2 = center(r2)
    return ((x1-x2)**2 + (y1-y2)**2)**(1/2)
#===============================================================#
def who_first(r1, r2):
    r_one = max(r1, r2)
    r_two = min(r1, r2)
    return r_one, r_two
#===============================================================#
def who_top(r1, r2):
    r1[0], r1[1] = r1[1], r1[0]
    r2[0], r2[1] = r2[1], r2[0]
    ry_one = max(r1, r2)
    ry_two = min(r1, r2)
    ry_one[0], ry_one[1] = ry_one[1], ry_one[0]
    ry_two[0], ry_two[1] = ry_two[1], ry_two[0]
    return ry_one, ry_two
#===============================================================#
def X_defer(r1, r2):
    r_1, r_2 = who_first(r1, r2)
    rX_two = r_2[0]+r_2[2]
    defer_x = max(0.0, rX_two-r_1[0])
    forX_squ = min(defer_x, r_1[2], r_2[2])
    return forX_squ
#===============================================================#
def Y_defer(r1, r2):
    r_1, r_2 = who_top(r1, r2)
    rY_one = r_1[1]-r_1[3]
    defer_squ = max(0.0, r_2[1]-rY_one)
    forY_squ = min(defer_squ, r_1[3], r_2[3])
    return forY_squ
#===============================================================#
def intersection(r1,r2):
    x = X_defer(r1,r2)
    y = Y_defer(r1,r2)
    sum = x*y
    return sum
#===============================================================#
def union(r1,r2):
    area3 = intersection(r1,r2)
    area1 = r1[2]*r1[3]
    area2 = r2[2]*r2[3]
    sum = (area1 + area2)-area3
    return sum
#===============================================================#
def iou(r1,r2):
    full_area = union(r1,r2)
    inter_area = intersection(r1,r2)
    sum = inter_area/full_area
    return sum
#===============================================================#

00171: HW01
bytecount: {'code': 686, 'const': 540, 'code+const': 1226}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  centerx=(r[0]+r[2]/2)
  centery=(r[1]-r[3]/2)
  c=[centerx,centery]
  return c
#======================================
def distance(r1, r2):
    a=center(r1)
    b=center(r2)
    d=((a[0]-b[0])**2+(a[1]-b[1])**2)**0.5
    return d
#======================================
def point(r):
    p1=r[0],r[1]
    p2=r[0]+r[2],r[1]
    p3=r[0],r[1]-r[3]
    p4=r[0]+r[2],r[1]-r[3]
    x1=r[0]
    x2=r[0]+r[2]
    x3=r[0]
    x4=r[0]+r[2]
    y1=r[1]
    y2=r[1]
    y3=r[1]-r[3]
    y4=r[1]-r[3]
    xd=[x1,x2]
    yd=[y1,y3]
    pd=[p1,p2,p3,p4]
    return xd,yd,pd
def intersection(r1, r2):
    a=point(r1)
    b=point(r2)
    x1l=a[0][0]
    x1r=a[0][1]
    x2l=b[0][0]
    x2r=b[0][1]
    xl=max(x1l,x2l)
    xr=min(x1r,x2r)
    w=max(xr-xl,0)
    h1t=a[1][0]
    h1b=a[1][1]
    h2t=b[1][0]
    h2b=b[1][1]
    ht=min(h1t,h2t)
    hb=max(h1b,h2b)
    h=max(ht-hb,0)
    return w*h
#======================================
def union(r1, r2):
    a1=r1[2]*r1[3]
    a2=r2[2]*r2[3]
    alla=a1+a2
    u=alla-intersection(r1, r2)
    return u
#======================================
def iou(r1, r2):
    i=intersection(r1, r2)/union(r1, r2)
    return i
#======================================

00172: HW01
bytecount: {'code': 742, 'const': 576, 'code+const': 1318}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none


00173: HW01
bytecount: {'code': 684, 'const': 660, 'code+const': 1344}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x,y = ((2*r[0])+r[2])/2, ((2*r[1])-r[3])/2
  return [x,y]
def distance(r1, r2):
  a,b = ((2*r1[0])+r1[2])/2, ((2*r1[1])-r1[3])/2
  c,d = ((2*r2[0])+r2[2])/2, ((2*r2[1])-r2[3])/2
  s,t = (c-a)**2, (b-d)**2
  dt = (s+t)**(1/2)
  return dt
def intersection(r1, r2):
  w = max(min((r1[0]+r1[2]),(r2[0]+r2[2])) - max(r1[0],r2[0]),0)
  h = max(min(r1[1],r2[1]) - max((r1[1]-r1[3]),(r2[1]-r2[3])),0)
  ints = abs(w*h)  
  return ints
def union(r1, r2):
  at = (r1[2]*r1[3]) + (r2[2]*r2[3])
  w = min((r1[0]+r1[2]),(r2[0]+r2[2])) - max(r1[0],r2[0])
  h = min(r1[1],r2[1]) - max((r1[1]-r1[3]),(r2[1]-r2[3]))
  ints = w*h
  uni = at-ints
  return uni
def iou(r1, r2):
  ints = (min((r1[0]+r1[2]),(r2[0]+r2[2])) - max(r1[0],r2[0])) * (min(r1[1],r2[1]) - max((r1[1]-r1[3]),(r2[1]-r2[3])))
  uni = (r1[2]*r1[3]) + (r2[2]*r2[3]) - ints
  i_u = ints/uni
  return i_u

00174: HW01
bytecount: {'code': 732, 'const': 660, 'code+const': 1392}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = r[0] + r[2]/2
    y = r[1] - r[3]/2
    return [x, y]
#======================================
def distance(r1, r2):
    x1 = r1[0] + r1[2]/2
    y1 = r1[1] - r1[3]/2
    x2 = r2[0] + r2[2]/2
    y2 = r2[1] - r2[3]/2
    d = (((x1 - x2))**2 + (((y1 - y2)))**2)**(1/2)
    return d
#======================================
def intersection(r1, r2):
    w1 = max(r1[0], r2[0])
    w2 = min(r1[0] + r1[2], r2[0] + r2[2])
    w = max(0, w2 - w1)
    l1 = min(r1[1], r2[1])
    l2 = max(r1[1] - r1[3], r2[1] - r2[3])
    l = max(0, l1 - l2)
    itsc = w*l
    return itsc
#======================================
def union(r1, r2):
    a1 = r1[2] * r1[3]
    a2 = r2[2] * r2[3]
    w1 = max(r1[0], r2[0])
    w2 = min(r1[0] + r1[2], r2[0] + r2[2])
    w = max(0, w2 - w1)
    l1 = min(r1[1], r2[1])
    l2 = max(r1[1] - r1[3], r2[1] - r2[3])
    l = max(0, l1 - l2)
    itsc = w*l
    u = a1 + a2 - itsc
    return u
#======================================
def iou(r1, r2):
    a1 = r1[2] * r1[3]
    a2 = r2[2] * r2[3]
    w1 = max(r1[0], r2[0])
    w2 = min(r1[0] + r1[2], r2[0] + r2[2])
    w = max(0, w2 - w1)
    l1 = min(r1[1], r2[1])
    l2 = max(r1[1] - r1[3], r2[1] - r2[3])
    l = max(0, l1 - l2)
    itsc = w*l
    u = a1 + a2 - itsc
    i = itsc/u
    return i
#======================================

00175: HW01
bytecount: {'code': 956, 'const': 500, 'code+const': 1456}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = (float(r[2])/2)+float(r[0])
  y = (float(r[1])-(float(r[3])/2))
  return [x,y]
#======================================
def distance(r1, r2):
  x1 = (float(r1[2])/2)+float(r1[0])
  x2 = (float(r2[2])/2)+float(r2[0])
  y1 = (float(r1[1])-(float(r1[3])/2))
  y2 = (float(r2[1])-(float(r2[3])/2))
  d = ( (x2-x1)**2 + (y2-y1)**2 )**(1/2)
  return d
#======================================
def intersection(r1, r2):
  core_x = [float(r1[0]),float(r1[0])+float(r1[2]),float(r2[0]),float(r2[0])+float(r2[2])]
  core_xmax = float(max(core_x))
  core_xmin = float(min(core_x))
  x1max = max(float(r1[0]),float(r1[0])+float(r1[2]))
  x1min = min(float(r1[0]),float(r1[0])+float(r1[2]))
  x2max = max(float(r2[0]),float(r2[0])+float(r2[2]))
  x2min = min(float(r2[0]),float(r2[0])+float(r2[2]))
  w1 = abs(core_xmax-core_xmin)-abs(x2max-x1max)-abs(x2min-x1min)
  w = max(w1,0)
  core_y = [float(r1[1]),float(r1[1])-float(r1[3]),float(r2[1]),float(r2[1])-float(r2[3])]
  core_ymax = float(max(core_y)) #5
  core_ymin = float(min(core_y))  #2
  y1max = max(float(r1[1]),float(r1[1])-float(r1[3])) #4
  y1min = min(float(r1[1]),float(r1[1])-float(r1[3]))  #2
  y2max = max(float(r2[1]),float(r2[1])-float(r2[3]))   #5
  y2min = min(float(r2[1]),float(r2[1])-float(r2[3]))   #3
  h1 = abs(core_ymax-core_ymin)-abs(y2max-y1max)-abs(y2min-y1min)
  h = max(h1,0)
  return w*h
#======================================
def union(r1, r2):
  area_r1 = float(r1[2])*float(r1[3])
  area_r2 = float(r2[2])*float(r2[3])
  r1_r2 = intersection(r1,r2)
  r1Ur2 = (area_r1+area_r2)-(r1_r2)
  return r1Ur2
#======================================
def iou(r1, r2):
  tub = intersection(r1,r2)
  krob = union(r1,r2)
  ratio = tub/krob
  return ratio
#======================================

00176: HW01
bytecount: {'code': 808, 'const': 660, 'code+const': 1468}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    e = []
    x = r[0] + (r[2]/2)
    y = r[1]-r[3] + (r[3]/2)
    e.append(x)
    e.append(y)
    return e
#======================================
def distance(r1, r2):
    x1 = r1[0] + (r1[2]/2)
    y1 = r1[1]-r1[3] + (r1[3]/2)
    x2 = r2[0] + (r2[2]/2)
    y2 = r2[1]-r2[3] + (r2[3]/2)
    d = (((x2-x1)**2)+((y2-y1)**2))**0.5
    return d
#======================================
def intersection(r1, r2):
    x1 = r1[0]
    W1 = r1[2]
    x2 = r2[0]
    W2 = r2[2]
    y1 = r1[1]
    y2 = r2[1]
    H1 = r1[3]
    H2 = r2[3]
    a1 = min(x1+W1, x2+W2)
    b1 = max(x1, x2)
    c1 = min(y2, y1)
    d1 = max(y1-H1, y2-H2)
    width = a1 - b1
    height = c1 -d1
    width = abs(width)+ width and width
    return width*height
#======================================
def union(r1, r2):
    Area1 = r1[2] * r1[3]
    Area2 = r2[2] * r2[3]
    x1 = r1[0]
    W1 = r1[2]
    x2 = r2[0]
    W2 = r2[2]
    y1 = r1[1]
    y2 = r2[1]
    H1 = r1[3]
    H2 = r2[3]
    a1 = min(x1+W1, x2+W2)
    b1 = max(x1, x2)
    c1 = min(y2, y1)
    d1 = max(y1-H1, y2-H2)
    length_x3 = a1 - b1 
    length_y3 = c1 - d1
    AREA = (length_x3)*(length_y3)
    ans = (Area1 + Area2) - (AREA)
    return ans
#======================================
def iou(r1, r2):
    x1 = r1[0]
    W1 = r1[2]
    x2 = r2[0]
    W2 = r2[2]
    y1 = r1[1]
    y2 = r2[1]
    H1 = r1[3]
    H2 = r2[3]
    a1 = min(x1+W1, x2+W2)
    b1 = max(x1, x2)
    c1 = min(y2, y1)
    d1 = max(y1-H1, y2-H2)
    length_x3 = a1 - b1 
    length_y3 = c1 - d1
    AREA = (length_x3)*(length_y3)
    I = AREA
    Area1 = r1[2] * r1[3]
    Area2 = r2[2] * r2[3]
    ans = (Area1 + Area2) - (AREA)
    U = ans
    ratio = I/U
    return ratio
#======================================

00177: HW01
bytecount: {'code': 844, 'const': 660, 'code+const': 1504}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x_1 = r[0]
  x_2 = r[0] + r [2]
  y_1 = r[1] 
  y_2 = r[1]- r[-1]
  return [(x_1 + x_2)/2 , (y_1 + y_2)/2]
#======================================
def distance(r1, r2):
    x_11 = r1[0]
    x_21 = r1[0] + r1[2]
    y_11 = r1[1]
    y_21 = r1[1]- r1[-1]
    x_12 = r2[0]
    x_22 = r2[0] + r2[2]
    y_12 = r2[1]
    y_22 = r2[1]- r2[-1]
    middle_r1 = [(x_11 + x_21)/2 , (y_11 + y_21)/2]
    middle_r2 = [(x_12 + x_22)/2 , (y_12 + y_22)/2]
    PQ =  (((middle_r2[0] - middle_r1[0])**2) + ((middle_r2[1] - middle_r1[1])**2))**0.5
    return PQ
#======================================
def intersection(r1, r2):  
    x_11 = r1[0]
    x_21 = r1[0] + r1[2]
    y_11 = r1[1]
    y_21 = r1[1]- r1[-1]
    x_12 = r2[0]
    x_22 = r2[0] + r2[2]
    y_12 = r2[1]
    y_22 = r2[1]- r2[-1]
    intersec_1 = (max(0,min(x_21,x_22) - max(x_11,x_12))* (max(0,min(y_11,y_12) - max(y_21,y_22))))
    return intersec_1
#======================================
def union(r1, r2):
    x_11 = r1[0]
    x_21 = r1[0] + r1[2]
    y_11 = r1[1]
    y_21 = r1[1]- r1[-1]
    x_12 = r2[0]
    x_22 = r2[0] + r2[2]
    y_12 = r2[1]
    y_22 = r2[1]- r2[-1]
    intersec_1 = (max(0,min(x_21,x_22) - max(x_11,x_12))* (max(0,min(y_11,y_12) - max(y_21,y_22))))
    Union_1 = ((((x_21 - x_11)*(y_11 - y_21)) + ((x_22 - x_12)*(y_12 - y_22) - intersec_1 )))
    return Union_1
#======================================
def iou(r1, r2):
    x_11 = r1[0]
    x_21 = r1[0] + r1[2]
    y_11 = r1[1]
    y_21 = r1[1]- r1[-1]
    x_12 = r2[0]
    x_22 = r2[0] + r2[2]
    y_12 = r2[1]
    y_22 = r2[1]- r2[-1]
    intersec_1 = (max(0,min(x_21,x_22) - max(x_11,x_12))* (max(0,min(y_11,y_12) - max(y_21,y_22))))
    Union_1 = ((((x_21 - x_11)*(y_11 - y_21)) + ((x_22 - x_12)*(y_12 - y_22) - intersec_1 )))
    ratio_1 = intersec_1 / Union_1
    return ratio_1
#print(center(r1))
#print(center(r2))
#print(round(distance(r1,r2),2))
#print(round(distance(r3,r4),2))
#print(intersection(r1,r2)) 
#print(intersection(r2,r3))
#print(intersection(r4,r5))
#print(intersection(r1,r5))
#print(union(r1,r2))
#print(union(r2,r3))
#print(union(r4,r5))
#print(round(iou(r1,r2),2))
#print(round(iou(r2,r3),2))
#print(round(iou(r4,r5),2))

00178: HW01
bytecount: {'code': 856, 'const': 660, 'code+const': 1516}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    x = float(r[0]) ; y = float(r[1]) ; w = float(r[2]) ; h = float(r[3])
    c = [x+w/2,(y-h/2)]
    return c
#======================================
def distance(r1, r2):
    x1 = float(r1[0]) ; y1 = float(r1[1]) ; w1 = float(r1[2]) ; h1 = float(r1[3])
    x2 = float(r2[0]) ; y2 = float(r2[1]) ; w2 = float(r2[2]) ; h2 = float(r2[3])
    d12 = (((x1+w1/2)-(x2+w2/2))**2 + ((y1-h1/2)-(y2-h2/2))**2)**(1/2)
    return d12
#======================================
def intersection(r1, r2):
    x1 = float(r1[0]) ; y1 = float(r1[1]) ; w1 = float(r1[2]) ; h1 = float(r1[3])
    x2 = float(r2[0]) ; y2 = float(r2[1]) ; w2 = float(r2[2]) ; h2 = float(r2[3])
    ww = max(0,min(x1+w1,x2+w2) - max(x1,x2))
    hh = max(0,min(y1,y2) - max(y1-h1,y2-h2))
    m = (ww*hh)
    return m
#======================================
def union(r1, r2):
    x1 = float(r1[0]) ; y1 = float(r1[1]) ; w1 = float(r1[2]) ; h1 = float(r1[3])
    x2 = float(r2[0]) ; y2 = float(r2[1]) ; w2 = float(r2[2]) ; h2 = float(r2[3])
    ww = max(0,min(x1+w1,x2+w2) - max(x1,x2))
    hh = max(0,min(y1,y2) - max(y1-h1,y2-h2))
    m = (ww*hh)
    union = ((w1)*(h1)+((w2)*(h2))-m)
    return(union)
#======================================
def iou(r1, r2):
    x1 = float(r1[0]) ; y1 = float(r1[1]) ; w1 = float(r1[2]) ; h1 = float(r1[3])
    x2 = float(r2[0]) ; y2 = float(r2[1]) ; w2 = float(r2[2]) ; h2 = float(r2[3])
    ww = max(0,min(x1+w1,x2+w2) - max(x1,x2))
    hh = max(0,min(y1,y2) - max(y1-h1,y2-h2))
    m = (ww*hh)
    union = ((w1)*(h1)+((w2)*(h2))-m)
    iou = m/union
    return(iou)
    #======================================

00179: HW01
bytecount: {'code': 896, 'const': 644, 'code+const': 1540}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    d = [float(e) for e in r]
    x = d[0] + d[2]/2
    y = d[1] - d[3]/2
    cen = [x,y]
    return cen
#======================================
def distance(r1, r2):
    a = center(r1)
    b = center(r2)
    a1 = a[0]
    a2 = a[1]
    b1 = b[0]
    b2 = b[1]
    dis = (((a1 - b1)**2) + ((a2 - b2))**2) ** (1/2)
    return dis
#======================================
def disdot_to_dot(d1,d2):
    ddtd = (((d1[0] - d2[0])**2) + ((d1[1] - d2[1]))**2) ** (1/2)
    return ddtd
#======================================
def intersection(r1, r2):
    f1 = [float(e) for e in r1]
    f2 = [float(e) for e in r2]
    point1 = [f1[0] , f1[1]]
    point2 = [f1[0] , (f1[1] - f1[3])]
    point3 = [(f1[0] + f1[2]) , f1[1]]
    dot1 = [f2[0] , f2[1]]
    dot2 = [f2[0] , (f2[1] - f2[3])]
    dot3 = [(f2[0] + f2[2]) , f2[1]]
    n = min(point1[1], dot1[1])
    p = max(point2[1], dot2[1])
    h_insq = n - p
    H = max(0,h_insq)
    r = max(point1[0], dot1[0])
    l = min(point3[0], dot3[0])
    w_insq = l - r
    W = max(0,w_insq)
    inter_area = H * W
    return inter_area
#======================================
def union(r1, r2):
    s = [float(e) for e in r1]
    q = [float(e) for e in r2]
    s1 = [s[0] , s[1]]
    s2 = [s[0] , (s[1] - s[3])]
    s3 = [(s[0] + s[2]) , s[1]]
    q1 = [q[0] , q[1]]
    q2 = [q[0] , (q[1] - q[3])]
    q3 = [(q[0] + q[2]) , q[1]]
    ws = disdot_to_dot(s1, s3)
    hs = disdot_to_dot(s1, s2)
    area_s = ws * hs
    wq = disdot_to_dot(q1, q3)
    hq = disdot_to_dot(q1, q2)
    area_q = wq * hq
    uni_area = (area_s + area_q) - intersection(r1,r2)
    return uni_area
#======================================
def iou(r1, r2):
    answer = intersection(r1,r2) / union(r1,r2) 
    return answer
#======================================

00180: HW01
bytecount: {'code': 930, 'const': 660, 'code+const': 1590}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    (x,y)= ((r[0]+r[2]/2), (r[1]-r[3]/2))
    return [x, y]
#======================================
def distance(r1, r2):
    x1 = r1[0]+r1[2]/2
    x2 = r2[0]+r2[2]/2
    y1 = r1[1]-r1[3]/2
    y2 = r2[1]-r2[3]/2
    d = ((x1-x2)**2 + (y1-y2)**2)**0.5
    return d
#======================================
def intersection(r1, r2):
    max_x = max(r1[0], r2[0])
    min_x = min(r1[0]+r1[2], r2[0]+r2[2])
    intersec_x = min_x - max_x
    min_y = min(r1[1], r2[1])
    max_y = max(r1[1]-r1[3], r2[1]-r2[3])
    intersec_y = min_y - max_y
    a = max(intersec_y,0)
    b = max(intersec_x,0)
    area = max(a*b,0)
    return area
#======================================
def union(r1, r2):
    area1 = r1[3]*r1[2]
    area2 = r2[3]*r2[2]
    max_x = max(r1[0], r2[0])
    min_x = min(r1[0]+r1[2], r2[0]+r2[2])
    intersec_x = min_x - max_x
    min_y = min(r1[1], r2[1])
    max_y = max(r1[1]-r1[3], r2[1]-r2[3])
    intersec_y = min_y - max_y
    a = max(intersec_y,0)
    b = max(intersec_x,0)
    area = max(a*b,0)
    union_12 = area1+area2-area
    return union_12
#======================================
def iou(r1, r2):
    max_x = max(r1[0], r2[0])
    min_x = min(r1[0]+r1[2], r2[0]+r2[2])
    intersec_x = min_x - max_x
    min_y = min(r1[1], r2[1])
    max_y = max(r1[1]-r1[3], r2[1]-r2[3])
    intersec_y = min_y - max_y
    a = max(intersec_y,0)
    b = max(intersec_x,0)
    area = max(a*b,0)
    area1 = r1[3]*r1[2]
    area2 = r2[3]*r2[2]
    max_x = max(r1[0], r2[0])
    min_x = min(r1[0]+r1[2], r2[0]+r2[2])
    intersec_x = min_x - max_x
    min_y = min(r1[1], r2[1])
    max_y = max(r1[1]-r1[3], r2[1]-r2[3])
    intersec_y = min_y - max_y
    a = max(intersec_y,0)
    b = max(intersec_x,0)
    area = max(a*b,0)
    union_12 = area1+area2-area
    A = area/union_12
    return A
#======================================

00181: HW01
bytecount: {'code': 1038, 'const': 628, 'code+const': 1666}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
  x = float(r[0])
  y = float(r[1])
  w = float(r[2])
  h = float(r[3])
  c1 = x + (w * 0.5)
  c2 = y - (h * 0.5)
  return [c1,c2]
#======================================
def distance(r1, r2):
  a1 = float(center(r1)[0])
  a2 = float(center(r1)[1])
  b1 = float(center(r2)[0])
  b2 = float(center(r2)[1])
  return (((b1 - a1)** 2) + ((b2 - a2)** 2)) ** 0.5
#======================================
def xwidth(r1, r2):
  x1 = float(r1[0])
  x = float(r1[2])
  x2 = x1 + x
  w1 = float(r2[0])
  w = float(r2[2])
  w2 = w1 + w
  g = min(x, w)
  G = max(x, w)
  Q = max(x2, x1)
  P = max(w2, w1)
  R = min(x2, x1)
  S = min(w2, w1)
  F = g - abs(x1 - w1) 
  J = G - abs(w1 - x1)
  I = G - abs(w2 - x2)
  u = min(J, I)
  K = max(u, 0)
  M = max(K, 10**(-100 ))
  N = K//M
  a = Q - S
  A = R - P
  D = min(abs(a), abs(A))
  b = D // g
  f = min(b, 1)
  k = max(f, 0)
  p = abs(D) % g
  q = max(p, 0)
  r = ((k * g) + q) * N
  return min(r, g)
def yheight(r1, r2):
  y1 = float(r1[1])
  y = float(r1[3])
  y2 = y1 - y
  h1 = float(r2[1])
  h = float(r2[3])
  h2 = h1 - h
  g = min(y, h)
  G = max(y, h)
  Q = max(y2, y1)
  P = max(h2, h1)
  R = min(y2, y1)
  S = min(h2, h1)
  F = g - abs(y1 - h1) 
  J = G - abs(h1 - y1)
  I = G - abs(h2 - y2)
  u = min(J, I)
  K = max(u, 0)
  M = max(K, 10**(-100 ))
  N = K//M
  a = Q - S
  A = R - P
  D = min(abs(a), abs(A))
  b = D // g
  f = min(b, 1)
  k = max(f, 0)
  p = abs(D) % g
  q = max(p, 0)
  r = ((k * g) + q) * N
  return min(r, g)
def intersection(r1, r2):
  w = float(xwidth(r1, r2))
  h = float(yheight(r1, r2))
  return w*h
#======================================
def union(r1, r2):
  A1 = float(r1[2]) * float(r1[3])
  A2 = float(r2[2]) * float(r2[3])
  In = float(intersection(r1, r2))
  return (A1 + A2) - In
#======================================
def iou(r1, r2):
  A = float(union(r1, r2))
  a = float(intersection(r1, r2))
  return a/A
#======================================

00182: HW01
bytecount: {'code': 1084, 'const': 660, 'code+const': 1744}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    #Coordinate
    Rx1=r[0]
    Rx2=r[0]+r[2]
    Ry1=r[1]-r[3]
    Ry2=r[1]
    A=(Rx1+Rx2)/2
    B=(Ry1+Ry2)/2
    return([A,B])
#======================================
def distance(r1, r2):
    #Coordinate
    R1x1=r1[0]
    R1x2=r1[0]+r1[2]
    R1y1=r1[1]-r1[3]
    R1y2=r1[1]
    A1=(R1x1+R1x2)/2
    B1=(R1y1+R1y2)/2
    R2x1=r2[0]
    R2x2=r2[0]+r2[2]
    R2y1=r2[1]-r2[3]
    R2y2=r2[1]
    A2=(R2x1+R2x2)/2
    B2=(R2y1+R2y2)/2
    D=((B1-B2)**2+(A1-A2)**2)**0.5
    return(D)
#======================================
def intersection(r1, r2):
    #Coordinate
    R1x1=r1[0]
    R1x2=r1[0]+r1[2]
    R1y1=r1[1]-r1[3]
    R1y2=r1[1]
    R2x1=r2[0]
    R2x2=r2[0]+r2[2]
    R2y1=r2[1]-r2[3]
    R2y2=r2[1]
    #length SqR1,SqR2
    DxR1=R1x2-R1x1
    DxR2=R2x2-R2x1
    DyR1=R1y2-R1y1
    DyR2=R2y2-R2y1
    #lineup(amountX)  
    #Max0x=max(R1x1,R1x2,R2x1,R2x2)
    #Min0x=min(R1x1,R1x2,R2x1,R2x2)
    #m1x=max(R1x1,Min0x)
    #m2x=max(R2x1,Min0x)
    #m3x=min(R1x2,Max0x)
    #m4x=min(R2x2,Max0x)
    #n1x=max(m1x,m2x)
    #n2x=min(m3x,m4x)
    #O1x=min(n1x,n2x)#x2
    #O2x=max(n1x,n2x)#x3
    #lineup(amountY)
    #Max0y=max(R1y1,R1y2,R2y1,R2y2)
    #Min0y=min(R1y1,R1y2,R2y1,R2y2)
    #m1y=max(R1y1,Min0y)
    #m2y=max(R2y1,Min0y)
    #m3y=min(R1y2,Max0y)
    #m4y=min(R2y2,Max0y)
    #n1y=max(m1y,m2y)
    #n2y=min(m3y,m4y)
    #O1y=min(n1y,n2y)
    #O2y=max(n1y,n2y)
    #intersect=(O2y-O1y)*(O2x-O1x)
    Max0x=max(R1x1,R1x2,R2x1,R2x2)
    Min0x=min(R1x1,R1x2,R2x1,R2x2)
    X=max((DxR1)+(DxR2)-(Max0x-Min0x),0)
    Max0y=max(R1y1,R1y2,R2y1,R2y2)
    Min0y=min(R1y1,R1y2,R2y1,R2y2)    
    Y=max((DyR1)+(DyR2)-(Max0y-Min0y),0)
    intersect=X*Y
    return(intersect)
#======================================
def union(r1, r2):
    #Coordinate
    R1x1=r1[0]
    R1x2=r1[0]+r1[2]
    R1y1=r1[1]-r1[3]
    R1y2=r1[1]
    R2x1=r2[0]
    R2x2=r2[0]+r2[2]
    R2y1=r2[1]-r2[3]
    R2y2=r2[1]
    #length SqR1,SqR2
    DxR1=R1x2-R1x1
    DxR2=R2x2-R2x1
    DyR1=R1y2-R1y1
    DyR2=R2y2-R2y1
    #intersect
    Max0x=max(R1x1,R1x2,R2x1,R2x2)
    Min0x=min(R1x1,R1x2,R2x1,R2x2)
    X=max((DxR1)+(DxR2)-(Max0x-Min0x),0)
    Max0y=max(R1y1,R1y2,R2y1,R2y2)
    Min0y=min(R1y1,R1y2,R2y1,R2y2)    
    Y=max((DyR1)+(DyR2)-(Max0y-Min0y),0)
    intersect=X*Y
    #Covering Area
    AreaR1=DxR1*DyR1
    AreaR2=DxR2*DyR2
    U=AreaR1+AreaR2-intersect
    return(U)
#======================================
def iou(r1, r2):
    R1x1=r1[0]
    R1x2=r1[0]+r1[2]
    R1y1=r1[1]-r1[3]
    R1y2=r1[1]
    R2x1=r2[0]
    R2x2=r2[0]+r2[2]
    R2y1=r2[1]-r2[3]
    R2y2=r2[1]
    DxR1=R1x2-R1x1
    DxR2=R2x2-R2x1
    DyR1=R1y2-R1y1
    DyR2=R2y2-R2y1
    #intersect
    Max0x=max(R1x1,R1x2,R2x1,R2x2)
    Min0x=min(R1x1,R1x2,R2x1,R2x2)
    X=max((DxR1)+(DxR2)-(Max0x-Min0x),0)
    Max0y=max(R1y1,R1y2,R2y1,R2y2)
    Min0y=min(R1y1,R1y2,R2y1,R2y2)    
    Y=max((DyR1)+(DyR2)-(Max0y-Min0y),0)
    intersect=X*Y
    #Covering Area
    AreaR1=DxR1*DyR1
    AreaR2=DxR2*DyR2
    U=AreaR1+AreaR2-intersect
    #Ratio
    ratio=intersect/U
    return(ratio)
#======================================

00183: HW01
bytecount: {'code': 1958, 'const': 548, 'code+const': 2506}
check_if({}) deep: none
check_import({'allowable': ['math']}) deep: none
def center(r):
    return [(r[2])/2+r[0],r[1]-(r[3])/2]
# ======================================
def distance(r1, r2):
    return ((center(r1)[0]-center(r2)[0])**2+(center(r1)[1]-center(r2)[1])**2)**(0.5)
# ======================================
def intersection(r1, r2):
    r1_list = [[center(r1)[0] - r1[2] / 2, center(r1)[1] - r1[3] / 2],
               [center(r1)[0] - r1[2] / 2, center(r1)[1] + r1[3] / 2],
               [center(r1)[0] + r1[2] / 2, center(r1)[1] + r1[3] / 2],
               [center(r1)[0] + r1[2] / 2, center(r1)[1] - r1[3] / 2]]
    r2_list = [[center(r2)[0] - r2[2] / 2, center(r2)[1] - r2[3] / 2],
               [center(r2)[0] - r2[2] / 2, center(r2)[1] + r2[3] / 2],
               [center(r2)[0] + r2[2] / 2, center(r2)[1] + r2[3] / 2],
               [center(r2)[0] + r2[2] / 2, center(r2)[1] - r2[3] / 2]]
    min_x1, max_x1 = min(r1_list[0][0], r1_list[1][0], r1_list[2][0], r1_list[3][0]), max(r1_list[0][0], r1_list[1][0],  r1_list[2][0], r1_list[3][0])
    min_y1, max_y1 = min(r1_list[0][1], r1_list[1][1], r1_list[2][1], r1_list[3][1]), max(r1_list[0][1], r1_list[1][1],  r1_list[2][1], r1_list[3][1])
    min_x2, max_x2 = min(r2_list[0][0], r2_list[1][0], r2_list[2][0], r2_list[3][0]), max(r2_list[0][0], r2_list[1][0], r2_list[2][0], r2_list[3][0])
    min_y2, max_y2 = min(r2_list[0][1], r2_list[1][1], r2_list[2][1], r2_list[3][1]), max(r2_list[0][1], r2_list[1][1], r2_list[2][1], r2_list[3][1])
    min_x_area = max(min_x1, min_x2)
    max_x_area = min(max_x1, max_x2)
    min_y_area = max(min_y1, min_y2)
    max_y_area = min(max_y1, max_y2)
    area = (max_y_area - min_y_area) * (max_x_area - min_x_area)
    return ((min_x1 <= max_x2) and (max_x1 >= min_x2) and (min_y1 <= max_y2) and (max_y1 >= min_y2)) and area or 0.0
# ======================================
def union(r1, r2):
    r1_list = [[center(r1)[0] - r1[2] / 2, center(r1)[1] - r1[3] / 2],
               [center(r1)[0] - r1[2] / 2, center(r1)[1] + r1[3] / 2],
               [center(r1)[0] + r1[2] / 2, center(r1)[1] + r1[3] / 2],
               [center(r1)[0] + r1[2] / 2, center(r1)[1] - r1[3] / 2]]
    r2_list = [[center(r2)[0] - r2[2] / 2, center(r2)[1] - r2[3] / 2],
               [center(r2)[0] - r2[2] / 2, center(r2)[1] + r2[3] / 2],
               [center(r2)[0] + r2[2] / 2, center(r2)[1] + r2[3] / 2],
               [center(r2)[0] + r2[2] / 2, center(r2)[1] - r2[3] / 2]]
    min_x1, max_x1 = min(r1_list[0][0], r1_list[1][0], r1_list[2][0], r1_list[3][0]), max(r1_list[0][0], r1_list[1][0],  r1_list[2][0], r1_list[3][0])
    min_y1, max_y1 = min(r1_list[0][1], r1_list[1][1], r1_list[2][1], r1_list[3][1]), max(r1_list[0][1], r1_list[1][1],  r1_list[2][1], r1_list[3][1])
    min_x2, max_x2 = min(r2_list[0][0], r2_list[1][0], r2_list[2][0], r2_list[3][0]), max(r2_list[0][0], r2_list[1][0], r2_list[2][0], r2_list[3][0])
    min_y2, max_y2 = min(r2_list[0][1], r2_list[1][1], r2_list[2][1], r2_list[3][1]), max(r2_list[0][1], r2_list[1][1], r2_list[2][1], r2_list[3][1])
    min_x_area = max(min_x1, min_x2)
    max_x_area = min(max_x1, max_x2)
    min_y_area = max(min_y1, min_y2)
    max_y_area = min(max_y1, max_y2)
    area = (max_y_area - min_y_area) * (max_x_area - min_x_area)
    return ((min_x1 <= max_x2) and (max_x1 >= min_x2) and (min_y1 <= max_y2) and (max_y1 >= min_y2)) and ((r1[2]*r1[3]+r2[2]*r2[3])-(area)) or r1[2]*r1[3]+r2[2]*r2[3]
# ======================================
def iou(r1, r2):
    return intersection(r1,r2)/union(r1,r2)
# ======================================