Chercher autour d’une ligne
Depuis la version 0.7.55, le filtre around accepte une liste de points : (around:rayon,lat1,lon1,lat2,lon2,…) trouve ce qui se trouve dans le rayon, en mètres, de la ligne qui les relie. La latitude vient en premier.
[out:json][timeout:25];
node["amenity"="drinking_water"](around:150,46.2044,6.1432,46.1990,6.1500,46.1900,6.1520);
out;
Cette requête cherche l’eau potable à moins de 150 m d’une ligne de trois points qui traverse Genève. Notre endpoint a répondu avec 14 points d’eau en 0,3 seconde.
D’un fichier GPX à une liste avec kilomètres
Une trace GPX a un point tous les quelques mètres, et une requête avec des milliers de coordonnées est longue et lente. Le script garde un point tous les 250 m, envoie une requête et donne à chaque lieu le kilomètre du point gardé le plus proche. Il faut pip install requests gpxpy.
import math
import sys
import gpxpy
import requests
OVERPASS_URL = "https://overpass-api.de/api/interpreter"
HEADERS = {"User-Agent": "my-ride-planner/1.0"}
def track_points(path):
"""Every point of every track in a GPX file, as (lat, lon)."""
with open(path) as f:
gpx = gpxpy.parse(f)
return [(p.latitude, p.longitude)
for track in gpx.tracks for segment in track.segments for p in segment.points]
def metres(a, b):
"""Distance between two (lat, lon) points in metres."""
lat1, lon1, lat2, lon2 = map(math.radians, (*a, *b))
h = math.sin((lat2 - lat1) / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin((lon2 - lon1) / 2) ** 2
return 2 * 6371000 * math.asin(math.sqrt(h))
def thin(points, step_m):
"""Keep a point every step_m metres, with the distance from the start of each."""
kept, along, last = [(points[0], 0.0)], 0.0, points[0]
for p in points[1:]:
along += metres(last, p)
last = p
if along - kept[-1][1] >= step_m:
kept.append((p, along))
if kept[-1][0] != points[-1]:
kept.append((points[-1], along))
return kept
def overpass_query(line, radius_m):
coords = ",".join(f"{lat:.5f},{lon:.5f}" for (lat, lon), _ in line)
return f"""[out:json][timeout:90];
(
nwr["amenity"="drinking_water"](around:{radius_m},{coords});
nwr["drinking_water"="yes"](around:{radius_m},{coords});
);
out center;"""
def water_along(path, radius_m=100, step_m=250):
line = thin(track_points(path), step_m)
response = requests.post(OVERPASS_URL, data={"data": overpass_query(line, radius_m)}, headers=HEADERS, timeout=120)
response.raise_for_status()
places = []
for element in response.json()["elements"]:
where = (element["lat"], element["lon"]) if "lat" in element else (element["center"]["lat"], element["center"]["lon"])
# The nearest kept point gives the kilometre, to within half a step.
(_, km) = min(((metres(where, p), along) for p, along in line))
places.append((km / 1000, element["tags"].get("name", ""), element["type"], element["id"]))
return sorted(places)
if __name__ == "__main__":
for km, name, kind, osm_id in water_along(sys.argv[1]):
print(f"{km:6.1f} km {kind}/{osm_id} {name}")
Sur un itinéraire vélo de 42 km de Genève à Annecy, envoyé à notre endpoint (il accepte la même requête), il a trouvé 23 lieux avec de l’eau potable :
python water_along_track.py ride.gpx
0.0 km node/6597445539
1.9 km node/4426603391 rue des Allobroges
25.5 km node/11059601131
36.3 km node/8291624277
...
- Le kilomètre est celui du point gardé le plus proche, il peut donc s’écarter d’un demi-pas, ici 125 m. Pour des kilomètres exacts, projetez chaque lieu sur la trace complète.
- Sur les routes sinueuses, un pas de 250 m coupe les lacets. Gardez plus de points (un
step_mplus petit) ou prenez un rayon plus grand. out centerdonne un point aux ways et aux relations, si bien qu’une fontaine cartographiée comme surface reçoit aussi un kilomètre.
Quels tags demander
Remplacez les deux lignes entre les parenthèses de la requête par les tags de ce qu’il vous faut. Voici les tags courants dans OpenStreetMap :
| Quoi | Tags |
|---|---|
| Eau potable | amenity=drinking_water, et drinking_water=yes sur les fontaines et robinets |
| Nourriture | amenity=cafe, restaurant, fast_food ; shop=bakery |
| Courses | shop=supermarket, convenience |
| Toilettes | amenity=toilets |
| Réparation vélo | shop=bicycle, amenity=bicycle_repair_station |
Traces longues et serveur public
Une longue trace donne une longue requête et une longue exécution. Sur overpass-api.de, une requête qui déclare plus de temps que le serveur n’en a de libre est refusée avec 504, et toutes les demandes d’une même adresse IP se partagent quelques slots. Découpez une longue trace en morceaux d’environ 50 km et envoyez-les l’un après l’autre, pas en même temps.
Depuis avril 2026, le serveur public refuse aussi certaines demandes d’office avec 406, par exemple celles qui portent le User-Agent par défaut de requests en Python ; c’est pourquoi le script fixe le sien. Le guide des erreurs Overpass explique 429, 406 et 504 et ce qu’il faut changer.
La même chose en une requête avec notre API
POST /v1/route-poi/corridor reçoit la trace sous forme de points avec leur distance depuis le départ, et répond avec le kilomètre de chaque lieu et sa distance à l’itinéraire, ainsi que les tronçons de plus de 40 km sans eau ni nourriture. Ce code reprend track_points et thin du script ci-dessus :
import os
import sys
import requests
from water_along_track import thin, track_points
KEY = os.environ["RUNNING_CAT_KEY"]
points = thin(track_points(sys.argv[1]), step_m=100)
if len(points) > 1000:
points = thin(track_points(sys.argv[1]), step_m=points[-1][1] / 999)
body = {
"points": [{"lat": lat, "lon": lon, "d": round(d)} for (lat, lon), d in points],
"categories": ["water", "food", "toilets"],
}
response = requests.post("https://geo.runningcat.dev/v1/route-poi/corridor", json=body,
headers={"Authorization": f"Bearer {KEY}"}, timeout=60)
response.raise_for_status()
answer = response.json()
for poi in answer["pois"]:
print(f'{poi["distanceAlongRouteKm"]:6.1f} km {poi["category"]:8} {poi["subtype"]:16} {poi["name"] or ""} ({poi["offsetFromRouteM"]} m off)')
for gap in answer["gaps"]:
print("No water or food:", gap)
Elle accepte jusqu’à 1 000 points, le script allège donc une longue trace pour qu’elle tienne. Les catégories sont eau, nourriture, courses, toilettes, magasins de vélo, carburant et quelques autres, chacune avec sa propre distance à l’itinéraire, jusqu’à 5 km. Les détails sont sur POI le long d’un itinéraire ; l’offre gratuite donne 500 requêtes par jour.
Sources : Overpass QL sur le wiki OpenStreetMap, le filtre around, lu le 16 novembre 2026. Les exemples ont été exécutés sur geo.runningcat.dev le même jour.