app.py

import streamlit as st
import folium
import numpy as np
from scipy.optimize import linear_sum_assignment
from folium import plugins
import requests
from datetime import datetime
from geopy.geocoders import Nominatim

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:
                origin = places[i][1]      # coordinates
                destination = places[j][1]  # coordinates
                
                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']
                    }
    
    return distances, routing_info

def optimize_route(distances):
    """Optimize route using Hungarian algorithm"""
    row_ind, col_ind = linear_sum_assignment(distances)
    return col_ind

def get_place_coordinates(place_name):
    """Get coordinates using Nominatim geocoding"""
    try:
        geolocator = Nominatim(user_agent="my_travel_app")
        location = geolocator.geocode(place_name)
        return (location.latitude, location.longitude) if location else None
    except:
        return None

def create_numbered_marker(number):
    """Create a custom marker with a number"""
    return plugins.BeautifyIcon(
        number=number,
        border_color='#b4b4b4',
        border_width=1,
        text_color='black',
        background_color='white',
        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 (with OSRM)")
    
    # Sidebar for inputs
    st.sidebar.header("Travel Parameters")
    
    # Input for places
    places = []
    num_places = st.sidebar.number_input("Number of places to visit", min_value=2, max_value=10, value=3)
    
    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}")
    
    # Only proceed if we have all places
    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)
            
            # Optimize route
            optimized_indices = 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)
            
            # 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])
            
            # 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()