def test_nx_to_gdf(self):
nx = mm.gdf_to_nx(self.df_streets)
nodes, edges, W = mm.nx_to_gdf(nx, spatial_weights=True)
assert len(nodes) == 29
assert len(edges) == 35
assert W.n == 29
nodes, edges = mm.nx_to_gdf(nx)
assert len(nodes) == 29
assert len(edges) == 35
edges = mm.nx_to_gdf(nx, points=False)
assert len(edges) == 35
nodes, W = mm.nx_to_gdf(nx, lines=False, spatial_weights=True)
assert len(nodes) == 29
assert W.n == 29
nodes = mm.nx_to_gdf(nx, lines=False, spatial_weights=False)
assert len(nodes) == 29
dual = mm.gdf_to_nx(self.df_streets, approach="dual")
edges = mm.nx_to_gdf(dual)
assert len(edges) == 35
dual.graph["approach"] = "nonexistent"
with pytest.raises(ValueError):
mm.nx_to_gdf(dual)
G = networkx.Graph()
with pytest.raises(KeyError):
mm.nx_to_gdf(G)
def test_get_node_id(self):
nx = mm.gdf_to_nx(self.df_streets)
nodes, edges = mm.nx_to_gdf(nx)
self.df_buildings["nID"] = mm.get_network_id(self.df_buildings,
self.df_streets, "nID")
ids = mm.get_node_id(self.df_buildings, nodes, edges, "nodeID", "nID")
assert not ids.isna().any()
convex_hull = edges.unary_union.convex_hull
enclosures = mm.enclosures(edges, limit=gpd.GeoSeries([convex_hull]))
enclosed_tess = mm.Tessellation(self.df_buildings,
unique_id="uID",
enclosures=enclosures).tessellation
links = mm.get_network_ratio(enclosed_tess, edges)
enclosed_tess[links.columns] = links
ids = mm.get_node_id(
enclosed_tess,
nodes,
edges,
node_id="nodeID",
edge_keys="edgeID_keys",
edge_values="edgeID_values",
)
assert not ids.isna().any()
def test_nx_to_gdf(self):
nx = mm.gdf_to_nx(self.df_streets)
nodes, edges, W = mm.nx_to_gdf(nx, spatial_weights=True)
assert len(nodes) == 29
assert len(edges) == 35
assert W.n == 29
nodes, edges = mm.nx_to_gdf(nx)
assert len(nodes) == 29
assert len(edges) == 35
edges = mm.nx_to_gdf(nx, nodes=False)
assert len(edges) == 35
nodes, W = mm.nx_to_gdf(nx, edges=False, spatial_weights=True)
assert len(nodes) == 29
assert W.n == 29
nodes = mm.nx_to_gdf(nx, edges=False, spatial_weights=False)
assert len(nodes) == 29
def setup(self):
test_file_path = mm.datasets.get_path("bubenec")
self.df_buildings = gpd.read_file(test_file_path, layer="buildings")
self.df_streets = gpd.read_file(test_file_path, layer="streets")
self.df_tessellation = gpd.read_file(test_file_path,
layer="tessellation")
self.df_streets["nID"] = mm.unique_id(self.df_streets)
self.df_buildings["height"] = np.linspace(10.0, 30.0, 144)
self.df_tessellation["area"] = self.df_tessellation.geometry.area
self.df_buildings["area"] = self.df_buildings.geometry.area
self.df_buildings["fl_area"] = mm.FloorArea(self.df_buildings,
"height").series
self.df_buildings["nID"] = mm.get_network_id(self.df_buildings,
self.df_streets, "nID")
blocks = mm.Blocks(self.df_tessellation, self.df_streets,
self.df_buildings, "bID", "uID")
self.blocks = blocks.blocks
self.df_buildings["bID"] = blocks.buildings_id
self.df_tessellation["bID"] = blocks.tessellation_id
self.swb = Queen.from_dataframe(self.df_buildings)
self.sw5 = mm.sw_high(k=5, gdf=self.df_tessellation, ids="uID")
self.sw3 = mm.sw_high(k=3, gdf=self.df_tessellation, ids="uID")
self.sws = mm.sw_high(k=2, gdf=self.df_streets)
nx = mm.gdf_to_nx(self.df_streets)
nx = mm.node_degree(nx)
self.nodes, self.edges, W = mm.nx_to_gdf(nx, spatial_weights=True)
self.swn = mm.sw_high(k=3, weights=W)
def test_get_node_id(self):
nx = mm.gdf_to_nx(self.df_streets)
nodes, edges = mm.nx_to_gdf(nx)
self.df_buildings["nID"] = mm.get_network_id(
self.df_buildings, self.df_streets, "nID"
)
ids = mm.get_node_id(self.df_buildings, nodes, edges, "nodeID", "nID")
assert not ids.isna().any()
def test_nx_to_gdf(self):
nx = mm.gdf_to_nx(self.df_streets)
nodes, edges, W = mm.nx_to_gdf(nx, spatial_weights=True)
assert len(nodes) == 29
assert len(edges) == 35
assert W.n == 29
nodes, edges = mm.nx_to_gdf(nx)
assert len(nodes) == 29
assert len(edges) == 35
edges = mm.nx_to_gdf(nx, points=False)
assert len(edges) == 35
nodes, W = mm.nx_to_gdf(nx, lines=False, spatial_weights=True)
assert len(nodes) == 29
assert W.n == 29
nodes = mm.nx_to_gdf(nx, lines=False, spatial_weights=False)
assert len(nodes) == 29
dual = mm.gdf_to_nx(self.df_streets, approach="dual")
edges = mm.nx_to_gdf(dual)
assert len(edges) == 35
dual.graph["approach"] = "nonexistent"
with pytest.raises(ValueError):
mm.nx_to_gdf(dual)
# check graph without attributes
G = networkx.MultiGraph()
key = 0
for index, row in self.df_streets.iterrows():
first = row.geometry.coords[0]
last = row.geometry.coords[-1]
data = [row[f] for f in list(self.df_streets.columns)]
attributes = dict(zip(list(self.df_streets.columns), data))
G.add_edge(first, last, key=key, **attributes)
key += 1
nodes, edges = mm.nx_to_gdf(G)
assert len(nodes) == 29
assert len(edges) == 35
# LineString Z
line1 = LineString([(0, 0, 0), (1, 1, 1)])
line2 = LineString([(0, 0, 0), (-1, -1, -1)])
gdf = gpd.GeoDataFrame(geometry=[line1, line2])
G = mm.gdf_to_nx(gdf)
pts, lines = mm.nx_to_gdf(G)
assert pts.iloc[0].geometry.wkt == "POINT Z (0 0 0)"
assert lines.iloc[0].geometry.wkt == "LINESTRING Z (0 0 0, 1 1 1)"
def setup(self):
test_file_path = mm.datasets.get_path("bubenec")
self.df_buildings = gpd.read_file(test_file_path, layer="buildings")
self.df_tessellation = gpd.read_file(test_file_path, layer="tessellation")
self.df_streets = gpd.read_file(test_file_path, layer="streets")
self.df_streets["nID"] = range(len(self.df_streets))
self.limit = mm.buffered_limit(self.df_buildings, 50)
nx = mm.gdf_to_nx(self.df_streets)
self.nodes, self.edges = mm.nx_to_gdf(nx)
self.df_buildings["nID"] = mm.get_network_id(
self.df_buildings, self.df_streets, "nID"
)
def test_NodeDensity(self):
nx = mm.gdf_to_nx(self.df_streets)
nx = mm.node_degree(nx)
nodes, edges, W = mm.nx_to_gdf(nx, spatial_weights=True)
sw = mm.sw_high(k=3, weights=W)
density = mm.NodeDensity(nodes, edges, sw).series
weighted = mm.NodeDensity(
nodes, edges, sw, weighted=True, node_degree="degree"
).series
array = mm.NodeDensity(nodes, edges, W).series
assert density.mean() == 0.012690163074599968
assert weighted.mean() == 0.023207675994368446
assert array.mean() == 0.008554067995928158
def test_subgraph(self):
net = mm.subgraph(self.network)
nodes = mm.nx_to_gdf(net, lines=False)
cols = [
"meshedness",
"cds_length",
"mean_node_degree",
"proportion_3",
"proportion_4",
"proportion_0",
"cyclomatic",
"edge_node_ratio",
"gamma",
"local_closeness",
]
for c in cols:
assert c in nodes.columns
def make_graph_great_again(gdf): G = momepy.gdf_to_nx(gdf, approach='primal') # выбор наибольшего графа из подграфов # (когда ребра удаляются выше, остаются подвешенные куски графа, их надо удалить) # whatever graph you're working with cur_graph = G # def del_subgraphs(cur_graph): list_subgraphs = [cur_graph] if not nx.is_connected(cur_graph): # get a list of unconnected networks def connected_component_subgraphs(cur_graph): for c in nx.connected_components(cur_graph): yield cur_graph.subgraph(c) sub_graphs = connected_component_subgraphs(cur_graph) list_graph = [] i=0 for i in sub_graphs: list_graph.append(i) main_graph = list_graph[0] list_subgraphs = [] #list_subgraphs.append(main_graph) # find the largest network in that list for sg in list_graph: if len(sg.nodes()) > len(main_graph.nodes()): main_graph = sg else: list_subgraphs.append(sg) try: list_subgraphs.remove(main_graph) except: pass cur_graph = main_graph # ##### #create gdfs # формирование таблиц из графа и узлов (nodes) nodes, new_graph = momepy.nx_to_gdf(cur_graph) return nodes, new_graph
def GetRoutes(From, To):
nodes, edges, sw = momepy.nx_to_gdf(Graph_streets,
points=True,
lines=True,
spatial_weights=True)
nodes['x'] = nodes.geometry.apply(lambda p: p.x)
nodes['y'] = nodes.geometry.apply(lambda p: p.y)
# Find the nearest nodes
tree = KDTree(nodes[['y', 'x']], metric='euclidean')
source_idx = tree.query([Source], k=1, return_distance=False)[0]
dest_idx = tree.query([Destination], k=1, return_distance=False)[0]
closest_node_to_source = nodes.iloc[source_idx].index.values[0]
closest_node_to_dest = nodes.iloc[dest_idx].index.values[0]
route = nx.shortest_path(
Graph_streets,
source=list(Graph_streets.nodes())[closest_node_to_source],
target=list(Graph_streets.nodes())[closest_node_to_dest],
weight='Lenght')
route_weighted = nx.shortest_path(
Graph_streets,
source=list(Graph_streets.nodes())[closest_node_to_source],
target=list(Graph_streets.nodes())[closest_node_to_dest],
weight='Lenght_weighted')
ruta_geo = gp.GeoDataFrame()
ruta_geo['geometry'] = [LineString(route), LineString(route_weighted)]
# get the points for each linestring as a list of tuples
short_route = [[x[0], x[1]] for x in list(ruta_geo.geometry[0].coords)]
healthy_route = [[x[0], x[1]] for x in list(ruta_geo.geometry[1].coords)]
return short_route, healthy_route
def test_nx_to_gdf_osmnx(self):
# osmnx compatibility
G = ox.graph_from_place("Preborov, Czechia", network_type="drive")
pts, lines = mm.nx_to_gdf(G)
assert len(pts) == 7
assert len(lines) == 16
dublin_boundary.plot(ax=ax, facecolor="none", edgecolor="cyan")
hv_stations_dublin.plot(ax=ax, color="black")
# # Link Each Small Area Centroid to a Station via Network
#
# Use `networkx` to find the station that is closest along the network to each small area centroid:
# - Convert `geopandas` `GeoDataFrame` to `networkx` `MultiGraph` via `momepy` for network analysis
# - Extract the largest unbroken network
# - Extract all stations and small areas near the network
# - Trace the path from each small area centroid to the nearest station along the network
G = momepy.gdf_to_nx(mv_network_lines, approach="primal")
G_largest = distance.get_largest_subgraph(G)
G_largest_nodes, G_largest_edges, G_largest_sw = momepy.nx_to_gdf(
G_largest, points=True, lines=True, spatial_weights=True)
G_largest_edges_buffered = (G_largest_edges[[
"geometry"
]].assign(geometry=lambda gdf: gdf.buffer(750)).dissolve())
small_areas_near_g_largest = esb.centroids_within(small_areas,
G_largest_edges_buffered)
hv_stations_near_g_largest = gpd.sjoin(
hv_stations_dublin,
G_largest_edges_buffered,
op="within",
).drop(columns="index_right").reset_index(drop=True)
hv_stations_snapped_to_g_largest = esb.snap_points_to_network(
# 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")
add_basemap(facet)
def time_nx_to_gdf_primal(self):
mm.nx_to_gdf(self.nx, spatial_weights=True)
def time_nx_to_gdf_dual(self):
mm.nx_to_gdf(self.dual)
print("cds length")
graph = mm.cds_length(graph, radius=3, name="ldsCDL")
print("eigenvector")
try:
graph = mm.eigenvector(graph, name="xcnEiC", max_iter=500)
except Exception:
graph = mm.eigenvector(graph, name="xcnEiC", max_iter=1000)
print("clustering")
graph = mm.clustering(graph, name="xcnSCl")
print("mean_node_dist")
graph = mm.mean_node_dist(graph, name="mtdMDi")
nodes, edges, sw = mm.nx_to_gdf(graph, spatial_weights=True)
print("saving")
nodes.to_file("files/elements.gpkg", layer="nodes", driver="GPKG")
edges.to_file("files/elements.gpkg", layer="edges", driver="GPKG")
fo = libpysal.io.open("files/GRnodes.gal", "w")
fo.write(sw)
fo.close()
edges_w3 = mm.sw_high(k=3, gdf=edges)
edges["ldsMSL"] = mm.SegmentsLength(edges, spatial_weights=edges_w3,
mean=True).series
tess = gpd.read_file("files/elements.gpkg", layer="tessellation")
