Update app.py

app.py

@@ -1,43 +1,72 @@
 import streamlit as st
-from transformers import pipeline
 import folium
 import numpy as np
 from scipy.optimize import linear_sum_assignment
-import pandas as pd
 from folium import plugins
+import requests
+from datetime import datetime
+from geopy.geocoders import Nominatim
 
-def calculate_distances(coordinates):
-    """Calculate distances between all points using Haversine formula"""
-    n = len(coordinates)
+def get_route_from_osrm(coord1, coord2):
+    """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",
+        "geometries": "polyline",
+        "steps": "true",
+        "annotations": "true"
+    }
+    
+    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:
+        pass
+    return None
+
+def calculate_real_distances(places):
+    """Calculate real driving distances using OSRM"""
+    n = len(places)
     distances = np.zeros((n, n))
+    routing_info = {}
     
     for i in range(n):
         for j in range(n):
             if i != j:
-                lat1, lon1 = coordinates[i]
-                lat2, lon2 = coordinates[j]
+                origin = places[i][1]      # coordinates
+                destination = places[j][1]  # coordinates
                 
-                R = 6371  # Earth's radius in kilometers
+                route_data = get_route_from_osrm(origin, destination)
                 
-                dlat = np.radians(lat2 - lat1)
-                dlon = np.radians(lon2 - lon1)
-                
-                a = np.sin(dlat/2)**2 + np.cos(np.radians(lat1)) * np.cos(np.radians(lat2)) * np.sin(dlon/2)**2
-                c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1-a))
-                distances[i,j] = R * c
-                
-    return distances
+                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']
+                    }
+    
+    return distances, routing_info
 
-def optimize_route(coordinates):
+def optimize_route(distances):
     """Optimize route using Hungarian algorithm"""
-    distances = calculate_distances(coordinates)
     row_ind, col_ind = linear_sum_assignment(distances)
     return col_ind
 
 def get_place_coordinates(place_name):
     """Get coordinates using Nominatim geocoding"""
     try:
-        from geopy.geocoders import Nominatim
         geolocator = Nominatim(user_agent="my_travel_app")
         location = geolocator.geocode(place_name)
         return (location.latitude, location.longitude) if location else None
@@ -55,8 +84,18 @@ def create_numbered_marker(number):
         inner_icon_style='margin-top:0;'
     )
 
+def format_instructions(steps):
+    """Format routing instructions from OSRM steps"""
+    instructions = []
+    for step in steps:
+        if 'maneuver' in step:
+            instruction = step.get('maneuver', {}).get('instruction', '')
+            if instruction:
+                instructions.append(instruction)
+    return instructions
+
 def main():
-    st.title("AI Travel Route Optimizer")
+    st.title("AI Travel Route Optimizer (with OSRM)")
     
     # Sidebar for inputs
     st.sidebar.header("Travel Parameters")
@@ -71,64 +110,113 @@ def main():
             coordinates = get_place_coordinates(place)
             if coordinates:
                 places.append((place, coordinates))
+            else:
+                st.error(f"Couldn't find coordinates for {place}")
     
     # Only proceed if we have all places
     if len(places) == num_places and num_places >= 2:
         
-        # Extract coordinates for optimization
-        coordinates = [coord for _, coord in places]
-        
-        # Optimize route
-        optimized_indices = optimize_route(coordinates)
-        
-        # Create map
-        center_lat = sum(coord[0] for coord in coordinates) / len(coordinates)
-        center_lon = sum(coord[1] for coord in coordinates) / len(coordinates)
-        
-        m = folium.Map(location=[center_lat, center_lon], zoom_start=4)
-        
-        # Create optimized itinerary list first
-        optimized_places = [(i+1, places[idx][0]) for i, idx in enumerate(optimized_indices)]
-        
-        # Add markers and route lines
-        for i in range(len(optimized_indices)):
-            current_idx = optimized_indices[i]
-            next_idx = optimized_indices[(i + 1) % len(optimized_indices)]
+        with st.spinner("Calculating optimal route..."):
+            # Calculate real distances
+            distances, routing_info = calculate_real_distances(places)
             
-            # Add numbered marker
-            place_name, (lat, lon) = places[current_idx]
-            folium.Marker(
-                [lat, lon],
-                popup=f"Stop {i+1}: {place_name}",
-                icon=create_numbered_marker(i+1)
-            ).add_to(m)
+            # Optimize route
+            optimized_indices = optimize_route(distances)
             
-            # Add line to next point
-            next_lat, next_lon = coordinates[next_idx]
-            folium.PolyLine(
-                locations=[[lat, lon], [next_lat, next_lon]],
-                weight=2,
-                color='blue',
-                opacity=0.8
-            ).add_to(m)
-        
-        # Display map
-        st.components.v1.html(m._repr_html_(), height=600)
-        
-        # Display optimized itinerary
-        st.header("Optimized Itinerary")
-        for stop_num, place_name in optimized_places:
-            st.write(f"{stop_num}. {place_name}")
-        
-        # Calculate total distance
-        total_distance = 0
-        distances = calculate_distances(coordinates)
-        for i in range(len(optimized_indices)):
-            current_idx = optimized_indices[i]
-            next_idx = optimized_indices[(i + 1) % len(optimized_indices)]
-            total_distance += distances[current_idx][next_idx]
+            # 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)
+            
+            # Create optimized itinerary list
+            optimized_places = [(i+1, places[idx][0]) for i, idx in enumerate(optimized_indices)]
+            
+            # Add markers and route lines
+            for i in range(len(optimized_indices)):
+                current_idx = optimized_indices[i]
+                next_idx = optimized_indices[(i + 1) % len(optimized_indices)]
+                
+                # Add numbered marker
+                place_name, (lat, lon) = places[current_idx]
+                next_place = places[next_idx]
+                
+                # Get routing info for this segment
+                segment_info = routing_info.get((current_idx, next_idx), {})
+                
+                # Create detailed popup content
+                popup_content = f"""
+                <b>Stop {i+1}: {place_name}</b><br>
+                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 using polyline from OSRM
+                if 'geometry' in segment_info:
+                    try:
+                        import polyline
+                        route_coords = polyline.decode(segment_info['geometry'])
+                        folium.PolyLine(
+                            route_coords,
+                            weight=2,
+                            color='blue',
+                            opacity=0.8
+                        ).add_to(m)
+                    except:
+                        # Fallback to straight line if polyline decoding fails
+                        folium.PolyLine(
+                            [[lat, lon], [next_place[1][0], next_place[1][1]]],
+                            weight=2,
+                            color='red',
+                            opacity=0.8
+                        ).add_to(m)
+            
+            # Display map
+            st.components.v1.html(m._repr_html_(), height=600)
+            
+            # Display optimized itinerary with route information
+            st.header("Optimized Itinerary")
+            
+            total_distance = 0
+            total_duration = 0
+            
+            for i in range(len(optimized_indices)):
+                current_idx = optimized_indices[i]
+                next_idx = optimized_indices[(i + 1) % len(optimized_indices)]
+                
+                place_name = places[current_idx][0]
+                segment_info = routing_info.get((current_idx, next_idx), {})
+                
+                st.write(f"{i+1}. {place_name}")
+                
+                if i < len(optimized_indices) - 1:
+                    st.write(f"   ↓ ({segment_info.get('distance_km', 'N/A')}, "
+                            f"Duration: {segment_info.get('duration_mins', 'N/A')})")
+                    
+                    # Display turn-by-turn instructions
+                    if 'steps' in segment_info:
+                        with st.expander(f"Route instructions to next stop"):
+                            instructions = format_instructions(segment_info['steps'])
+                            for idx, instruction in enumerate(instructions, 1):
+                                st.write(f"{idx}. {instruction}")
+                
+                # 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])
             
-        st.write(f"\nTotal distance: {total_distance:.2f} km")
+            # 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)")
 
 if __name__ == "__main__":
     main()