Daniel Bruneß

Waterways from OpenStreetMap as SVG

2025-08-10T00:00:00+02:00

Rivers and streams create organic, recognizable shapes that work well as design elements. Here I extract the waterway network around Offenbach am Main from OpenStreetMap and export it as a clean SVG.

Fetching waterways

OSMnx handles the query:

import osmnx as ox

tags = {'waterway': ['river', 'stream', 'canal', 'drain', 'ditch']}
gdf = ox.features.features_from_address(
    "Offenbach am Main, Germany", tags=tags, dist=5000
)

A 5 km radius around the city center captures the Main and all tributaries (Bieber, Rodau, Hainbach, plus several canals near the harbor).

Filtering and export

OSM waterway features can be points, lines, or polygons. For a clean river network, keep only lines:

gdf_lines = gdf[gdf.geometry.type.isin(['LineString', 'MultiLineString'])]

Matplotlib saves directly to SVG:

fig, ax = plt.subplots(figsize=(12, 12))
gdf_lines.plot(ax=ax, color='blue', linewidth=1.5, alpha=0.8)
ax.set_aspect('equal')
plt.savefig('offenbach_waterways.svg', format='svg', bbox_inches='tight')

The result shows the distinctive shape of the Main at Offenbach – the old harbor branching off – with smaller streams radiating inland. The SVG scales to any size, and the GeoJSON export (gdf_lines.to_file(...)) works for web maps or further processing.

The same code works for any city – just change the address and radius.

70 Years of Temperature Data in Offenbach

2025-07-15T00:00:00+02:00

Almost 70 years of temperature data from Offenbach (1957–2025), based on over 20,000 daily measurements from the German Weather Service (DWD).

The first chart shows average daily maximum temperature in June. The GAM trend line confirms what you’d expect: it’s getting warmer.

The second chart counts hot days (daily max >= 30°C) per year. Record: 40 hot days in 2018. The year 1958 had just 2.

There’s a data gap from roughly 1995 to 2005 – no measurements are available for that period. The analysis combines records from three DWD stations in Offenbach (IDs 03776, 03775, 07341).

Code

DWD daily climate files (Offenbach stations 03776, 03775, 07341) are loaded, then:

June temperature trend — GAM via pygam for a smooth non-linear fit:

from pygam import LinearGAM, s
import pandas as pd
import numpy as np

# df from DWD produkt_klima_tag_*.txt, columns: MESS_DATUM, MONAT, JAHR, TXK (max temp)
df_monthly = df[df["MONAT"] == 6].groupby("JAHR")["TXK"].mean()
x = df_monthly.index.values.reshape(-1, 1)
y = df_monthly.values

gam = LinearGAM(s(0, n_splines=5)).fit(x, y)
y_pred = gam.predict(np.sort(x, axis=0))
# conf_interval = gam.confidence_intervals(x_sorted, width=0.95)

Hot days per year (≥30°C):

df_hot = df[df["TXK"] >= 30].groupby("JAHR").size()

Data: DWD Climate Data Center. Full script: hot_days.py.

Isochrone Maps with Python

2025-05-29T00:00:00+02:00

Isochrone maps show areas reachable within a given travel time from a starting point. This project combines OSRM travel time calculations with satellite-derived elevation data to produce maps that show both accessibility and topography.

Process overview

Load and process a Digital Elevation Model (DEM)
Calculate travel times via OSRM
Color-code administrative areas by travel time
Overlay hillshading, city labels, and street networks

DEM processing

The elevation data goes through several steps: CRS transformation, masking to the area of interest, and hillshading.

def _process_dem(self):
    if self.kwargs.use_elevation:
        bounds = self.get_shp_bounds()
        elevation_file = self.get_elevation_dem(bounds)
    else:
        elevation_file = self.kwargs.dem_file

    with rio.open(elevation_file) as src:
        working_dem = transform_dem(src, self.config["dem"]["dest_crs"])
        if self.kwargs.reduce_size != 1.0:
            working_dem = resize_dem(working_dem, self.kwargs.reduce_size)
        working_dem = mask_dem(working_dem, self.admin_shp["geometry"])
        transformed_shaded = hillshade(working_dem.read(1), azimuth=315, angle_altitude=45)
        return recreate_dataset_reader(transformed_shaded, working_dem.meta, 1)

CRS transformation is straightforward with rasterio:

def transform_dem(dem_dataset, target_crs):
    if dem_dataset.crs == target_crs:
        return dem_dataset
    transform, width, height = calculate_default_transform(
        dem_dataset.crs, target_crs,
        dem_dataset.width, dem_dataset.height,
        *dem_dataset.bounds
    )
    kwargs = dem_dataset.meta.copy()
    kwargs.update({'crs': target_crs, 'transform': transform, 'width': width, 'height': height})
    return recreate_dataset_reader(dem_dataset.read(), kwargs)

Masking clips the raster to the administrative boundary:

def mask_dem(dem_dataset, geometries):
    out_image, out_transform = rio_mask(dem_dataset, geometries, crop=True, all_touched=True)
    out_meta = dem_dataset.meta.copy()
    out_meta.update({
        "height": out_image.shape[1], "width": out_image.shape[2], "transform": out_transform
    })
    return recreate_dataset_reader(out_image, out_meta)

Hillshading uses gradient-based slope and aspect calculation:

def hillshade(array, azimuth=315, angle_altitude=45):
    x, y = np.gradient(array)
    slope = np.pi/2 - np.arctan(np.sqrt(x*x + y*y))
    aspect = np.arctan2(-x, y)
    azimuthrad = azimuth * np.pi / 180
    altituderad = angle_altitude * np.pi / 180
    return (np.sin(altituderad) * np.sin(slope) +
            np.cos(altituderad) * np.cos(slope) *
            np.cos((azimuthrad - np.pi/2) - aspect)) * 255

Travel time calculation

OSRM (Open Source Routing Machine) computes driving times from a central point to the centroid of every administrative area. Coordinates are converted from UTM to WGS84 before querying:

class OSRM:
    def calculate_travel_time(self, gdf):
        gdf = self._init_gdf_fields(gdf)
        for _, row in tqdm(gdf.iterrows(), total=len(gdf)):
            utm_x, utm_y = row["geometry"].centroid.coords[0]
            lat, lon = utm.to_latlon(utm_x, utm_y, 32, 'U')
            result = self._get_distance_duration(lat, lon)
            if result:
                distance, duration = result
                gdf = self._update_gdf(gdf, row["DEBKG_ID"], lat, lon, distance, duration)
        return gdf

The areas are then dissolved by travel time bucket for a cleaner visualization:

Combining DEM and travel times

Each administrative area is colored by travel time using a gold-to-blue gradient, then multiplied with the hillshade raster:

def combine_shape_dem(self, admin_gdf, dem):
    unique_colors = len(admin_gdf["traveltime_h"].unique())
    cmap = LinearSegmentedColormap.from_list(
        "Custom", [(255/255, 215/255, 0/255), (0/255, 87/255, 183/255)], N=unique_colors
    )
    base_image = np.full((dem.shape[0], dem.shape[1], 3), np.array([0, 0, 0]))
    
    for _, area in tqdm(admin_gdf.iterrows(), total=len(admin_gdf)):
        out_image, _ = rio_mask(dem, [area["geometry"]], crop=False, all_touched=False)
        color_index, ccode = self._get_colorcode_val(
            area["traveltime_h"], area["traveltime_h30"], unique_colors
        )
        rgba = cmap(ccode)
        rgb = np.array(rgba[:3])
        base_color = np.full((dem.shape[0], dem.shape[1], 3), rgb)
        image_data = np.expand_dims(out_image[0, :, :], axis=2)
        base_image = base_image + np.rint(base_color * image_data).astype("int")
    return base_image

Final map

The final render adds city labels, a street network overlay, and a legend:

def plot_map(colored_image, street_graph_edges, city_label_gdf, eu_gdf, config, legend_used_colors):
    fig, ax = plt.subplots(figsize=config["map"]["size"])
    ax.imshow(colored_image)
    if street_graph_edges is not None:
        street_graph_edges.plot(ax=ax, linewidth=0.5, alpha=0.5)
    for idx, row in city_label_gdf.iterrows():
        ax.annotate(row['city'], (row.geometry.x, row.geometry.y), fontsize=config["map"]["fontsize"])
    plot_legend(ax, legend_used_colors)
    plt.savefig(config["map"]["output_file"], dpi=300, bbox_inches='tight')

The coordinate handling juggles WGS84 (EPSG:4326) for GPS coordinates and UTM Zone 32N (EPSG:25832) for local measurements, with rasterio and GeoPandas handling the conversions.

Bundestagswahl 2025: Offenbach by Wahlbezirk

2025-02-25T00:00:00+01:00

Offenbach has voted. Here’s how the 79 polling districts (Wahlbezirke) went, mapped by Zweitstimme (second vote) winner. The 24 postal voting districts are excluded.

District-level winners: CDU 31, Linke 30, AfD 10, SPD 5, Grüne 3.

The remaining charts show the geographic distribution of Zweitstimme shares per party:

Data and code

Election results from Votemanager Open Data (Stand 24.02.2025, 09:00). Wahlbezirk geometries via GeoJSON (props to @lsy_161).

import geopandas as gpd
import pandas as pd
import matplotlib.pyplot as plt
import osmnx as nx
import contextily as cx

# Load Wahlbezirk geometries and election results
gdf = gpd.read_file("wahlbezirke.geojson")
wahl_df = pd.read_csv("data/Open-Data-06413000-Bundestagswahl-Wahlbezirk.csv", sep=";")
wahl_df.rename(columns={"gebiet-nr": "Wahlbezirk"}, inplace=True)

# Merge, keep Zweitstimmen columns (F1, F2, ...)
df = gdf.merge(wahl_df, on="Wahlbezirk")
zweitstimmen_cols = [c for c in df.columns if c.startswith("F") and c != "F"]
df_filtered = df[["Wahlbezirk", "geometry"] + zweitstimmen_cols]

# Winner per district = column with max Zweitstimmen
max_values = df_filtered.loc[:, zweitstimmen_cols].idxmax(axis=1)

# Plot each district with party color (F1=SPD, F2=CDU, F6=Linke, etc.)
fig, ax = plt.subplots(figsize=(12, 12))
for i, mv in enumerate(max_values):
    df_filtered.loc[[i], "geometry"].plot(ax=ax, color=parteifarben[mv], alpha=1., edgecolor="#ffffff")
cx.add_basemap(ax, crs=df_filtered.crs, source=nx.providers.OpenStreetMap.Mapnik)

OSM base map via OSMnx and contextily. Full notebook: bundestagswahl2025.ipynb.

All Roads Lead to Offenbach

2024-12-20T00:00:00+01:00

10,000 randomly placed points across Europe, each routed to Offenbach am Main via OSRM.

The approach: take the outline of Europe, scatter random points on land, then compute the optimal driving route from each point to Offenbach using a self-hosted OSRM server. The result is a cobweb of routes that reveals the continental road network structure – the major corridors through France, the Alps, the Balkans, and Scandinavia emerge naturally.

Built in R. Geocode the city, sample 10,000 points within a 4,000 km buffer on European land (using the cobweb package’s Europe geometry), then fetch routes in parallel via OSRM:

library(osrm)
library(sf)
library(mapsf)
library(tidygeocoder)
library(parallel)
library(doParallel)
library(foreach)

# Geocode city, sample points on land within buffer
v_raw <- tidygeocoder::geo("Offenbach am Main, Germany", progress_bar = FALSE)
v <- st_as_sf(v_raw[1,], coords = c("long", "lat"), crs = "EPSG:4326")
zone <- st_buffer(st_transform(v, "EPSG:3035"), 4000 * 1000)
land <- st_read(system.file("gpkg/europe.gpkg", package = "cobweb"), layer = "fg")
pts <- st_sample(st_intersection(st_geometry(zone), st_geometry(land)), size = 10000)
df <- data.frame(srcx = v_raw$long, srcy = v_raw$lat,
                 dstx = st_coordinates(st_transform(pts, 4326))[,1],
                 dsty = st_coordinates(st_transform(pts, 4326))[,2])

# Parallel OSRM routing (12 cores)
roads <- get_routes(df, ncl = 12, url = "http://0.0.0.0:5000/")
# ... mf_map(roads) for visualization

The get_routes() helper splits the work across 12 cores, calling osrmRoute() for each origin–destination pair. Map export uses mapsf. Full implementation: streetplotter.R.

Inspired by rcarto’s OSRM server tutorial.

Vehicle Fleet by Fuel Type in Offenbach

2023-12-15T00:00:00+01:00

Four views of the vehicle fleet in registration district Offenbach am Main (Stadt, 06413), based on data from the Kraftfahrt-Bundesamt (KBA).

The first chart compares hybrid, electric, and gas-powered vehicles. Hybrid and electric registrations have grown steadily, while gas vehicles are declining:

The second chart shows the petrol and diesel split, with “Sonstige” (other) bundling electric, gas, and hybrid:

All fuel types side by side in absolute numbers (some years have data gaps):

Finally, the percentage growth of electric vehicles across all German registration districts. Offenbach (red) sits in the middle of the pack at 1.91% EV share in 2023:

Data: Kraftfahrt-Bundesamt.

Bicycle Counter at the Harbor: A Year in Rides

2023-06-10T00:00:00+02:00

The bike path along Offenbach’s harbor has a bicycle counter. This calendar heatmap shows the daily count for all of 2022.

Peak day: 4,746 cyclists on a sunny Sunday in May (15.05.22). Lowest: 142 on December 19th – a cold, rainy Monday. Summer vs. winter is obvious, but the week-level patterns are interesting too: weekends consistently outperform weekdays, and a few rainy summer days drop below their surrounding weeks.

Data source

The data comes from the eco-counter API (Hafen Messstation, id 300023687). The counter distinguishes inbound and outbound directions across four channels. All public bicycle counting stations in Hesse are available via raddaten-hessen.de.

import requests
import pandas as pd
import seaborn as sns

# eco-counter API for the Hafen station
station_id = 300023687
flow_id = 353306686

# Fetch daily counts, pivot into calendar form, plot as heatmap
sns.heatmap(pivot, annot=True, fmt='d', cmap='YlOrRd')

Surface Temperature of Offenbach from Landsat Satellite Data

2023-05-20T00:00:00+02:00

Surface temperature maps of Offenbach derived from Landsat satellite imagery between 2017 and 2022. The first image shows the highest recorded temperature in that period (in the Waldhof industrial area). The second shows the lowest – the roof of a company specializing in cooling and climate technology. Make of that what you will.

How it works

Landsat satellites capture multispectral imagery including shortwave infrared. Band 11 provides surface temperature readings in Celsius. The resolution is 30m x 30m per pixel.

The analysis uses the ArcGIS Multispectral Landsat Imagery Layer, filtered for cloud cover below 5%:

class RemoteSensing:
    def get_sat_images(self):
        self.get_landsat()
        self.get_city_geometry()
        self.get_city_area()

        selected = self._landsat.filter_by(
            where=f"(Category = 1) AND (cloudcover<={MAX_CLOUD_COVER})",
            time=[START_DATE, END_DATE],
            geometry=arcgis.geometry.filters.intersects(self._city_area['extent'])
        )

        for img_id in sat_image_ids:
            img = self._landsat.filter_by('OBJECTID=' + str(img_id))
            normal = apply(img, 'Band 11 Surface Temperature in Celsius')
            normal = clip(normal, self._city_geometry)
            normal.export_image(...)

Each exported raster is then overlaid with OSM building footprints and the road network for context. The annotation arrow points to the pixel with the extreme value.

Takeaway: when it gets hot, head to the Main or into the forest.

Public Transit from Offenbach to Frankfurt Hauptbahnhof

2023-04-01T00:00:00+02:00

How long does it take from your front door to Frankfurt Hauptbahnhof by public transit? This map color-codes the travel time from every building in Offenbach to Frankfurt Hbf.

The fastest connections start at S-Bahn Kaiserlei and Offenbach Hauptbahnhof (12 minutes). The slowest: Biebernsee at 55 minutes. The city-wide average sits at 33 minutes.

Data comes from the RMV API, queried for a Monday morning at 09:00. Building and map data from OpenStreetMap. White dots mark bus and rail stops.

The map makes the value of S-Bahn proximity very tangible – the yellow zones hug the rail lines tightly, while areas between stops or beyond the rail network fall off quickly into orange and red.

How Long by Bike to the Wilhelmsplatz?

2023-02-15T00:00:00+01:00

Local bike isochrone map centered on the Wilhelmsplatz in Offenbach. Color steps are 2-minute intervals – yellow means you’re within two minutes of the market square, darker colors mean longer rides.

Assumptions: average speed of 15 km/h, traffic lights ignored. Map data from OpenStreetMap, routing via OSMnx network analysis.

The shape of the isochrones is determined by the street network – the S-Bahn tracks and the Main river create natural barriers that stretch certain corridors while compressing others.