DEV Community: TopoLines

Reading 9 national lidar terrain models over HTTP, without downloading a country

TopoLines — Mon, 19 Oct 2026 10:42:52 +0000

Most countries in Europe now publish a lidar-derived terrain model (DTM) at 1–5 m as open data. On paper that's amazing. In practice, each one sits behind a different web service with its own idea of what a "bounding box" is, what "no data" looks like, and how long you're allowed to wait.

I build TopoLines, a web tool that traces contour lines for a zone you draw on a map. To trace a zone in France on 5 m lidar instead of a 30 m global model, I need that zone's elevations, in a few seconds, without downloading a département. So I wired nine national models plus two global ones, all read over HTTP, all in plain Python (rasterio + numpy, no GDAL CLI, no Docker).

This post is the field notes. The full list — endpoints, native resolution, licence, native CRS — is open on GitHub as Markdown and CSV.

The four shapes of "give me elevations for this box"

Every provider I've met falls into one of four access patterns:

Pattern	Who	What you get
One big Cloud-Optimized GeoTIFF	GEDTM30 (worldwide)	Read a window with HTTP range requests
WMS / ImageServer that returns raw floats	IGN France, USGS 3DEP	One request, one GeoTIFF for the whole box
WCS 2.0.1 GetCoverage	Spain, England, Italy, North Rhine-Westphalia	One request, but each server has opinions about axes and CRS
Tiles (COG or plain GeoTIFF)	Switzerland, Austria, Bavaria	Find the tiles, read each, mosaic

1. A global COG: read just a window

GEDTM30 (OpenGeoHub, CC BY 4.0) is a 30 m bare-earth model of the whole planet, published as a single Cloud-Optimized GeoTIFF. You never download it: rasterio opens it through /vsicurl/ and only fetches the byte ranges for your window.

The GDAL settings matter more than you'd think. Without them GDAL tries to list the bucket directory before opening the file, which is slow and pointless:

import rasterio
from rasterio.windows import from_bounds

URL = ("https://opentopography.s3.sdsc.edu/raster/GEDTM30/GEDTM30_be/"
       "gedtm_rf_m_30m_s_20060101_20151231_go_epsg.4326.3855_v1.2.tif")

env = {
    "GDAL_DISABLE_READDIR_ON_OPEN": "EMPTY_DIR",   # don't list the bucket
    "CPL_VSIL_CURL_ALLOWED_EXTENSIONS": ".tif",    # don't probe sidecar files
    "GDAL_HTTP_TIMEOUT": "20",
    "VSI_CACHE": "TRUE",
}

def gedtm_window(west, south, east, north):
    with rasterio.Env(**env), rasterio.open(f"/vsicurl/{URL}") as ds:
        win = from_bounds(west, south, east, north, ds.transform)
        win = win.round_offsets().round_lengths()
        arr = ds.read(1, window=win).astype("float32")
        arr[arr >= 3.4e38] = float("nan")          # float32-max = sea / void
        return arr, ds.window_transform(win)

The same file is mirrored on OpenGeoHub's own S3, so I try one host and fall through to the other.

2. WMS and ImageServer that return numbers, not pictures

People think of WMS as "the thing that returns map images". But IGN's Géoplateforme will hand you raw float32 elevations as a GeoTIFF if you ask for the right layer:

params = {
    "SERVICE": "WMS", "VERSION": "1.3.0", "REQUEST": "GetMap",
    "LAYERS": "ELEVATION.ELEVATIONGRIDCOVERAGE.HIGHRES",
    "STYLES": "",
    "CRS": "EPSG:4326",
    "BBOX": f"{south},{west},{north},{east}",   # WMS 1.3.0 + 4326 = lat,lon order!
    "WIDTH": width, "HEIGHT": height,
    "FORMAT": "image/geotiff",
}
r = requests.get("https://data.geopf.fr/wms-r/wms", params=params, timeout=30)

Two things bit me here:

Axis order. WMS 1.3.0 with EPSG:4326 wants lat,lon. Get it wrong and you get a valid GeoTIFF of somewhere else.
"200 OK" isn't success. WMS can answer 200 with an XML ServiceException in the body. Check the Content-Type before you write anything to disk.

I also measured how big one GetMap can be: 0.8 Mpx answered in 4.7 s, 2.4 Mpx in 7.8 s, and 4.2 Mpx returned a 504 no matter how long I waited. Splitting into tiles works (the seams are invisible), but it multiplies the failure surface. So I cap a request at 3 Mpx — roughly 75 km² at 5 m — and above that I use a coarser source rather than promise 5 m and time out.

USGS 3DEP works the same way through an ArcGIS ImageServer exportImage. The nice surprise: the mosaic picks the best source per pixel, so a 5 m request returns lidar-derived heights wherever lidar has been flown and the 1/3″ (~10 m) product elsewhere. Force your own noData so you know what a void looks like:

params = {
    "bbox": f"{west},{south},{east},{north}", "bboxSR": 4326, "imageSR": 4326,
    "size": f"{width},{height}", "format": "tiff", "pixelType": "F32",
    "noData": -9999, "noDataInterpretation": "esriNoDataMatchAny",
    "interpolation": "RSP_BilinearInterpolation", "f": "image",
}

3. WCS 2.0.1: same standard, four dialects

WCS is the "proper" way to get coverage data, and four of my providers use it. They do not agree on much.

Spain (IGN España) is the polite one: you subset in lat/long, SCALESIZE pins the output grid, the server reprojects for you.

params = [
    ("SERVICE", "WCS"), ("VERSION", "2.0.1"), ("REQUEST", "GetCoverage"),
    ("COVERAGEID", "Elevacion4258_5"),
    ("SUBSET", f"long({west},{east})"),
    ("SUBSET", f"lat({south},{north})"),
    ("SCALESIZE", f"long({width}),lat({height})"),
    ("FORMAT", "image/tiff"),
]

The catch: there is no void value. The sea and the land outside Spain (Portugal, France) both come back as a flat 0. If you trace contours on that, you get a 0 m contour drawn along the Portuguese border. I remap 0 to a void sentinel before anything else.

England (Environment Agency), Italy (INGV TINITALY) and North Rhine-Westphalia only behave in their native projected CRS. On the EA's GeoServer, a lon/lat subset errors or hangs for minutes. Asking in British National Grid eastings/northings with SCALEFACTOR returns a 5 m grid for a 6 × 6 km box in about a second:

from rasterio.warp import transform_bounds

e0, n0, e1, n1 = transform_bounds("EPSG:4326", "EPSG:27700", west, south, east, north)
pad = 50  # metres, so the warp back to lon/lat has data at the edges
params = [
    ("SERVICE", "WCS"), ("VERSION", "2.0.1"), ("REQUEST", "GetCoverage"),
    ("COVERAGEID", COVERAGE_ID),
    ("SUBSET", f"E({e0 - pad:.0f},{e1 + pad:.0f})"),
    ("SUBSET", f"N({n0 - pad:.0f},{n1 + pad:.0f})"),
    ("SCALEFACTOR", f"{1.0 / 5.0:g}"),   # native 1 m → 5 m
    ("FORMAT", "image/tiff"),
]

Then I warp the result onto my lon/lat grid myself. The same function serves England (EPSG:27700), Italy (EPSG:32632 — for the whole country, eastern regions included) and NRW (EPSG:25832).

One more English trap: a subset entirely off the data (Wales, Scotland) also comes back as a flat 0 with no nodata tag. Real lidar ground in England is never exactly 0.0 — even the Fens read −11.42 m — so there, 0 means "no data".

4. Tiles: find them, read them, mosaic them

Switzerland (swisstopo swissALTI3D) publishes 1 km Cloud-Optimized GeoTIFFs behind a STAC API. Ask for items in your bbox, and you'll often get several survey years for the same tile, so keep the newest:

url = ("https://data.geo.admin.ch/api/stac/v0.9/collections/ch.swisstopo.swissalti3d/items"
       f"?bbox={west},{south},{east},{north}&limit=100")
newest = {}
while url:
    data = requests.get(url, timeout=30).json()
    for feat in data["features"]:
        _, year, tile = feat["id"].rsplit("_", 2)          # swissalti3d_<year>_<E>-<N>
        href = next(a["href"] for a in feat["assets"].values()
                    if a["href"].endswith("_2_2056_5728.tif"))   # the 2 m asset
        if int(year) > newest.get(tile, (0, ""))[0]:
            newest[tile] = (int(year), href)
    url = next((l["href"] for l in data["links"] if l["rel"] == "next"), None)

The tiles are kilometre-aligned in LV95, so they mosaic without resampling at the seams. Then I warp once to lon/lat.

Austria (BEV) publishes 50 km COG tiles in EPSG:3035 with internal overviews. Asking rasterio for a window at a coarser out_shape makes GDAL pick the matching overview, so a 5–20 m read only pulls a few MB. There are exactly 55 published tiles; anything else 404s, so I keep the list in code instead of guessing.

Bavaria is the hard one: no open WCS (the INSPIRE one needs a login), only 1 km GeoTIFF tiles that are not cloud-optimized, about 2.5 MB each. Every tile is a full download, so I read them in parallel and cap the count.

And Germany as a whole has no free nationwide DGM1 — the federal one is licensed — so each Land is its own provider with its own service. Baden-Württemberg's INSPIRE WCS answers, but over part of the Land it returns whole-metre integers with no CRS, which terraces every contour. It's not wired yet.

The part nobody warns you about: is that void the sea, or France?

National models stop at the border and at the coast, and both show up as "no data". For contours, these mean opposite things:

Void = sea → keep it, it's your coastline.
Void = a neighbouring country → this zone isn't fully covered; use another source.

My heuristic: look at the ring of valid pixels around each void. If the median elevation of that ring is below 60 m, it's a shoreline. If it's higher, the void is foreign land the national model doesn't cover, and the zone falls back to a worldwide source. Above 0.5 % of void pixels inside the box, I don't trust the national model for that zone at all.

This also leads to a rule I'd recommend to anyone mixing sources: one dataset per map. A national model is only used when the zone lies entirely inside its coverage. Stitching a 1 m lidar model to a 30 m global one at a border gives you a visible step in the contours exactly where you least want it.

What I'd tell myself a year ago

Check the Content-Type, always. Every OGC server here returns errors as XML or JSON with a 200 status.
Ask in the native CRS. Reprojection on the server is where WCS implementations break.
Know what "no data" looks like for each source. It's NaN, -9999, -99999, float32-max, or 0, depending on who you ask.
Measure the server, then cap below it. Falling back fast is better than a 30 s timeout.
Licences differ, attribution doesn't. CC BY 4.0, OGL v3.0, Etalab 2.0 and swisstopo's terms all require a credit; I write it into the metadata of every export.

The full list, with endpoints, native resolution, licence and CRS for each model, is on GitHub: open national elevation models (CSV). If you know an open national DTM with a usable web service that isn't there, open an issue and I'll test it.

And if you just want the contours: TopoLines traces them for any zone on Earth, on whichever of these models covers it, and exports GeoJSON or DXF in your CRS.

I built a web tool that traces contour lines from real elevation data (GeoJSON, DXF, SVG, PNG)

TopoLines — Sat, 25 Jul 2026 14:50:45 +0000

Update — October 2026: TopoLines now traces on GEDTM30 (30 m bare-earth) worldwide and on national lidar terrain models at 5–10 m in France, the US, Spain, England, Austria, Switzerland, Italy and parts of Germany, and exports GeoJSON and DXF in your CRS alongside SVG and PNG. Current docs: topolines.app/docs · GitHub. This post has been updated to match.

Hey DEV Community 👋

For the past few months I've been building TopoLines — a browser-based contour line generator that traces topographic contours from real, citable elevation data anywhere on Earth. You draw a box on a map, pick your settings, and it traces the contours of that exact area — exported as GeoJSON or DXF in the coordinate system of your choice, or as SVG and PNG.

This is a follow-up to my first post about the designer workflow. This time I want to go deeper on how it actually works under the hood, show a gallery of real places, and talk about the elevation data pipeline — because a lot of you asked.

The TopoLines editor — tracing the Brittany coastline, France, from IGN RGE ALTI 5 m elevation data.

Why contour lines are surprisingly hard to get

If you've ever needed contour lines for a real place — a site study, a GIS project, a CAD drawing, a laser-cut terrain model, a hiking map, a data visualisation or a design layout — you've probably hit the same wall I did:

Full GIS software like QGIS, ArcGIS or GRASS can do it, but first you have to find the right DEM (Digital Elevation Model), download and clip it, reproject it, run gdal_contour, clean the noise, and style the output. That's a multi-hour job if you don't do it every day.
Static asset packs give you pre-made contour patterns — you can't change the location, the contour interval, or the resolution.
Generative noise tools produce topographic-looking squiggles that don't correspond to any real terrain.

I wanted the contour step of a GIS workflow, with the data sourcing already done, and without installing anything. So I built it.

What TopoLines does

Search any place on Earth — cities, mountains, coastlines, islands, valleys — using the built-in geocoder.
Draw a bounding box on the map to define your area.
The best elevation model covering that zone is picked for you — and named in the editor:
- GEDTM30 30 m (free) — a worldwide bare-earth model: it follows the ground under forest, not the canopy.
- National terrain models at 5–10 m, mostly lidar — IGN RGE ALTI (France), USGS 3DEP (US), IGN España MDT, Environment Agency LIDAR (England), BEV (Austria), swissALTI3D (Switzerland), TINITALY (Italy), DGM1 (Bavaria, North Rhine-Westphalia).
- Your own GeoTIFF if you have survey data.
Set the trace: contour interval (down to 5 m), index contours, smoothing, a minimum contour length to drop DEM-noise loops, auxiliary contours on flat ground, depression contours with inward hachures.
Style it: elevation gradients, stroke width and taper, contour labels cut into the line, scale bar, north arrow and legend.
Export:
- GeoJSON — each feature carries its elevation and contour type; written in WGS 84, automatic UTM, Lambert-93, Web Mercator, British National Grid or ETRS89 UTM.
- DXF — one layer per contour type, same CRS options, for CAD and laser cutting.
- SVG — editable paths grouped by elevation, opens cleanly in Figma, Illustrator or Inkscape.
- PNG — up to 3200 px wide.

Every export carries the name of the dataset it was traced from and its licence credit in its metadata.

It runs in the browser, with no software to install. The free tier needs a Google or GitHub sign-in (no payment) and exports a real PNG.

The elevation data pipeline (for the curious)

The terrain comes from open elevation datasets:

GEDTM30 v1.2 (OpenGeoHub, CC BY 4.0) is a single global Cloud-Optimized GeoTIFF. I read just the window I need over HTTP range requests (/vsicurl), so there's nothing to download or stitch.
National models are read from each agency's own web service — WMS, WCS, ArcGIS ImageServer, STAC + COG tiles — each with its own quirks (I wrote them up here). A national model is only used when the zone lies entirely inside its coverage, so a map is never stitched from two datasets.
AWS Terrain Tiles (elevation-tiles-prod) is the fallback.
OpenStreetMap coastlines (natural=coastline) clip contours at the shore, because many elevation models report non-zero heights over the sea.

The processing chain is pure Python — rasterio to read and warp the DEM, scikit-image's marching squares to trace the iso-elevation contours, shapely for geometry and simplification, Pillow for the raster output, and rasterio's warp machinery again to reproject vector exports into your CRS. Each contour line is a true iso-line connecting points of equal altitude.

Everything is generated server-side, so what you download is a genuine vector file with real paths — not a traced bitmap.

A gallery of real places

All of these were generated straight from real elevation data, no manual editing:

Sarajevo, Bosnia and Herzegovina

Funchal, Madeira, Portugal

Montenegro mountains

Who it's for

GIS and survey users who need contours for an area quickly, with a named source and CRS.
Architects, landscape architects and engineers doing site studies — DXF in a projected CRS, on 5 m lidar where available.
Cartographers and designers who want editable, correctly sourced vectors in Figma or Illustrator.
Makers cutting layered terrain models, one DXF/SVG layer per elevation.
Hikers and outdoor folks looking at the real terrain of a trail or a peak.
Data visualisation people who want iso-lines grounded in real data.

Try it with a place you know

The best way to judge it is to trace a place you actually know — your city, the mountain you last climbed, the coastline you grew up on.

👉 topolines.app — free with a Google or GitHub account. Docs: topolines.app/docs · feedback and roadmap on GitHub.

I'd genuinely love feedback from this community: feature requests, edge cases, places that break it, formats or CRS you'd want. Drop a comment with the place you traced — I read every one. 🙏

I built a vector topographic contour map generator for designers (SVG export)

TopoLines — Tue, 21 Jul 2026 00:40:34 +0000

Hey everyone! 👋

As a designer, I constantly needed high-quality vector topographic contour lines and generative patterns for branding, UI hero backgrounds, and print projects. Most existing tools were either heavy GIS software (like QGIS) or required static file purchases.

So I built Topolines—a fast, web-based vector topographic generator.

🎛️ Key Features:

Parametric Control: Fine-tune elevation density, noise scale, detail, and line weights in real-time.
Custom Styling: Full visual control over color palettes, gradients, contrast, and backgrounds.
Clean Vector Export: Instant SVG exports (perfect for Figma, Illustrator, or web code) and HD PNGs.
Frictionless Free Tier: Direct PNG exports without even needing an account.

I'd love for you to try it out at topolines.app and let me know your feedback or feature requests!