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