gdf2osmnx

momepy/coins.py

@@ -20,7 +20,6 @@
 
 
 class COINS:
-
     """
     Calculates natural continuity and hierarchy of street networks in a given
     GeoDataFrame using the COINS algorithm.

momepy/distribution.py

@@ -411,7 +411,6 @@ def __init__(
 
 
 class Alignment:
-
     """
     Calculate the mean deviation of solar orientation of objects on adjacent cells
     from an object.

momepy/preprocessing.py

@@ -150,9 +150,9 @@ def preprocess(
                         geoms.append(blg[blg["mm_uid"] == j].iloc[0].geometry)
                         blg.drop(blg[blg["mm_uid"] == j].index[0], inplace=True)
                 new_geom = shapely.ops.unary_union(geoms)
-                blg.loc[
-                    blg.loc[blg["mm_uid"] == key].index[0], blg.geometry.name
-                ] = new_geom
+                blg.loc[blg.loc[blg["mm_uid"] == key].index[0], blg.geometry.name] = (
+                    new_geom
+                )
 
         blg.drop(delete, inplace=True)
     return blg[buildings.columns]
@@ -1568,7 +1568,9 @@ def __init__(
                 [gdf.unary_union]
             ).geoms,  # get parts of the collection from polygonize
             crs=gdf.crs,
-        ).explode(ignore_index=True)  # shouldn't be needed but doesn't hurt to ensure
+        ).explode(
+            ignore_index=True
+        )  # shouldn't be needed but doesn't hurt to ensure
 
         # Store geometries as a GeoDataFrame
         self.polygons = gpd.GeoDataFrame(geometry=polygons)

momepy/shape.py

@@ -1258,9 +1258,11 @@ def __init__(self, gdf):
         self.gdf = gdf
 
         euclidean = gdf.geometry.apply(
-            lambda geom: self._dist(geom.coords[0], geom.coords[-1])
-            if geom.geom_type == "LineString"
-            else np.nan
+            lambda geom: (
+                self._dist(geom.coords[0], geom.coords[-1])
+                if geom.geom_type == "LineString"
+                else np.nan
+            )
         )
         self.series = euclidean / gdf.geometry.length
 

momepy/tests/test_preprocess.py

@@ -196,6 +196,7 @@ def test_consolidate_intersections_unsupported(self):
                 rebuild_edges_method="banana",
             )
 
+
 def test_FaceArtifacts():
     pytest.importorskip("esda")
     osmnx = pytest.importorskip("osmnx")

momepy/tests/test_utils.py

@@ -54,6 +54,11 @@ def test_gdf_to_nx(self):
             ValueError, match="Approach 'nonexistent' is not supported."
         ):
             mm.gdf_to_nx(self.df_streets, approach="nonexistent")
+        with pytest.raises(
+            ValueError,
+            match="OSMnx-compatible graphs must be directed, of multigraph type, and using the primal approach.",
+        ):
+            mm.gdf_to_nx(self.df_streets, approach="dual", osmnx_like=True)
 
         nx = mm.gdf_to_nx(self.df_streets, multigraph=False)
         assert isinstance(nx, networkx.Graph)
@@ -70,6 +75,12 @@ def test_gdf_to_nx(self):
         assert nx.number_of_nodes() == 29
         assert nx.number_of_edges() == 35
 
+        nx = mm.gdf_to_nx(self.df_streets, directed=True, osmnx_like=True)
+        assert isinstance(nx, networkx.MultiDiGraph)
+        assert nx.number_of_nodes() == 83
+        assert nx.number_of_edges() == 89
+        assert networkx.degree_histogram(nx) == [0, 11, 58, 6, 7, 1]
+
         self.df_streets["oneway"] = True
         self.df_streets.loc[0, "oneway"] = False  # first road section is bidirectional
         nx = mm.gdf_to_nx(self.df_streets, directed=True, oneway_column="oneway")

momepy/utils.py

@@ -8,7 +8,8 @@
 import networkx as nx
 import numpy as np
 from numpy.lib import NumpyVersion
-from shapely.geometry import Point
+from shapely.geometry import Point, LineString
+from shapely.ops import linemerge
 
 __all__ = [
     "unique_id",
@@ -47,7 +48,14 @@
     return abs((a2 - a1 + 180) % 360 - 180)
 
 
-def _generate_primal(graph, gdf_network, fields, multigraph, oneway_column=None):
+def _make_edgetuples(nodelist):
+    """Zip list of nodes into list of edgetuples. Helper function for _generate_primal"""
+    return [z for z in zip(nodelist, nodelist[1:])]
+
+
+def _generate_primal(
+    graph, gdf_network, fields, multigraph, osmnx_like, oneway_column=None
+):
     """Generate a primal graph. Helper for ``gdf_to_nx``."""
     graph.graph["approach"] = "primal"
 
@@ -71,24 +79,67 @@
             stacklevel=3,
         )
 
-    key = 0
-    for row in gdf_network.itertuples():
-        first = row.geometry.coords[0]
-        last = row.geometry.coords[-1]
+    if osmnx_like:
 
-        data = list(row)[1:]
-        attributes = dict(zip(fields, data, strict=True))
-        if multigraph:
-            graph.add_edge(first, last, key=key, **attributes)
-            key += 1
-
-            if oneway_column:
-                oneway = bool(getattr(row, oneway_column))
-                if not oneway:
-                    graph.add_edge(last, first, key=key, **attributes)
-                    key += 1
-        else:
-            graph.add_edge(first, last, **attributes)
+        gdf_network["geometry"] = gdf_network["geometry"].apply(
+            lambda x: linemerge(x) if x.geom_type == "MultiLineString" else x
+        )
+        gdf_network = gdf_network.explode(index_parts=False)
+        gdf_network = gdf_network[fields]
+
+        coords = gdf_network.get_coordinates()
+        tuples = list(set([(row.x, row.y) for row in coords.itertuples()]))
+
+        tupledict = {}
+        for i, t in enumerate(tuples):
+            tupledict[t] = i
+        nodedict = {}
+        for i, t in enumerate(tuples):
+            nodedict[i] = t
+
+        for (x, y), id in tupledict.items():
+            graph.add_node(id, x=x, y=y)
+
+        edgetuples = gdf_network.apply(
+            lambda x: _make_edgetuples([tupledict[c] for c in x.geometry.coords]),
+            axis=1,
+        )
+        for row in gdf_network.itertuples():
+            data = list(row)[1:]
+            attributes = dict(zip(fields, data, strict=True))
+            for u, v in edgetuples[row[0]]:
+                attributes["geometry"] = LineString([nodedict[u], nodedict[v]])
+                edgedata = graph.get_edge_data(u=u, v=v)
+                if edgedata:
+                    key = max(edgedata.keys()) + 1
+                else:
+                    key = 0
+                graph.add_edge(u_for_edge=u, v_for_edge=v, key=key, **attributes)
+                if oneway_column:
+                    oneway = bool(getattr(row, oneway_column))
+                    if not oneway:
+                        graph.add_edge(
+                            u_for_edge=v, v_for_edge=u, key=key + 1, **attributes
+                        )
+    else:
+        key = 0
+        for row in gdf_network.itertuples():
+            first = row.geometry.coords[0]
+            last = row.geometry.coords[-1]
+
+            data = list(row)[1:]
+            attributes = dict(zip(fields, data, strict=True))
+            if multigraph:
+                graph.add_edge(first, last, key=key, **attributes)
+                key += 1
+
+                if oneway_column:
+                    oneway = bool(getattr(row, oneway_column))
+                    if not oneway:
+                        graph.add_edge(last, first, key=key, **attributes)
+                        key += 1
+            else:
+                graph.add_edge(first, last, **attributes)
 
 
 def _generate_dual(graph, gdf_network, fields, angles, multigraph, angle):
@@ -150,6 +201,7 @@
     angles=True,
     angle="angle",
     oneway_column=None,
+    osmnx_like=False,
 ):
     """
     Convert a LineString GeoDataFrame to a ``networkx.MultiGraph`` or other
@@ -188,7 +240,10 @@
         path traversal by specifying the boolean column in the GeoDataFrame. Note,
         that the reverse conversion ``nx_to_gdf(gdf_to_nx(gdf, directed=True,
         oneway_column="oneway"))`` will contain additional duplicated geometries.
-
+    osmnx_like: bool, default False
+        if osmnx_like=True, returns a MultiDiGraph object that is compatible
+        with OSMnx functions (edges have (u,v,key), nodes have (x,y) attributes
+        where coordinates are stored).
     Returns
     -------
     net : networkx.Graph, networkx.MultiGraph, networkx.DiGraph, networkx.MultiDiGraph
@@ -235,11 +290,16 @@
     <networkx.classes.multigraph.MultiGraph object at 0x7f8cf9150fd0>
 
     """
+    if osmnx_like and (not directed or not multigraph or approach == "dual"):
+        raise ValueError(
+            "OSMnx-compatible graphs must be directed, of multigraph type, and using the primal approach."
+        )
+
     gdf_network = gdf_network.copy()
     if "key" in gdf_network.columns:
         gdf_network.rename(columns={"key": "__key"}, inplace=True)
 
-    if multigraph and directed:
+    if (multigraph and directed) or osmnx_like:
         net = nx.MultiDiGraph()
     elif multigraph and not directed:
         net = nx.MultiGraph()
@@ -251,14 +311,15 @@
     net.graph["crs"] = gdf_network.crs
     gdf_network[length] = gdf_network.geometry.length
     fields = list(gdf_network.columns)
-
     if approach == "primal":
         if oneway_column and not directed:
             raise ValueError(
                 "Bidirectional lines are only supported for directed graphs."
             )
 
-        _generate_primal(net, gdf_network, fields, multigraph, oneway_column)
+        _generate_primal(
+            net, gdf_network, fields, multigraph, osmnx_like, oneway_column
+        )
 
     elif approach == "dual":
         if directed: