Description: remove doc examples that are doing network access Author: Thomas Goirand Forwarded: no Last-Update: 2024-04-29 --- a/examples/graph/plot_football.py 2023-10-28 10:35:40.000000000 +0200 +++ /dev/null 2024-04-29 07:51:47.908104658 +0200 @@ -1,44 +0,0 @@ -""" -======== -Football -======== - -Load football network in GML format and compute some network statistics. - -Shows how to download GML graph in a zipped file, unpack it, and load -into a NetworkX graph. - -Requires Internet connection to download the URL -http://www-personal.umich.edu/~mejn/netdata/football.zip -""" - -import urllib.request -import io -import zipfile - -import matplotlib.pyplot as plt -import networkx as nx - -url = "http://www-personal.umich.edu/~mejn/netdata/football.zip" - -sock = urllib.request.urlopen(url) # open URL -s = io.BytesIO(sock.read()) # read into BytesIO "file" -sock.close() - -zf = zipfile.ZipFile(s) # zipfile object -txt = zf.read("football.txt").decode() # read info file -gml = zf.read("football.gml").decode() # read gml data -# throw away bogus first line with # from mejn files -gml = gml.split("\n")[1:] -G = nx.parse_gml(gml) # parse gml data - -print(txt) -# print degree for each team - number of games -for n, d in G.degree(): - print(f"{n:20} {d:2}") - -options = {"node_color": "black", "node_size": 50, "linewidths": 0, "width": 0.1} - -pos = nx.spring_layout(G, seed=1969) # Seed for reproducible layout -nx.draw(G, pos, **options) -plt.show() --- a/examples/geospatial/plot_lines.py 2023-10-28 10:35:40.000000000 +0200 +++ /dev/null 2024-04-29 07:51:47.908104658 +0200 @@ -1,115 +0,0 @@ -""" -========================== -Graphs from a set of lines -========================== - -This example shows how to build a graph from a set of geographic lines -(sometimes called "linestrings") using GeoPandas, momepy and alternatively -PySAL. We'll plot some rivers and streets, as well as their graphs formed -from the segments. - -There are generally two ways of creating graph object from line geometry. -Let's use an example of street network to illustrate both: - -The first way is a so-called primal approach, where each intersection is -a node and each linestring segment connecting two intersections is an edge. - -The second way is so-called dual approach, where each line is a node and -intersection topology is turned into edges. One of the options how this is -used for street network analysis is an angular analysis, where your routing -is weighted via angles between street segments on intersections. - -We will use GeoPandas to read spatial data and momepy to generate first -primal graph and then dual graph. Furthermore, we will use PySAL to -illustrate an alternative way of creating raw dual graph. -""" - -import geopandas -import matplotlib.pyplot as plt -import momepy -import networkx as nx -from contextily import add_basemap -from libpysal import weights - -# %% -# Read in example river geometry from GeoJSON. Source of example data: -# https://doi.org/10.3390/data5010008 (Nicolas Cadieux) -rivers = geopandas.read_file("rivers.geojson") - -# %% -# Construct the primal graph. momepy automatically preserves all attributes -# from GeoDataFrame and stores then as edge attributes. -G = momepy.gdf_to_nx(rivers, approach="primal") - -# %% -# Each node is encoded by its coordinates, which allows us to use them -# in plotting. -positions = {n: [n[0], n[1]] for n in list(G.nodes)} - -# Plot -f, ax = plt.subplots(1, 2, figsize=(12, 6), sharex=True, sharey=True) -rivers.plot(color="k", ax=ax[0]) -for i, facet in enumerate(ax): - facet.set_title(("Rivers", "Graph")[i]) - facet.axis("off") -nx.draw(G, positions, ax=ax[1], node_size=5) - -# %% -# Once we finish graph-based analysis, we can convert graph back -# to GeoDataFrames. momepy can return nodes as point geometry, -# edges as original line geometry and W object, which is PySAL -# spatial weights matrix encoding original graph so we can use -# it with node GeoDataFrame. -nodes, edges, W = momepy.nx_to_gdf(G, spatial_weights=True) - - -# Read in example street network from GeoPackage -streets = geopandas.read_file(momepy.datasets.get_path("bubenec"), layer="streets") - -# Construct the primal graph -G_primal = momepy.gdf_to_nx(streets, approach="primal") - -# Plot -f, ax = plt.subplots(1, 2, figsize=(12, 6), sharex=True, sharey=True) -streets.plot(color="k", ax=ax[0]) -for i, facet in enumerate(ax): - facet.set_title(("Streets", "Graph")[i]) - facet.axis("off") - try: # For issues with downloading/parsing in CI - add_basemap(facet) - except: - pass -nx.draw( - G_primal, {n: [n[0], n[1]] for n in list(G_primal.nodes)}, ax=ax[1], node_size=50 -) - -# %% -# Construct the dual graph. momepy will store row attributes as node attributes and -# automatically measures angle between lines. -G_dual = momepy.gdf_to_nx(streets, approach="dual") - -# Plot -f, ax = plt.subplots(1, 2, figsize=(12, 6), sharex=True, sharey=True) -streets.plot(color="k", ax=ax[0]) -for i, facet in enumerate(ax): - facet.set_title(("Streets", "Graph")[i]) - facet.axis("off") - try: # For issues with downloading/parsing in CI - add_basemap(facet) - except: - pass -nx.draw(G_dual, {n: [n[0], n[1]] for n in list(G_dual.nodes)}, ax=ax[1], node_size=50) -plt.show() - -# Convert dual graph back to GeoDataFrame. Returns only original line geometry. -lines = momepy.nx_to_gdf(G_dual) - -# %% -# We can also construct the dual graph using PySAL. Note that it only encodes -# relationship between geometries and do not any store attributes. However, it is -# significantly faster than momepy.gdf_to_nx(). -# Create PySAL weights (graph). -W = weights.Queen.from_dataframe(streets) - -# Convert the graph to networkx -G_dual = W.to_networkx() --- a/examples/geospatial/plot_points.py 2023-10-28 10:35:40.000000000 +0200 +++ /dev/null 2024-04-29 07:51:47.908104658 +0200 @@ -1,62 +0,0 @@ -""" -============================= -Graphs from geographic points -============================= - -This example shows how to build a graph from a set of points -using PySAL and geopandas. In this example, we'll use the famous -set of cholera cases at the Broad Street Pump, recorded by John Snow in 1853. -The methods shown here can also work directly with polygonal data using their -centroids as representative points. -""" - -from libpysal import weights, examples -from contextily import add_basemap -import matplotlib.pyplot as plt -import networkx as nx -import numpy as np -import geopandas - -# read in example data from a geopackage file. Geopackages -# are a format for storing geographic data that is backed -# by sqlite. geopandas reads data relying on the fiona package, -# providing a high-level pandas-style interface to geographic data. -cases = geopandas.read_file("cholera_cases.gpkg") - -# construct the array of coordinates for the centroid -coordinates = np.column_stack((cases.geometry.x, cases.geometry.y)) - -# construct two different kinds of graphs: - -## 3-nearest neighbor graph, meaning that points are connected -## to the three closest other points. This means every point -## will have exactly three neighbors. -knn3 = weights.KNN.from_dataframe(cases, k=3) - -## The 50-meter distance band graph will connect all pairs of points -## that are within 50 meters from one another. This means that points -## may have different numbers of neighbors. -dist = weights.DistanceBand.from_array(coordinates, threshold=50) - -# Then, we can convert the graph to networkx object using the -# .to_networkx() method. -knn_graph = knn3.to_networkx() -dist_graph = dist.to_networkx() - -# To plot with networkx, we need to merge the nodes back to -# their positions in order to plot in networkx -positions = dict(zip(knn_graph.nodes, coordinates)) - -# plot with a nice basemap -f, ax = plt.subplots(1, 2, figsize=(8, 4)) -for i, facet in enumerate(ax): - cases.plot(marker=".", color="orangered", ax=facet) - try: # For issues with downloading/parsing basemaps in CI - add_basemap(facet) - except: - pass - facet.set_title(("KNN-3", "50-meter Distance Band")[i]) - facet.axis("off") -nx.draw(knn_graph, positions, ax=ax[0], node_size=5, node_color="b") -nx.draw(dist_graph, positions, ax=ax[1], node_size=5, node_color="b") -plt.show() --- a/examples/geospatial/plot_delaunay.py 2023-10-28 10:35:40.000000000 +0200 +++ /dev/null 2024-04-29 07:51:47.908104658 +0200 @@ -1,76 +0,0 @@ -""" -====================================== -Delaunay graphs from geographic points -====================================== - -This example shows how to build a delaunay graph (plus its dual, -the set of Voronoi polygons) from a set of points. -For this, we will use the set of cholera cases at the Broad Street Pump, -recorded by John Snow in 1853. The methods shown here can also work -directly with polygonal data using their centroids as representative points. -""" - -from libpysal import weights, examples -from libpysal.cg import voronoi_frames -from contextily import add_basemap -import matplotlib.pyplot as plt -import networkx as nx -import numpy as np -import geopandas - -# read in example data from a geopackage file. Geopackages -# are a format for storing geographic data that is backed -# by sqlite. geopandas reads data relying on the fiona package, -# providing a high-level pandas-style interface to geographic data. -# Many different kinds of geographic data formats can be read by geopandas. -cases = geopandas.read_file("cholera_cases.gpkg") - -# In order for networkx to plot the nodes of our graph correctly, we -# need to construct the array of coordinates for each point in our dataset. -# To get this as a numpy array, we extract the x and y coordinates from the -# geometry column. -coordinates = np.column_stack((cases.geometry.x, cases.geometry.y)) - -# While we could simply present the Delaunay graph directly, it is useful to -# visualize the Delaunay graph alongside the Voronoi diagram. This is because -# the two are intrinsically linked: the adjacency graph of the Voronoi diagram -# is the Delaunay graph for the set of generator points! Put simply, this means -# we can build the Voronoi diagram (relying on scipy.spatial for the underlying -# computations), and then convert these polygons quickly into the Delaunay graph. -# Be careful, though; our algorithm, by default, will clip the voronoi diagram to -# the bounding box of the point pattern. This is controlled by the "clip" argument. -cells, generators = voronoi_frames(coordinates, clip="convex hull") - -# With the voronoi polygons, we can construct the adjacency graph between them using -# "Rook" contiguity. This represents voronoi cells as being adjacent if they share -# an edge/face. This is an analogue to the "von Neuman" neighborhood, or the 4 cardinal -# neighbors in a regular grid. The name comes from the directions a Rook piece can move -# on a chessboard. -delaunay = weights.Rook.from_dataframe(cells) - -# Once the graph is built, we can convert the graphs to networkx objects using the -# relevant method. -delaunay_graph = delaunay.to_networkx() - -# To plot with networkx, we need to merge the nodes back to -# their positions in order to plot in networkx -positions = dict(zip(delaunay_graph.nodes, coordinates)) - -# Now, we can plot with a nice basemap. -ax = cells.plot(facecolor="lightblue", alpha=0.50, edgecolor="cornsilk", linewidth=2) -try: # Try-except for issues with timeout/parsing failures in CI - add_basemap(ax) -except: - pass - -ax.axis("off") -nx.draw( - delaunay_graph, - positions, - ax=ax, - node_size=2, - node_color="k", - edge_color="k", - alpha=0.8, -) -plt.show() --- a/examples/geospatial/plot_osmnx.py 2023-10-28 10:35:40.000000000 +0200 +++ /dev/null 2024-04-29 07:51:47.908104658 +0200 @@ -1,53 +0,0 @@ -""" -======================== -OpenStreetMap with OSMnx -======================== - -This example shows how to use OSMnx to download and model a street network -from OpenStreetMap, visualize centrality, then save the graph as a GeoPackage, -or GraphML file. - -OSMnx is a Python package to download, model, analyze, and visualize street -networks and other geospatial features from OpenStreetMap. You can download -and model walking, driving, or biking networks with a single line of code then -easily analyze and visualize them. You can just as easily work with urban -amenities/points of interest, building footprints, transit stops, elevation -data, street orientations, speed/travel time, and routing. - -See https://osmnx.readthedocs.io for the OSMnx documentation. -See https://github.com/gboeing/osmnx-examples for the OSMnx Examples gallery. -""" - -import networkx as nx -import osmnx as ox - -ox.settings.use_cache = True - -# download street network data from OSM and construct a MultiDiGraph model -G = ox.graph.graph_from_point((37.79, -122.41), dist=750, network_type="drive") - -# impute edge (driving) speeds and calculate edge travel times -G = ox.speed.add_edge_speeds(G) -G = ox.speed.add_edge_travel_times(G) - -# you can convert MultiDiGraph to/from GeoPandas GeoDataFrames -gdf_nodes, gdf_edges = ox.utils_graph.graph_to_gdfs(G) -G = ox.utils_graph.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.plot_graph( - G, bgcolor="k", node_color=nc, node_size=50, edge_linewidth=2, edge_color="#333333" -) - -# save graph as a geopackage or graphml file -ox.io.save_graph_geopackage(G, filepath="./graph.gpkg") -ox.io.save_graphml(G, filepath="./graph.graphml")