def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # Forces result to be floats
(1.0, 2.0, 0.0)
"""
area, x_point, y_point = 0, 0, 0
for k in range(0, len(polygon) - 1):
general_formula = (latitude(polygon[k])*longitude(polygon[k+1])-latitude(polygon[k+1])*longitude(polygon[k]))
x_point += (latitude(polygon[k])+latitude(polygon[k+1]))*general_formula
y_point += (longitude(polygon[k])+longitude(polygon[k+1]))*general_formula
area += general_formula
if area != 0:
area = area/2
x_point = (x_point/(6*area))
y_point = (y_point/(6*area))
area = abs(area)
else:
x_point, y_point = (latitude(polygon[0]), longitude(polygon[0]))
return (x_point, y_point, area)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p2, p1])
(1, 2, 0)
"""
area,coor_x,coor_y=0,0,0
for i in range(0,len(polygon)-1):
area+=(abs(latitude(polygon[i]))*abs(longitude(polygon[i+1]))-abs(latitude(polygon[i+1]))*abs(longitude(polygon[i])))/2
coor_x+=(latitude(polygon[i])+latitude(polygon[i+1]))*(latitude(polygon[i])*longitude(polygon[i+1])-latitude(polygon[i+1])*longitude(polygon[i]))/6
coor_y+=(longitude(polygon[i])+longitude(polygon[i+1]))*(latitude(polygon[i])*longitude(polygon[i+1])-latitude(polygon[i+1])*longitude(polygon[i]))/6
if area==0:
return (latitude(polygon[0]),longitude(polygon[0]),0)
return (coor_x/area,coor_y/area,abs(area))
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
"*** YOUR CODE HERE ***"
def helper(xi, yi, xi1, yi1):
term = xi*yi1-xi1*yi
return Cx+(xi+xi1)*term, Cy+(yi+yi1)*term, A+0.5*term
Cx, Cy, A = 0, 0, 0
for c in range(len(polygon)-1):
Cx, Cy, A = helper(latitude(polygon[c]), longitude(polygon[c]), latitude(polygon[c+1]), longitude(polygon[c+1]))
return [Cx/(6*A), Cy/(6*A), abs(A)] if A else [latitude(polygon[0]), longitude(polygon[0]), 0.0]
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
x, y, a, i = 0, 0, 0, 0
while i < len(polygon) - 1:
x += (latitude(polygon[i]) + latitude(polygon[i + 1])) * (latitude(polygon[i]) * longitude(polygon[i + 1]) - (latitude(polygon[i + 1]) * longitude(polygon[i])))
y += (longitude(polygon[i]) + longitude(polygon[i + 1])) * (latitude(polygon[i]) * longitude(polygon[i + 1]) - (latitude(polygon[i + 1]) * longitude(polygon[i])))
a += (latitude(polygon[i]) * longitude(polygon[i + 1])) - (latitude(polygon[i + 1]) * longitude(polygon[i]))
i += 1
if a != 0:
a = (1 / 2) * a
x = (1 / (6 * a)) * x
y = (1 / (6 * a)) * y
return (x, y, abs(a))
else:
return (latitude(polygon[0]), longitude(polygon[0]), 0)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p2, p1])
(1, 2, 0)
"""
"*** YOUR CODE HERE ***"
total= 0
for i in range(len(polygon)-1):
total = total + (latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i]))
total /=2
if total == 0:
return latitude(polygon[0]), longitude(polygon[0]), 0
ax = 0
by = 0
for i in range(len(polygon) - 1):
ax = ax +(latitude(polygon[i]) + latitude(polygon[i+1])) * (latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i]))
by = by + (longitude(polygon[i]) + longitude(polygon[i+1])) * (latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i]))
ax /= 6 * total
by /= 6 * total
return ax, by, abs(total)
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
"*** YOUR CODE HERE ***"
cx, cy, area, index = 0, 0, 0, 0
while index < len(polygon) - 1:
x, y, x_next, y_next = latitude(polygon[index]), longitude(polygon[index]), latitude(polygon[index+1]), longitude(polygon[index+1])
temparea = x * y_next - x_next * y
cx, cy, area, index = cx + (x + x_next) * temparea, cy + (y + y_next) * temparea, area + temparea, index + 1
area = area * 0.5
return [latitude(polygon[0]), longitude(polygon[0]), 0] if area == 0 else [(1/(6*area))*cx, (1/(6*area))*cy, abs(area)]
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude (x), centroid longitude(y), and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> list(map(round5, find_centroid(triangle)))
[3.0, 2.0, 6.0]
>>> list(map(round5, find_centroid([p1, p3, p2, p1])))
[3.0, 2.0, 6.0]
>>> list(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
"*** YOUR CODE HERE ***"
cx, cy, area, multiplyer = 0, 0, 0, 0
for i in range(len(polygon) -1):
cx += ((latitude(polygon[i]) + latitude(polygon[i + 1])) * (latitude(polygon[i]) * longitude(polygon[i + 1]) - longitude(polygon[i]) * latitude(polygon[i + 1])))
cy += ((longitude(polygon[i]) + longitude(polygon[i + 1])) * (latitude(polygon[i]) * longitude(polygon[i + 1]) - longitude(polygon[i]) * latitude(polygon[i + 1])))
area += (latitude(polygon[i]) * longitude(polygon[i + 1])) - (latitude(polygon[i + 1]) * longitude(polygon[i]))
area = area * (1/2)
if area == 0:
return latitude(polygon[0]), longitude(polygon[0]), area
cx = (cx / (6 * area))
cy = (cy / (6 * area))
return [cx, cy, abs(area)]
def find_center(polygons):
"""Compute the geographic center of a state, averaged over its polygons.
The center is the average position of centroids of the polygons in polygons,
weighted by the area of those polygons.
Arguments:
polygons -- a list of polygons
>>> ca = find_center(us_states['CA']) # California
>>> round(latitude(ca), 5)
37.25389
>>> round(longitude(ca), 5)
-119.61439
>>> hi = find_center(us_states['HI']) # Hawaii
>>> round(latitude(hi), 5)
20.1489
>>> round(longitude(hi), 5)
-156.21763
"""
"*** YOUR CODE HERE ***"
# Case 1: State is only a single polygon
if len(polygons) == 1:
return make_position(latitude(find_centroid(polygons[0])), longitude(find_centroid(polygons[0])))
# Case 2: States are multiple polygons
x_weight = 0
y_weight = 0
area = 0
for poly in polygons: # Using the formula from Wikipedia, we calculate the sum of the X and Y coordinates per polygon weighting it by the area.
x_weight += latitude(find_centroid(poly)) * find_centroid(poly)[2]
y_weight += longitude(find_centroid(poly)) * find_centroid(poly)[2]
area += find_centroid(poly)[2]
return make_position(x_weight/area, y_weight/area)
def find_centroid(polygon): """Find the centroid of a polygon. http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon polygon -- A list of positions, in which the first and last are the same Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area Hint: If a polygon has 0 area, use the latitude and longitude of its first position as its centroid. >>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0) >>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex >>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits >>> tuple(map(round5, find_centroid(triangle))) (3.0, 2.0, 6.0) >>> tuple(map(round5, find_centroid([p1, p3, p2, p1]))) (3.0, 2.0, 6.0) >>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon (1.0, 2.0, 0.0) """ area, cent_lat, cent_lon = 0, 0, 0 for i in range(len(polygon) - 1): x1, y1 = latitude(polygon[i]), longitude(polygon[i]) x2, y2 = latitude(polygon[i+1]), longitude(polygon[i+1]) area += .5 * (x1*y2 - x2*y1) cent_lat += (x1+x2) * (x1*y2 - x2*y1) cent_lon += (y1+y2) * (x1*y2 - x2*y1) if area == 0: return latitude(polygon[0]), longitude(polygon[0]), area return cent_lat / (6*area), cent_lon / (6*area), abs(area)
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
cent_lat, cent_long, poly_area = 0, 0, 0
for vertex in list(range(len(polygon) - 1)):
poly_area += .5 * (latitude(polygon[vertex]) * longitude(polygon[vertex + 1]) - latitude(polygon[vertex + 1]) * longitude(polygon[vertex]))
if poly_area == 0:
return latitude(polygon[0]), longitude(polygon[0]), 0
for vertex in list(range(len(polygon) - 1)):
cent_lat += (1 / (6 * poly_area)) * (latitude(polygon[vertex]) + latitude(polygon[vertex + 1])) * (latitude(polygon[vertex]) * longitude(polygon[vertex + 1]) - latitude(polygon[vertex + 1]) * longitude(polygon[vertex]))
cent_long += (1 / (6 * poly_area)) * (longitude(polygon[vertex]) + longitude(polygon[vertex + 1])) * (latitude(polygon[vertex]) * longitude(polygon[vertex + 1]) - latitude(polygon[vertex + 1]) * longitude(polygon[vertex]))
return cent_lat, cent_long, abs(poly_area)
def area(polygon):
area_value = 0
for _ in range(len(polygon) - 1):
area_value += (latitude(polygon[_]) * longitude(
polygon[_ + 1])) - (latitude(polygon[_ + 1]) *
longitude(polygon[_]))
return .5 * area_value
def cent_lat(polygon):
lat_value = 0
for _ in range(len(polygon) - 1):
lat_value += (latitude(polygon[_]) + latitude(polygon[_ + 1])) * (
(latitude(polygon[_ + 1]) * longitude(polygon[_])) -
(latitude(polygon[_]) * longitude(polygon[_ + 1])))
return (1 / (6 * area_poly)) * lat_value
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> list(map(round5, find_centroid(triangle)))
[3.0, 2.0, 6.0]
>>> list(map(round5, find_centroid([p1, p3, p2, p1])))
[3.0, 2.0, 6.0]
>>> list(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
"*** YOUR CODE HERE ***"
area = 0
lat = lon = 0
for i in range(len(polygon)-1):
area += latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i])
lat += (latitude(polygon[i]) + latitude(polygon[i+1])) * (latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i]))
lon += (longitude(polygon[i]) + longitude(polygon[i+1])) * (latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i]))
area /= 2
if area == 0:
return latitude(polygon[0]),longitude(polygon[0]),0
lat,lon = lat/(6*area),lon/(6*area)
return lat,lon,abs(area)
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
total_area, area, i, c_lat, c_lon = 0, 0, 0, 0, 0
while i < len(polygon) - 1:
area = latitude(polygon[i])*longitude(polygon[i+1]) - latitude(polygon[i+1])*longitude(polygon[i])
c_lat += area * (latitude(polygon[i]) + latitude(polygon[i+1]))
c_lon += area * (longitude(polygon[i]) + longitude(polygon[i+1]))
total_area += area
i += 1
total_area = total_area / 2
if total_area == 0:
return [latitude(polygon[0]), longitude(polygon[0]), 0]
return [c_lat/(6*total_area), c_lon/(6*total_area), abs(total_area)]
def poly_area(x=0):
area = 0
while x < len(polygon)-1:
area+=(0.5)*(latitude(polygon[x])*longitude(polygon[x+1])-\
(latitude(polygon[x+1])*longitude(polygon[x])))
x+=1
return area
def poly_area(x=0):
area = 0
while x < len(polygon) - 1:
area+=(0.5)*(latitude(polygon[x])*longitude(polygon[x+1])-\
(latitude(polygon[x+1])*longitude(polygon[x])))
x += 1
return area
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
"""
def area(polygon):
area_value = 0
for _ in range(len(polygon) - 1):
area_value += (latitude(polygon[_]) * longitude(polygon[_ + 1])) - (latitude(polygon[_ + 1]) * longitude(polygon[_]))
return .5 * area_value
area_poly = area(polygon)
if area(polygon) == 0:
return latitude(polygon[0]), longitude(polygon[0]), area(polygon)
def cent_lat(polygon):
lat_value = 0
for _ in range(len(polygon) - 1):
lat_value += (latitude(polygon[_]) + latitude(polygon[_ + 1])) * ((latitude(polygon[_ + 1]) * longitude(polygon[_])) - (latitude(polygon[_]) * longitude(polygon[_ + 1])))
return (1/(6 * area_poly)) * lat_value
def cent_lon(polygon):
lon_value = 0
for _ in range(len(polygon) - 1):
lon_value += (longitude(polygon[_]) + longitude(polygon[_ + 1])) * ((latitude(polygon[_ + 1]) * longitude(polygon[_])) - (latitude(polygon[_]) * longitude(polygon[_ + 1])))
return (1/(6 * area_poly)) * lon_value
return -1 * cent_lat(polygon), -1 * cent_lon(polygon), abs(area_poly)"""
area_value, lat_value, lon_value = 0, 0, 0
for _ in range(len(polygon) - 1):
lat1, lat2, lon1, lon2 = latitude(polygon[_]), latitude(polygon[_ + 1]), longitude(polygon[_]), longitude(polygon[_ + 1])
area_value += lat1 * lon2 - lat2 * lon1
lat_value += (lat1 + lat2) * (lat1 * lon2 - lat2 * lon1)
lon_value += (lon1 + lon2) * (lat1 * lon2 - lat2 * lon1)
area_poly = .5 * area_value
if area_poly == 0:
return latitude(polygon[0]), longitude(polygon[0]), area_poly
lat_poly = (1/(6 * area_poly)) * lat_value
lon_poly = (1/(6 * area_poly)) * lon_value
return lat_poly, lon_poly, abs(area_poly)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
"""
def area(polygon):
area_value = 0
for _ in range(len(polygon) - 1):
area_value += (latitude(polygon[_]) * longitude(polygon[_ + 1])) - (latitude(polygon[_ + 1]) * longitude(polygon[_]))
return .5 * area_value
area_poly = area(polygon)
if area(polygon) == 0:
return latitude(polygon[0]), longitude(polygon[0]), area(polygon)
def cent_lat(polygon):
lat_value = 0
for _ in range(len(polygon) - 1):
lat_value += (latitude(polygon[_]) + latitude(polygon[_ + 1])) * ((latitude(polygon[_ + 1]) * longitude(polygon[_])) - (latitude(polygon[_]) * longitude(polygon[_ + 1])))
return (1/(6 * area_poly)) * lat_value
def cent_lon(polygon):
lon_value = 0
for _ in range(len(polygon) - 1):
lon_value += (longitude(polygon[_]) + longitude(polygon[_ + 1])) * ((latitude(polygon[_ + 1]) * longitude(polygon[_])) - (latitude(polygon[_]) * longitude(polygon[_ + 1])))
return (1/(6 * area_poly)) * lon_value
return -1 * cent_lat(polygon), -1 * cent_lon(polygon), abs(area_poly)"""
area_value, lat_value, lon_value = 0, 0, 0
for _ in range(len(polygon) - 1):
lat1, lat2, lon1, lon2 = latitude(polygon[_]), latitude(
polygon[_ + 1]), longitude(polygon[_]), longitude(polygon[_ + 1])
area_value += lat1 * lon2 - lat2 * lon1
lat_value += (lat1 + lat2) * (lat1 * lon2 - lat2 * lon1)
lon_value += (lon1 + lon2) * (lat1 * lon2 - lat2 * lon1)
area_poly = .5 * area_value
if area_poly == 0:
return latitude(polygon[0]), longitude(polygon[0]), area_poly
lat_poly = (1 / (6 * area_poly)) * lat_value
lon_poly = (1 / (6 * area_poly)) * lon_value
return lat_poly, lon_poly, abs(area_poly)
def cent_longitude(x = 0):
cent_long = 0
while x < len(polygon)-1:
cent_long += (longitude(polygon[x])+longitude(polygon[x+1]))*\
(latitude(polygon[x])*longitude(polygon[x+1])-\
latitude(polygon[x+1])*longitude(polygon[x]))
x+=1
return (cent_long)/(6*new_area)
def cent_longitude(x=0):
cent_long = 0
while x < len(polygon) - 1:
cent_long += (longitude(polygon[x])+longitude(polygon[x+1]))*\
(latitude(polygon[x])*longitude(polygon[x+1])-\
latitude(polygon[x+1])*longitude(polygon[x]))
x += 1
return (cent_long) / (6 * new_area)
def vert_center(n):
if area(len(polygon) - 1) == 0:
return longitude(polygon[0])
elif n == 0:
return 0
else:
x0, x1 = latitude(polygon[n - 1]), latitude(polygon[n])
y0, y1 = longitude(polygon[n - 1]), longitude(polygon[n])
return (1 / (6 * area(len(polygon) - 1))) * (y0 + y1) * (x0 * y1 - x1 * y0) + vert_center(n - 1)
def area(n):
if (len(polygon) - 1) <= 2:
return 0
elif n == 0:
return 0
else:
x0, x1 = latitude(polygon[n - 1]), latitude(polygon[n])
y0, y1 = longitude(polygon[n - 1]), longitude(polygon[n])
return (1 / 2 * (x0 * y1 - x1 * y0)) + area(n - 1)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
# find area
area = 0
pos = 0
while len(polygon)-1 > pos:
area+=(latitude(polygon[pos])*longitude(polygon[pos+1])-(latitude(polygon[pos+1])*longitude(polygon[pos]))) # area equation
pos = pos + 1 # increment the position index
area = area * (.5) # final part of area calculation
newArea = area # variable that holds the area of polygon we are working with currently
#if the area of the polygon is 0, this returns the initial position
if newArea == 0:
return (latitude(polygon[0]), longitude(polygon[0]), 0)
# finds the central latitude
# initalize center latitude value and pos value
centerLat = 0
pos = 0
while len(polygon)-1 > pos:
# calculate first part of overall latitiude calculation for each polygon
centerLat += (latitude(polygon[pos])+latitude(polygon[pos+1]))*(latitude(polygon[pos])*longitude(polygon[pos+1])-latitude(polygon[pos+1])*longitude(polygon[pos]))
pos+=1 # increment the pos variable to access next polygon
# calculate second part of overall latitude calculation for each polygon
centerLat = (centerLat)/(6*area)
#finds the cenral longitude
pos = 0
centerLong = 0 # initalize center longitude value and pos value
while len(polygon)-1 > pos:
# calculate first part of overall longitude calculation for each polygon
centerLong += (longitude(polygon[pos])+longitude(polygon[pos+1]))*(latitude(polygon[pos])*longitude(polygon[pos+1])-latitude(polygon[pos+1])*longitude(polygon[pos]))
pos+=1
# calculate first part of overall latitude calculation for each polygon
centerLong = (centerLong)/(6*area)
return (centerLat, centerLong, abs(area))
def centroid_helper(fn):
value = 0
i = 0
while i < len(polygon) - 1:
value = value + (fn(polygon[i]) + fn(polygon[i + 1])) * (
(latitude(polygon[i]) * longitude(polygon[i + 1])) -
(latitude(polygon[i + 1]) * longitude(polygon[i])))
i += 1
return value / (6 * area)
def compute_center_y(polygon):
sum = 0
for i in range(num_sides):
expression1 = (longitude(polygon[i]) + longitude(polygon[i + 1]))
expression2 = (latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i]))
sum += expression1 * expression2
if area == 0:
return longitude(polygon[0])
return sum / (6 * area)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # Forces result to be floats
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
n = len(polygon) - 1
A = reduce(add, map(lambda x: latitude(polygon[x])*longitude(polygon[x+1])-\
latitude(polygon[x+1])*longitude(polygon[x]), range(n)))/2
if A == 0:
return latitude(polygon[0]), longitude(polygon[0]), int(A)
else:
Cx = reduce(add, map(lambda x: (latitude(polygon[x])+latitude(polygon[x+1]))\
*(latitude(polygon[x])*longitude(polygon[x+1])-\
latitude(polygon[x+1])*longitude(polygon[x])), range(n)))/(6*A)
Cy = reduce(add, map(lambda x: (longitude(polygon[x])+longitude(polygon[x+1]))\
*(latitude(polygon[x])*longitude(polygon[x+1])-\
latitude(polygon[x+1])*longitude(polygon[x])), range(n)))/(6*A)
return (Cx, Cy, abs(A))
def find_centroid(polygon):
"""
Finds the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
"""
area = 0
x = 0
y = 0
for index in range(0, len(polygon) - 1):
area += (latitude(polygon[index]) * longitude(polygon[index + 1])) - (
latitude(polygon[index + 1]) * longitude(polygon[index]))
if (area == 0):
return latitude(polygon[0]), longitude(polygon[0]), 0
for index in range(0, len(polygon) - 1):
x += (latitude(polygon[index]) + latitude(polygon[index + 1])) * (
(latitude(polygon[index]) * longitude(polygon[index + 1])) -
(latitude(polygon[index + 1]) * longitude(polygon[index])))
y += (longitude(polygon[index]) + longitude(polygon[index + 1])) * (
(latitude(polygon[index]) * longitude(polygon[index + 1])) -
(latitude(polygon[index + 1]) * longitude(polygon[index])))
area = area / 2
x = x / (6 * area)
y = y / (6 * area)
return (x, y, abs(area))
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p2, p1])
(1, 2, 0)
"""
"*** YOUR CODE HERE ***"
#we will talk about this in class, but it is pretty straightforward.
Cx=0
Cy=0
A =0
count = len(polygon)
for i in range(count-1):
point1 = polygon[i]
point2 = polygon[i+1]
x1 = latitude(point1)
x2 = latitude(point2)
y1 = longitude (point1)
y2 = longitude (point2)
foo = x1 * y2
bar = x2 * y1
result = foo - bar
A += result
Cx += (x1+x2)*(x1*y2-x2*y1)
Cy += (y1+y2)*(x1*y2-x2*y1)
A = (A/2.0)
if A == 0 or count <= 3:
Cx = latitude(polygon[0])
Cy = longitude(polygon[0])
A=0
else:
Cx = (Cx/(6.0*A))
Cy = (Cy/ (6.0*A))
A = abs(A)
return(Cx, Cy, A)
def compute_center_x(polygon):
sum = 0
for i in range(num_sides):
expression1 = (latitude(polygon[i]) + latitude(polygon[i + 1]))
expression2 = (latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i]))
# print("i = ",i," ",expression1," * ",expression2," = ", expression1*expression2)
sum += expression1 * expression2
if area == 0:
return latitude(polygon[0])
return sum / (6 * area)
def area(p):
A = 0
n = len(p) - 1
for i in range(n):
plus_i = p[i+1]
pos_i = p[i]
xi = latitude(pos_i)
yi = longitude(pos_i)
xi_plus_1 = latitude(plus_i)
yi_plus_1 = longitude(plus_i)
A = A + (xi * yi_plus_1- xi_plus_1 * yi)
return A/2
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE***"
s_area = 0.0
cen_lat = 0.0
cen_lon = 0.0
#Sum over area
for i in range(0, len(polygon) - 1):
s_area += (latitude(polygon[i]) * longitude(polygon[i + 1])) - (
latitude(polygon[i + 1]) * longitude(polygon[i]))
#Half area
s_area /= 2
#Sum over for centroid latitude and longitude
for i in range(0, len(polygon) - 1):
cen_lat += (latitude(polygon[i]) + latitude(polygon[i + 1])) * s_area
cen_lon += (longitude(polygon[i]) + longitude(polygon[i + 1])) * s_area
#If zero-area return area as 0.0 and return latitude and longitude as is
if (s_area == 0.0):
s_area = 0.0
cen_lat = latitude(polygon[0])
cen_lon = longitude(polygon[0])
#If has area, find centroid latitude, longitude
else:
cen_lat /= (s_area * 6.0)
cen_lon /= (s_area * 6.0)
#Return centroid lat, lon and area
return cen_lat, cen_lon, abs(s_area)
def all_i_need(polygon):
area_value, lat_value, lon_value = 0, 0, 0
for _ in range(len(polygon) - 1):
lat1, lat2, lon1, lon2 = latitude(polygon[_]), latitude(
polygon[_ + 1]), longitude(polygon[_]), longitude(polygon[_ +
1])
area_value += lat1 * lon2 - lat2 * lon1
lat_value += (lat1 + lat2) * (lat1 * lon2 - lat2 * lon1)
lon_value += (lon1 + lon2) * (lat1 * lon2 - lat2 * lon1)
area_poly = .5 * area_value
lat_poly = (1 / (6 * area_poly)) * lat_value
lon_poly = (1 / (6 * area_poly)) * lon_value
return -1 * lat_poly, -1 * lon_poly, abs(area_poly)
def cy(p):
count = 0
n = len(p) - 1
for i in range(n):
plus_i = p[i+1]
pos_i = p[i]
xi = latitude(pos_i)
yi = longitude(pos_i)
xi_plus_1 = latitude(plus_i)
yi_plus_1 = longitude(plus_i)
count = count + (yi + yi_plus_1) * (xi * yi_plus_1 - xi_plus_1 * yi)
A = area(polygon)
return (1/(6*A)) * count
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
counter = 0
x = 0
y = 0
a = 0
the_latitude = 0
the_longitude = 0
the_area = 0
while counter < len(polygon) - 1:
current_x = latitude(polygon[counter])
next_x = latitude(polygon[counter + 1])
current_y = longitude(polygon[counter])
next_y = longitude(polygon[counter + 1])
x -= (current_x + next_x) * (current_x * next_y - next_x * current_y)
y -= (current_y + next_y) * (current_x * next_y - next_x * current_y)
a += (current_x * next_y - next_x * current_y)
counter += 1
if a != 0:
if (a > 0 and (x < 0 or y < 0) or (a < 0 and (x > 0 or y > 0))):
the_area = ( -1 * (a / 2))
the_latitude = ((x) * (1 / (6 * the_area)))
the_longitude = ((y) * (1 / (6 * the_area)))
return ((the_latitude), (the_longitude), abs(the_area))
the_area = abs((a / 2))
the_latitude = (abs(x) * (1 / (6 * the_area)))
the_longitude = (abs(y) * (1 / (6 * the_area)))
return ((the_latitude), (the_longitude), abs(the_area))
return (latitude(polygon[0]), longitude(polygon[0]), 0)
def calculate_summations(polygon, identifier): #1 identifier is for Area. #2 identifier is for centroid_x. #3 identifier is for centroid_y
if polygon[1:]==[]:
return 0
first_point = polygon[0]
second_point = polygon[1]
x_ident = latitude(first_point) + latitude(second_point)
y_ident = longitude(first_point) + longitude(second_point)
summation = latitude(first_point) * longitude(second_point) - latitude(second_point) * longitude(first_point)
if identifier == 1:
return summation + calculate_summations(polygon[1:], 1)
elif identifier == 2:
return summation * x_ident + calculate_summations(polygon[1:], 2)
else:
return summation * y_ident + calculate_summations(polygon[1:], 3)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p2, p1])
(1, 2, 0)
"""
area, cx, cy, i = 0, 0, 0, 0
while i < (len(polygon) - 1):
x0 = latitude(polygon[i])
y0 = longitude(polygon[i])
x1 = latitude(polygon[i+1])
y1 = longitude(polygon[i+1])
sub = (x0 * y1) - (x1 * y0)
area += sub
cx += (x0 + x1) * (sub)
cy += (y0 + y1) * (sub)
i += 1
area *= 0.5
if area != 0:
cx /= (6*area)
cy /= (6*area)
else:
cx = latitude(polygon[0])
cy = longitude(polygon[0])
area = 0
return (cx, cy, abs(area))
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
# lat and lon of 1st position
x_c = [latitude(x) for x in polygon]
y_c = [longitude(x) for x in polygon]
i = 0
total = 0
while i < len(polygon) - 1:
total = total + x_c[i] * y_c[i + 1] - x_c[i + 1] * y_c[i]
i += 1
area = abs(total / 2)
if area == 0:
return [latitude(polygon[0]), longitude(polygon[0])] + [area]
i = 0
total = 0
while i < len(polygon) - 1:
total = total + (x_c[i] + x_c[i + 1]) * (x_c[i] * y_c[i + 1] -
x_c[i + 1] * y_c[i])
i += 1
Cx = abs(total / (6 * area))
i = 0
total = 0
while i < len(polygon) - 1:
total = total + (y_c[i] + y_c[i + 1]) * (x_c[i] * y_c[i + 1] -
x_c[i + 1] * y_c[i])
i += 1
Cy = abs(total / (6 * area))
return [Cx, Cy, area]
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A tuple of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = (p1, p2, p3, p1) # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid((p1, p3, p2, p1))
(3.0, 2.0, 6.0)
>>> find_centroid((p1, p2, p1))
(1, 2, 0)
"""
"*** YOUR CODE HERE ***"
i = 0
area_total = 0
cenlat_total = 0
cenlong_total = 0
while i < len(polygon) - 1:
area_total += (latitude(polygon[i]) * longitude(polygon[i+1])) - (latitude(polygon[i+1])*longitude(polygon[i]))
i += 1
area_total = area_total/2
i = 0
if area_total != 0:
while i < len(polygon) - 1:
cenlat_total += (latitude(polygon[i]) + latitude(polygon[i+1])) * ((latitude(polygon[i])*longitude(polygon[i+1])) - (latitude(polygon[i+1])*longitude(polygon[i])))
cenlong_total += (longitude(polygon[i]) + longitude(polygon[i+1])) * ((latitude(polygon[i])*longitude(polygon[i+1])) - (latitude(polygon[i+1])*longitude(polygon[i])))
i += 1
cenlat_total = cenlat_total/(6*area_total)
cenlong_total = cenlong_total/(6*area_total)
else:
return (latitude(polygon[0]), longitude(polygon[0]), 0)
return (cenlat_total, cenlong_total, abs(area_total))
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A tuple of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = (p1, p2, p3, p1) # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid((p1, p3, p2, p1))
(3.0, 2.0, 6.0)
>>> find_centroid((p1, p2, p1))
(1, 2, 0)
"""
"*** YOUR CODE HERE ***"
def Area(polygon):
l = len(polygon)-1
temp = 0
area =0
while(temp<l):
area+= (latitude(polygon[temp]) *longitude(polygon[temp+1])-latitude(polygon[temp+1])*longitude(polygon[temp]))
temp +=1
area = area/2
return (area)
area = Area(polygon)
l = len(polygon)-1
temp = 0
Cx, Cy = 0, 0
while (temp <l):
Cx += (latitude(polygon[temp])+latitude(polygon[temp+1]))*(latitude(polygon[temp]) *longitude(polygon[temp+1])-latitude(polygon[temp+1])*longitude(polygon[temp]))
Cy += (longitude(polygon[temp])+longitude(polygon[temp+1]))*(latitude(polygon[temp]) *longitude(polygon[temp+1])-latitude(polygon[temp+1])*longitude(polygon[temp]))
temp +=1
if (area)==0:
return latitude(polygon[0]), longitude(polygon[0]), 0
Cx = Cx/(6*area)
Cy = Cy/ (6*area)
return Cx, Cy, abs(area)
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
area = 0
i = 0
while i < len(polygon) - 1:
area = area + ((latitude(polygon[i]) * longitude(polygon[i + 1])) -
(latitude(polygon[i + 1]) * longitude(polygon[i])))
i += 1
area = area / 2
if area == 0:
return latitude(polygon[0]), longitude(polygon[0]), area
def centroid_helper(fn):
value = 0
i = 0
while i < len(polygon) - 1:
value = value + (fn(polygon[i]) + fn(polygon[i + 1])) * (
(latitude(polygon[i]) * longitude(polygon[i + 1])) -
(latitude(polygon[i + 1]) * longitude(polygon[i])))
i += 1
return value / (6 * area)
cx = centroid_helper(latitude)
cy = centroid_helper(longitude)
return cx, cy, abs(area)
def min_distance(position, points):
"""Return a string with the closest dictionary key from a dictionary
of points to a point."""
x_1 = latitude(position)
y_1 = longitude(position)
min_dist = False
for points_key in points:
x_2 = latitude(points[points_key])
y_2 = longitude(points[points_key])
dist = pow(x_2 - x_1, 2)
dist += pow(y_2 - y_1, 2)
dist = pow(dist, 1 / 2)
if not min_dist or dist < min_dist:
min_dist = dist
closest_key = points_key
return closest_key
def group_tweets_by_state(tweets):
"""Return a dictionary that groups tweets by their nearest state center.
The keys of the returned dictionary are state names and the values are
lists of tweets that appear closer to that state center than any other.
Arguments:
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> len(two_tweets_by_state)
2
>>> california_tweets = two_tweets_by_state['CA']
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
lis=[]
for elem in tweets:
lat,lon=latitude(tweet_location(elem)),longitude(tweet_location(elem))
state=closest_state(lat,lon)
lis+=[[state, elem]]
return group_by_key(lis)
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
"*** YOUR CODE HERE ***"
if len(polygon):
return [latitude(polygon[0]),longitude(polygon[0]),0]
else:
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p2, p1])
(1, 2, 0.0)
"""
"*** YOUR CODE HERE ***"
polygon = polygon + [
polygon[0]
] # add first vertex to end but in a way to not change original list
area, cx, cy = 0, 0, 0
for i in range(len(polygon) - 1):
x1 = latitude(polygon[i])
x2 = latitude(polygon[i + 1])
y1 = longitude(polygon[i])
y2 = longitude(polygon[i + 1])
cx += (x1 + x2) * (x1 * y2 - x2 * y1)
cy += (y1 + y2) * (x1 * y2 - x2 * y1)
area += x1 * y2 - x2 * y1
area /= 2
if area == 0:
cx = latitude(polygon[0])
cy = longitude(polygon[0])
else:
cx /= (6 * area)
cy /= (6 * area)
return cx, cy, abs(area)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
element = 0
area = 0
x = 0.0
y = 0.0
vertices = len(polygon) -1
while element < vertices:
x_i = latitude(polygon[element])
x_i_plus1 = latitude(polygon[element + 1])
y_i = longitude(polygon[element])
y_i_plus1 = longitude(polygon[element + 1])
area = area + (x_i * y_i_plus1) - (x_i_plus1 * y_i)
x = x + ((x_i + x_i_plus1) * (((x_i * y_i_plus1) - (x_i_plus1 * y_i))))
y = y + ((y_i + y_i_plus1) * (((x_i * y_i_plus1) - (x_i_plus1 * y_i))))
element += 1
area = area / 2
if area == 0:
x = latitude(polygon[0])
y = longitude(polygon[0])
else:
x = x / (area*6)
y = y / (area*6)
if area <= 0:
area = abs(area)
return x, y, area
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
#Helper function to calculate the area
def area_point_calc(p1,p2):
return (latitude(p1)*longitude(p2))-(latitude(p2)*longitude(p1))
#Helper function to calculate the latitude of the centroid
def lat_center(p1,p2):
return (latitude(p1)+latitude(p2))*(latitude(p1)*longitude(p2)-latitude(p2)*longitude(p1))
#Helper function to calculate the longitude of the centroid
def lon_center(p1,p2):
return (longitude(p1)+longitude(p2))*(latitude(p1)*longitude(p2)-latitude(p2)*longitude(p1))
area=0
i=0
centroid_x=0
centroid_y=0
#Sum up all the areas, centroid_x and centroid_y values
while i < len(polygon)-1:
area += area_point_calc(polygon[i],polygon[i+1])
centroid_x += lat_center(polygon[i],polygon[i+1])
centroid_y += lon_center(polygon[i],polygon[i+1])
i += 1
area=area/2
if area==0:
centroid_x=latitude(polygon[0])
centroid_y=longitude(polygon[0])
#Finish calculating the final values of centroid_x and centroid_y
else:
centroid_x= centroid_x / (6 * area)
centroid_y= centroid_y / (6 * area)
return (centroid_x, centroid_y, abs(area))
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
area = 0
def mathhelper(n, polygon):
x=latitude(polygon[n])
y=longitude(polygon[n])
x2=latitude(polygon[n+1])
y2=longitude(polygon[n+1])
return x*y2-x2*y
for n in range(len(polygon)-1):
#1/2*(x*y2+x2*y)
area+=0.5*mathhelper(n,polygon)
if area==0:
center_x=latitude(polygon[0])
center_y=longitude(polygon[0])
else:
center_x=0
center_y=0
for n in range(len(polygon)-1):
#1/6a*(x+x2)*(x*y2+x2*y)
center_x+=(latitude(polygon[n])+latitude(polygon[n+1]))*(mathhelper(n,polygon))/(6*area)
#1/6a*(y+y2)*(x*y2+x2*y)
center_y+=(longitude(polygon[n])+longitude(polygon[n+1]))*(mathhelper(n,polygon))/(6*area)
return center_x, center_y, abs(area)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
c_lat = 0
c_lon = 0
area = 0
for x in range(len(polygon)-1):
pos0 = polygon[x]
pos1 = polygon[x+1]
fac = (latitude(pos0) * longitude(pos1)) - \
(latitude(pos1) * longitude(pos0))
area += fac
c_lat += (latitude(pos0) + latitude(pos1)) * fac
c_lon += (longitude(pos0) + longitude(pos1)) * fac
if area == 0:
return (latitude(polygon[0]), longitude(polygon[0]), 0)
area = area / 2
c_lat = c_lat / (6 * area)
c_lon = c_lon / (6 * area)
return (c_lat, c_lon, abs(area))
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
area = 0
i = 0
c_x = 0
c_y = 0
while i < (len(polygon) - 1):
area += (latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i]))
i = 1 + i
area = 1 / 2 * (area)
if area == 0:
return latitude(polygon[0]), longitude(polygon[0]), 0
else:
i = 0
while i < (len(polygon) - 1):
c_x += (latitude(polygon[i]) + latitude(polygon[i + 1])) * (
(latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i])))
c_y += (longitude(polygon[i]) + longitude(polygon[i + 1])) * (
(latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i])))
i += 1
c_x = ((1 / (6 * area))) * c_x
c_y = ((1 / (6 * area))) * c_y
return c_x, c_y, abs(area)
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
# get a value for n in the equation on Wikipedia // n = len(polygon) - 1
# compute area // use a for loop "for i in range(n)", implement formula for area
# check if area is zero; if yes, set to first position // set x to latitude(polygon[0]) and y to longitude(polygon[0])
# if not, compute the values of x and y // use a for loop "for i in range(n)", implement formulae for x and y
# return list of x, y and area // make sure to take the absolute value of area
n = len(polygon) - 1
area = 0
x = 0
y = 0
for i in range(n):
area += (latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i])) / 2
if area == 0:
x = latitude(polygon[0])
y = longitude(polygon[0])
else:
for i in range(n):
x += ((latitude(polygon[i]) + latitude(polygon[i + 1])) *
(latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i]))) / (6 *
area)
y += ((longitude(polygon[i]) + longitude(polygon[i + 1])) *
(latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i]))) / (6 *
area)
return [x, y, abs(area)]
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p2, p1])
(1, 2, 0)
"""
"*** YOUR CODE HERE ***"
soma_area = 0
i = 0
while i<(len(polygon) - 1):
soma_area+=(latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i]))
i+=1
area = soma_area/2
if area==0:
return (latitude(polygon[0]), longitude(polygon[0]), 0)
else:
soma_centroide = 0
i = 0
while i<(len(polygon) - 1):
soma_centroide+=(latitude(polygon[i]) + latitude(polygon[i+1])) * (latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i]))
i+=1
latitude_centroide = soma_centroide/(6*area)
soma_centroide = 0
i = 0
while i<(len(polygon) - 1):
soma_centroide+=(longitude(polygon[i]) + longitude(polygon[i+1])) * (latitude(polygon[i]) * longitude(polygon[i+1]) - latitude(polygon[i+1]) * longitude(polygon[i]))
i+=1
longitude_centroide = soma_centroide/(6*area)
return latitude_centroide,longitude_centroide,abs(area)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> list(map(round5, find_centroid(triangle)))
[3.0, 2.0, 6.0]
>>> list(map(round5, find_centroid([p1, p3, p2, p1])))
[3.0, 2.0, 6.0]
>>> list(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
"*** YOUR CODE HERE ***"
cx_minus_coefficient = 0
cy_minus_coefficient = 0
double_area = 0
for i in range(len(polygon)):
if i <= (len(polygon) - 2):
double_area += (latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i]))
area = double_area * (1 / 2)
if area == 0: #a zero area polygon
cx = latitude(polygon[0])
cy = longitude(polygon[0])
else:
for i in range(len(polygon)):
if i <= (len(polygon) - 2):
cx_minus_coefficient += (
latitude(polygon[i]) + latitude(polygon[i + 1])) * (
latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i]))
cx = (1 / (6 * area)) * cx_minus_coefficient
for i in range(len(polygon)):
if i <= (len(polygon) - 2):
cy_minus_coefficient += (
longitude(polygon[i]) + longitude(polygon[i + 1])) * (
latitude(polygon[i]) * longitude(polygon[i + 1]) -
latitude(polygon[i + 1]) * longitude(polygon[i]))
cy = (1 / (6 * area)) * cy_minus_coefficient
return cx, cy, abs(area)
def Area(polygon):
l = len(polygon)-1
temp = 0
area =0
while(temp<l):
area+= (latitude(polygon[temp]) *longitude(polygon[temp+1])-latitude(polygon[temp+1])*longitude(polygon[temp]))
temp +=1
area = area/2
return (area)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, return its first position as its centroid
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> find_centroid(triangle)
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p3, p2, p1])
(3.0, 2.0, 6.0)
>>> find_centroid([p1, p2, p1])
(1, 2, 0)
"""
total = 0
for i in range(len(polygon) - 1):
total += (latitude(polygon[i]) * longitude(polygon[i + 1])) - (
latitude(polygon[i + 1]) * longitude(polygon[i]))
area = total / 2
if area == 0:
return (latitude(polygon[0]), longitude(polygon[0]), 0)
total = 0
for i in range(len(polygon) - 1):
total += (latitude(polygon[i]) + latitude(polygon[i + 1])) * (
(latitude(polygon[i]) * longitude(polygon[i + 1])) -
(latitude(polygon[i + 1]) * longitude(polygon[i])))
centroid_latitude = total / (6 * area)
total = 0
for i in range(len(polygon) - 1):
total += (longitude(polygon[i]) + longitude(polygon[i + 1])) * (
(latitude(polygon[i]) * longitude(polygon[i + 1])) -
(latitude(polygon[i + 1]) * longitude(polygon[i])))
centroid_longitude = total / (6 * area)
if area < 0:
return (centroid_latitude, centroid_longitude, -area)
else:
return (centroid_latitude, centroid_longitude, area)
def find_centroid(polygon):
"""Find the centroid of a polygon.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
polygon -- A list of positions, in which the first and last are the same
Returns: 3 numbers; centroid latitude, centroid longitude, and polygon area
Hint: If a polygon has 0 area, use the latitude and longitude of its first
position as its centroid.
>>> p1, p2, p3 = make_position(1, 2), make_position(3, 4), make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round5 = lambda x: round(x, 5) # Rounds floats to 5 digits
>>> tuple(map(round5, find_centroid(triangle)))
(3.0, 2.0, 6.0)
>>> tuple(map(round5, find_centroid([p1, p3, p2, p1])))
(3.0, 2.0, 6.0)
>>> tuple(map(float, find_centroid([p1, p2, p1]))) # A zero-area polygon
(1.0, 2.0, 0.0)
"""
"*** YOUR CODE HERE ***"
sum_area = 0
sum_lat = 0
sum_lon = 0
length = len(polygon)
for i in range(0, length - 1):
pos_i = polygon[i]
pos_i2 = polygon[i + 1]
common = latitude(pos_i) * longitude(pos_i2) - latitude(
pos_i2) * longitude(pos_i)
sum_area += common
sum_lat += (latitude(pos_i) + latitude(pos_i2)) * common
sum_lon += (longitude(pos_i) + longitude(pos_i2)) * common
area = abs(sum_area / 2)
if (area == 0):
lat = latitude(polygon[0])
lon = longitude(polygon[0])
else:
lat = sum_lat / 6 / sum_area * 2
lon = sum_lon / 6 / sum_area * 2
return lat, lon, area
def find_centroid(polygon):
"""Find the centroid of a polygon. If a polygon has 0 area, use the latitude
and longitude of its first position as its centroid.
http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
Arguments:
polygon -- A list of positions, in which the first and last are the same
Returns 3 numbers: centroid latitude, centroid longitude, and polygon area.
>>> p1 = make_position(1, 2)
>>> p2 = make_position(3, 4)
>>> p3 = make_position(5, 0)
>>> triangle = [p1, p2, p3, p1] # First vertex is also the last vertex
>>> round_all = lambda s: [round(x, 5) for x in s]
>>> round_all(find_centroid(triangle))
[3.0, 2.0, 6.0]
>>> round_all(find_centroid([p1, p3, p2, p1])) # reversed
[3.0, 2.0, 6.0]
>>> apply_to_all(float, find_centroid([p1, p2, p1])) # A zero-area polygon
[1.0, 2.0, 0.0]
"""
"*** YOUR CODE HERE ***"
length = len(polygon) - 1 #as last element same as first
centroid_lat, centroid_long, area, i = 0, 0, 0, 0
while i < length: #formula from Wikipedia
current = polygon[i]
next = polygon[i + 1]
common = (latitude(current) * longitude(next) -
latitude(next) * longitude(current)
) # The common term in the formula for area, lat and lon
centroid_lat += (latitude(current) + latitude(next)) * common
centroid_long += (longitude(current) + longitude(next)) * common
area += 0.5 * common
i += 1
if area == 0:
return latitude(polygon[0]), longitude(polygon[0]), area
centroid_lat = centroid_lat / (6 * area)
centroid_long = centroid_long / (6 * area)
return [centroid_lat, centroid_long, abs(area)]
