def setup_method(self):
test_file_path = mm.datasets.get_path("bubenec")
self.df_streets = gpd.read_file(test_file_path, layer="streets")
self.network = mm.gdf_to_nx(self.df_streets)
self.network = mm.node_degree(self.network)
self.dual = mm.gdf_to_nx(self.df_streets, approach="dual")
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_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
# osmnx compatibility
import osmnx as ox
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
# 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 test_gdf_to_nx(self):
nx = mm.gdf_to_nx(self.df_streets)
assert nx.number_of_nodes() == 29
assert nx.number_of_edges() == 35
dual = mm.gdf_to_nx(self.df_streets, approach="dual")
assert dual.number_of_nodes() == 35
assert dual.number_of_edges() == 74
self.df_streets["ix"] = np.arange(0, len(self.df_streets) * 2, 2)
self.df_streets.set_index("ix", inplace=True)
dual2 = mm.gdf_to_nx(self.df_streets, approach="dual")
assert dual2.number_of_nodes() == 35
assert dual2.number_of_edges() == 74
with pytest.raises(ValueError):
mm.gdf_to_nx(self.df_streets, approach="nonexistent")
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.first_order = libpysal.weights.Queen.from_dataframe(
self.df_tessellation)
self.nx = mm.gdf_to_nx(self.df_streets)
self.dual = mm.gdf_to_nx(self.df_streets, approach="dual")
test_file_path2 = mm.datasets.get_path("tests")
self.os_buildings = gpd.read_file(test_file_path2, layer="os")
self.false_network = gpd.read_file(test_file_path2, layer="network")
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 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 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_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 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 graphs(links, epsg):
graph = momepy.gdf_to_nx(links.to_crs(epsg=epsg),
directed=True,
length='Shape_Leng')
G = nx.Graph(crs="EPSG:" + str(epsg))
return graph, G
def time_gdf_to_nx_dual(self):
mm.gdf_to_nx(self.df_streets, "dual")
def time_gdf_to_nx_primal(self):
mm.gdf_to_nx(self.df_streets)
import momepy as mm
import geopandas as gpd
import libpysal
streets = gpd.read_file("files/elements.gpkg", layer="streets")
graph = mm.gdf_to_nx(streets)
print("node degree")
graph = mm.node_degree(graph)
print("subgraph")
graph = mm.subgraph(
graph,
radius=5,
meshedness=True,
cds_length=False,
mode="sum",
degree="degree",
length="mm_len",
mean_node_degree=False,
proportion={
0: True,
3: True,
4: True
},
cyclomatic=False,
edge_node_ratio=False,
gamma=False,
local_closeness=True,
closeness_distance="mm_len",
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)
# %%
# Source: https://networkx.org/documentation/latest/auto_examples/geospatial/plot_lines.html
import geopandas
import matplotlib.pyplot as plt
import momepy
import networkx as nx
import contextily as cx
# %%
# Read in example street geometry from GeoJSON. Source of example data: OSM
streets = geopandas.read_file("streets.geojson")
f, ax = plt.subplots(figsize=(10, 10))
streets.plot(ax=ax)
ax.set_axis_off()
# %%
# Construct the primal graph. momepy automatically preserves all attributes
# from GeoDataFrame and stores then as edge attributes.
G = 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")
cx.add_basemap(facet, crs=streets.crs.to_string())
nx.draw(G, {n: [n[0], n[1]] for n in list(G.nodes)}, ax=ax[1], node_size=50)
plt.show()
def setup_method(self):
test_file_path = mm.datasets.get_path('bubenec')
self.df_streets = gpd.read_file(test_file_path, layer='streets')
self.network = mm.gdf_to_nx(self.df_streets)
self.network = mm.node_degree(self.network)
def test_node_degree(self):
graph = mm.gdf_to_nx(self.df_streets)
deg1 = mm.node_degree(graph=graph)
assert deg1.nodes[(1603650.450422848,
6464368.600601688)]['degree'] == 4
GREEN = '#00ff00'
RED = '#ff0000'
BLOCK = 100.0 # block size in metres
AVES = [chr(c) for c in range(ord('A'), ord('V') + 1)]
ST_SUFS = ['st', 'nd', 'rd'] + ['th'] * 15
with open('provided/stepinator.json') as f:
a = load(f) # acceleration data
v = [0.0] # speed data
disp = [0.0] # displacement data
for ax in a:
disp.append(v[-1] + 0.5 * ax)
v.append(v[-1] + ax)
G = gdf_to_nx(read_file('maps/city-shapefile/edges.shp'))
def tup_scalar_mul(scalar, tup):
return tuple(x * scalar for x in tup)
def add_tups(tup1, tup2):
return tuple(map(lambda x, y: x + y, tup1, tup2))
class Path:
def __init__(self, t, pos, d, visited):
self.t = t # time
self.pos = pos # position
self.d = d # direction vector
ax = dublin_admin_county_boundaries.plot(figsize=(15, 15),
facecolor="orange",
edgecolor="orange")
mv_network_lines.plot(ax=ax)
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,
nodes_restr = first_find[['osm_id', 'other_tags', 'node_from', 'node_via', 'node_to']].copy()
nodes_restr = nodes_restr.drop_duplicates(nodes_restr.columns).reset_index(drop=True)
return nodes_restr
############# END of Checking restrictions #############
try:
nodes_restr = oneRestr(gdf_other_lines,gdf_other_points)
except:
lst_nr = ['osm_id', 'other_tags', 'node_from', 'node_via', 'node_to']
nodes_restr = gpd.GeoDataFrame(columns=lst_nr, data=None)
############# Find neighbours of graph #########
all_graph = momepy.gdf_to_nx(new_graph, approach='primal')
# поиск всех ближайших (только в первом колене) соседей для каждого узла
all_neigh = []
i=0
for i in (range(len(all_graph))):
lst_neigh = []
one_node = list(all_graph.nodes())[i]
lst_neigh = list(nx.all_neighbors(all_graph, one_node))
# lst_neigh.append(neighs)
all_neigh.append(lst_neigh)
#
# подтягивание node_id (потому что в поиске нашлась только их геометрия)
neigh_names = []
node_names = []
def test_gdf_to_nx(self):
nx = mm.gdf_to_nx(self.df_streets)
assert nx.number_of_nodes() == 29
assert nx.number_of_edges() == 35
dual = mm.gdf_to_nx(self.df_streets, approach="dual")
assert dual.number_of_nodes() == 35
assert dual.number_of_edges() == 74
self.df_streets["ix"] = np.arange(0, len(self.df_streets) * 2, 2)
self.df_streets.set_index("ix", inplace=True)
dual2 = mm.gdf_to_nx(self.df_streets, approach="dual")
assert dual2.number_of_nodes() == 35
assert dual2.number_of_edges() == 74
with pytest.raises(ValueError):
mm.gdf_to_nx(self.df_streets, approach="nonexistent")
nx = mm.gdf_to_nx(self.df_streets, multigraph=False)
assert isinstance(nx, networkx.Graph)
assert nx.number_of_nodes() == 29
assert nx.number_of_edges() == 35
nx = mm.gdf_to_nx(self.df_streets, multigraph=False, directed=True)
assert isinstance(nx, networkx.DiGraph)
assert nx.number_of_nodes() == 29
assert nx.number_of_edges() == 35
nx = mm.gdf_to_nx(self.df_streets, directed=True)
assert isinstance(nx, networkx.MultiDiGraph)
assert nx.number_of_nodes() == 29
assert nx.number_of_edges() == 35
dual = mm.gdf_to_nx(self.df_streets, approach="dual", angles=False)
assert (dual.edges[(1603499.42326969, 6464328.7520580515),
(1603510.1061735682, 6464204.555117119), 0, ] == {})
dual = mm.gdf_to_nx(self.df_streets, approach="dual", angle="ang")
assert dual.edges[(1603499.42326969, 6464328.7520580515),
(1603510.1061735682, 6464204.555117119), 0, ] == {
"ang": 1.0963654487814474
}
dual = mm.gdf_to_nx(self.df_streets,
approach="dual",
angles=False,
multigraph=False)
assert isinstance(nx, networkx.Graph)
assert (dual.edges[(1603499.42326969, 6464328.7520580515),
(1603510.1061735682, 6464204.555117119), ] == {})
dual = mm.gdf_to_nx(self.df_streets, approach="dual", multigraph=False)
assert isinstance(nx, networkx.Graph)
assert dual.edges[(1603499.42326969, 6464328.7520580515),
(1603510.1061735682, 6464204.555117119), ] == {
"angle": 1.0963654487814474
}
with pytest.raises(ValueError):
mm.gdf_to_nx(self.df_streets, approach="dual", directed=True)
def test_gdf_to_nx(self):
nx = mm.gdf_to_nx(self.df_streets)
assert nx.number_of_nodes() == 29
assert nx.number_of_edges() == 35
