def test_network_saving_loading():
# save graph as shapefile and geopackage
G = ox.graph_from_place(place1, network_type="drive")
ox.save_graph_shapefile(G)
ox.save_graph_geopackage(G)
# save/load graph as graphml file
ox.save_graphml(G, gephi=True)
ox.save_graphml(G, gephi=False)
filepath = os.path.join(ox.settings.data_folder, "graph.graphml")
G = ox.load_graphml(filepath, node_type=str)
# test osm xml output
default_all_oneway = ox.settings.all_oneway
ox.settings.all_oneway = True
G = ox.graph_from_point(location_point, dist=500, network_type="drive")
ox.save_graph_xml(G, merge_edges=False)
# test osm xml output merge edges
ox.save_graph_xml(G, merge_edges=True, edge_tag_aggs=[("length", "sum")])
# test osm xml output from gdfs
nodes, edges = ox.graph_to_gdfs(G)
ox.save_graph_xml([nodes, edges])
# test ordered nodes from way
df = pd.DataFrame({
"u": [54, 2, 5, 3, 10, 19, 20],
"v": [76, 3, 8, 10, 5, 20, 15]
})
ordered_nodes = ox.io._get_unique_nodes_ordered_from_way(df)
assert ordered_nodes == [2, 3, 10, 5, 8]
ox.settings.all_oneway = default_all_oneway
def test_network_saving_loading():
# save graph as shapefile and geopackage
G = ox.graph_from_place('Piedmont, California, USA')
ox.save_graph_shapefile(G)
ox.save_graph_geopackage(G)
# save/load graph as graphml file
ox.save_graphml(G)
ox.save_graphml(G, 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_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 test_network_saving_loading():
# save graph as shapefile and geopackage
G = ox.graph_from_place(place1, network_type="drive")
ox.save_graph_shapefile(G)
ox.save_graph_geopackage(G)
# save/load graph as graphml file
ox.save_graphml(G, gephi=True)
ox.save_graphml(G, gephi=False)
filepath = os.path.join(ox.settings.data_folder, "graph.graphml")
G2 = ox.load_graphml(filepath)
# verify everything in G is equivalent in G2
for (n1, d1), (n2, d2) in zip(G.nodes(data=True), G2.nodes(data=True)):
assert n1 == n2
assert d1 == d2
for (u1, v1, k1, d1), (u2, v2, k2,
d2) in zip(G.edges(keys=True, data=True),
G2.edges(keys=True, data=True)):
assert u1 == u2
assert v1 == v2
assert k1 == k2
assert tuple(d1.keys()) == tuple(d2.keys())
assert tuple(d1.values()) == tuple(d2.values())
for (k1, v1), (k2, v2) in zip(G.graph.items(), G2.graph.items()):
assert k1 == k2
assert v1 == v2
assert tuple(G.graph["streets_per_node"].keys()) == tuple(
G2.graph["streets_per_node"].keys())
assert tuple(G.graph["streets_per_node"].values()) == tuple(
G2.graph["streets_per_node"].values())
# test custom data types
nd = {"osmid": str}
ed = {"length": str, "osmid": float}
G2 = ox.load_graphml(filepath, node_dtypes=nd, edge_dtypes=ed)
# test osm xml output
default_all_oneway = ox.settings.all_oneway
ox.settings.all_oneway = True
G = ox.graph_from_point(location_point, dist=500, network_type="drive")
ox.save_graph_xml(G, merge_edges=False)
# test osm xml output merge edges
ox.save_graph_xml(G, merge_edges=True, edge_tag_aggs=[("length", "sum")])
# test osm xml output from gdfs
nodes, edges = ox.graph_to_gdfs(G)
ox.save_graph_xml([nodes, edges])
# test ordered nodes from way
df = pd.DataFrame({
"u": [54, 2, 5, 3, 10, 19, 20],
"v": [76, 3, 8, 10, 5, 20, 15]
})
ordered_nodes = ox.io._get_unique_nodes_ordered_from_way(df)
assert ordered_nodes == [2, 3, 10, 5, 8]
ox.settings.all_oneway = default_all_oneway
def test_graph_save_load():
# save graph as shapefile and geopackage
G = ox.graph_from_place(place1, network_type="drive")
ox.save_graph_shapefile(G)
ox.save_graph_geopackage(G, directed=False)
# save/load geopackage and convert graph to/from node/edge GeoDataFrames
fp = ".temp/data/graph-dir.gpkg"
ox.save_graph_geopackage(G, filepath=fp, directed=True)
gdf_nodes1 = gpd.read_file(fp, layer="nodes").set_index("osmid")
gdf_edges1 = gpd.read_file(fp, layer="edges").set_index(["u", "v", "key"])
G2 = ox.graph_from_gdfs(gdf_nodes1, gdf_edges1)
G2 = ox.graph_from_gdfs(gdf_nodes1, gdf_edges1, graph_attrs=G.graph)
gdf_nodes2, gdf_edges2 = ox.graph_to_gdfs(G2)
assert set(gdf_nodes1.index) == set(gdf_nodes2.index) == set(G.nodes) == set(G2.nodes)
assert set(gdf_edges1.index) == set(gdf_edges2.index) == set(G.edges) == set(G2.edges)
# create random boolean graph/node/edge attributes
attr_name = "test_bool"
G.graph[attr_name] = False
bools = np.random.randint(0, 2, len(G.nodes))
node_attrs = {n: bool(b) for n, b in zip(G.nodes, bools)}
nx.set_node_attributes(G, node_attrs, attr_name)
bools = np.random.randint(0, 2, len(G.edges))
edge_attrs = {n: bool(b) for n, b in zip(G.edges, bools)}
nx.set_edge_attributes(G, edge_attrs, attr_name)
# save/load graph as graphml file
ox.save_graphml(G, gephi=True)
ox.save_graphml(G, gephi=False)
filepath = Path(ox.settings.data_folder) / "graph.graphml"
G2 = ox.load_graphml(
filepath,
graph_dtypes={attr_name: ox.io._convert_bool_string},
node_dtypes={attr_name: ox.io._convert_bool_string},
edge_dtypes={attr_name: ox.io._convert_bool_string},
)
# verify everything in G is equivalent in G2
assert tuple(G.graph.keys()) == tuple(G2.graph.keys())
assert tuple(G.graph.values()) == tuple(G2.graph.values())
z = zip(G.nodes(data=True), G2.nodes(data=True))
for (n1, d1), (n2, d2) in z:
assert n1 == n2
assert tuple(d1.keys()) == tuple(d2.keys())
assert tuple(d1.values()) == tuple(d2.values())
z = zip(G.edges(keys=True, data=True), G2.edges(keys=True, data=True))
for (u1, v1, k1, d1), (u2, v2, k2, d2) in z:
assert u1 == u2
assert v1 == v2
assert k1 == k2
assert tuple(d1.keys()) == tuple(d2.keys())
assert tuple(d1.values()) == tuple(d2.values())
# test custom data types
nd = {"osmid": str}
ed = {"length": str, "osmid": float}
G2 = ox.load_graphml(filepath, node_dtypes=nd, edge_dtypes=ed)
def test_graph_save_load():
# save graph as shapefile and geopackage
G = ox.graph_from_place(place1, network_type="drive")
ox.save_graph_shapefile(G)
ox.save_graph_geopackage(G, directed=False)
# save/load geopackage and convert graph to/from node/edge GeoDataFrames
fp = ".temp/data/graph-dir.gpkg"
ox.save_graph_geopackage(G, filepath=fp, directed=True)
gdf_nodes1 = gpd.read_file(fp, layer="nodes").set_index("osmid")
gdf_edges1 = gpd.read_file(fp, layer="edges").set_index(["u", "v", "key"])
G2 = ox.graph_from_gdfs(gdf_nodes1, gdf_edges1, graph_attrs=G.graph)
gdf_nodes2, gdf_edges2 = ox.graph_to_gdfs(G2)
assert set(gdf_nodes1.index) == set(gdf_nodes2.index) == set(G.nodes) == set(G2.nodes)
assert set(gdf_edges1.index) == set(gdf_edges2.index) == set(G.edges) == set(G2.edges)
# save/load graph as graphml file
ox.save_graphml(G, gephi=True)
ox.save_graphml(G, gephi=False)
filepath = Path(ox.settings.data_folder) / "graph.graphml"
G2 = ox.load_graphml(filepath)
# verify everything in G is equivalent in G2
for (n1, d1), (n2, d2) in zip(G.nodes(data=True), G2.nodes(data=True)):
assert n1 == n2
assert d1 == d2
for (u1, v1, k1, d1), (u2, v2, k2, d2) in zip(
G.edges(keys=True, data=True), G2.edges(keys=True, data=True)
):
assert u1 == u2
assert v1 == v2
assert k1 == k2
assert tuple(d1.keys()) == tuple(d2.keys())
assert tuple(d1.values()) == tuple(d2.values())
for (k1, v1), (k2, v2) in zip(G.graph.items(), G2.graph.items()):
assert k1 == k2
assert v1 == v2
# test custom data types
nd = {"osmid": str}
ed = {"length": str, "osmid": float}
G2 = ox.load_graphml(filepath, node_dtypes=nd, edge_dtypes=ed)
def add_elevations(country_folder, graph_filename):
# load graph
graph_filepath = os.path.join(graphml_folder, country_folder, graph_filename)
G = ox.load_graphml(filepath=graph_filepath)
print(ox.ts(), 'load', len(G), 'nodes and', len(G.edges), 'edges from', graph_filepath)
# get the elevation data for this graph's nodes
graph_elevs = df_elevs.loc[set(G.nodes)].sort_index()
# set nodes' elevation attributes
nx.set_node_attributes(G, name='elevation', values=graph_elevs['elevation'].astype(int))
nx.set_node_attributes(G, name='elevation_aster', values=graph_elevs['elev_aster'].dropna().astype(int))
nx.set_node_attributes(G, name='elevation_srtm', values=graph_elevs['elev_srtm'].dropna().astype(int))
# confirm that no graph node is missing elevation
assert set(G.nodes) == set(nx.get_node_attributes(G, 'elevation'))
# then calculate edge grades
G = ox.add_edge_grades(G, add_absolute=True)
# resave graphml now that it has elevations/grades
ox.save_graphml(G, filepath=graph_filepath)
print(ox.ts(), 'save', graph_filepath)
# save node/edge lists
uc_name = graph_filename.replace('.graphml', '')
nelist_output_folder = os.path.join(nelist_folder, country_folder, uc_name)
save_node_edge_lists(G, nelist_output_folder)
print(ox.ts(), 'save', nelist_output_folder)
# save as geopackage
gpkg_filename = uc_name + '.gpkg'
gpkg_filepath = os.path.join(gpkg_folder, country_folder, gpkg_filename)
ox.save_graph_geopackage(G, filepath=gpkg_filepath)
print(ox.ts(), 'save', gpkg_filepath)
# impute edge (driving) speeds and calculate edge traversal times
G = ox.add_edge_speeds(G)
G = ox.add_edge_travel_times(G)
# you can convert MultiDiGraph to/from geopandas GeoDataFrames
gdf_nodes, gdf_edges = ox.graph_to_gdfs(G)
G = ox.graph_from_gdfs(gdf_nodes, gdf_edges, graph_attrs=G.graph)
# convert MultiDiGraph to DiGraph to use nx.betweenness_centrality function
# choose between parallel edges by minimizing travel_time attribute value
D = ox.utils_graph.get_digraph(G, weight="travel_time")
# calculate node betweenness centrality, weighted by travel time
bc = nx.betweenness_centrality(D, weight="travel_time", normalized=True)
nx.set_node_attributes(G, values=bc, name="bc")
# plot the graph, coloring nodes by betweenness centrality
nc = ox.plot.get_node_colors_by_attr(G, "bc", cmap="plasma")
fig, ax = ox.plot_graph(G,
bgcolor="k",
node_color=nc,
node_size=50,
edge_linewidth=2,
edge_color="#333333")
# save graph to shapefile, geopackage, or graphml
ox.save_graph_shapefile(G, filepath="./graph_shapefile/")
ox.save_graph_geopackage(G, filepath="./graph.gpkg")
ox.save_graphml(G, filepath="./graph.graphml")
import osmnx as ox
import geobr
# Initial setup
print(ox.__version__)
ox.config(use_cache=True)
# Download census tracts
tracts = geobr.read_census_tract(3143302, year=2010, simplified=False)
# Get only urban tracts
tracts.query('zone == "URBANO" & code_district == "314330205"', inplace=True)
# Dissolve boundaries to create the mask
mask = tracts.dissolve(by='code_muni')
# Download corresponding street network
graph_nx = ox.graph_from_polygon(mask.geometry.all())
# Save graph for backup
ox.save_graph_geopackage(graph_nx, filepath='./data/moc_2010_network.gpkg')
import geopandas as gpd, pandas as pd, osmnx as ox
#smaller dataset for testing purposes
#RoadNetwork = ox.graph_from_place('Anthem, Arizona, USA', network_type='drive')
#grab OSM road network only within our custom SHP bounding box
study_area = gpd.read_file('C:/Users/micha/Desktop/studyArea/')
polygon = study_area['geometry'].iloc[0]
RoadNetwork = ox.graph_from_polygon(polygon,
network_type='drive',
simplify=False)
ox.save_graph_geopackage(RoadNetwork,
filepath='C:/Users/micha/Desktop/PHXRoadNetwork.gpkg')
#prepare OSMnx stats for this area
#dictionary for reading the stats
#https://osmnx.readthedocs.io/en/stable/osmnx.html#module-osmnx.stats
stats = ox.basic_stats(RoadNetwork)
data_out = pd.DataFrame(pd.Series(stats, name='value'))
data_out.to_csv(path_or_buf="C:/users/micha/Desktop/PHXRoadNetwork.csv")
