Update app.py

app.py

@@ -5,7 +5,8 @@ import geopandas as gpd
 from shapely.geometry import LineString, Point
 import folium
 from streamlit_folium import st_folium
-
+import networkx as nx
+from collections import defaultdict  # Add this line if missing
 import os, sys
 import traceback
 
@@ -31,108 +32,191 @@ shapes_gdf.columns = ["shape_id", "geometry"]
 crs_obj = CRS.from_epsg(4326)  # Crea el objeto CRS correctamente
 shapes_gdf = gpd.GeoDataFrame(shapes_gdf, geometry="geometry", crs=crs_obj)
 
-# =========================
-#   UI
-# =========================
+# Precompute graph for routing
+route_short = routes.set_index('route_id')['route_short_name'].to_dict()
+stops_routes = defaultdict(set)
+G = nx.DiGraph()
+
+# Group by route_id and shape_id to capture variants/directions
+group_cols = ['route_id', 'shape_id']
+trips_grouped = trips.groupby(group_cols)
+
+transfer_penalty = 20
+
+for name, group in trips_grouped:
+    if group.empty:
+        continue
+    route_id, shape_id = name
+    trip_id_sample = group['trip_id'].iloc[0]
+    stops_trip = stop_times[stop_times['trip_id'] == trip_id_sample].sort_values('stop_sequence')
+    stop_ids = stops_trip['stop_id'].tolist()
+    
+    # Add routes to stops
+    for stop_id in stop_ids:
+        stops_routes[stop_id].add(route_id)
+    
+    # Add ride edges
+    for i in range(len(stop_ids) - 1):
+        stop1 = stop_ids[i]
+        stop2 = stop_ids[i + 1]
+        G.add_edge((stop1, route_id), (stop2, route_id), weight=1)
+
+# Add transfer edges
+for stop_id, routes_set in stops_routes.items():
+    routes_list = list(routes_set)
+    for i in range(len(routes_list)):
+        for j in range(len(routes_list)):
+            if i != j:
+                G.add_edge((stop_id, routes_list[i]), (stop_id, routes_list[j]), weight=transfer_penalty)
+
+# UI
 st.title("🚍 Planificador inteligente — TransMilenio")
+st.write("Esta app detecta si la ruta **en la que ya vas** te sirve para llegar al destino, y sugiere transbordos si es necesario.")
 
-st.write("Esta app detecta si la ruta **en la que ya vas** te sirve para llegar al destino.")
-
-
-# =========================
-#   INPUTS DEL USUARIO
-# =========================
-
+# Inputs
 st.header("1️⃣ ¿En qué ruta vas?")
-ruta_seleccionada = st.selectbox(
-    "Selecciona tu ruta",
-    routes.route_short_name.unique(),
-)
+ruta_seleccionada = st.selectbox("Selecciona tu ruta", routes.route_short_name.unique())
 
 st.header("2️⃣ ¿Dónde estás?")
 col1, col2 = st.columns(2)
 with col1:
     modo_origen = st.radio("Selecciona cómo indicar dónde estás:", ["Parada", "Coordenadas"])
 
+route_id = routes.loc[routes.route_short_name == ruta_seleccionada, "route_id"].iloc[0]
+trips_ruta = trips[trips.route_id == route_id]
+
+if trips_ruta.empty:
+    st.error("No se encontraron viajes para esta ruta.")
+    st.stop()
+
+# Get all unique stops for the route across all trips
+trip_ids = trips_ruta['trip_id'].unique()
+all_stops_route = stop_times[stop_times['trip_id'].isin(trip_ids)].merge(stops, on="stop_id")['stop_name'].unique()
+
 if modo_origen == "Parada":
-    parada_origen = st.selectbox("Selecciona tu parada actual", stops.stop_name.unique())
+    parada_origen = st.selectbox("Selecciona tu parada actual", all_stops_route)
     stop_actual = stops[stops.stop_name == parada_origen].iloc[0]
-
+    current_stop_id = stop_actual['stop_id']
 else:
     lat = st.number_input("Latitud", value=4.65)
     lon = st.number_input("Longitud", value=-74.1)
-    stop_actual = {"stop_lat": lat, "stop_lon": lon}
-
+    # Find nearest stop among all stops on the route
+    all_stops_route_df = stop_times[stop_times['trip_id'].isin(trip_ids)].merge(stops, on="stop_id").drop_duplicates('stop_id')
+    stops_route_gdf = gpd.GeoDataFrame(all_stops_route_df, geometry=gpd.points_from_xy(all_stops_route_df.stop_lon, all_stops_route_df.stop_lat), crs=4326)
+    user_point = Point(lon, lat)
+    distances = stops_route_gdf.geometry.distance(user_point)
+    nearest_idx = distances.argmin()
+    stop_actual = stops_route_gdf.iloc[nearest_idx]
+    current_stop_id = stop_actual['stop_id']
+    st.write(f"Parada más cercana detectada: {stop_actual.stop_name}")
 
 st.header("3️⃣ ¿A dónde vas?")
 destino = st.text_input("Escribe la parada o dirección de destino")
 
 calcular = st.button("Calcular ruta")
 
-# =========================
-#   PROCESAMIENTO
-# =========================
-
 if calcular:
-
-    # ---- 1. Filtrar rutas por route_short_name ----
-    route_id = routes.loc[routes.route_short_name == ruta_seleccionada, "route_id"].iloc[0]
-    trips_ruta = trips[trips.route_id == route_id]
-
-    if trips_ruta.empty:
-        st.error("No se encontraron viajes para esta ruta.")
+    # Find a trip that includes the current stop (to determine variant)
+    relevant_trips = stop_times[(stop_times['stop_id'] == current_stop_id) & (stop_times['trip_id'].isin(trip_ids))]['trip_id'].unique()
+    if len(relevant_trips) == 0:
+        st.error("La parada actual no está en esta ruta.")
         st.stop()
-
-    # ---- 2. Seleccionar un trip (en GTFS cada ruta tiene varios) ----
-    trip_id = trips_ruta.iloc[0].trip_id
+    trip_id = relevant_trips[0]  # Pick first matching trip
     st.write(f"Usando trip: `{trip_id}`")
 
-    stops_trip = stop_times[stop_times.trip_id == trip_id].merge(stops, on="stop_id")
+    stops_trip = stop_times[stop_times.trip_id == trip_id].merge(stops, on="stop_id").sort_values('stop_sequence')
 
-    # ---- 3. Buscar destino por nombre aproximado ----
-    destino_results = stops_trip[stops_trip.stop_name.str.contains(destino, case=False, na=False)]
+    # Current sequence
+    current_sequence = stops_trip[stops_trip.stop_id == current_stop_id]['stop_sequence'].iloc[0]
 
-    if not destino_results.empty:
-        parada_destino = destino_results.iloc[0]
-        st.success(f"Esta ruta **SÍ** te sirve. Debes bajarte en: **{parada_destino.stop_name}**")
+    # Find destination
+    destino_results = stops[stops.stop_name.str.contains(destino, case=False, na=False)]
+    if destino_results.empty:
+        st.error("No se encontró la parada de destino. Intenta con otro nombre.")
+        st.stop()
+    destino_stop = destino_results.iloc[0]
+    destination_id = destino_stop['stop_id']
+    st.write(f"Destino interpretado como: {destino_stop.stop_name}")
+
+    # Direct check
+    destino_in_trip = stops_trip[(stops_trip.stop_id == destination_id) & (stops_trip.stop_sequence > current_sequence)]
+    if not destino_in_trip.empty:
+        dest_seq = destino_in_trip['stop_sequence'].iloc[0]
+        num_paradas = dest_seq - current_sequence
+        st.success(f"Esta ruta **SÍ** te sirve directamente. Debes bajarte en {num_paradas} paradas: **{destino_stop.stop_name}**")
+        parada_destino = destino_stop
     else:
-        st.warning("Esta ruta NO te lleva directamente al destino. (Transbordos: próximo paso)")
-        parada_destino = None
-
-    # =========================
-    #   MAPA
-    # =========================
-
+        # Graph routing
+        source = (current_stop_id, route_id)
+        targets = [(destination_id, r) for r in stops_routes[destination_id]]
+        
+        paths = {}
+        for t in targets:
+            try:
+                path = nx.shortest_path(G, source, t, weight='weight')
+                cost = nx.shortest_path_length(G, source, t, weight='weight')
+                paths[cost] = path
+            except nx.NetworkXNoPath:
+                pass
+        
+        if paths:
+            min_cost = min(paths.keys())
+            best_path = paths[min_cost]
+            
+            # Reconstruct legs
+            legs = []
+            current_leg_route = best_path[0][1]
+            start_stop_id = best_path[0][0]
+            leg_stops = 0
+            for i in range(1, len(best_path)):
+                next_stop_id, next_route = best_path[i]
+                if next_route != current_leg_route:
+                    from_name = stops[stops.stop_id == start_stop_id]['stop_name'].iloc[0]
+                    to_name = stops[stops.stop_id == best_path[i-1][0]]['stop_name'].iloc[0]
+                    legs.append({
+                        'route': route_short[current_leg_route],
+                        'from': from_name,
+                        'to': to_name,
+                        'num_paradas': leg_stops
+                    })
+                    start_stop_id = best_path[i-1][0]
+                    current_leg_route = next_route
+                    leg_stops = 0
+                leg_stops += 1
+            # Last leg
+            from_name = stops[stops.stop_id == start_stop_id]['stop_name'].iloc[0]
+            to_name = stops[stops.stop_id == best_path[-1][0]]['stop_name'].iloc[0]
+            legs.append({
+                'route': route_short[current_leg_route],
+                'from': from_name,
+                'to': to_name,
+                'num_paradas': leg_stops
+            })
+            
+            # Recommendation
+            rec = "Ruta recomendada:\n"
+            for idx, leg in enumerate(legs):
+                if idx == 0:
+                    rec += f"- Vas en {leg['route']} desde {leg['from']}, bájate en {leg['num_paradas']} paradas en {leg['to']}.\n"
+                else:
+                    rec += f"- Luego, en {leg['from']}, toma {leg['route']} y bájate en {leg['num_paradas']} paradas en {leg['to']}.\n"
+            st.success(rec)
+            parada_destino = destino_stop
+        else:
+            st.warning("No se encontró ruta con transbordos.")
+            parada_destino = None
+
+    # Map
     st.header("🗺️ Mapa de tu ruta y posición")
-
-    # Crear mapa centrado en la posición actual
     m = folium.Map(location=[stop_actual["stop_lat"], stop_actual["stop_lon"]], zoom_start=13)
-
-    # ---- Marcar posición actual ----
-    folium.Marker(
-        [stop_actual["stop_lat"], stop_actual["stop_lon"]],
-        tooltip="Estás aquí",
-        icon=folium.Icon(color="blue")
-    ).add_to(m)
-
-    # ---- Dibujar route shape ----
-    # Buscar shape_id asociado
-    shape_id = trips_ruta.iloc[0].shape_id
+    folium.Marker([stop_actual["stop_lat"], stop_actual["stop_lon"]], tooltip="Estás aquí", icon=folium.Icon(color="blue")).add_to(m)
+    
+    # Draw shape
+    shape_id = trips[trips.trip_id == trip_id]['shape_id'].iloc[0]
     shape_geom = shapes_gdf[shapes_gdf.shape_id == shape_id].geometry.iloc[0]
-
-    folium.PolyLine(
-        locations=[(lat, lon) for lon, lat in zip(shape_geom.coords.xy[0], shape_geom.coords.xy[1])],
-        weight=5,
-        color="red",
-        tooltip=f"Ruta {ruta_seleccionada}"
-    ).add_to(m)
-
-    # ---- Marcar destino si existe----
+    folium.PolyLine(locations=[(lat, lon) for lon, lat in zip(shape_geom.coords.xy[0], shape_geom.coords.xy[1])], weight=5, color="red", tooltip=f"Ruta {ruta_seleccionada}").add_to(m)
+    
     if parada_destino is not None:
-        folium.Marker(
-            [parada_destino.stop_lat, parada_destino.stop_lon],
-            tooltip=f"Destino: {parada_destino.stop_name}",
-            icon=folium.Icon(color="green")
-        ).add_to(m)
-
+        folium.Marker([parada_destino.stop_lat, parada_destino.stop_lon], tooltip=f"Destino: {parada_destino.stop_name}", icon=folium.Icon(color="green")).add_to(m)
+    
     st_folium(m, width=700, height=500)