Note
Shape#
While the majority of momepy
functions require the interaction of more GeoDataFrames
or using spatial weights matrix, there are some which are calculated on single GeoDataFrame
assessing the dimensions or shapes of features. This notebook illustrates how to measure simple shape characters.
[1]:
import momepy
import geopandas as gpd
import matplotlib.pyplot as plt
import numpy as np
We will again use osmnx
to get the data for our example and after preprocessing of building layer will generate tessellation.
[2]:
import osmnx as ox
gdf = ox.geometries.geometries_from_place('Kahla, Germany', tags={'building':True})
buildings = ox.projection.project_gdf(gdf)
buildings['uID'] = momepy.unique_id(buildings)
limit = momepy.buffered_limit(buildings)
tess = momepy.Tessellation(buildings, unique_id='uID', limit=limit)
tessellation = tess.tessellation
Inward offset...
Generating input point array...
Generating Voronoi diagram...
Generating GeoDataFrame...
Dissolving Voronoi polygons...
[3]:
f, ax = plt.subplots(figsize=(10, 10))
tessellation.plot(ax=ax)
buildings.plot(ax=ax, color='white', alpha=.5)
ax.set_axis_off()
plt.show()

Building shapes#
Few examples of measuring building shapes. Circular compactness measures the ratio of object area to the area of its smallest circumsribed circle:
[4]:
blg_cc = momepy.CircularCompactness(buildings)
buildings['circular_com'] = blg_cc.series
[5]:
f, ax = plt.subplots(figsize=(10, 10))
buildings.plot(ax=ax, column='circular_com', legend=True, cmap='viridis')
ax.set_axis_off()
plt.show()

While elongation is seen as elongation of its minimum bounding rectangle:
[6]:
blg_elongation = momepy.Elongation(buildings)
buildings['elongation'] = blg_elongation.series
[7]:
f, ax = plt.subplots(figsize=(10, 10))
buildings.plot(ax=ax, column='elongation', legend=True, cmap='Blues_r')
ax.set_axis_off()
plt.show()

And squareness measures mean deviation of all corners from 90 degrees:
[8]:
blg_squareness = momepy.Squareness(buildings)
buildings['squareness'] = blg_squareness.series
100%|██████████| 2946/2946 [00:00<00:00, 9756.48it/s]
[9]:
f, ax = plt.subplots(figsize=(10, 10))
buildings.plot(ax=ax, column='squareness', legend=True, scheme='quantiles', cmap='Purples_r')
ax.set_axis_off()
plt.show()

For the form factor, we need to know the volume of each building. While we do not have building height data for Kahla, we will generate them randomly and pass a Series
containing volume values to FormFactor
.
Note: For the majority of parameters you can pass values as the name of the column, np.array
, pd.Series
or any other list-like object.
[10]:
height = np.random.randint(4, 20, size=len(buildings))
blg_volume = momepy.Volume(buildings, height)
buildings['formfactor'] = momepy.FormFactor(buildings, volumes=blg_volume.series, heights=height).series
[11]:
f, ax = plt.subplots(figsize=(10, 10))
buildings.plot(ax=ax, column='formfactor', legend=True, scheme='quantiles', k=10, cmap='PuRd_r')
ax.set_axis_off()
plt.show()

Cell shapes#
In theory, you can measure most of the 2D characters on all elements, including tessellation or blocks:
[12]:
tes_cwa = momepy.CompactnessWeightedAxis(tessellation)
tessellation['cwa'] = tes_cwa.series
[13]:
f, ax = plt.subplots(figsize=(10, 10))
tessellation.plot(ax=ax, column='cwa', legend=True, scheme='quantiles', k=10, cmap='Greens_r')
ax.set_axis_off()
plt.show()

Street network shapes#
There are some characters which requires street network as an input. We can again use osmnx
to retrieve it from OSM.
[14]:
streets_graph = ox.graph_from_place('Kahla, Germany', network_type='drive')
streets_graph = ox.projection.project_graph(streets_graph)
osmnx
returns networkx Graph. While momepy works with graph in some cases, for this one we need GeoDataFrame
. To get it, we can use ox.graph_to_gdfs
.
Note: momepy.nx_to_gdf
might work as well, but OSM network needs to be complete in that case. osmnx
takes care of it.
[15]:
edges = ox.graph_to_gdfs(streets_graph, nodes=False, edges=True,
node_geometry=False, fill_edge_geometry=True)
[16]:
f, ax = plt.subplots(figsize=(10, 10))
edges.plot(ax=ax, color='pink')
buildings.plot(ax=ax, color='lightgrey')
ax.set_axis_off()
plt.show()

Now we can calculate linearity of each segment:
[17]:
edg_lin = momepy.Linearity(edges)
edges['linearity'] = edg_lin.series
[18]:
f, ax = plt.subplots(figsize=(10, 10))
edges.plot(ax=ax, column='linearity', legend=True, cmap='coolwarm_r', scheme='quantiles', k=4)
buildings.plot(ax=ax, color='lightgrey')
ax.set_axis_off()
plt.show()
