Update app.py

app.py

@@ -6,10 +6,49 @@ from folium import plugins
 import requests
 from datetime import datetime
 from geopy.geocoders import Nominatim
+import polyline
+from typing import List, Tuple, Dict, Optional
+import time
 
-def get_route_from_osrm(coord1, coord2):
+# 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>'
+    )
+
+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
+
+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
+
+def get_route_from_osrm(coord1: Tuple[float, float], coord2: Tuple[float, float]) -> Optional[Dict]:
     """Get route information from OSRM"""
-    # OSRM expects coordinates in format: longitude,latitude
     url = f"http://router.project-osrm.org/route/v1/driving/{coord1[1]},{coord1[0]};{coord2[1]},{coord2[0]}"
     params = {
         "overview": "full",
@@ -18,6 +57,9 @@ def get_route_from_osrm(coord1, coord2):
         "annotations": "true"
     }
     
+    # Add rate limiting
+    time.sleep(1)  # Respect OSRM usage guidelines
+    
     try:
         response = requests.get(url, params=params)
         if response.status_code == 200:
@@ -30,21 +72,25 @@ def get_route_from_osrm(coord1, coord2):
                     'geometry': route['geometry'],
                     'steps': route['legs'][0]['steps']
                 }
-    except:
-        pass
+    except Exception as e:
+        st.warning(f"Error getting route: {str(e)}")
     return None
 
-def calculate_real_distances(places):
+def calculate_real_distances(places: List[Tuple[str, Tuple[float, float]]]) -> Tuple[np.ndarray, Dict]:
     """Calculate real driving distances 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]      # coordinates
-                destination = places[j][1]  # coordinates
+                origin = places[i][1]
+                destination = places[j][1]
                 
                 route_data = get_route_from_osrm(origin, destination)
                 
@@ -56,22 +102,20 @@ def calculate_real_distances(places):
                         'geometry': route_data['geometry'],
                         'steps': route_data['steps']
                     }
+                
+                current_calc += 1
+                progress_bar.progress(current_calc / total_calcs)
     
     return distances, routing_info
 
-def optimize_route(distances):
-    """
-    Optimize route using modified Hungarian algorithm for TSP.
-    Returns the optimal order of visits.
-    """
+def optimize_route(distances: np.ndarray) -> List[int]:
+    """Optimize route using modified Hungarian algorithm for TSP"""
     n = len(distances)
-    
-    # Solve assignment problem
     row_ind, col_ind = linear_sum_assignment(distances)
     
     # Convert assignment to tour
     tour = []
-    current = 0  # Start from first city
+    current = 0
     for _ in range(n):
         tour.append(current)
         current = col_ind[current]
@@ -79,102 +123,119 @@ def optimize_route(distances):
     return tour
 
 def main():
-    st.title("AI Travel Route Optimizer (with OSRM)")
-    
-    # Sidebar for inputs
-    st.sidebar.header("Travel Parameters")
+    st.set_page_config(page_title="AI Travel Route Optimizer", layout="wide")
     
-    # Input for places
-    places = []
-    num_places = st.sidebar.number_input("Number of places to visit", min_value=2, max_value=10, value=3)
+    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.
+    """)
     
-    for i in range(num_places):
-        place = st.sidebar.text_input(f"Place {i+1}")
-        if place:
-            coordinates = get_place_coordinates(place)
-            if coordinates:
-                places.append((place, coordinates))
-            else:
-                st.error(f"Couldn't find coordinates for {place}")
+    # Sidebar for inputs
+    with st.sidebar:
+        st.header("📍 Destinations")
+        
+        # Input for places
+        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}")
     
-    # Only proceed if we have all places
+    # Main content area
     if len(places) == num_places and num_places >= 2:
-        with st.spinner("Calculating optimal route..."):
-            # Calculate real distances
-            distances, routing_info = calculate_real_distances(places)
-            
-            # Get optimized route order
-            optimal_order = optimize_route(distances)
-            
-            # Create map
-            center_lat = sum(coord[0] for _, coord in places) / len(places)
-            center_lon = sum(coord[1] for _, coord in places) / len(places)
-            m = folium.Map(location=[center_lat, center_lon], zoom_start=4)
-            
-            # Add markers and route lines following optimal order
-            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)]
-                
-                # Get current and next place info
-                current_place, (lat, lon) = places[current_idx]
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            with st.spinner("🚗 Calculating optimal route..."):
+                # Calculate real distances
+                distances, routing_info = calculate_real_distances(places)
                 
-                # Get routing info for this segment
-                segment_info = routing_info.get((current_idx, next_idx), {})
+                # Get optimized route order
+                optimal_order = optimize_route(distances)
                 
-                # Add marker with proper numbering
-                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')}
-                    """
+                # Create map
+                center_lat = sum(coord[0] for _, coord in places) / len(places)
+                center_lon = sum(coord[1] for _, coord in places) / len(places)
+                m = folium.Map(location=[center_lat, center_lon], zoom_start=4)
                 
-                folium.Marker(
-                    [lat, lon],
-                    popup=folium.Popup(popup_content, max_width=300),
-                    icon=create_numbered_marker(i+1)
-                ).add_to(m)
+                # Add markers and route lines
+                total_distance = 0
+                total_duration = 0
                 
-                # Draw route line to next point
-                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:
-                            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)
+                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])
                 
-                # Add to totals if not last point
-                if i < len(optimal_order) - 1:
-                    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])
+                # Display map
+                st.components.v1.html(m._repr_html_(), height=600)
+        
+        with col2:
+            st.header("📝 Optimized Itinerary")
             
-            # Display map
-            st.components.v1.html(m._repr_html_(), height=600)
-            
-            # Display optimized itinerary
-            st.header("Optimized Itinerary")
+            # Display summary first
+            st.markdown("### 📊 Summary")
+            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)]
@@ -182,23 +243,19 @@ def main():
                 current_place = places[current_idx][0]
                 segment_info = routing_info.get((current_idx, next_idx), {})
                 
-                st.write(f"{i+1}. {current_place}")
+                st.markdown(f"**Stop {i+1}: {current_place}**")
                 
                 if i < len(optimal_order) - 1:
-                    st.write(f"   ↓ ({segment_info.get('distance_km', 'N/A')}, "
-                            f"Duration: {segment_info.get('duration_mins', 'N/A')})")
+                    st.markdown(f"↓ *{segment_info.get('distance_km', 'N/A')}, "
+                              f"Duration: {segment_info.get('duration_mins', 'N/A')}*")
                     
-                    # Show turn-by-turn directions
                     if 'steps' in segment_info:
-                        with st.expander(f"Route instructions to next stop"):
+                        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}")
-            
-            # Display totals
-            st.write("\nSummary:")
-            st.write(f"Total distance: {total_distance:.1f} km")
-            st.write(f"Total estimated duration: {total_duration:.0f} minutes ({total_duration/60:.1f} hours)")
+    else:
+        st.info("👈 Please enter all destinations in the sidebar to get started")
 
 if __name__ == "__main__":
     main()