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")