def load_graphs(name):
'''
Load the graphs (bike and drive) and the CSV with the results of the algorithm into the script.
---
name: str name of the city to be loaded
layer: str layer to be loaded, it can be: drive, bike, walk, rail.
returns: Networkx MultiDiGraph
'''
crs = {
'Phoenix': {
'init': 'epsg:2763'
},
'Detroit': {
'init': 'epsg:2763'
},
'Manhattan': {
'init': 'epsg:2763'
},
'Amsterdam': {
'init': 'epsg:32633'
},
'Mexico': {
'init': 'epsg:6372'
},
'London': {
'init': 'epsg:32633'
},
'Singapore': {
'init': 'epsg:3414'
},
'Budapest': {
'init': 'epsg:32633'
},
'Copenhagen': {
'init': 'epsg:32633'
},
'Barcelona': {
'init': 'epsg:32633'
},
'Portland': {
'init': 'epsg:26949'
},
'Bogota': {
'init': 'epsg:3116'
},
'LA': {
'init': 'epsg:2763'
},
'Jakarta': {
'init': 'epsg:5331'
}
}
G_bike = ox.load_graphml('{}/{}_bike.graphml'.format(name, name))
G_bike = ox.project_graph(G_bike, to_crs=crs[name])
G_drive = ox.load_graphml('{}/{}_drive.graphml'.format(name, name))
G_drive = ox.project_graph(G_drive, to_crs=crs[name])
return G_bike, G_drive
def simplify_network(network):
"""
Simplifies a given road-network using OSMnx.
"""
network_proj = ox.project_graph(network)
simplified_proj = ox.consolidate_intersections(network_proj,
rebuild_graph=True,
tolerance=50,
dead_ends=False)
simplified = ox.project_graph(simplified_proj, network.graph["crs"])
return simplified
def get_streets(perimeter=None,
point=None,
radius=None,
dilate=6,
custom_filter=None):
if perimeter is not None:
# Boundary defined by polygon (perimeter)
streets = ox.graph_from_polygon(union(perimeter.geometry),
custom_filter=custom_filter)
streets = ox.project_graph(streets)
streets = ox.graph_to_gdfs(streets, nodes=False)
#streets = ox.project_gdf(streets)
streets = MultiLineString(list(streets.geometry)).buffer(dilate)
elif (point is not None) and (radius is not None):
# Boundary defined by polygon (perimeter)
streets = ox.graph_from_point(point,
dist=radius,
custom_filter=custom_filter)
crs = ox.graph_to_gdfs(streets, nodes=False).crs
streets = ox.project_graph(streets)
perimeter = GeoDataFrame(geometry=[Point(point[::-1])], crs=crs)
perimeter = ox.project_gdf(perimeter).geometry[0].buffer(radius)
streets = ox.graph_to_gdfs(streets, nodes=False)
streets = MultiLineString(
list(
filter(
# Filter lines with at least 2 points
lambda line: len(line) >= 2,
# Iterate over lines in geometry
map(
# Filter points within perimeter
lambda line: list(
filter(lambda xy: Point(xy).within(perimeter),
zip(*line.xy))),
streets.geometry)))).buffer(dilate) # Dilate lines
if not isinstance(streets, Iterable):
streets = [streets]
streets = list(map(pathify, streets))
return streets, perimeter
def test_network_saving_loading():
# save/load graph as shapefile and graphml file
G = ox.graph_from_place('Piedmont, California, USA')
G_projected = ox.project_graph(G)
ox.save_graph_shapefile(G_projected)
ox.save_graphml(G_projected)
ox.save_graphml(G_projected, filename='gephi.graphml', gephi=True)
G2 = ox.load_graphml('graph.graphml')
G3 = ox.load_graphml('graph.graphml', node_type=str)
# convert graph to node/edge GeoDataFrames and back again
gdf_edges = ox.graph_to_gdfs(G, nodes=False, edges=True, fill_edge_geometry=False)
gdf_nodes, gdf_edges = ox.graph_to_gdfs(G, nodes=True, edges=True, node_geometry=True, fill_edge_geometry=True)
G4 = ox.gdfs_to_graph(gdf_nodes, gdf_edges)
# find graph nodes nearest to some set of points
X = gdf_nodes['x'].head()
Y = gdf_nodes['y'].head()
nn1 = ox.get_nearest_nodes(G, X, Y)
nn2 = ox.get_nearest_nodes(G, X, Y, method='kdtree')
nn3 = ox.get_nearest_nodes(G, X, Y, method='balltree')
# find graph edges nearest to some set of points
ne1 = ox.get_nearest_edges(G, X, Y)
ne2 = ox.get_nearest_edges(G, X, Y, method='kdtree')
ne3 = ox.get_nearest_edges(G, X, Y, method='kdtree', dist=50)
def city_statistics(city: str):
result = {'city': city}
G = get_graph(city)
if G is None:
return result
G_proj = ox.project_graph(G)
nodes_proj = ox.graph_to_gdfs(G_proj, edges=False)
area = compute_area_m(nodes_proj)
result['area_km'] = area / 1e6
bs = compute_basic_stats(G, area)
#basic statistics from osmnx
result.update(bs)
result.update(edge_length_stats(G))
result.update(degree_stats(G))
orig_point = compute_center(nodes_proj)
node0 = ox.get_nearest_node(G_proj, (orig_point.y, orig_point.x),
method='euclidean',
return_dist=False)
# print('node0 ', node0)
central_paths = compute_paths(G_proj, node0)
result['central_sp_mean'] = central_paths[0]
result['central_sp_std'] = central_paths[1]
# result.update(compute_extended_stats(G))
# print(result)
return result
def load_grid_edges(grid_x, grid_y, crs):
x1 = grid_x - GRID_SIZE / 2
x2 = grid_x + GRID_SIZE + GRID_SIZE / 2
y1 = grid_y - GRID_SIZE / 2
y2 = grid_y + GRID_SIZE + GRID_SIZE / 2
ls = LineString([
[x1, y1],
[x2, y1],
[x2, y2],
[x1, y2],
[x1, y1],
])
t = gpd.GeoDataFrame(geometry=[ls], crs=crs)
tll = ox.project_gdf(t, to_latlong=True)
west, south, east, north = tll.total_bounds
try:
tgp = ox.project_graph(ox.graph_from_bbox(
north, south, east, west,
truncate_by_edge=True, simplify=True, clean_periphery=False, network_type='all', retain_all=True
))
tnp, tep = ox.graph_to_gdfs(tgp, nodes=True, edges=True)
return tep
except ox.core.EmptyOverpassResponse:
pass
return gpd.GeoDataFrame(geometry=[])
def detect_drive_network_from_point(lat=13.14633,
lon=77.514386,
distance=2000,
save=True,
filename='icts2000'):
G = ox.graph_from_point((lat, lon),
distance=distance,
network_type='drive',
simplify=False)
hwy_types = ['primary', 'motorway', 'trunk']
gdf = ox.graph_to_gdfs(G, nodes=False)
mask = ~gdf['highway'].map(lambda x: isinstance(x, str) and x in hwy_types)
edges = zip(gdf[mask]['u'], gdf[mask]['v'], gdf[mask]['key'])
G.remove_edges_from(edges)
G = ox.remove_isolated_nodes(G)
G_projected = ox.project_graph(G)
filename += '-' + str(distance)
fig, ax = ox.plot_graph(G_projected,
show=False,
save=save,
filename=filename,
file_format='svg')
plt.scatter(*utm.from_latlon(lat, lon)[:2])
plt.show()
ox.save_graphml(G, filename=filename + '.graphml')
return G
def get_map_data_with_elevation(self, city_name, key):
# get model data from osmnx of 2d and elevation
#city_name = 'Amherst' # 'Springfield'
place_query = {
'city': city_name,
'state': 'Massachusetts',
'country': 'USA'
}
graph_orig = ox.graph_from_place(place_query, network_type='walk')
#add Elevation data from GoogleMaps
key = self.get_key()
graph_orig = ox.add_node_elevations(
graph_orig, api_key=key
) # 'AIzaSyDVqjj0iKq0eNNHlmslH4fjoFgRj7n-5gs') # from elevation
graph_orig = ox.add_edge_grades(graph_orig)
pkl.dump(graph_orig, open("data/" + city_name + "_city_graph.pkl",
"wb"))
#project map on to 2D space
graph_project = ox.project_graph(graph_orig)
pkl.dump(graph_project,
open("data/" + city_name + "_city_graph_projected.pkl", "wb"))
#print ("pkl: ", type(graph_orig))
return graph_project, graph_orig
def download_data(self):
all_g = []
for address in self.addresses:
print('Address: ', address)
if self.check_data_exists(address):
G = pickle.load(open(self.save_path + '/addresses/{}.p'.format(address), 'rb'))
else:
G = ox.graph_from_place(address, network_type='drive')
G = ox.project_graph(G)
pickle.dump(G, open(self.save_path + '/addresses/{}.p'.format(address), 'wb'))
all_g.append(G)
for i, g in enumerate(all_g):
if i == 0:
raw_data = pd.DataFrame([data for u, v, key, data in g.edges(keys=True, data=True)])
else:
d = nx.to_pandas_edgelist(g)
raw_data = pd.concat(d, raw_data)
raw_data.to_csv(self.save_path + '/raw_data/raw.csv')
return raw_data
def GenerateIsoPoints(lon, lat, time, speed):
'''
Function generates points cloud of isochrone from OSM
depending on route type.
Returns list of points.
'''
distance = speed * 1000 / 60 * time * 1.5
streets_graph = ox.graph_from_point([lat, lon], distance=distance, network_type=route, simplify=False)
center_node = ox.get_nearest_node(streets_graph, (lat, lon), method='euclidean')
streets_graph.add_node('dummy', osmid=999999999, x=lon, y=lat)
dummy_length = geopy.distance.vincenty((streets_graph.node['dummy']['y'], streets_graph.node['dummy']['x']),
(streets_graph.node[center_node]['y'], streets_graph.node[center_node]['x'])).m
streets_graph.add_edge('dummy', center_node, length=dummy_length)
projected_graph = ox.project_graph(streets_graph)
travel_speed = speed
meters_per_minute = travel_speed * 1000 / 60
for u, v, k, data in projected_graph.edges(data=True, keys=True):
data['time'] = data['length'] / meters_per_minute
subgraph = nx.ego_graph(projected_graph, center_node, radius=time, distance='time')
node_points = [[data['lon'], data['lat']] for node, data in subgraph.nodes(data=True)]
points = np.array(node_points)
return points
def __init__ (self, village, province, country, roads_type='drive'):
"""
Initialize.
:param village: <str> The village to download from OpenMaps
:param province: <str> The province the villange belongs to
:param country: <str> The country
:param roads_type: <str> The type of roads to download. Possibilities
are drive, bike, and walk.
:attr place_name: <str> The place downloaded from OpenMaps
:attr nodes: <dict> The list of nodes
:attr edges: <dict> The list of edges
:attr graph: <networkx.classes.multidigraph.MultiDiGraph> The full graph object
"""
self.place_name = ", ".join((village, province, country))
print (f"Scraping of {self.place_name}...", end="")
g = ox.project_graph(ox.graph_from_place (self.place_name, network_type=roads_type))
self.nodes_gpd, self.edges_gpd = ox.graph_to_gdfs (g, nodes=True, edges=True)
self.nodes = {i : Node(n, n.osmid, n.x, n.y, n.lat, n.lon, n.geometry) for i, n in self.nodes_gpd.iterrows()}
self.edges = {i : Edge(e, e.osmid, e.name, e.highway, e.oneway, e.length, e.geometry, e.maxspeed, e.lanes, e.u, e.v)
for i, e in self.edges_gpd.iterrows()}
self.graph = g
print ("done")
def test_stats():
# create graph, add bearings, project it
location_point = (37.791427, -122.410018)
G = ox.graph_from_point(location_point,
distance=500,
distance_type='network')
G = ox.add_edge_bearings(G)
G_proj = ox.project_graph(G)
# calculate stats
stats1 = ox.basic_stats(G)
stats2 = ox.basic_stats(G, area=1000)
stats3 = ox.basic_stats(G_proj,
area=1000,
clean_intersects=True,
tolerance=15,
circuity_dist='euclidean')
# calculate extended stats
stats4 = ox.extended_stats(G,
connectivity=True,
anc=False,
ecc=True,
bc=True,
cc=True)
def load_map(location='Manhattan, New York, USA',
cache_directory='/tmp',
force_redownload=False):
cached_filename = hashlib.md5(location).hexdigest() + '.graphml'
try:
if force_redownload:
raise IOError('Forcing re-download of graph.')
logging.info('Trying to load map from "%s"',
os.path.join(cache_directory, cached_filename))
graph = ox.load_graphml(cached_filename, folder=cache_directory)
except IOError:
logging.info('Downloading map from "%s"', location)
graph = ox.graph_from_place(location, network_type='drive')
# Keep the largest strongly connected component.
logging.info('Finding largest component')
graph = max(nx.strongly_connected_component_subgraphs(graph), key=len)
graph = ox.project_graph(graph)
logging.info('Saving map to "%s"',
os.path.join(cache_directory, cached_filename))
ox.save_graphml(graph,
filename=cached_filename,
folder=cache_directory)
# Add dummy speed and length information.
for u, v, key, data in graph.edges(data=True, keys=True):
if 'time' not in data:
time = data['length'] / _DEFAULT_SPEED
data['time'] = time
data['speed'] = _DEFAULT_SPEED
else:
data['time'] = float(data['time'])
data['speed'] = float(data['speed'])
graph.add_edge(u, v, **data)
return graph
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 test_plots():
G = ox.graph_from_place('Piedmont, California, USA', network_type='drive', simplify=False)
G2 = ox.simplify_graph(G, strict=False)
# test getting colors
co = ox.get_colors(n=5, return_hex=True)
nc = ox.get_node_colors_by_attr(G2, 'osmid')
ec = ox.get_edge_colors_by_attr(G2, 'length')
# save a plot to disk as png
fig, ax = ox.plot_graph(G, save=True, file_format='png')
# save a plot to disk as svg
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)
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 read_proj_graphml(proj_graphml_filepath, ori_graphml_filepath, to_crs):
"""
Read a projected graph from local disk if exist,
otherwise, reproject origional graphml to the UTM zone appropriate for its geographic location,
and save the projected graph to local disk
Parameters
----------
proj_graphml_filepath: string
the projected graphml filepath
ori_graphml_filepath: string
the original graphml filepath
to_crs: dict or string or pyproj.CRS
project to this CRS
Returns
-------
networkx multidigraph
"""
# if the projected graphml file already exist in disk, then load it from the path
if os.path.isfile(proj_graphml_filepath):
print("Read network from disk.")
return ox.load_graphml(proj_graphml_filepath)
# else, read original study region graphml and reproject it
else:
print("Reproject network, and save the projected network to disk")
# load and project origional graphml from disk
G = ox.load_graphml(ori_graphml_filepath)
G_proj = ox.project_graph(G, to_crs=to_crs)
# save projected graphml to disk
ox.save_graphml(G_proj, proj_graphml_filepath)
return G_proj
def test_nearest_edges():
from pyproj import Proj
# test in closest edge section
sheik_sayed_dubai = [25.09, 25.06, 55.16, 55.11]
location_coordinates = (25.071764, 55.138978)
G = ox.graph_from_bbox(*sheik_sayed_dubai,
simplify=False,
retain_all=True,
network_type='drive')
# Unprojected
ne1 = ox.get_nearest_edges(
G,
X=[location_coordinates[1], location_coordinates[1]],
Y=[location_coordinates[0], location_coordinates[0]],
method='balltree',
dist=0.0001)
# Projected
G2 = ox.project_graph(G)
crs = Proj(G2.graph['crs'])
projected_point = crs(location_coordinates[1], location_coordinates[0])
ne2 = ox.get_nearest_edges(G2,
X=[projected_point[0], projected_point[0]],
Y=[projected_point[1], projected_point[1]],
method='kdtree',
dist=10)
assert (ne1 == ne2).all()
def save_graph(target, graph_name, distance=1000, is_address=True):
# Load graph from OSM
if is_address:
graph = ox.graph_from_address(address=target,
distance=distance,
network_type='drive')
else:
graph = ox.graph_from_place(query=target, network_type='drive')
# Project graph
graph_proj = ox.project_graph(graph)
folder_path = path.join('graphs', graph_name)
if not path.exists(folder_path):
mkdir(folder_path)
graph_data = graph_proj.graph
serialize_dict(dictionary=graph_data,
file_path=path.join(folder_path, 'graph_data.pkl.gz'))
# We make the graph strongly connected to ensure that any combination of source / sink
# constitutes a valid problem
graph_component = ox.get_largest_component(graph_proj,
strongly=True).to_directed()
# Save pictures of the graph
plot_road_graph(graph_component,
graph_name=graph_name,
file_path=path.join(folder_path, 'graph'))
# Save graph
ox.save_graphml(graph_component,
filename='graph.graphml',
folder=folder_path,
gephi=True)
# Save a selection of graph-wide stats.
stats_file = path.join(folder_path, 'stats.csv')
delete_if_exists(stats_file)
n_nodes = graph_component.number_of_nodes()
n_edges = graph_component.number_of_edges()
avg_in_deg = np.average([d for _, d in graph_component.in_degree()])
avg_out_deg = np.average([d for _, d in graph_component.out_degree()])
diam = nx.diameter(graph_component)
append_row_to_log(['Number of Nodes', n_nodes], stats_file)
append_row_to_log(['Number of Edges', n_edges], stats_file)
append_row_to_log(['Average In Degree', avg_in_deg], stats_file)
append_row_to_log(['Average Out Degree', avg_out_deg], stats_file)
append_row_to_log(['Diameter', diam], stats_file)
cleaned_target = target.replace('\"', '').replace('\'',
'').replace(',', '')
query = '{0}; Dist: {1}'.format(cleaned_target,
distance) if is_address else cleaned_target
append_row_to_log(['Query', query], stats_file)
return graph_component
def test_stats():
# create graph, add bearings, project it
location_point = (37.791427, -122.410018)
G = ox.graph_from_point(location_point,
distance=500,
distance_type='network')
G = ox.add_edge_bearings(G)
G_proj = ox.project_graph(G)
# calculate stats
stats1 = ox.basic_stats(G)
stats2 = ox.basic_stats(G, area=1000)
stats3 = ox.basic_stats(G_proj,
area=1000,
clean_intersects=True,
tolerance=15,
circuity_dist='euclidean')
try:
stats4 = ox.extended_stats(G,
connectivity=True,
anc=True,
ecc=True,
bc=True,
cc=True)
except NetworkXNotImplemented as e:
warnings.warn(
"Testing coordinates results in a MultiDigraph, and extended stats are not available for it"
)
warnings.warn(e.args)
def use_osmnx() -> None:
graph = ox.graph_from_place('Leuven, Belgium', network_type='drive')
graph_proj = ox.project_graph(graph)
# Create GeoDataFrames
# Approach 1
nodes_proj, edges_proj = ox.graph_to_gdfs(graph_proj,
nodes=True,
edges=True)
for nid, row in nodes_proj[['x', 'y']].iterrows():
map_con.add_node(nid, (row['x'], row['y']))
for nid, row in edges_proj[['u', 'v']].iterrows():
map_con.add_edge(row['u'], row['v'])
# Approach 2
nodes, edges = ox.graph_to_gdfs(graph_proj, nodes=True, edges=True)
nodes_proj = nodes.to_crs("EPSG:3395")
edges_proj = edges.to_crs("EPSG:3395")
for nid, row in nodes_proj.iterrows():
map_con.add_node(nid, (row['lat'], row['lon']))
# adding edges using networkx graph
for nid1, nid2, _ in graph.edges:
map_con.add_edge(nid1, nid2)
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 load_graph(graph_name):
folder_path = path.join('graphs', graph_name)
graph_data = deserialize_dict(
file_path=path.join(folder_path, 'graph_data.pkl.gz'))
graph = ox.load_graphml(filename='graph.graphml', folder=folder_path)
# graph = nx.MultiDiGraph(nx.read_graphml(path.join(folder_path, 'graph.graphml'), node_type=int))
if not nx.is_strongly_connected(graph):
graph = ox.get_largest_component(graph, strongly=True)
node_mapping = {node: i for i, node in enumerate(sorted(graph.nodes()))}
graph = nx.relabel_nodes(graph, node_mapping)
# Ensure nodes and edges are ordered consistently
G = nx.MultiDiGraph()
for node, data in sorted(graph.nodes(data=True), key=lambda t: t[0]):
data['demand'] = 0
G.add_node(node, **data)
for src, dst, data in sorted(graph.edges(data=True),
key=lambda t: (t[0], t[1])):
# Remove parallel edges and self-loops
if src == dst or (src in G and dst in G[src]):
continue
# Dummy data for compatibility with plotter
data['zero'] = 0
G.add_edge(src, dst, key=0, **data)
G.graph['crs'] = graph_data['crs']
G.graph['name'] = graph_data['name']
G = ox.project_graph(G, to_crs=graph_data['crs'])
return G.to_directed()
def plot_edge_grades():
files_map = '../data/maps/m43.96267779776494_m19.944747838679202_m43.929659815391865_m19.905049264605925.graphml'
G = ox.load_graphml(files_map)
max_lat = -12.934333867695516
min_lat = -12.961083555974895
max_lon = -38.473331269107426
min_lon = -38.49996781691653
name_geotiff = '../data/maps/19S45_ZN.tif'
G = ox.graph_from_bbox(max_lat,
min_lat,
max_lon,
min_lon,
network_type='all')
G = Graph.set_node_elevation(G, name_geotiff)
# deadends = [(u, v) for u, v, k, data in G.edges(keys=True, data=True) if data['highway'] == '']
# print(deadends)
# G2.remove_nodes_from(deadends)
G = Graph.edge_grades(G)
G_proj = ox.project_graph(G)
ec = ox.plot.get_edge_colors_by_attr(G_proj,
"grade",
cmap="plasma",
num_bins=5,
equal_size=True)
fig, ax = ox.plot_graph(G_proj,
edge_color=ec,
edge_linewidth=0.5,
node_size=0,
bgcolor="w")
def get_graph(place):
string = place.split(',')[0]
print('Fetching graph data for {}'.format(place))
poly = get_polygon(string)
if poly == -1:
gdf = ox.gdf_from_place('{}'.format(string))
G = ox.graph_from_bbox(gdf.bbox_north, gdf.bbox_south, gdf.bbox_east,
gdf.bbox_west)
val = 0
else:
try:
G = nx.read_gpickle('data/{a}/{a}'.format(a=string))
val = 1
except FileNotFoundError:
G = ox.graph_from_polygon(poly, network_type='drive')
val = 0
G = ox.project_graph(G)
print('Writing graph file')
try:
os.mkdir('data/{}'.format(string))
except FileExistsError:
pass
if val != 1:
nx.write_gpickle(G, path='data/{a}/{a}'.format(a=string))
return G
def test_plots():
G = ox.graph_from_place('Piedmont, California, USA', network_type='drive', simplify=False)
G2 = ox.simplify_graph(G, strict=False)
# test getting colors
co = ox.get_colors(n=5, return_hex=True)
nc = ox.get_node_colors_by_attr(G2, 'osmid')
ec = ox.get_edge_colors_by_attr(G2, 'length')
# save a plot to disk as png
fig, ax = ox.plot_graph(G, save=True, file_format='png')
# save a plot to disk as svg
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)
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 get_OSM_edges_gdf(shapefile_path, OSM_folder, polygon=None, network_type= 'walk'):
"""
If studyregion gdf file exist:
Load a (projected) edge shapefile from disk
Else: query OSM to get the network gdf.
Parameters
----------
shapefile_path : string
the name of the shapefile path(including file extension)
OSM_folder : string
the folder containing the OSM file, if None, use default data folder
polygon : shapely Polygon or MultiPolygon
the shape to get network data within. coordinates should be in units of
latitude-longitude degrees.
network_type : string
what type of street network to get. Default type is pedestrain network
Returns
-------
GeoDataFrame
"""
if os.path.exists(shapefile_path):
edges = gpd.GeoDataFrame.from_file(shapefile_path)
else:
G = ox.graph_from_polygon(polygon, network_type=network_type, retain_all = True)
G_proj = ox.project_graph(G)
edges = ox.graph_to_gdfs(G_proj, nodes=False, edges=True, fill_edge_geometry=True)
return edges
def download_map(location_point, range):
G = ox.graph_from_point(location_point,
distance=range,
simplify=False,
network_type='drive')
G = ox.project_graph(G)
return G
def test_network_saving_loading():
# save/load graph as shapefile and graphml file
G = ox.graph_from_place('Piedmont, California, USA')
G_projected = ox.project_graph(G)
ox.save_graph_shapefile(G_projected)
ox.save_graphml(G_projected)
ox.save_graphml(G_projected, filename='gephi.graphml', gephi=True)
G2 = ox.load_graphml('graph.graphml')
# convert graph to node/edge GeoDataFrames and back again
gdf_edges = ox.graph_to_gdfs(G,
nodes=False,
edges=True,
fill_edge_geometry=False)
gdf_nodes, gdf_edges = ox.graph_to_gdfs(G,
nodes=True,
edges=True,
node_geometry=True,
fill_edge_geometry=True)
G3 = ox.gdfs_to_graph(gdf_nodes, gdf_edges)
# find graph nodes nearest to some set of points
X = gdf_nodes['x'].head()
Y = gdf_nodes['y'].head()
nn1 = ox.get_nearest_nodes(G, X, Y)
nn2 = ox.get_nearest_nodes(G, X, Y, method='kdtree')
nn3 = ox.get_nearest_nodes(G, X, Y, method='balltree')
def Save_OSM_G_proj(placename=placename, network_type= 'walk', suffix=suffix, folder=OSM_folder, to_crs=None):
"""
save a projected graphml from graphml file
Parameters
----------
network_type : string
what type of street network to get. Default type is pedestrain network
placename: string
place name
suffix: string
output data date
folder : string
where to save the shapefile, specify local folder path for OSM resource
Returns
-------
none
"""
G = ox.load_graphml(filename='{studyregion}_{network_type}{suffix}.graphml'.format(
studyregion = placename, network_type=network_type, suffix = suffix), folder=folder)
#set up project projection, and save the projected graph (project to UTM so we can use metres as a unit when buffering)
G_proj = ox.project_graph(G, to_crs=to_crs)
ox.save_graphml(G_proj, filename='{studyregion}_proj_{network_type}{suffix}.graphml'.format(
studyregion = placename, network_type=network_type, suffix = suffix), folder=folder)
ox.plot_graph(G_proj)
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.consolidate_intersections(G_proj,
tolerance=10,
rebuild_graph=True,
dead_ends=True)
def get_map(self, name):
file_path = os.path.dirname(os.path.abspath(__file__))
file_path = file_path[:len(file_path) - 7] + 'maps/'
try:
with open(file_path + name + '.p', 'rb') as f:
self._graph = pickle.load(f)
except:
try:
self._graph = ox.graph_from_place(name, network_type='drive')
except:
self._graph = ox.graph_from_address(name,
distance=250,
network_type='drive')
with open(file_path + name + '.p', 'wb') as f:
pickle.dump(self._graph, f)
self._graph_proj = ox.project_graph(self._graph)
self._nodes, self._edges = ox.graph_to_gdfs(self._graph_proj,
nodes=True,
edges=True)
def __init__(self, node_name, place_name, publish_rate):
#initialise class variables
self._place_name = place_name
self._ros_node_name = node_name
self._road_info = pointsList()
self._road_points = pointsList()
self._publish_rate = publish_rate
#create publisher to the topic "road_info"
self._road_info_publisher = rospy.Publisher("road_info",
pointsList,
queue_size=100)
self._road_points_publisher = rospy.Publisher("road_points",
pointsList,
queue_size=100)
#create a node
rospy.init_node(self._ros_node_name, anonymous=False)
self._publish_rate = rospy.Rate(self._publish_rate) # 1hz
#convert place in a map to a graph
self._graph = ox.graph_from_place(self._place_name,
network_type='drive')
self._graph_proj = ox.project_graph(self._graph)
#extract edges and nodes
#edges define the geometry of the road
#nodes define the start and end points of each road
self._nodes, self._edges = ox.graph_to_gdfs(self._graph_proj,
nodes=True,
edges=True)
def test_stats():
# create graph, add bearings, project it
location_point = (37.791427, -122.410018)
G = ox.graph_from_point(location_point, distance=500, distance_type='network')
G = ox.add_edge_bearings(G)
G_proj = ox.project_graph(G)
# calculate stats
stats1 = ox.basic_stats(G)
stats2 = ox.basic_stats(G, area=1000)
stats3 = ox.basic_stats(G_proj, area=1000, clean_intersects=True, tolerance=15, circuity_dist='euclidean')
stats4 = ox.extended_stats(G, connectivity=True, anc=True, ecc=True, bc=True, cc=True)
def test_nearest_edges():
from pyproj import Proj
# test in closest edge section
sheik_sayed_dubai = [25.09, 25.06, 55.16, 55.11]
location_coordinates = (25.071764, 55.138978)
G = ox.graph_from_bbox(*sheik_sayed_dubai, simplify=False, retain_all=True, network_type='drive')
# Unprojected
ne1 = ox.get_nearest_edges(G, X=[location_coordinates[1], location_coordinates[1]],
Y=[location_coordinates[0], location_coordinates[0]], method='balltree', dist=0.0001)
# Projected
G2 = ox.project_graph(G)
crs = Proj(G2.graph['crs'])
projected_point = crs(location_coordinates[1], location_coordinates[0])
ne2 = ox.get_nearest_edges(G2, X=[projected_point[0], projected_point[0]],
Y=[projected_point[1], projected_point[1]], method='kdtree', dist=10)
assert (ne1 == ne2).all()
place_names = ['Ho Chi Minh City, Vietnam',
#'Beijing, China',
#'Jakarta, Indonesia',
'London, UK',
'Los Angeles, California, USA',
'Manila, Philippines',
#'Mexico City, Mexico',
'New Delhi, India',
'Sao Paulo, Brazil',
'New York, New York, USA',
'Seoul',
'Singapore',
#'Tokyo, Japan',
#'Nairobi, Kenya',
#'Bangalore, India'
]
# In this for-loop, we save all the shapefiles for the valid cities.
for city in place_names:
city_admin_20kmbuff = ox.gdf_from_place(city, gdf_name = 'global_cities', buffer_dist = 20000)
fig, ax = ox.plot_shape(city_admin_20kmbuff)
ox.save_gdf_shapefile(city_admin_20kmbuff, filename = city)
# In this for-loop, we save all the street networks for the valid cities.
for city in place_names:
grid = ox.graph_from_place(city, network_type = 'drive', retain_all = True)
grid_projected = ox.project_graph(grid)
ox.save_graph_shapefile(grid_projected, filename = city + '_grid')
ox.plot_graph(grid_projected)
ox.config(log_console=True, use_cache=True, data_folder='data/vector/city_networks/')
scriptpath = os.path.dirname(__file__)
cities = glob.glob("data/vector/city_boundaries/*.shp")
#indir = "data/vector/city_boundaries/"
for city in cities:
name = os.path.basename(city).split('.')[0]
place = gpd.read_file(city)
place_simple = place.unary_union # disolving boundaries based on attributes
# Use retain_all if you want to keep all disconnected subgraphs (e.g. when your places aren't adjacent)
G = ox.graph_from_polygon(place_simple, network_type='drive', retain_all=True)
G_projected = ox.project_graph(G)
# save the shapefile to disk
#name = os.path.basename("beijing.shp")).split(".")[0] # make better place_names
ox.save_graph_shapefile(G_projected, filename=name)
area = ox.project_gdf(place).unary_union.area
stats = ox.basic_stats(G, area=area)
# save to file:
def ensure_dir(file_path):
directory = os.path.dirname(file_path)
if not os.path.exists(directory):
os.makedirs(directory)
path = os.path.join('data/vector/city_networks/', name)
ensure_dir(path)
def ensure_dir(file_path):
directory = os.path.dirname(file_path)
if not os.path.exists(directory):
os.makedirs(directory)
for place in places:
name = (place.replace(",","").replace(" ","")) # make better place_names
print('working on: ', name)
#make a geodataframe of the street network (outline) from openstreetmap place names
# use retain_all if you want to keep all disconnected subgraphs (e.g. when your places aren't adjacent)
G = ox.graph_from_place(place, network_type='drive', retain_all=True)
G = ox.project_graph(G)
#make a geodataframe of the shape (outline) from openstreetmap place names
gdf = ox.gdf_from_place(place)
gdf = ox.project_gdf(gdf)
ox.save_graph_shapefile(G, filename=name)
print(name, ' has crs:' )
gdf.to_crs({'init': 'epsg:3395'})
# Confirm big step of projection change
# calculate basic stats for the shape
# TODO adjust this to calculate stats based on neighborhoods
stats = ox.basic_stats(G, area=gdf['geometry'].area[0])
print('area', gdf['area'][0] / 10**6, 'sqkm')
