Examples of usage¶

Spatial graphs are used across momepy. This notebook will illustrate its use on three examples.

import momepy
import osmnx as ox
from libpysal import graph

We will again use osmnx to get the data for our example and after preprocessing of building layer will generate tessellation layer.

gdf = ox.features_from_place("Kahla, Germany", tags={"building": True})
buildings = ox.projection.project_gdf(gdf).reset_index()

limit = momepy.buffered_limit(buildings)
tessellation = momepy.morphological_tessellation(buildings, clip=limit)

First order contiguity¶

Distance to neighbours¶

To calculate the mean distance to neighbouring buildings, we need queen contiguity weights of the first order capturing the relationship between immediate neighbours. Relationship between buildings is here represented by relationships between their tessellation cells.

contiguity = graph.Graph.build_contiguity(tessellation)
contiguity

<Graph of 3052 nodes and 17774 nonzero edges (6 components, 3 isolates) indexed by
 [0, 1, 2, 3, 4, ...]>

buildings["neighbour_dist"] = momepy.neighbor_distance(buildings, contiguity)

ax = buildings.plot(
    column="neighbour_dist",
    scheme="naturalbreaks",
    k=8,
    legend=True,
    cmap="Spectral",
    figsize=(8, 8),
)
ax.set_axis_off()

Higher order / distance¶

However, typical usage of spatial graphs is to capture the vicinity of each feature. As illustrated in the previous notebook, there are multiple options on how to capture it. In this example, we will use queen contiguity of the higher order (3) based on morphological tessellation. Because we want to treat the building itself as part of its neighborhood, we assing self weights on top.

contiguity_k3 = contiguity.higher_order(3).assign_self_weight()
contiguity_k3

<Graph of 3052 nodes and 75684 nonzero edges (8 components, 0 isolates) indexed by
 [0, 1, 2, 3, 4, ...]>

Neighborhood description¶

Mean value of selected character within a vicinity of each cell (or building, plot) is a simple example. Most of the common descriptive statistics are available using the method Graph.describe().

describe_k3 = contiguity_k3.describe(tessellation.area)
describe_k3.head()

ax = tessellation.plot(
    column=describe_k3["mean"],
    legend=True,
    scheme="quantiles",
    k=10,
    cmap="Blues_r",
    figsize=(8, 8),
)
buildings.plot(ax=ax, color="white", alpha=0.4)
ax.set_axis_off()

ax = tessellation.plot(
    column=describe_k3["median"],
    legend=True,
    scheme="quantiles",
    k=10,
    cmap="Blues_r",
    figsize=(8, 8),
)
buildings.plot(ax=ax, color="white", alpha=0.4)
ax.set_axis_off()

In some cases, we might want to eliminate the effect of outliers. To do so, we can specify the quantile range on which should describe work. Below we will measure only interquartile mean.

describe_k3_iqr = contiguity_k3.describe(tessellation.area, q=(25, 75))

ax = tessellation.plot(
    column=describe_k3_iqr["mean"],
    legend=True,
    scheme="quantiles",
    k=10,
    cmap="Greens_r",
    figsize=(8, 8),
)
buildings.plot(ax=ax, color="white", alpha=0.4)
ax.set_axis_off()

Weighted character¶

The weighted average is another example using the same spatial graphs. For illustration, we can try area-weighted circular compactness:

circular_compactness = momepy.circular_compactness(buildings)
buildings["weighted_circom"] = momepy.weighted_character(
    circular_compactness, buildings.area, contiguity_k3
)

ax = buildings.plot(
    column="weighted_circom",
    legend=True,
    scheme="quantiles",
    k=15,
    cmap="viridis",
    figsize=(8, 8),
)
ax.set_axis_off()

Density¶

We will again use our Manhattan case study to illustrate using graphs in capturing gross density.

point = (40.731603, -73.977857)
dist = 1000
gdf = ox.features_from_point(point, dist=dist, tags={"building": True})
gdf_projected = ox.projection.project_gdf(gdf)
buildings = gdf_projected[
    gdf_projected.geom_type.isin(["Polygon", "MultiPolygon"])
].reset_index()

limit = momepy.buffered_limit(buildings)
tessellation = momepy.morphological_tessellation(buildings, clip=limit)

ax = tessellation.plot(figsize=(8, 8))
buildings.plot(ax=ax, color="white", alpha=0.5)
ax.set_axis_off()

To get gross density, we need to know floor areas:

def clean_heights(x):
    try:
        return float(x)
    except ValueError:
        return 0


buildings["height"] = buildings["height"].fillna(0).apply(clean_heights)
buildings["floors"] = buildings["height"] // 3

buildings["floor_area"] = buildings.area * buildings["floors"]

Gross density can be expressed as sum of floor area in a neighborhood divided by sum areas within the same neighborhoods. Graph.describe() is perfect for that.

First, build the Graph.

contiguity_ny_k3 = (
    graph.Graph.build_contiguity(tessellation)
    .higher_order(3)
    .assign_self_weight()
)
contiguity_ny_k3

<Graph of 3157 nodes and 99033 nonzero edges (4 components, 0 isolates) indexed by
 [0, 1, 2, 3, 4, ...]>

Then you can measure sums and derive gross density.

areas = contiguity_ny_k3.describe(tessellation.area, statistics=["sum"])["sum"]
floor_areas = contiguity_ny_k3.describe(
    buildings["floor_area"], statistics=["sum"]
)["sum"]

tessellation["gross_density"] = floor_areas / areas

ax = tessellation.plot(
    column="gross_density",
    legend=True,
    scheme="naturalbreaks",
    k=10,
    figsize=(8, 8),
)
buildings.plot(ax=ax, color="white", alpha=0.5)
ax.set_axis_off()

In a similar way can be done gross coverage.

areas = contiguity_ny_k3.describe(tessellation.area, statistics=["sum"])["sum"]
blg_areas = contiguity_ny_k3.describe(buildings.area, statistics=["sum"])["sum"]

tessellation["gross_coverage"] = blg_areas / areas

ax = tessellation.plot(figsize=(8, 8), column="gross_coverage", legend=True)
buildings.plot(ax=ax, color="white", alpha=0.5)
ax.set_axis_off()