Update app.py

app.py

@@ -60,39 +60,23 @@ def calculate_real_distances(places):
     return distances, routing_info
 
 def optimize_route(distances):
-    """Optimize route using Hungarian algorithm"""
+    """
+    Optimize route using modified Hungarian algorithm for TSP.
+    Returns the optimal order of visits.
+    """
+    n = len(distances)
+    
+    # Solve assignment problem
     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
+    
+    # Convert assignment to tour
+    tour = []
+    current = 0  # Start from first city
+    for _ in range(n):
+        tour.append(current)
+        current = col_ind[current]
+    
+    return tour
 
 def main():
     st.title("AI Travel Route Optimizer (with OSRM)")
@@ -115,42 +99,42 @@ def main():
     
     # 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)
+            # 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)
             
-            # Create optimized itinerary list
-            optimized_places = [(i+1, places[idx][0]) for i, idx in enumerate(optimized_indices)]
+            # Add markers and route lines following optimal order
+            total_distance = 0
+            total_duration = 0
             
-            # 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)]
+            for i in range(len(optimal_order)):
+                current_idx = optimal_order[i]
+                next_idx = optimal_order[(i + 1) % len(optimal_order)]
                 
-                # Add numbered marker
-                place_name, (lat, lon) = places[current_idx]
-                next_place = places[next_idx]
+                # Get current and next place info
+                current_place, (lat, lon) = places[current_idx]
                 
                 # Get routing info for this segment
                 segment_info = routing_info.get((current_idx, next_idx), {})
                 
-                # Create detailed popup content
+                # Add marker with proper numbering
                 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')}
+                <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],
@@ -158,60 +142,58 @@ def main():
                     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)
+                # 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)
+                
+                # 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)
             
-            # Display optimized itinerary with route information
+            # Display optimized itinerary
             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)]
+            for i in range(len(optimal_order)):
+                current_idx = optimal_order[i]
+                next_idx = optimal_order[(i + 1) % len(optimal_order)]
                 
-                place_name = places[current_idx][0]
+                current_place = places[current_idx][0]
                 segment_info = routing_info.get((current_idx, next_idx), {})
                 
-                st.write(f"{i+1}. {place_name}")
+                st.write(f"{i+1}. {current_place}")
                 
-                if i < len(optimized_indices) - 1:
+                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')})")
                     
-                    # Display turn-by-turn instructions
+                    # Show turn-by-turn directions
                     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:")