Buscar alrededor de una línea
Desde la versión 0.7.55 el filtro around acepta una lista de puntos: (around:radio,lat1,lon1,lat2,lon2,…) encuentra lo que está dentro del radio, en metros, de la línea que los une. La latitud va primero.
[out:json][timeout:25];
node["amenity"="drinking_water"](around:150,46.2044,6.1432,46.1990,6.1500,46.1900,6.1520);
out;
Esta consulta pide agua potable a menos de 150 m de una línea de tres puntos que cruza Ginebra. Nuestro endpoint respondió con 14 fuentes en 0,3 segundos.
De un archivo GPX a una lista con kilómetros
Un track GPX tiene un punto cada pocos metros, y una consulta con miles de coordenadas es larga y lenta. El script conserva un punto cada 250 m, envía una consulta y da a cada lugar el kilómetro del punto conservado más cercano. Necesita 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}")
En una ruta en bici de 42 km de Ginebra a Annecy, enviada a nuestro endpoint (acepta la misma consulta), encontró 23 lugares con agua 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
...
- El kilómetro es el del punto conservado más cercano, así que puede variar hasta medio paso, aquí 125 m. Para kilómetros exactos, proyecta cada lugar sobre el track completo.
- En carreteras con curvas un paso de 250 m corta las horquillas. Conserva más puntos (un
step_mmenor) o usa un radio mayor. out centerda a vías y relaciones un solo punto, así que una fuente mapeada como área también recibe su kilómetro.
Qué etiquetas pedir
Sustituye las dos líneas entre los paréntesis de la consulta por las etiquetas de lo que necesitas. Estas son las habituales en OpenStreetMap:
| Qué | Etiquetas |
|---|---|
| Agua potable | amenity=drinking_water, y drinking_water=yes en fuentes y grifos |
| Comida | amenity=cafe, restaurant, fast_food; shop=bakery |
| Tiendas de comestibles | shop=supermarket, convenience |
| Aseos | amenity=toilets |
| Reparación de bicis | shop=bicycle, amenity=bicycle_repair_station |
Tracks largos y el servidor público
Un track largo da una consulta larga y una ejecución larga. En overpass-api.de una consulta que declara más tiempo del que el servidor tiene libre se rechaza con 504, y todas las peticiones de una IP comparten unos pocos slots. Divide un track largo en tramos de unos 50 km y envíalos uno tras otro, no a la vez.
Desde abril de 2026 el servidor público también rechaza algunas peticiones directamente con 406, por ejemplo las que llevan el User-Agent por defecto de requests de Python; por eso el script pone el suyo. La guía de errores de Overpass explica 429, 406 y 504 y qué cambiar.
Lo mismo en una petición con nuestra API
POST /v1/route-poi/corridor recibe el track como puntos con su distancia desde el inicio y responde con el kilómetro de cada lugar y su distancia a la ruta, además de los tramos de más de 40 km sin agua ni comida. Usa track_points y thin del script de arriba:
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)
Acepta hasta 1.000 puntos, así que el script reduce un track largo para que quepa. Las categorías son agua, comida, comestibles, aseos, tiendas de bicis, gasolineras y algunas más, cada una con su propia distancia a la ruta, hasta 5 km. Los detalles están en POI a lo largo de una ruta; el plan gratuito da 500 peticiones al día.
Fuentes: Overpass QL en la wiki de OpenStreetMap, el filtro around, leída el 16 de noviembre de 2026. Los ejemplos se ejecutaron contra geo.runningcat.dev el mismo día.