Update app.py

app.py

@@ -1,143 +1,239 @@
 import streamlit as st
 import folium
 from geopy.geocoders import Nominatim
-from geopy.distance import geodesic
 from itertools import combinations
 import numpy as np
-
-# Algoritma Held-Karp untuk TSP
-def held_karp_tsp(dist_matrix):
-    if len(dist_matrix) < 2:
-        return 0, []
-
-    n = len(dist_matrix)
-    inf = float('inf')
-    memo = {}
-
-    # Initialize memo table for subsets of size 2
-    for i in range(1, n):
-        memo[(1 << i, i)] = dist_matrix[0][i]
-
-    # Fill memo table for larger subsets
-    for subset_size in range(2, n):
-        for subset in combinations(range(1, n), subset_size):
-            bits = 0
-            for bit in subset:
-                bits |= 1 << bit
-            for next_city in subset:
-                prev_bits = bits & ~(1 << next_city)
-                if (prev_bits, next_city) in memo:
-                    min_dist = memo[(prev_bits, next_city)] + dist_matrix[next_city][0]
-                    memo[(bits, next_city)] = min_dist
-
-    # Find optimal tour
-    bits = (2 ** n - 1) - 1
-    min_tour_cost = inf
-    last_city = None
-    for k in range(1, n):
-        if (bits, k) in memo:
-            tour_cost = memo[(bits, k)] + dist_matrix[k][0]
-            if tour_cost < min_tour_cost:
-                min_tour_cost = tour_cost
-                last_city = k
-
-    # Backtrack to find the full tour
-    tour = [0]
-    bits = (2 ** n - 1) - 1
-    for _ in range(n - 1):
-        if last_city is not None:
-            tour.append(last_city)
-            bits &= ~(1 << last_city)
-            if bits == 0:
-                break
-            next_city = min(
-                [(memo[(bits, k)] + dist_matrix[k][last_city], k) for k in range(n) if (bits, k) in memo],
-                key=lambda x: x[0],
-            )[1]
-            last_city = next_city
+import requests
+import polyline
+import time
+from functools import lru_cache
+import json
+from concurrent.futures import ThreadPoolExecutor
+
+@st.cache_data
+def get_route_osrm(start_coords: tuple, end_coords: tuple) -> tuple:
+    """
+    Get route using OSRM public API
+    Returns: (distance in km, encoded polyline of the route)
+    """
+    try:
+        # Format coordinates for OSRM (lon,lat format)
+        coords = f"{start_coords[1]},{start_coords[0]};{end_coords[1]},{end_coords[0]}"
+        
+        # OSRM public API endpoint
+        url = f"http://router.project-osrm.org/route/v1/driving/{coords}"
+        params = {
+            "overview": "full",
+            "geometries": "polyline",
+            "annotations": "distance"
+        }
+        
+        response = requests.get(url, params=params)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data["code"] == "Ok" and len(data["routes"]) > 0:
+                route = data["routes"][0]
+                distance = route["distance"] / 1000  # Convert to km
+                geometry = route["geometry"]  # Already encoded polyline
+                return distance, geometry
+            else:
+                st.warning("No route found")
+                return None, None
         else:
-            break
-
-    if len(tour) == n + 1:
-        return min_tour_cost, tour
-    else:
-        return inf, []
-
-# Mendapatkan koordinat kota dari nama
-def get_coordinates(city_name):
-    geolocator = Nominatim(user_agent="tsp_app")
-    location = geolocator.geocode(city_name)
-    if location:
-        return (location.latitude, location.longitude)
-    else:
+            st.warning(f"OSRM API error: {response.status_code}")
+            return None, None
+            
+    except Exception as e:
+        st.error(f"Error getting route: {str(e)}")
+        return None, None
+
+@st.cache_data
+def cached_geocoding(city_name: str) -> tuple:
+    """Cache geocoding results"""
+    try:
+        geolocator = Nominatim(user_agent="tsp_app")
+        location = geolocator.geocode(city_name, timeout=10)
+        if location:
+            return (location.latitude, location.longitude)
+        return None
+    except Exception as e:
+        st.error(f"Error geocoding {city_name}: {str(e)}")
         return None
 
-# Menghitung jarak antar semua pasangan kota
-def create_distance_matrix(coordinates):
+def create_distance_matrix_with_routes(coordinates: list) -> tuple:
+    """
+    Create distance matrix and store routes between all points using OSRM
+    """
     valid_coordinates = [c for c in coordinates if c is not None]
     n = len(valid_coordinates)
+    
     if n < 2:
-        return np.array([]), valid_coordinates
+        return np.array([]), valid_coordinates, {}
+        
     dist_matrix = np.zeros((n, n))
-    for i in range(n):
-        for j in range(i + 1, n):
-            dist_matrix[i][j] = geodesic(valid_coordinates[i], valid_coordinates[j]).kilometers
-            dist_matrix[j][i] = dist_matrix[i][j]
-    return dist_matrix, valid_coordinates
-
-# Fungsi untuk menampilkan peta rute
-def plot_route(map_obj, coordinates, route):
-    for i in range(len(route) - 1):
-        start = coordinates[route[i]]
-        end = coordinates[route[i + 1]]
-        folium.Marker(location=start, tooltip=f'City {route[i] + 1}').add_to(map_obj)
-        folium.Marker(location=end, tooltip=f'City {route[i + 1] + 1}').add_to(map_obj)
-        folium.PolyLine([start, end], color="blue", weight=2.5, opacity=1).add_to(map_obj)
-
-    # Add markers for start and end points
-    folium.Marker(location=coordinates[0], tooltip='Start', icon=folium.Icon(color="green")).add_to(map_obj)
-    folium.Marker(location=coordinates[route[-2]], tooltip='End', icon=folium.Icon(color="red")).add_to(map_obj)
+    routes_dict = {}  # Store encoded polylines for routes
+    
+    def calculate_route(i, j):
+        if i != j:
+            # Add delay to avoid hitting rate limits
+            time.sleep(0.1)  
+            distance, route = get_route_osrm(valid_coordinates[i], valid_coordinates[j])
+            if distance is not None:
+                return i, j, distance, route
+        return i, j, 0, None
+
+    with ThreadPoolExecutor(max_workers=5) as executor:  # Limit concurrent requests
+        futures = []
+        for i in range(n):
+            for j in range(i + 1, n):
+                futures.append(executor.submit(calculate_route, i, j))
+        
+        with st.spinner("Calculating routes..."):
+            for future in futures:
+                i, j, distance, route = future.result()
+                if route is not None:
+                    dist_matrix[i][j] = distance
+                    dist_matrix[j][i] = distance
+                    routes_dict[f"{i}-{j}"] = route
+                    routes_dict[f"{j}-{i}"] = route
+                
+    return dist_matrix, valid_coordinates, routes_dict
+
+def plot_route_with_roads(map_obj: folium.Map, coordinates: list, route: list, 
+                         city_names: list, routes_dict: dict) -> folium.Map:
+    """
+    Plot route using actual road paths from OSRM
+    """
+    route_group = folium.FeatureGroup(name="Route")
+    
+    # Plot road segments between consecutive points
+    total_distance = 0
+    for i in range(len(route)-1):
+        start_idx = route[i]
+        end_idx = route[i+1]
+        route_key = f"{start_idx}-{end_idx}"
+        
+        if route_key in routes_dict:
+            # Decode and plot the polyline
+            decoded_path = polyline.decode(routes_dict[route_key])
+            folium.PolyLine(
+                decoded_path,
+                color="blue",
+                weight=3,
+                opacity=0.8,
+                tooltip=f"Segment {i+1}: {city_names[start_idx]} → {city_names[end_idx]}"
+            ).add_to(route_group)
+    
+    # Add markers with custom icons
+    for i, point_idx in enumerate(route):
+        icon_color = "green" if i == 0 else "red" if i == len(route)-1 else "blue"
+        popup_text = f"""
+        <div style='font-size: 12px'>
+            <b>City:</b> {city_names[point_idx]}<br>
+            <b>Stop:</b> {i + 1} of {len(route)}
+        </div>
+        """
+        folium.Marker(
+            location=coordinates[point_idx],
+            popup=folium.Popup(popup_text, max_width=200),
+            tooltip=f'Stop {i + 1}: {city_names[point_idx]}',
+            icon=folium.Icon(color=icon_color, icon='info-sign')
+        ).add_to(route_group)
+    
+    route_group.add_to(map_obj)
+    
+    # Add OpenStreetMap tile layer
+    folium.TileLayer(
+        tiles='https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+        attr='&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
+    ).add_to(map_obj)
+    
     return map_obj
 
-# Streamlit UI
-st.title("Traveling Salesman Problem Solver")
-
-# Create map
-map_obj = folium.Map(location=[0, 0], zoom_start=2)
-
-# Input kota
-st.subheader("Pilih Kota")
-city_count = st.number_input("Jumlah kota", min_value=2, step=1)
-city_names = []
-city_coords = []
-for i in range(int(city_count)):
-    city_name = st.text_input(f"Kota {i+1}", key=f"city_{i}")
-    city_coords.append(get_coordinates(city_name))
-    if city_coords[-1] is None:
-        st.warning(f"Kota '{city_name}' tidak ditemukan. Harap periksa ejaan dan coba lagi.")
-    else:
-        city_names.append(city_name)
-
-if st.button("Optimasi Rute"):
-    dist_matrix, valid_coordinates = create_distance_matrix(city_coords)
-
-    if len(valid_coordinates) < 2:
-        st.error("Tidak cukup kota yang valid untuk dioptimalkan.")
-    else:
-        # Hitung rute optimal
-        min_cost, optimal_route = held_karp_tsp(dist_matrix)
+def main():
+    st.set_page_config(page_title="TSP Solver with OSRM", layout="wide")
+    
+    st.title("🌍 TSP Route Optimizer")
+    st.markdown("""
+    Find the optimal driving route between multiple cities using OSRM.
+    Enter city names below and click 'Optimize Route' to see the results.
+    """)
+
+    col1, col2 = st.columns([1, 2])
+
+    with col1:
+        st.subheader("📍 Enter Cities")
+        city_count = st.number_input("Number of cities", min_value=2, max_value=10, value=3, step=1,
+                                   help="Maximum 10 cities recommended due to API limits")
+        
+        if 'city_inputs' not in st.session_state:
+            st.session_state.city_inputs = [''] * city_count
+        
+        if len(st.session_state.city_inputs) != city_count:
+            st.session_state.city_inputs = st.session_state.city_inputs[:city_count] + [''] * max(0, city_count - len(st.session_state.city_inputs))
+        
+        city_names = []
+        city_coords = []
         
-        # Tampilkan hasil
-        if min_cost == float('inf'):
-            st.write("Tidak ada rute optimal yang dapat ditemukan.")
+        for i in range(city_count):
+            city_name = st.text_input(
+                f"City {i+1}",
+                value=st.session_state.city_inputs[i],
+                key=f"city_{i}"
+            )
+            st.session_state.city_inputs[i] = city_name
+            
+            if city_name:
+                coords = cached_geocoding(city_name)
+                if coords:
+                    city_names.append(city_name)
+                    city_coords.append(coords)
+                else:
+                    st.warning(f"⚠️ Could not find coordinates for '{city_name}'")
+
+    with col2:
+        if not city_coords:
+            map_center = [-2.548926, 118.014863]  # Center of Indonesia
+            zoom_start = 5
         else:
-            st.write(f"Biaya total minimum: {min_cost:.2f} km")
-            st.write("Rute optimal:", " -> ".join([city_names[i] for i in optimal_route]))
-
-            # Buat peta
-            map_obj = folium.Map(location=valid_coordinates[0], zoom_start=5)
-            plot_route(map_obj, valid_coordinates, optimal_route)
+            map_center = city_coords[0]
+            zoom_start = 5
             
-            # Render map
-            st.markdown("### Rute Optimal")
-            st_folium = st.components.v1.html(folium.Map._repr_html_(map_obj), width=800, height=600)
+        map_obj = folium.Map(location=map_center, zoom_start=zoom_start)
+        
+        if st.button("🔄 Optimize Route", key="optimize"):
+            if len(city_coords) < 2:
+                st.error("❌ Please enter at least 2 valid cities")
+            else:
+                with st.spinner("Calculating optimal route..."):
+                    start_time = time.time()
+                    
+                    # Get distance matrix and routes
+                    dist_matrix, valid_coordinates, routes_dict = create_distance_matrix_with_routes(city_coords)
+                    
+                    # Calculate optimal route
+                    from held_karp_tsp import held_karp_tsp  # Menggunakan fungsi yang sudah ada
+                    min_cost, optimal_route = held_karp_tsp(dist_matrix)
+                    
+                    end_time = time.time()
+                    
+                    if min_cost == float('inf'):
+                        st.error("❌ Could not find a valid route")
+                    else:
+                        # Display results
+                        st.success(f"✅ Route calculated in {end_time - start_time:.2f} seconds")
+                        st.write(f"🛣️ Total driving distance: {min_cost:.2f} km")
+                        st.write("📍 Optimal route:")
+                        route_text = " → ".join([city_names[i] for i in optimal_route])
+                        st.code(route_text)
+                        
+                        # Update map with route
+                        map_obj = plot_route_with_roads(map_obj, valid_coordinates, optimal_route, 
+                                                      city_names, routes_dict)
+
+        # Display map
+        st.components.v1.html(folium.Map._repr_html_(map_obj), height=600)
+
+if __name__ == "__main__":
+    main()