Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,144 +1,135 @@
 import streamlit as st
 import pandas as pd
+import os
 import osmnx as ox
 import networkx as nx
 import geopandas as gpd
 from shapely.geometry import LineString
 from geopy.distance import geodesic
 from datetime import datetime, timedelta
-import matplotlib.pyplot as plt
 from streamlit_folium import st_folium
 import folium
 import warnings
 warnings.filterwarnings("ignore")
 
-# Load Data
-data = pd.read_csv("D:\uni-sem2\tegraf\FP\poi_places.csv")
-df_nodes = pd.read_csv("D:\uni-sem2\tegraf\FP\road_nodes.csv")
-df_edges = pd.read_csv("D:\uni-sem2\tegraf\FP\road_edges.csv")
+# Atasi PermissionError di Hugging Face
+os.environ["MPLCONFIGDIR"] = "/tmp"
+os.environ["STREAMLIT_STATIC_DIR"] = "/tmp"
 
-df_nodes['geometry'] = gpd.GeoSeries.from_wkt(df_nodes['geometry'])
-df_edges['geometry'] = gpd.GeoSeries.from_wkt(df_edges['geometry'])
+st.set_page_config(
+    page_title="Multimodal Rute Jakarta",
+    page_icon="🛣️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
-# Convert to GeoDataFrame
-gdf_nodes = gpd.GeoDataFrame(df_nodes, geometry='geometry', crs="EPSG:4326")
-gdf_edges = gpd.GeoDataFrame(df_edges, geometry='geometry', crs="EPSG:4326")
+@st.cache_data
+def load_data():
+    data = pd.read_csv("data/poi_places.csv")
+    df_nodes = pd.read_csv("data/road_nodes.csv")
+    df_edges = pd.read_csv("data/road_edges.csv")
 
-gdf_bld = gpd.GeoDataFrame(
-    data,
-    geometry=gpd.points_from_xy(data.longitude, data.latitude),
-    crs="EPSG:4326"
-)
+    df_nodes['geometry'] = gpd.GeoSeries.from_wkt(df_nodes['geometry'])
+    df_edges['geometry'] = gpd.GeoSeries.from_wkt(df_edges['geometry'])
+
+    gdf_nodes = gpd.GeoDataFrame(df_nodes, geometry='geometry', crs="EPSG:4326")
+    gdf_edges = gpd.GeoDataFrame(df_edges, geometry='geometry', crs="EPSG:4326")
+    gdf_poi = gpd.GeoDataFrame(data, geometry=gpd.points_from_xy(data.longitude, data.latitude), crs="EPSG:4326")
+
+    return gdf_nodes, gdf_edges, gdf_poi
+
+@st.cache_data
+def build_graph(gdf_nodes, gdf_edges, gdf_poi):
+    G = nx.Graph()
+    for _, row in gdf_nodes.iterrows():
+        G.add_node(row['osmid'], x=row.geometry.x, y=row.geometry.y)
 
-# Build Graph G
-G = nx.Graph()
-for idx, row in gdf_nodes.iterrows():
-    G.add_node(row['osmid'], x=row.geometry.x, y=row.geometry.y)
+    for _, row in gdf_edges.iterrows():
+        if pd.notna(row['length']):
+            G.add_edge(row['u'], row['v'], length=row['length'])
 
-for idx, row in gdf_edges.iterrows():
-    if pd.notna(row['length']):
-        G.add_edge(row['u'], row['v'], length=row['length'])
+    for idx, row in gdf_poi.iterrows():
+        nid = f"poi_{idx}"
+        G.add_node(nid, x=row.geometry.x, y=row.geometry.y, name=row['name'])
 
-for idx, row in gdf_bld.iterrows():
-    nid = f"bldg_{idx}"
-    G.add_node(nid, x=row.geometry.x, y=row.geometry.y, name=row['name'])
+    road_nodes_list = [(n, data['y'], data['x']) for n, data in G.nodes(data=True) if isinstance(n, (int, float))]
 
-road_nodes_list = [(n, data['y'], data['x']) for n, data in G.nodes(data=True) if isinstance(n, (int, float))]
+    for idx, row in gdf_poi.iterrows():
+        bnode = f"poi_{idx}"
+        b_lat, b_lon = row.latitude, row.longitude
+        nearest = min(road_nodes_list, key=lambda item: geodesic((b_lat, b_lon), (item[1], item[2])).meters)[0]
+        dist = geodesic((b_lat, b_lon), (G.nodes[nearest]['y'], G.nodes[nearest]['x'])).meters
+        G.add_edge(bnode, nearest, length=dist)
+        G.add_edge(nearest, bnode, length=dist)
 
-for idx, row in gdf_bld.iterrows():
-    bnode = f"bldg_{idx}"
-    b_lat, b_lon = row.latitude, row.longitude
-    nearest = min(road_nodes_list, key=lambda item: geodesic((b_lat, b_lon), (item[1], item[2])).meters)[0]
-    dist = geodesic((b_lat, b_lon), (G.nodes[nearest]['y'], G.nodes[nearest]['x'])).meters
-    G.add_edge(bnode, nearest, length=dist)
-    G.add_edge(nearest, bnode, length=dist)
+    return G
 
-def get_building_node_id_by_name(name):
-    match = gdf_bld[gdf_bld['name'].str.lower().str.strip() == name.lower().strip()]
+def get_node_id_by_name(name, gdf):
+    match = gdf[gdf['name'].str.lower().str.strip() == name.lower().strip()]
     if not match.empty:
         idx = match.index[0]
-        return f"bldg_{idx}"
+        return f"poi_{idx}"
     else:
-        st.error(f"Building name '{name}' not found.")
         return None
 
-def plot_path(path, title):
-    path_edges = list(zip(path, path[1:]))
-    lines = []
-    for u, v in path_edges:
-        x1, y1 = G.nodes[u]['x'], G.nodes[u]['y']
-        x2, y2 = G.nodes[v]['x'], G.nodes[v]['y']
-        lines.append(LineString([(x1, y1), (x2, y2)]))
-
-    gdf_path = gpd.GeoDataFrame(geometry=lines, crs="EPSG:4326")
-    ax = gdf_edges.plot(figsize=(10,10), linewidth=0.5, edgecolor='gray')
-    gdf_bld.plot(ax=ax, color='blue', markersize=30, label='POI')
-    gdf_path.plot(ax=ax, linewidth=3, color='red', label='Shortest Path')
-    plt.legend()
-    plt.title(title)
-    st.pyplot(plt)
-
-def Gojek_mode(start_name, end_name):
-    src = get_building_node_id_by_name(start_name)
-    dst = get_building_node_id_by_name(end_name)
-    if src is None or dst is None:
-        return
-    path = nx.dijkstra_path(G, source=src, target=dst, weight='length')
-    dist_m = nx.shortest_path_length(G, source=src, target=dst, weight='length')
+def plot_folium_path(G, path, start_name, end_name):
+    m = folium.Map(location=[-6.18, 106.83], zoom_start=14)
+    coords = [(G.nodes[n]['y'], G.nodes[n]['x']) for n in path if 'x' in G.nodes[n] and 'y' in G.nodes[n]]
+    folium.PolyLine(coords, color='blue', weight=5, popup='Rute').add_to(m)
+
+    folium.Marker(coords[0], tooltip='Start', icon=folium.Icon(color='green')).add_to(m)
+    folium.Marker(coords[-1], tooltip='Destination', icon=folium.Icon(color='red')).add_to(m)
+
+    return m
+
+def compute_drive(G, start_id, end_id):
+    path = nx.shortest_path(G, start_id, end_id, weight='length')
+    dist_m = nx.shortest_path_length(G, start_id, end_id, weight='length')
     dist_km = dist_m / 1000
+    est_time = (dist_km / 30) * 60
     cost = int(dist_km * 3000)
-    time_min = (dist_km / 30) * 60
-    st.subheader("🚗 Drive Mode")
-    st.markdown(f"**Distance:** {dist_km:.2f} km")
-    st.markdown(f"**Estimated Time:** {time_min:.1f} minutes")
-    st.markdown(f"**Estimated Cost:** {cost} IDR")
-    plot_path(path, f"Gojek Route: {start_name} → {end_name}")
-
-def busMode(start_name, end_name, time_str):
-    bus_stops = gdf_bld[gdf_bld['tag'] == 'bus_stop']
-    def get_nearest_bus_stop(coord):
-        nearest = None
-        min_dist = float('inf')
-        for idx, row in bus_stops.iterrows():
-            dist = geodesic(coord, (row['latitude'], row['longitude'])).meters
-            if dist < min_dist:
-                min_dist = dist
-                nearest = f"bldg_{row.name}"
-        return nearest
-
-    src_coord = gdf_bld[gdf_bld['name'] == start_name][['latitude','longitude']].values
-    dst_coord = gdf_bld[gdf_bld['name'] == end_name][['latitude','longitude']].values
-
-    if not len(src_coord) or not len(dst_coord):
-        st.error("Could not find coordinates.")
-        return
-
-    node_start = get_nearest_bus_stop(tuple(src_coord[0]))
-    node_end = get_nearest_bus_stop(tuple(dst_coord[0]))
-
-    if node_start is None or node_end is None:
-        st.error("Nearest bus stop not found.")
-        return
-
-    path = nx.shortest_path(G, source=node_start, target=node_end, weight='length')
-    dist_m = nx.shortest_path_length(G, source=node_start, target=node_end, weight='length')
+    return path, dist_km, est_time, cost
+
+def compute_bus(G, start_id, end_id, time_now):
+    path = nx.shortest_path(G, start_id, end_id, weight='length')
+    dist_m = nx.shortest_path_length(G, start_id, end_id, weight='length')
     dist_km = dist_m / 1000
-    time_min = (dist_km / 25) * 60
-    arrival = datetime.strptime(time_str, "%H:%M") + timedelta(minutes=time_min)
-
-    st.subheader("🚌 Bus Mode")
-    st.markdown(f"**Distance:** {dist_km:.2f} km")
-    st.markdown(f"**Travel Time:** {time_min:.1f} minutes")
-    st.markdown(f"**Arrival Time:** {arrival.strftime('%H:%M')}")
-    st.markdown(f"**Estimated Cost:** 3500 IDR")
-    plot_path(path, f"Bus Route: {start_name} → {end_name}")
-
-# --- Streamlit UI ---
-st.title("🗺️ Multimodal Shortest Path Finder - Jakarta")
-start = st.text_input("Start Location", "Universitas Indonesia")
-end = st.text_input("End Location", "Stasiun Gambir")
-time_now = st.time_input("Departure Time")
-
-if st.button("Find Routes"):
-    Gojek_mode(start, end)
-    busMode(start, end, time_now.strftime("%H:%M"))
+    est_time = (dist_km / 25) * 60
+    arrival = datetime.strptime(time_now, "%H:%M") + timedelta(minutes=est_time)
+    return path, dist_km, est_time, arrival.strftime("%H:%M")
+
+# ==== UI ====
+st.title("🚏 Multimodal Shortest Path Jakarta")
+st.markdown("Bandingkan rute tercepat antara **Drive** dan **Bus** dari titik-titik penting di Jakarta Pusat.")
+
+with st.sidebar:
+    st.header("📍 Input Rute")
+    gdf_nodes, gdf_edges, gdf_poi = load_data()
+    name_list = sorted(gdf_poi['name'].dropna().unique().tolist())
+    start_name = st.selectbox("Pilih Lokasi Awal:", name_list)
+    end_name = st.selectbox("Pilih Lokasi Tujuan:", name_list, index=1)
+    time_now = st.time_input("Jam Keberangkatan", value=datetime.now().time())
+
+if st.button("🔍 Cari Rute"):
+    G = build_graph(gdf_nodes, gdf_edges, gdf_poi)
+
+    src = get_node_id_by_name(start_name, gdf_poi)
+    dst = get_node_id_by_name(end_name, gdf_poi)
+
+    if src is None or dst is None:
+        st.error("Lokasi tidak ditemukan dalam daftar POI.")
+    else:
+        st.subheader("🚗 Drive Mode")
+        drive_path, drive_dist, drive_time, drive_cost = compute_drive(G, src, dst)
+        st.write(f"**Jarak:** {drive_dist:.2f} km")
+        st.write(f"**Estimasi Waktu:** {drive_time:.1f} menit")
+        st.write(f"**Biaya:** {drive_cost:,} IDR")
+        st_folium(plot_folium_path(G, drive_path, start_name, end_name), width=700)
+
+        st.subheader("🚌 Bus Mode")
+        bus_path, bus_dist, bus_time, bus_arrival = compute_bus(G, src, dst, time_now.strftime("%H:%M"))
+        st.write(f"**Jarak:** {bus_dist:.2f} km")
+        st.write(f"**Estimasi Waktu:** {bus_time:.1f} menit")
+        st.write(f"**Waktu Tiba:** {bus_arrival}")
+        st.write("**Biaya:** 3.500 IDR")
+        st_folium(plot_folium_path(G, bus_path, start_name, end_name), width=700)