Time Isochrones Precalculated

Isochoronas Pre-calculadas — Time

Cuándo usar esta skill

Cuando necesites:

• Calcular isócronas reales sin depender de APIs externas
• Añadir nuevas ciudades al proyecto Time
• Mejorar la precisión de las isócronas existentes
• Entender cómo funciona el cálculo offline

Arquitectura

Python (OSMnx + NetworkX) → JSON GeoJSON → Server Node.js → Frontend Leaflet
     ↓                          ↓                ↓                ↓
Descarga grafo OSM     Guarda isócronas    Sirve /isochrones/   Renderiza polígonos

Scripts

scripts/precalcular-isocronas.py (principal)

Genera isócronas para TODAS las ciudades configuradas.

# Instalar dependencias
pip3 install osmnx networkx numpy shapely

# Calcular todas las ciudades
python3 scripts/precalcular-isocronas.py

# Calcular una ciudad específica
python3 scripts/precalcular-isocronas.py --ciudad bilbao

# Listar ciudades disponibles
python3 scripts/precalcular-isocronas.py --listar

scripts/calcular-isocronas.py (helper)

Calcula una isócrona individual para debugging.

# Calcular isócona de coche 30min en Bilbao
python3 scripts/calcular-isocronas.py --ciudad bilbao --modo car --tiempo 30

Ciudades configuradas

Formato de salida

JSON combinado (data/isochrones/{ciudad}.json)

{
  "ciudad": "bilbao",
  "centro": [43.263, -2.935],
  "generado": "2026-06-25T18:00:00Z",
  "isochrones": {
    "car": {
      "15": { "geojson": {...}, "area_km2": 12.5, "radio_m": 6000 },
      "30": { "geojson": {...}, "area_km2": 45.2, "radio_m": 12000 },
      "60": { "geojson": {...}, "area_km2": 156.8, "radio_m": 24000 }
    },
    "bike": { ... },
    "foot": { ... }
  }
}

JSON individual (data/isochrones/{ciudad}_{modo}_{tiempo}.json)

{
  "ciudad": "bilbao",
  "modo": "car",
  "tiempo_min": 30,
  "area_km2": 45.2,
  "radio_m": 12000,
  "geojson": {
    "type": "FeatureCollection",
    "features": [{
      "type": "Feature",
      "geometry": { "type": "Polygon", "coordinates": [...] },
      "properties": { "modo": "car", "minutos": 30, "area_km2": 45.2 }
    }]
  }
}

Endpoints del servidor

Algoritmo OSMnx + NetworkX

import osmnx as ox
import networkx as nx

# 1. Descargar grafo de calles
G = ox.graph_from_place("Bilbao, España", network_type='drive')

# 2. Encontrar nodo más cercano al punto
center = ox.geocode("Plaza Mayor, Bilbao")
origin_node = ox.distance.nearest_nodes(G, center[1], center[0])

# 3. Calcular distancias desde el origen (Dijkstra)
lengths = nx.single_source_dijkstra_path_length(G, origin_node, cutoff=1800)  # 30 min

# 4. Filtrar nodos alcanzables
reachable_nodes = [n for n, l in lengths.items() if l <= 1800]

# 5. Generar polígono convexo hull
from shapely.geometry import MultiPoint
points = [(G.nodes[n]['x'], G.nodes[n]['y']) for n in reachable_nodes]
polygon = MultiPoint(points).convex_hull

# 6. Convertir a GeoJSON
from shapely.geometry import mapping
geojson = mapping(polygon)

Velocidades por modo y tipo de vía

Alternativa: CSR binario para Web Workers (ISOTime)

En vez de generar GeoJSON estático, se puede serializar el grafo OSM a binario CSR (Compressed Sparse Row) y cargarlo en un Web Worker para correr Dijkstra en el navegador. Esto permite isocronas en tiempo real 100% client-side, sin API ni servidor.

Implementado en ISOTime (github.com/Ntizar/ISOTime):

• Python (OSMnx) → binario CSR (1-2MB por ciudad) → fetch estático → Web Worker → Dijkstra + binary heap → polígono
• 40K nodos se calculan en <1s en el navegador
• Formato: header (32B) + city name (32B) + node coords (f32) + CSR offsets (u32) + edge targets/lengths/speeds
• Ver skill routing-isochrones → references/dijkstra-web-worker-csr.md para formato completo y código

Pitfalls

1. OSMnx descarga datos grandes — El grafo de una ciudad puede ocupar 50-200MB en cache. Usar cache/ directory.
2. Tiempo de cálculo — 1-5 minutos por ciudad dependiendo del tamaño. Ejecutar como batch job.
3. network_type — 'drive' para coche, 'bike' para bici, 'walk' para peatón, 'all' para todos.
4. cutoff en segundos — Dijkstra usa segundos, no minutos. 15min = 900s, 30min = 1800s, 60min = 3600s.
5. convex hull — El polígono resultante es convex hull, no sigue la costa. Para ciudades costeras, recortar con shoreline.
6. ⚠️ OSMnx OOM en VMs pequeñas (2GB RAM) — Radio de 20km para Madrid (40K+ nodos) causa OOM (exit 137, killed). Usar 12km máximo para ciudades grandes (Madrid, Barcelona, Valencia). Ciudades pequeñas (Bilbao, Zaragoza) toleran 15km. Síntoma: el proceso Python muere sin traceback, exit code 137. Solución: reducir dist en graph_from_point() o usar graph_from_place() con un boundary más pequeño.
7. Primera ejecución — Descarga datos de Overpass API. Necesita internet solo la primera vez.
8. Actualizaciones — Los datos OSM cambian. Recalcular periódicamente (mensual recomendado).
9. CSR binario vs GeoJSON — CSR binario es 10-50x más pequeño que GeoJSON y permite cálculo en tiempo real en el navegador. GeoJSON es más simple pero estático (no puedes cambiar el tiempo/modo sin regenerar). Usar CSR para apps client-side, GeoJSON para pre-visualización o export.

Alternativa: OSRM Real-time (sin API key) — Boundary Detection

Cuando necesites calcular isócronas en tiempo real desde el navegador sin depender de APIs premium, usar el endpoint público de OSRM con boundary detection por dirección.

⚠️ NO usar convex hull — Produce círculos de mierda. David lo probó y corrigió. Usar boundary detection que genera formas irregulares siguiendo la red de carreteras.

Concepto

72 direcciones × 8 radios = 576 puntos radiales
  → OSRM Table endpoint (multi-batch de 89 coords)
  → Para cada dirección: interpolación lineal último alcanzable / primero que excede
  → Polígono irregular que sigue la red vial real

Algoritmo

1. Generar puntos radiales: 72 direcciones (cada 5°) × radios adaptativos

   • Radios: [2, 5, 8, 12, 18, 25, 35, 50, 65, 80] filtrados por max(minutos * 0.9, 5)
   • Ejemplo 30min: [2, 5, 8, 12, 18, 25] → 432 puntos

2. Query OSRM table por batches (max 89 coords, stagger 80ms):

   GET https://router.project-osrm.org/table/v1/driving/{coords}?annotations=duration
   

3. Para cada dirección, encontrar boundary:

   const ptsDir = resultados.filter(r => r.dir === d).sort((a,b) => a.radioKm - b.radioKm);
   let lastReach = null, firstOver = null;
   for (const p of ptsDir) {
     if (p.dur <= targetSec) lastReach = p;
     else if (!firstOver) { firstOver = p; break; }
   }
   // Interpolación lineal
   if (lastReach && firstOver && firstOver.dur > lastReach.dur) {
     const frac = (targetSec - lastReach.dur) / (firstOver.dur - lastReach.dur);
     rBoundary = lastReach.radioKm + frac * (firstOver.radioKm - lastReach.radioKm);
   }
   

4. Cerrar polígono — Conectar boundary points en orden angular (sin convex hull)

Resultados comparados (Madrid, 30min coche)

Pitfalls OSRM

1. OSRM público solo tiene driving — No hay perfil foot o bicycle. Para andar, usar ORS o simulación.
2. Variable case-sensitive — dlat ≠ dLat. JS no da error, solo undefined.
3. Max ~89 coordenadas por llamada table — Dividir en batches, stagger 80ms.
4. Rate limit no documentado — En la práctica tolerante con stagger.
5. Sin semáforos ni restricciones horarias — OSRM usa datos OSM básicos.
6. No hay datos de elevación — La velocidad es plana. Para pendientes, usar Valhalla con DEM.
7. Radios muy bajos = pocos puntos — Asegurar al menos [2, 5] km para tiempos cortos.

Cadena de fallback recomendada

async function calcularIsocrona(lng, lat, modo, minutos) {
  // 1. ORS (si hay key — más preciso)
  const apiKey = localStorage.getItem('isotime_ors_key');
  if (apiKey) {
    try { return await calcularIsocronaORS(lng, lat, modo, minutos, apiKey); }
    catch (e) { console.warn('ORS failed:', e.message); }
  }
  // 2. OSRM (solo coche — routing real sin key)
  if (modo === 'car') {
    try { return await calcularIsocronaOSRM(lng, lat, minutos); }
    catch (e) { console.warn('OSRM failed:', e.message); }
  }
  // 3. Simulación (fallback final)
  return calcularIsocronaSim(lng, lat, modo, minutos);
}

Futuras mejoras

1. Shoreline clipping — Recortar isócronas costeras con Natural Earth data
2. Valhalla local — Para isócronas con elevación real (desnivel)
3. OTP integration — Isochrone de transporte público con transbordos reales
4. Cron de actualización — Recalcular isócronas mensualmente vía cron job
5. More cities — Añadir Madrid, Barcelona, etc.