def create_intersections_db_by_zip(data):
"""This function creates a database of the coordinates and streets of all intersections in a mile radius of a given zipcode. Currently set to drive network and a radius of 1610m (1 mile). Edit the parameters in line 81 to fit your preferences"""
d = data[1]
zipcode = d[1]
city = d[2]
state = d[3]
county = d[4]
tablename = "intersections_" + str(zipcode)
try:
cur.execute(
"CREATE TABLE " + tablename +
" (zip_code TEXT, city TEXT, state TEXT, county TEXT, latlon_str TEXT);"
)
latlon_array = []
streetname_array = []
latlon_array_str = ""
streetname_array_str = ""
try:
G = ox.graph_from_address(zipcode,
network_type='drive',
distance=1610)
G_proj = ox.project_graph(G)
# clean up the intersections and extract their xy coords
intersections = ox.clean_intersections(G_proj,
tolerance=15,
dead_ends=False)
points = np.array([point.xy for point in intersections])
gdf = gpd.GeoDataFrame(geometry=intersections)
gdf.crs = G_proj.graph['crs']
lonlat = ox.project_gdf(gdf, to_latlong=True)
a = lonlat['geometry'].tolist()
for coord in a:
lon = coord.x
lat = coord.y
latlon_tuple = (lat, lon)
# nearest_streets = get_nearest_streetnames(latlon_tuple)
# streetname_array.append(nearest_streets)
latlon_array.append(latlon_tuple)
except:
#THROW A WARNING THAT THERE IS NO LAT/LON DATA FOR THIS ZIPCODE
pass
latlon_array_str = str(latlon_array).strip('[]')
# streetname_array_str = str(streetname_array).strip('[]')
to_db = [zipcode, city, state, county, latlon_array_str]
cmd = "INSERT INTO " + tablename + " (zip_code, city, state, county,latlon_str) VALUES (?, ?, ?, ?, ?);"
cur.execute(cmd, to_db)
for row in cur.execute("SELECT * from " + tablename):
print(row)
except:
print(tablename + " already exists")
def get_nearest_streetnames(location_tuple, distFromPoint=50):
"""This function retrieves the nearest streets of a coordinate tuple (lat, lon). Currently set to drive network. Edit the parameters in line 40 to fit your preferences."""
try:
G = ox.graph_from_point(location_tuple,
network_type='drive',
distance=distFromPoint)
G = ox.project_graph(G)
ints = ox.clean_intersections(G)
gdf = gpd.GeoDataFrame(ints, columns=['geometry'], crs=G.graph['crs'])
X = gdf['geometry'].map(lambda pt: pt.coords[0][0])
Y = gdf['geometry'].map(lambda pt: pt.coords[0][1])
nodes = ox.get_nearest_nodes(G, X, Y, method='kdtree')
streetnames = []
for n in nodes:
for nbr in nx.neighbors(G, n):
for d in G.get_edge_data(n, nbr).values():
if 'name' in d:
if type(d['name']) == str:
streetnames.append(d['name'])
elif type(d['name']) == list:
for name in d['name']:
streetnames.append(name)
streetnames = list(set(streetnames))
except:
streetnames = []
return streetnames
def connections(place):
'''
inputs - textual query specifying spatial boundaries of some geocodeable place(s)
returns - tuples of street intersections using OSM data
'''
# Create a networkx graph from OSM data within the spatial boundaries of geocodable place(s).
G = ox.graph_from_place(place, network_type='drive', timeout=3600)
# Project a graph from lat-long to the UTM zone appropriate for its geographic location.
# https://en.wikipedia.org/wiki/Universal_Transverse_Mercator_coordinate_system
Gp = ox.project_graph(G)
# Clean-up intersections comprising clusters of nodes by merging them and returning their centroids
ints = ox.clean_intersections(Gp)
# create a dataframe of intersections
gdf = gpd.GeoDataFrame(ints, columns=['geometry'], crs=Gp.graph['crs'])
# generate lists of X, Y locations (UTM zone)
X = gdf['geometry'].map(lambda pt: pt.coords[0][0])
Y = gdf['geometry'].map(lambda pt: pt.coords[0][1])
nodes = ox.get_nearest_nodes(Gp, X, Y, method='kdtree')
connections = {}
intersections = []
for n in nodes:
dict = {
'osmid': G.nodes()[n]['osmid'],
'latitude': G.nodes()[n]['y'],
'longitude': G.nodes()[n]['x']
}
# print(dict)
connections[n] = set([])
for nbr in nx.neighbors(G, n):
for d in G.get_edge_data(n, nbr).values():
if 'name' in d:
if type(d['name']) == str:
connections[n].add(d['name'])
elif type(d['name']) == list:
for name in d['name']:
connections[n].add(name)
else:
connections[n].add(None)
else:
connections[n].add(None)
if len(connections) > 0:
dict['streets'] = list(connections[n])
print(dict)
intersections.append(dict)
return intersections
def test_plots():
G = ox.graph_from_place('Piedmont, California, USA',
network_type='drive',
simplify=False)
G2 = ox.simplify_graph(G, strict=False)
nc = ox.get_node_colors_by_attr(G2, 'osmid')
ec = ox.get_edge_colors_by_attr(G2, 'length')
fig, ax = ox.plot_graph(G, save=True, file_format='png')
G_simplified = ox.simplify_graph(G)
fig, ax = ox.plot_graph(G_simplified,
show=False,
save=True,
close=True,
file_format='svg')
G_projected = ox.project_graph(G_simplified)
intersections = ox.clean_intersections(G_projected)
fig, ax = ox.plot_graph(G_projected)
fig, ax = ox.plot_graph(G_projected,
fig_height=5,
fig_width=5,
margin=0.05,
axis_off=False,
bgcolor='y',
file_format='png',
filename='x',
dpi=180,
annotate=True,
node_color='k',
node_size=5,
node_alpha=0.1,
node_edgecolor='b',
node_zorder=5,
edge_color='r',
edge_linewidth=2,
edge_alpha=0.1,
use_geom=False,
show=False,
save=True,
close=True)
fig, ax = ox.plot_figure_ground(G=G_simplified, file_format='png')
fig, ax = ox.plot_figure_ground(point=(33.694981, -117.841375),
file_format='png')
fig, ax = ox.plot_figure_ground(address='Denver, Colorado, USA',
file_format='png')
def test_stats():
# create graph, add bearings, project it
G = ox.graph_from_point(location_point, dist=500, network_type="drive")
G = ox.add_edge_bearings(G)
G_proj = ox.project_graph(G)
# calculate stats
stats = ox.basic_stats(G)
stats = ox.basic_stats(G, area=1000)
stats = ox.basic_stats(
G_proj, area=1000, clean_intersects=True, tolerance=15, circuity_dist="euclidean"
)
# calculate extended stats
stats = ox.extended_stats(G, connectivity=True, anc=False, ecc=True, bc=True, cc=True)
# test cleaning and rebuilding graph
G_clean = ox.clean_intersections(G_proj, tolerance=10, rebuild_graph=True, dead_ends=True)
def getIntersections(boundary, projection, tolerance=100):
'''
INPUT: boundary shap
projection in UTM
int (in meters) representing tolerance of clean_intersections() function for osmnx package
OUTPUT: GeoSeries of Intersections
'''
# Create Graph
G = ox.graph_from_polygon(boundary, network_type='drive')
ox.plot_graph(G)
plt.show()
# Clean Intersections
G_proj = ox.project_graph(G, to_crs=projection)
intersections = ox.clean_intersections(G_proj,
tolerance=tolerance,
dead_ends=False)
return intersections
def get_voronoi_grid(G, tolerance=15, remove_random=None, buffer=20, cutt_buffer= 400, remove_empty = True,
exclude_highways=None, is_dual=False, primal_graph=None, max_area_m=None,
cutt_geom = 'convex_hull'):
""" Função que recebe um grafo e retorna os poligonos das regiões voronoi associadas a cada ponto.
G: grafo (geralmente obtido com o osmnx);
cut_extremes: bool - se True, constroe um retangulo que abrange os pontos extremos do grafo e recorta regiões que
possivelmente saem desses limites.
Retorna:
voronoi_gdf: GeoDataFrame com os pontos (coordenadas) e os poligonos das regiões criadas;
p_pol: dicionário com os tuplas das coordenadas dos pontos como key e os poligonos como values
vor: instancia voronoi, que pode ser usada para plotar os pontos e as regiões
"""
# Criando um vetor com os pontos do grafo a partir do gdf do mesmo
if not is_dual:
primal_graph = G
if exclude_highways != None:
exclude_highways = list(exclude_highways)
ids = []
G_ = G.copy()
G_proj = ox.project_graph(G)
for node, d in G.nodes(data=True):
if d['osmid'] in ids:
G_.remove_node(node)
else:
ids.append(d['osmid'])
intersections = ox.clean_intersections(G_proj, tolerance=tolerance)
points = gpd.GeoDataFrame({'geometry':intersections},crs=G_proj.graph['crs'])
points = points.to_crs(G_.graph['crs']).geometry
if remove_random != None:
points = [(p.x,p.y) for p in points if random.random()>=remove_random]
else:
points = [(p.x,p.y) for p in points]
point_list = np.array(points)
# Criação da classe Voronoi, com os respectivos vertices e regiões
vor = Voronoi(point_list)
verts = vor.vertices.tolist()
regs = vor.regions
pr = vor.point_region
p_reg = {}
p_pol = []
p_coo = []
# cada pr[i] é um índice da lista de regiões relacionada ao ponto de índice i da lista verts
for i in range(len(pr)):
point = tuple(point_list[i])
r = regs[pr[i]] # cada r é uma região, expressa por uma lista com os índices dos vertices que a compõem
if (-1 in r) or (len(r)==0): continue # ignora regiões inexistentes ou infinitas
else:
p_reg[point] = [verts[v] for v in r] # dicionário com ponto as key e região as value
p_pol.append(Polygon(p_reg[point]))
p_coo.append(point)
voronoi_gdf = gpd.GeoDataFrame({'id': [n for n in range(len(p_pol))],'geometry': list(p_pol), 'coord': p_coo},
crs=G_.graph['crs'])
if cutt_geom!=None:
voronoi_gdf = cutt_from_predef_geometry(primal_graph, voronoi_gdf, G_proj=G_proj, geom_type = cutt_geom,
cutt_buffer=cutt_buffer)
if remove_empty:
polys = remove_excess_polys(primal_graph, voronoi_gdf, buffer=buffer, exclude_highways=exclude_highways)
if max_area_m != None:
polys_proj = polys.to_crs(G_proj.graph['crs'])
polys = polys[polys_proj.geometry.area<=max_area_m]
return polys
return voronoi_gdf