Update app.py

app.py

@@ -1,283 +1,122 @@
 import streamlit as st
 import folium
+from geopy.geocoders import Nominatim
+from geopy.distance import geodesic
+from itertools import combinations
 import numpy as np
-from typing import List, Tuple, Dict, Optional
-import time
-from collections import deque
-import requests
 import polyline
-from geopy.geocoders import Nominatim
+import requests
 
-# Utility Functions
-def create_numbered_marker(number: int) -> folium.features.DivIcon:
-    """Create a numbered marker icon for the map"""
-    return folium.features.DivIcon(
-        html=f'<div style="background-color: white; border-radius: 50%; width: 25px; height: 25px; '
-             f'display: flex; align-items: center; justify-content: center; border: 2px solid blue; '
-             f'font-weight: bold;">{number}</div>'
-    )
+# Algoritma Held-Karp untuk TSP
+def held_karp_tsp(dist_matrix):
+    n = len(dist_matrix)
+    inf = float('inf')
+    memo = {}
 
-def get_place_coordinates(place_name: str) -> Optional[Tuple[float, float]]:
-    """Get coordinates for a place using Nominatim geocoding"""
-    try:
-        geolocator = Nominatim(user_agent="travel_optimizer")
-        location = geolocator.geocode(place_name)
-        if location:
-            return (location.latitude, location.longitude)
-    except Exception as e:
-        st.error(f"Error geocoding {place_name}: {str(e)}")
-    return None
+    # Initialize memo table for subsets of size 2
+    for i in range(1, n):
+        memo[(1 << i, i)] = dist_matrix[0][i]
 
-def format_instructions(steps: List[Dict]) -> List[str]:
-    """Format OSRM route steps into readable instructions"""
-    instructions = []
-    for step in steps:
-        if 'maneuver' in step:
-            instruction = step.get('maneuver', {}).get('instruction', '')
-            if instruction:
-                # Add distance information if available
-                if 'distance' in step:
-                    distance_km = step['distance'] / 1000
-                    if distance_km >= 1:
-                        instruction += f" ({distance_km:.1f} km)"
-                    else:
-                        instruction += f" ({step['distance']:.0f} m)"
-                instructions.append(instruction)
-    return instructions
+    # 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)
+                min_dist = inf
+                for k in subset:
+                    if k == next_city:
+                        continue
+                    current_dist = memo[(prev_bits, k)] + dist_matrix[k][next_city]
+                    if current_dist < min_dist:
+                        min_dist = current_dist
+                memo[(bits, next_city)] = min_dist
 
-def get_route_from_osrm(coord1: Tuple[float, float], coord2: Tuple[float, float]) -> Optional[Dict]:
-    """Get route information from OSRM"""
-    url = f"http://router.project-osrm.org/route/v1/driving/{coord1[1]},{coord1[0]};{coord2[1]},{coord2[0]}"
-    params = {
-        "overview": "full",
-        "geometries": "polyline",
-        "steps": "true",
-        "annotations": "true"
-    }
-    
-    # Add rate limiting
-    time.sleep(1)  # Respect OSRM usage guidelines
-    
-    try:
-        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]
-                return {
-                    'distance': route['distance'] / 1000,  # Convert to km
-                    'duration': route['duration'] / 60,    # Convert to minutes
-                    'geometry': route['geometry'],
-                    'steps': route['legs'][0]['steps']
-                }
-    except Exception as e:
-        st.warning(f"Error getting route: {str(e)}")
-    return None
+    # Find optimal tour
+    bits = (2 ** n - 1) - 1
+    min_tour_cost = inf
+    last_city = None
+    for k in range(1, n):
+        tour_cost = memo[(bits, k)] + dist_matrix[k][0]
+        if tour_cost < min_tour_cost:
+            min_tour_cost = tour_cost
+            last_city = k
 
-def calculate_distance_matrix(places: List[Tuple[str, Tuple[float, float]]]) -> Tuple[np.ndarray, Dict]:
-    """Calculate distance matrix and routing information using OSRM"""
-    n = len(places)
-    distances = np.zeros((n, n))
-    routing_info = {}
-    
-    progress_bar = st.progress(0)
-    total_calcs = n * (n-1)
-    current_calc = 0
-    
-    for i in range(n):
-        for j in range(n):
-            if i != j:
-                origin = places[i][1]
-                destination = places[j][1]
-                
-                route_data = get_route_from_osrm(origin, destination)
-                
-                if route_data:
-                    distances[i,j] = route_data['distance']
-                    routing_info[(i,j)] = {
-                        'distance_km': f"{route_data['distance']:.1f} km",
-                        'duration_mins': f"{route_data['duration']:.0f} mins",
-                        'geometry': route_data['geometry'],
-                        'steps': route_data['steps']
-                    }
-                
-                current_calc += 1
-                progress_bar.progress(current_calc / total_calcs)
-    
-    return distances, routing_info
+    # Backtrack to find the full tour
+    tour = [0]
+    bits = (2 ** n - 1) - 1
+    for _ in range(n - 1):
+        tour.append(last_city)
+        bits &= ~(1 << last_city)
+        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
 
-def dijkstra(distances: np.ndarray, start_idx: int) -> Tuple[List[int], Dict[int, float]]:
-    """Implement Dijkstra's algorithm to find the optimal route"""
-    n = len(distances)
-    visited = [False] * n
-    distances_to = [float('inf')] * n
-    prev_node = [-1] * n
-    
-    distances_to[start_idx] = 0
-    queue = deque([start_idx])
-    
-    while queue:
-        current_node = queue.popleft()
-        visited[current_node] = True
-        
-        for neighbor in range(n):
-            if not visited[neighbor] and distances[current_node, neighbor] > 0:
-                new_distance = distances_to[current_node] + distances[current_node, neighbor]
-                if new_distance < distances_to[neighbor]:
-                    distances_to[neighbor] = new_distance
-                    prev_node[neighbor] = current_node
-                    queue.append(neighbor)
-    
-    # Reconstruct the optimal route
-    optimal_order = []
-    for i in range(n):
-        node = i
-        while prev_node[node] != -1:
-            optimal_order.insert(0, node)
-            node = prev_node[node]
-        if len(optimal_order) > 0 and optimal_order[0] == i:
-            optimal_order.insert(0, start_idx)
-            break
-    
-    return optimal_order, distances_to
+    tour.append(0)
+    return min_tour_cost, tour
 
-def add_markers_and_route(m: folium.Map, places: List[Tuple[str, Tuple[float, float]]], optimal_order: List[int], routing_info: Dict):
-    """Add markers and route lines to the map"""
-    total_distance = 0
-    total_duration = 0
-    
-    for i in range(len(optimal_order)):
-        current_idx = optimal_order[i]
-        next_idx = optimal_order[(i + 1) % len(optimal_order)]
-        
-        current_place, (lat, lon) = places[current_idx]
-        segment_info = routing_info.get((current_idx, next_idx), {})
-        
-        # Add marker
-        popup_content = f"""
-        <b>Stop {i+1}: {current_place}</b><br>
-        """
-        if i < len(optimal_order) - 1:
-            popup_content += f"""
-            To next stop:<br>
-            Distance: {segment_info.get('distance_km', 'N/A')}<br>
-            Duration: {segment_info.get('duration_mins', 'N/A')}
-            """
-        
-        folium.Marker(
-            [lat, lon],
-            popup=folium.Popup(popup_content, max_width=300),
-            icon=create_numbered_marker(i+1)
-        ).add_to(m)
-        
-        # Draw route line
-        if i < len(optimal_order) - 1:
-            if 'geometry' in segment_info:
-                try:
-                    route_coords = polyline.decode(segment_info['geometry'])
-                    folium.PolyLine(
-                        route_coords,
-                        weight=2,
-                        color='blue',
-                        opacity=0.8
-                    ).add_to(m)
-                except Exception as e:
-                    st.warning(f"Error drawing route: {str(e)}")
-                    next_place = places[next_idx][1]
-                    folium.PolyLine(
-                        [[lat, lon], [next_place[0], next_place[1]]],
-                        weight=2,
-                        color='red',
-                        opacity=0.8
-                    ).add_to(m)
-            
-            # Add to totals
-            if 'distance_km' in segment_info:
-                total_distance += float(segment_info['distance_km'].split()[0])
-            if 'duration_mins' in segment_info:
-                total_duration += float(segment_info['duration_mins'].split()[0])
-    
-    return total_distance, total_duration
+# 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:
+        return None
 
-def display_itinerary_summary(places: List[Tuple[str, Tuple[float, float]]], optimal_order: List[int], routing_info: Dict):
-    """Display the optimized itinerary summary"""
-    # Display summary first
-    st.markdown("### 📊 Summary")
-    total_distance, total_duration = add_markers_and_route(folium.Map(), places, optimal_order, routing_info)
-    st.info(f"""
-    🛣️ Total distance: **{total_distance:.1f} km**  
-    ⏱️ Total duration: **{total_duration:.0f} mins** ({total_duration/60:.1f} hours)
-    """)
-    
-    st.markdown("### 🗺️ Route Details")
-    for i in range(len(optimal_order)):
-        current_idx = optimal_order[i]
-        next_idx = optimal_order[(i + 1) % len(optimal_order)]
-        
-        current_place = places[current_idx][0]
-        segment_info = routing_info.get((current_idx, next_idx), {})
-        
-        st.markdown(f"**Stop {i+1}: {current_place}**")
-        
-        if i < len(optimal_order) - 1:
-            st.markdown(f"↓ *{segment_info.get('distance_km', 'N/A')}, "
-                      f"Duration: {segment_info.get('duration_mins', 'N/A')}*")
-            
-            if 'steps' in segment_info:
-                with st.expander("📍 Turn-by-turn directions"):
-                    instructions = format_instructions(segment_info['steps'])
-                    for idx, instruction in enumerate(instructions, 1):
-                        st.write(f"{idx}. {instruction}")
+# Menghitung jarak antar semua pasangan kota
+def create_distance_matrix(coordinates):
+    n = len(coordinates)
+    dist_matrix = np.zeros((n, n))
+    for i in range(n):
+        for j in range(i + 1, n):
+            dist_matrix[i][j] = geodesic(coordinates[i], coordinates[j]).kilometers
+            dist_matrix[j][i] = dist_matrix[i][j]
+    return dist_matrix
 
-def main():
-    st.set_page_config(page_title="AI Travel Route Optimizer", layout="wide")
-    st.title("🌍 AI Travel Route Optimizer")
-    st.markdown("""
-    This app helps you find the optimal route between multiple destinations using real driving distances.
-    Enter your destinations in the sidebar and get a customized route with turn-by-turn directions.
-    """)
+# 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)
 
-    # Sidebar for inputs
-    with st.sidebar:
-        st.header("📍 Destinations")
-        num_places = st.number_input("Number of destinations", min_value=2, max_value=10, value=3)
-        places = []
-        for i in range(num_places):
-            place = st.text_input(f"Destination {i+1}")
-            if place:
-                with st.spinner(f"Finding coordinates for {place}..."):
-                    coordinates = get_place_coordinates(place)
-                    if coordinates:
-                        places.append((place, coordinates))
-                        st.success(f"✓ Found coordinates for {place}")
-                    else:
-                        st.error(f"❌ Couldn't find coordinates for {place}")
+    # 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)
+    return map_obj
 
-    # Main content area
-    if len(places) >= 2:
-        col1, col2 = st.columns([2, 1])
-        with col1:
-            with st.spinner("🚗 Calculating optimal route..."):
-                # Calculate distance matrix
-                distances, routing_info = calculate_distance_matrix(places)
-                
-                # Get optimized route order using Dijkstra's algorithm
-                optimal_order, _ = dijkstra(distances, 0)
-                
-                # Update the route if the user changes the input
-                if st.button("Recalculate Route"):
-                    distances, routing_info = calculate_distance_matrix(places)
-                    optimal_order, _ = dijkstra(distances, 0)
+# Streamlit UI
+st.title("Traveling Salesman Problem Solver")
 
-                # Create map and display
-                m = folium.Map()
-                total_distance, total_duration = add_markers_and_route(m, places, optimal_order, routing_info)
-                st.components.v1.html(m._repr_html_(), height=600)
+# Input kota
+city_names = st.text_input("Masukkan nama kota (pisahkan dengan koma)", "Jakarta, Bandung, Surabaya, Yogyakarta")
+city_list = [city.strip() for city in city_names.split(",")]
 
-        with col2:
-            display_itinerary_summary(places, optimal_order, routing_info)
+if len(city_list) < 2:
+    st.warning("Masukkan setidaknya dua kota.")
+else:
+    coordinates = [get_coordinates(city) for city in city_list]
+    if None in coordinates:
+        st.error("Ada kota yang tidak ditemukan. Pastikan nama kota benar.")
     else:
-        st.info("👈 Please enter at least 2 destinations in the sidebar to get started")
+        # Buat distance matrix
+        dist_matrix = create_distance_matrix(coordinates)
+        min_cost, optimal_route = held_karp_tsp(dist_matrix)
+        
+        # Tampilkan hasil
+        st.write(f"Biaya total minimum: {min_cost:.2f} km")
+        st.write("Rute optimal:", " -> ".join([city_list[i] for i in optimal_route]))
 
-if __name__ == "__main__":
-    main()
+        # Buat peta
+        map_obj = folium.Map(location=coordinates[0], zoom_start=5)
+        plot_route(map_obj, coordinates, optimal_route)
+        
+        # Render map
+        st_folium = st.components.v1.html(folium.Map._repr_html_(map_obj), width=700, height=500)