inital commit

.gitignore

@@ -0,0 +1,6 @@
+.__pycache__
+*.pyc
+*.pyo
+*.pyd
+*.db
+cache/

app.py

@@ -0,0 +1,1139 @@
+from flask import Flask, request, jsonify, send_file
+from flask_cors import CORS
+import joblib
+import os
+import folium
+import tempfile
+import random
+import numpy as np
+import networkx as nx
+from datetime import datetime
+from route_optimizer import (
+    get_or_load_road_network,
+    get_simplified_road_network,
+    create_synthetic_network,
+    add_base_speeds_to_graph,
+    MLTrafficPredictor,
+    RoadCongestionClassifier,
+    TravelTimePredictor,
+    EnhancedDynamicRouter,
+    user_location_selection_feature,
+    check_graph_connectivity,
+    find_nearest_accessible_node,
+    create_enhanced_route_map,
+    create_route_focused_map,
+    display_route_details
+)
+
+app = Flask(__name__)
+CORS(app)
+
+MODEL_DIR = 'saved_models'
+TRAFFIC_MODEL_PATH = os.path.join(MODEL_DIR, 'traffic_predictor.pkl')
+CONGESTION_MODEL_PATH = os.path.join(MODEL_DIR, 'congestion_classifier.pkl')
+TRAVEL_TIME_MODEL_PATH = os.path.join(MODEL_DIR, 'travel_time_predictor.pkl')
+
+G = None
+edge_ids = None
+traffic_predictor = None
+congestion_classifier = None
+travel_predictor = None
+router = None
+congestion_risk = None
+
+def load_or_train_model(model_class, filepath, *args):
+    """Helper function to load model or train if not exists"""
+    if os.path.exists(filepath):
+        print(f"Loading {filepath}")
+        return model_class.load(filepath, *args)
+    else:
+        print(f"Training and saving {filepath}")
+        model = model_class(*args)
+        model.save(filepath)
+        return model
+
+def initialize_system():
+    """Initialize the route optimization system and cache the results"""
+    global G, edge_ids, traffic_predictor, congestion_classifier, travel_predictor, router, congestion_risk
+    
+    if G is None:
+        
+        # Get road network with better error handling
+        try:
+            G = get_or_load_road_network()
+        except Exception as e:
+            print(f"Error obtaining road network: {str(e)}")
+            print("Falling back to synthetic network")
+            G = create_synthetic_network()
+            
+        G = add_base_speeds_to_graph(G)
+        edge_ids = list(G.edges())
+
+        os.makedirs(MODEL_DIR, exist_ok=True)
+        
+        traffic_predictor = load_or_train_model(
+            MLTrafficPredictor,
+            TRAFFIC_MODEL_PATH,
+            edge_ids
+        )
+        
+        congestion_classifier = load_or_train_model(
+            RoadCongestionClassifier,
+            CONGESTION_MODEL_PATH,
+            G
+        )
+        
+        travel_predictor = load_or_train_model(
+            TravelTimePredictor,
+            TRAVEL_TIME_MODEL_PATH,
+            G
+        )
+        
+        # Classify congestion risk
+        congestion_risk = congestion_classifier.classify_roads()
+        
+        # Set up router
+        router = EnhancedDynamicRouter(G, edge_ids, travel_predictor)
+
+    return {
+        "G": G,
+        "edge_ids": edge_ids,
+        "traffic_predictor": traffic_predictor,
+        "congestion_classifier": congestion_classifier,
+        "travel_predictor": travel_predictor,
+        "router": router,
+        "congestion_risk": congestion_risk
+    }
+
+
+@app.route('/api/status', methods=['GET'])
+def status():
+    """Health check endpoint"""
+    return jsonify({"status": "online", "timestamp": datetime.now().isoformat()})
+
+@app.route('/api/network/stats', methods=['GET'])
+def get_network_stats():
+    """Get basic statistics about the road network"""
+    system = initialize_system()
+    G = system["G"]
+    
+    node_count = len(G.nodes())
+    edge_count = len(G.edges())
+    
+    # Get network bounding box
+    min_lat = min(G.nodes[node]['y'] for node in G.nodes())
+    max_lat = max(G.nodes[node]['y'] for node in G.nodes())
+    min_lon = min(G.nodes[node]['x'] for node in G.nodes())
+    max_lon = max(G.nodes[node]['x'] for node in G.nodes())
+    
+    # Road type statistics
+    road_types = {}
+    for _, _, data in G.edges(data=True):
+        road_type = data.get('highway', 'unknown')
+        if road_type in road_types:
+            road_types[road_type] += 1
+        else:
+            road_types[road_type] = 1
+    
+    return jsonify({
+        "node_count": node_count,
+        "edge_count": edge_count,
+        "bounding_box": {
+            "min_lat": min_lat,
+            "max_lat": max_lat,
+            "min_lon": min_lon,
+            "max_lon": max_lon
+        },
+        "road_types": road_types
+    })
+    
+    
+    
+# Add these routes to the Flask backend
+
+@app.route('/api/map/initial', methods=['GET'])
+def get_initial_map():
+    """Return an initial map centered on the network"""
+    system = initialize_system()
+    G = system["G"]
+    
+    # Calculate network center 
+    lat_values = [data['y'] for _, data in G.nodes(data=True) if 'y' in data]
+    lon_values = [data['x'] for _, data in G.nodes(data=True) if 'x' in data]
+    
+    if not lat_values or not lon_values:
+        # Default center if no nodes with coordinates'        
+        center_lat, center_lon = 0, 0
+    else:
+        center_lat = sum(lat_values) / len(lat_values)
+        center_lon = sum(lon_values) / len(lon_values)
+    
+    # Create a basic map centered on the network
+    m = folium.Map(location=[center_lat, center_lon], zoom_start=13)
+    
+    # Add a sample of network nodes for reference (limit to avoid heavy map)
+    node_sample = random.sample(list(G.nodes()), min(100, len(G.nodes())))
+    
+    for node_id in node_sample:
+        node_data = G.nodes[node_id]
+        if 'y' in node_data and 'x' in node_data:
+            folium.CircleMarker(
+                location=[node_data['y'], node_data['x']],
+                radius=2,
+                color='blue',
+                fill=True,
+                fill_opacity=0.7,
+                popup=f"Node ID: {node_id}"
+            ).add_to(m)
+    
+    # Add JavaScript to handle click events on the map
+# Add JavaScript to handle click events on the map with visual feedback
+    click_script = """
+    <script>
+    document.addEventListener('DOMContentLoaded', function() {
+        var map = document.querySelector('.folium-map');
+        
+        // Ensure map exists and has been initialized
+        if (!map || !map._leaflet_id) {
+            console.error('Map element not found or not initialized');
+            return;
+        }
+        
+        // Access the Leaflet map instance
+        var leafletMap = window.L.DomUtil.get('map')._leaflet_map || map._leaflet;
+        
+        // Add click event listener to the map with clear visual feedback
+        leafletMap.on('click', function(e) {
+            // Get lat/lon from the click event
+            var lat = e.latlng.lat;
+            var lon = e.latlng.lng;
+            
+            // Add a marker to show the selected point
+            var marker = L.marker([lat, lon], {
+                icon: L.divIcon({
+                    className: 'selected-node-marker',
+                    html: '<div style="background-color: red; width: 10px; height: 10px; border-radius: 50%; border: 2px solid white;"></div>'
+                })
+            }).addTo(leafletMap);
+            
+            // Send message to parent window with node selection info
+            window.parent.postMessage({
+                type: 'NODE_SELECTED',
+                data: {
+                    lat: lat,
+                    lon: lon
+                }
+            }, '*');
+            
+            // Show visual feedback about the selection
+            var popup = L.popup()
+                .setLatLng(e.latlng)
+                .setContent('<p>Point selected at ' + lat.toFixed(6) + ', ' + lon.toFixed(6) + '</p>')
+                .openOn(leafletMap);
+                
+            // Optional: Make an API call to get nearby nodes
+            fetch('/api/network/nearby-nodes?lat=' + lat + '&lon=' + lon)
+                .then(response => response.json())
+                .then(data => {
+                    if (data.success && data.nodes.length > 0) {
+                        // Show closest node
+                        var closestNode = data.nodes[0];
+                        L.circleMarker([closestNode.lat, closestNode.lon], {
+                            radius: 8,
+                            color: 'blue',
+                            fillColor: '#3186cc',
+                            fillOpacity: 0.7
+                        }).addTo(leafletMap)
+                        .bindPopup('Selected Node ID: ' + closestNode.id)
+                        .openPopup();
+                    }
+                })
+                .catch(error => console.error('Error fetching nearby nodes:', error));
+        });
+    });
+    </script>
+    """
+
+
+    
+    m.get_root().html.add_child(folium.Element(click_script))
+    
+    # Save to temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp:
+        m.save(tmp.name)
+        tmp_filename = tmp.name
+    
+    return send_file(tmp_filename, mimetype='text/html')
+
+@app.route('/api/map/update-with-nodes', methods=['POST'])
+def update_map_with_nodes():
+    """Update map to show search results"""
+    system = initialize_system()
+    G = system["G"]
+    
+    data = request.json
+    nodes = data.get('nodes', [])
+    
+    if not nodes:
+        return jsonify({
+            "error": "No nodes provided",
+            "success": False
+        }), 400
+    
+    # Calculate map center based on provided nodes
+    lat_values = [node['lat'] for node in nodes if 'lat' in node]
+    lon_values = [node['lon'] for node in nodes if 'lon' in node]
+    
+    if not lat_values or not lon_values:
+        # Default center if no nodes with coordinates
+        lat_values = [data['y'] for _, data in G.nodes(data=True) if 'y' in data]
+        lon_values = [data['x'] for _, data in G.nodes(data=True) if 'x' in data]
+        
+        if not lat_values or not lon_values:
+            center_lat, center_lon = 0, 0
+        else:
+            center_lat = sum(lat_values) / len(lat_values)
+            center_lon = sum(lon_values) / len(lon_values)
+    else:
+        center_lat = sum(lat_values) / len(lat_values)
+        center_lon = sum(lon_values) / len(lon_values)
+    
+    # Create map centered on search results
+    m = folium.Map(location=[center_lat, center_lon], zoom_start=14)
+    
+    # Add the search result nodes with distinct styling
+    for node in nodes:
+        if 'lat' in node and 'lon' in node:
+            folium.CircleMarker(
+                location=[node['lat'], node['lon']],
+                radius=5,
+                color='red',
+                fill=True,
+                fill_opacity=0.7,
+                popup=f"Node ID: {node['id']}"
+            ).add_to(m)
+    
+    # Add some surrounding nodes for context
+    nearby_nodes = []
+    for node_id, data in G.nodes(data=True):
+        if 'y' in data and 'x' in data:
+            for search_node in nodes:
+                if 'lat' in search_node and 'lon' in search_node:
+                    dist = ((data['y'] - search_node['lat'])**2 + (data['x'] - search_node['lon'])**2)**0.5
+                    if dist <= 0.005:  # Small radius in coordinate units
+                        nearby_nodes.append((node_id, data))
+                        break
+    
+    # Sample some nearby nodes to avoid cluttering the map
+    nearby_sample = random.sample(nearby_nodes, min(30, len(nearby_nodes)))
+    
+    for node_id, node_data in nearby_sample:
+        folium.CircleMarker(
+            location=[node_data['y'], node_data['x']],
+            radius=2,
+            color='blue',
+            fill=True,
+            fill_opacity=0.3,
+            popup=f"Node ID: {node_id}"
+        ).add_to(m)
+    
+    # Add click handler for selecting nodes
+  # Add JavaScript to handle click events on the map with visual feedback
+    click_script = """
+    <script>
+    document.addEventListener('DOMContentLoaded', function() {
+        var map = document.querySelector('.folium-map');
+        
+        // Ensure map exists and has been initialized
+        if (!map || !map._leaflet_id) {
+            console.error('Map element not found or not initialized');
+            return;
+        }
+        
+        // Access the Leaflet map instance
+        var leafletMap = window.L.DomUtil.get('map')._leaflet_map || map._leaflet;
+        
+        // Add click event listener to the map with clear visual feedback
+        leafletMap.on('click', function(e) {
+            // Get lat/lon from the click event
+            var lat = e.latlng.lat;
+            var lon = e.latlng.lng;
+            
+            // Add a marker to show the selected point
+            var marker = L.marker([lat, lon], {
+                icon: L.divIcon({
+                    className: 'selected-node-marker',
+                    html: '<div style="background-color: red; width: 10px; height: 10px; border-radius: 50%; border: 2px solid white;"></div>'
+                })
+            }).addTo(leafletMap);
+            
+            // Send message to parent window with node selection info
+            window.parent.postMessage({
+                type: 'NODE_SELECTED',
+                data: {
+                    lat: lat,
+                    lon: lon
+                }
+            }, '*');
+            
+            // Show visual feedback about the selection
+            var popup = L.popup()
+                .setLatLng(e.latlng)
+                .setContent('<p>Point selected at ' + lat.toFixed(6) + ', ' + lon.toFixed(6) + '</p>')
+                .openOn(leafletMap);
+                
+            // Optional: Make an API call to get nearby nodes
+            fetch('/api/network/nearby-nodes?lat=' + lat + '&lon=' + lon)
+                .then(response => response.json())
+                .then(data => {
+                    if (data.success && data.nodes.length > 0) {
+                        // Show closest node
+                        var closestNode = data.nodes[0];
+                        L.circleMarker([closestNode.lat, closestNode.lon], {
+                            radius: 8,
+                            color: 'blue',
+                            fillColor: '#3186cc',
+                            fillOpacity: 0.7
+                        }).addTo(leafletMap)
+                        .bindPopup('Selected Node ID: ' + closestNode.id)
+                        .openPopup();
+                    }
+                })
+                .catch(error => console.error('Error fetching nearby nodes:', error));
+        });
+    });
+    </script>
+    """
+
+    
+    m.get_root().html.add_child(folium.Element(click_script))
+    
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp:
+        m.save(tmp.name)
+        tmp_filename = tmp.name
+    
+    return send_file(tmp_filename, mimetype='text/html')
+
+@app.route('/api/map/update-route', methods=['POST'])
+def update_route_map():
+    """Update map to show selected depot and stops"""
+    system = initialize_system()
+    G = system["G"]
+    congestion_risk = system["congestion_risk"]
+    router = system["router"]
+    traffic_predictor = system["traffic_predictor"]
+    
+    data = request.json
+    stops = data.get('stops', [])
+    depot = data.get('depot')
+    hour = data.get('hour', 12)
+    day_of_week = data.get('day_of_week', 1)
+    is_weekend = day_of_week >= 5
+    
+    if not depot and not stops:
+        return jsonify({
+            "error": "No depot or stops provided",
+            "success": False
+        }), 400
+    
+    all_points = [depot] + stops if depot else stops
+    all_points = [p for p in all_points if p is not None]
+    
+    if len(all_points) < 1:
+        return jsonify({
+            "error": "Need at least one valid location",
+            "success": False
+        }), 400
+    
+    # Check connectivity and find valid nodes if needed
+    valid_points = []
+    for point in all_points:
+        if point in G:
+            valid_points.append(point)
+        else:
+            closest_node = find_nearest_accessible_node(G, point)
+            if closest_node:
+                valid_points.append(closest_node)
+    
+    if len(valid_points) < 1:
+        return jsonify({
+            "error": "No valid nodes found",
+            "success": False
+        }), 400
+    
+    # Update traffic for routing
+    traffic_multipliers = traffic_predictor.predict_for_time(hour, day_of_week)
+    router.update_edge_speeds(traffic_multipliers)
+    
+    # Generate a route if we have more than one point
+    route = None
+    if len(valid_points) > 1:
+        route = router.optimize_route(valid_points)
+    
+    # Create map
+    if route:
+        time_period_name = f"Hour_{hour}_{'Weekend' if is_weekend else 'Weekday'}"
+        route_map = create_enhanced_route_map(G, valid_points, route, time_period_name, congestion_risk)
+    else:
+        # Just create a map showing the points without a route
+        lat_values = [G.nodes[p]['y'] for p in valid_points if p in G.nodes()]
+        lon_values = [G.nodes[p]['x'] for p in valid_points if p in G.nodes()]
+        
+        if not lat_values or not lon_values:
+            return jsonify({
+                "error": "No valid coordinates found for selected nodes",
+                "success": False
+            }), 400
+        
+        center_lat = sum(lat_values) / len(lat_values)
+        center_lon = sum(lon_values) / len(lon_values)
+        
+        route_map = folium.Map(location=[center_lat, center_lon], zoom_start=14)
+        
+        for i, point_id in enumerate(valid_points):
+            if point_id in G.nodes():
+                color = 'green' if i == 0 and depot else 'blue'
+                folium.CircleMarker(
+                    location=[G.nodes[point_id]['y'], G.nodes[point_id]['x']],
+                    radius=7,
+                    color=color,
+                    fill=True,
+                    fill_opacity=0.7,
+                    popup=f"{'Depot' if i == 0 and depot else 'Stop'} ID: {point_id}"
+                ).add_to(route_map)
+    
+
+    click_script = """
+    <script>
+    document.addEventListener('DOMContentLoaded', function() {
+        var map = document.querySelector('.folium-map');
+        
+        // Ensure map exists and has been initialized
+        if (!map || !map._leaflet_id) {
+            console.error('Map element not found or not initialized');
+            return;
+        }
+        
+        // Access the Leaflet map instance
+        var leafletMap = window.L.DomUtil.get('map')._leaflet_map || map._leaflet;
+        
+        // Add click event listener to the map with clear visual feedback
+        leafletMap.on('click', function(e) {
+            // Get lat/lon from the click event
+            var lat = e.latlng.lat;
+            var lon = e.latlng.lng;
+            
+            // Add a marker to show the selected point
+            var marker = L.marker([lat, lon], {
+                icon: L.divIcon({
+                    className: 'selected-node-marker',
+                    html: '<div style="background-color: red; width: 10px; height: 10px; border-radius: 50%; border: 2px solid white;"></div>'
+                })
+            }).addTo(leafletMap);
+            
+            // Send message to parent window with node selection info
+            window.parent.postMessage({
+                type: 'NODE_SELECTED',
+                data: {
+                    lat: lat,
+                    lon: lon
+                }
+            }, '*');
+            
+            // Show visual feedback about the selection
+            var popup = L.popup()
+                .setLatLng(e.latlng)
+                .setContent('<p>Point selected at ' + lat.toFixed(6) + ', ' + lon.toFixed(6) + '</p>')
+                .openOn(leafletMap);
+                
+            // Optional: Make an API call to get nearby nodes
+            fetch('/api/network/nearby-nodes?lat=' + lat + '&lon=' + lon)
+                .then(response => response.json())
+                .then(data => {
+                    if (data.success && data.nodes.length > 0) {
+                        // Show closest node
+                        var closestNode = data.nodes[0];
+                        L.circleMarker([closestNode.lat, closestNode.lon], {
+                            radius: 8,
+                            color: 'blue',
+                            fillColor: '#3186cc',
+                            fillOpacity: 0.7
+                        }).addTo(leafletMap)
+                        .bindPopup('Selected Node ID: ' + closestNode.id)
+                        .openPopup();
+                    }
+                })
+                .catch(error => console.error('Error fetching nearby nodes:', error));
+        });
+    });
+    </script>
+    """
+    
+    route_map.get_root().html.add_child(folium.Element(click_script))
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp:
+        route_map.save(tmp.name)
+        tmp_filename = tmp.name
+    
+    return send_file(tmp_filename, mimetype='text/html')    
+    
+
+@app.route('/api/network/nodes', methods=['GET'])
+def get_network_nodes():
+    """Get all nodes in the network with their coordinates"""
+    system = initialize_system()
+    G = system["G"]
+    
+    limit = int(request.args.get('limit', 100))
+    nodes_data = []
+    
+    for i, (node_id, data) in enumerate(G.nodes(data=True)):
+        if i >= limit:
+            break
+            
+        nodes_data.append({
+            "id": node_id,
+            "lat": data.get('y'),
+            "lon": data.get('x')
+        })
+    
+    return jsonify({
+        "nodes": nodes_data,
+        "total": len(G.nodes()),
+        "returned": len(nodes_data)
+    })
+
+@app.route('/api/traffic/predict', methods=['POST'])
+def predict_traffic():
+    """Predict traffic conditions based on time"""
+    system = initialize_system()
+    traffic_predictor = system["traffic_predictor"]
+    
+    data = request.json
+    hour = data.get('hour', 12)
+    day_of_week = data.get('day_of_week', 1)  # 0=Monday, 6=Sunday
+    is_weekend = day_of_week >= 5
+    
+    # Predict traffic multipliers
+    traffic_multipliers = traffic_predictor.predict_for_time(hour, day_of_week)
+    
+    # Return only a subset of multipliers to avoid large payloads
+    return jsonify({
+        "hour": hour,
+        "day_of_week": day_of_week,
+        "is_weekend": is_weekend,
+        "traffic_sample": traffic_multipliers[:10].tolist(),  # Convert numpy array to list
+        "average_multiplier": float(np.mean(traffic_multipliers)),
+        "min_multiplier": float(np.min(traffic_multipliers)),
+        "max_multiplier": float(np.max(traffic_multipliers))
+    })
+
+@app.route('/api/congestion/classify', methods=['GET'])
+def get_congestion():
+    """Get road congestion classification"""
+    system = initialize_system()
+    G = system["G"]
+    congestion_risk = system["congestion_risk"]
+    
+    # Convert edge tuples to strings for JSON serialization
+    congestion_data = {}
+    for (u, v), risk in congestion_risk.items():
+        edge_key = f"{u}-{v}"
+        congestion_data[edge_key] = {
+            "risk_level": int(risk),
+            "risk_label": "Low" if risk == 0 else "Medium" if risk == 1 else "High",
+            "from_node": u,
+            "to_node": v
+        }
+    
+    # Count by risk level
+    risk_counts = {
+        "low": sum(1 for r in congestion_risk.values() if r == 0),
+        "medium": sum(1 for r in congestion_risk.values() if r == 1),
+        "high": sum(1 for r in congestion_risk.values() if r == 2)
+    }
+    
+    # Return only a sample of congestion data to avoid large payloads
+    sample_size = min(100, len(congestion_data))
+    sample_keys = random.sample(list(congestion_data.keys()), sample_size)
+    sample_data = {k: congestion_data[k] for k in sample_keys}
+    
+    return jsonify({
+        "congestion_sample": sample_data,
+        "risk_counts": risk_counts,
+        "total_roads": len(congestion_risk)
+    })
+
+@app.route('/api/route/optimize', methods=['POST'])
+def optimize_route():
+    """Optimize a delivery route based on stops and time"""
+    system = initialize_system()
+    G = system["G"]
+    router = system["router"]
+    traffic_predictor = system["traffic_predictor"]
+    congestion_risk = system["congestion_risk"]
+    
+    data = request.json
+    
+    # Get time parameters
+    hour = data.get('hour', 12)
+    day_of_week = data.get('day_of_week', 1)
+    is_weekend = day_of_week >= 5
+    
+    # Get stop parameters
+    depot_id = data.get('depot_id')
+    stop_ids = data.get('stop_ids', [])
+    
+    # If depot_id is not provided, use first node in the graph
+    if depot_id is None:
+        depot_id = list(G.nodes())[0]
+    
+    # If no stops are provided, select random nodes
+    if not stop_ids:
+        nodes = list(G.nodes())
+        if depot_id in nodes:
+            nodes.remove(depot_id)
+        stop_count = min(5, len(nodes))
+        stop_ids = random.sample(nodes, stop_count)
+    
+    # Combine depot and stops
+    all_stops = [depot_id] + stop_ids
+    
+    # Check connectivity and fix if needed
+    if not check_graph_connectivity(G, all_stops):
+        new_stops = []
+        for stop in all_stops:
+            if stop not in G:
+                closest_node = find_nearest_accessible_node(G, stop)
+                if closest_node:
+                    new_stops.append(closest_node)
+            else:
+                new_stops.append(stop)
+        all_stops = new_stops
+    
+    # Update traffic conditions
+    traffic_multipliers = traffic_predictor.predict_for_time(hour, day_of_week)
+    router.update_edge_speeds(traffic_multipliers)
+    
+    # Optimize route
+    route = router.optimize_route(all_stops)
+    
+    if not route:
+        return jsonify({
+            "error": "Failed to find a valid route",
+            "success": False
+        }), 400
+    
+    # Calculate time matrix and details
+    time_matrix = router.calculate_time_matrix(all_stops, hour=hour, is_weekend=is_weekend)
+    
+    # Calculate total time and segment details
+    total_time = 0
+    segments = []
+    
+    for i in range(len(route) - 1):
+        start_node = route[i]
+        end_node = route[i+1]
+        
+        start_idx = all_stops.index(start_node) if start_node in all_stops else i
+        end_idx = all_stops.index(end_node) if end_node in all_stops else i+1
+        
+        segment_time = time_matrix[start_idx][end_idx]
+        
+        # Handle unrealistic travel times as shown in display_route_details from second code
+        if segment_time > 1000:  # Unrealistic travel time
+            start_lat = G.nodes[start_node]['y']
+            start_lon = G.nodes[start_node]['x']
+            end_lat = G.nodes[end_node]['y']  
+            end_lon = G.nodes[end_node]['x']
+            
+            dist_km = ((start_lat - end_lat)**2 + (start_lon - end_lon)**2)**0.5 * 111
+            segment_time = (dist_km / 30) * 60  # Estimate based on distance
+            
+        total_time += segment_time
+        
+        segments.append({
+            "from_node": start_node,
+            "to_node": end_node,
+            "time_minutes": float(segment_time),
+            "cumulative_time": float(total_time)
+        })
+    
+    # Prepare node details
+    nodes_info = []
+    for i, node_id in enumerate(route):
+        if node_id in G.nodes():
+            nodes_info.append({
+                "id": node_id,
+                "lat": float(G.nodes[node_id].get('y', 0)),
+                "lon": float(G.nodes[node_id].get('x', 0)),
+                "is_depot": i == 0,
+                "stop_number": i
+            })
+    
+    return jsonify({
+        "success": True,
+        "route": route,
+        "total_time_minutes": float(total_time),
+        "segments": segments,
+        "nodes": nodes_info,
+        "hour": hour,
+        "day_of_week": day_of_week,
+        "is_weekend": is_weekend
+    })
+
+@app.route('/api/map/route', methods=['POST'])
+def generate_route_map():
+    """Generate an HTML map of the optimized route"""
+    system = initialize_system()
+    G = system["G"]
+    router = system["router"]
+    traffic_predictor = system["traffic_predictor"]
+    congestion_risk = system["congestion_risk"]
+    
+    data = request.json
+    
+    # Get time parameters
+    hour = data.get('hour', 12)
+    day_of_week = data.get('day_of_week', 1)
+    is_weekend = day_of_week >= 5
+    
+    # Get route parameters
+    route = data.get('route')
+    
+    if not route:
+        # If no route is provided, use the optimize_route endpoint logic
+        depot_id = data.get('depot_id')
+        stop_ids = data.get('stop_ids', [])
+        
+        if depot_id is None:
+            depot_id = list(G.nodes())[0]
+        
+        if not stop_ids:
+            nodes = list(G.nodes())
+            if depot_id in nodes:
+                nodes.remove(depot_id)
+            stop_count = min(5, len(nodes))
+            stop_ids = random.sample(nodes, stop_count)
+        
+        all_stops = [depot_id] + stop_ids
+        
+        if not check_graph_connectivity(G, all_stops):
+            new_stops = []
+            for stop in all_stops:
+                if stop not in G:
+                    closest_node = find_nearest_accessible_node(G, stop)
+                    if closest_node:
+                        new_stops.append(closest_node)
+                else:
+                    new_stops.append(stop)
+            all_stops = new_stops
+        
+        traffic_multipliers = traffic_predictor.predict_for_time(hour, day_of_week)
+        router.update_edge_speeds(traffic_multipliers)
+        
+        route = router.optimize_route(all_stops)
+    
+    if not route:
+        return jsonify({
+            "error": "Failed to generate route map",
+            "success": False
+        }), 400
+    
+    all_stops = route  # Use the route as our stops
+    time_matrix = router.calculate_time_matrix(all_stops, hour=hour, is_weekend=is_weekend)
+    
+    # Create map
+    time_period_name = f"Hour_{hour}_{'Weekend' if is_weekend else 'Weekday'}"
+    
+    # Based on the map_type parameter, create different map views
+    map_type = data.get('map_type', 'enhanced')
+    
+    if map_type == 'focused':
+        route_map = create_route_focused_map(G, all_stops, route, time_matrix)
+    else:  # default to enhanced
+        route_map = create_enhanced_route_map(G, all_stops, route, time_period_name, congestion_risk)
+    
+    # Save map to temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp:
+        route_map.save(tmp.name)
+        tmp_filename = tmp.name
+    
+    # Return the HTML file
+    return send_file(tmp_filename, mimetype='text/html')
+
+@app.route('/api/travel-time/predict', methods=['POST'])
+def predict_travel_time():
+    """Predict travel time between two nodes"""
+    system = initialize_system()
+    G = system["G"]
+    travel_predictor = system["travel_predictor"]
+    
+    data = request.json
+    from_node = data.get('from_node')
+    to_node = data.get('to_node')
+    hour = data.get('hour', 12)
+    day_of_week = data.get('day_of_week', 1)
+    is_weekend = day_of_week >= 5
+    
+    if from_node is None or to_node is None:
+        return jsonify({
+            "error": "from_node and to_node are required parameters",
+            "success": False
+        }), 400
+    
+    if from_node not in G or to_node not in G:
+        return jsonify({
+            "error": "One or both nodes not found in the network",
+            "success": False
+        }), 404
+    try:
+        travel_time = travel_predictor.predict_travel_time(from_node, to_node, hour, is_weekend)
+        
+        try:
+            path = nx.shortest_path(G, from_node, to_node, weight="travel_time")
+            
+            distance = 0
+            for i in range(len(path) - 1):
+                u, v = path[i], path[i+1]
+                if 'length' in G[u][v]:
+                    distance += G[u][v]['length']
+            
+            distance_km = distance / 1000
+            
+            path_coords = []
+            for node in path:
+                if node in G.nodes():
+                    path_coords.append({
+                        "lat": float(G.nodes[node].get('y', 0)),
+                        "lon": float(G.nodes[node].get('x', 0))
+                    })
+            
+            return jsonify({
+                "success": True,
+                "from_node": from_node,
+                "to_node": to_node,
+                "travel_time_minutes": float(travel_time),
+                "distance_km": float(distance_km),
+                "path": path,
+                "path_coords": path_coords,
+                "hour": hour,
+                "day_of_week": day_of_week,
+                "is_weekend": is_weekend
+            })
+        
+        except nx.NetworkXNoPath:
+            return jsonify({
+                "success": False,
+                "error": "No path found between the given nodes",
+                "travel_time_minutes": float(travel_time) if travel_time != float('inf') else None
+            }), 404
+    
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@app.route('/api/settings', methods=['GET'])
+def get_settings():
+    """Get system settings and parameters"""
+    return jsonify({
+        "time_periods": [
+            {"label": "Morning Rush (8 AM)", "hour": 8, "day_of_week": 1, "is_weekend": False},
+            {"label": "Mid-day (12 PM)", "hour": 12, "day_of_week": 1, "is_weekend": False},
+            {"label": "Evening Rush (6 PM)", "hour": 18, "day_of_week": 1, "is_weekend": False},
+            {"label": "Night (11 PM)", "hour": 23, "day_of_week": 1, "is_weekend": False},
+            {"label": "Weekend (12 PM)", "hour": 12, "day_of_week": 6, "is_weekend": True}
+        ],
+        "map_types": [
+            {"value": "enhanced", "label": "Enhanced (Full Traffic View)"},
+            {"value": "focused", "label": "Focused (Route Only)"}
+        ],
+        "congestion_levels": [
+            {"value": 0, "label": "Low", "color": "green"},
+            {"value": 1, "label": "Medium", "color": "orange"},
+            {"value": 2, "label": "High", "color": "red"}
+        ]
+    })
+
+@app.route('/api/network/nearby-nodes', methods=['GET'])
+def get_nearby_nodes():
+    """Find nodes near specified coordinates"""
+    system = initialize_system()
+    G = system["G"]
+    
+    lat = float(request.args.get('lat', 0))
+    lon = float(request.args.get('lon', 0))
+    radius = float(request.args.get('radius', 0.001))  # Default radius in coordinate units
+    limit = int(request.args.get('limit', 10))
+    
+    nearby_nodes = []
+    
+    for node_id, data in G.nodes(data=True):
+        if 'y' in data and 'x' in data:
+            dist = ((data['y'] - lat)**2 + (data['x'] - lon)**2)**0.5
+            if dist <= radius:
+                nearby_nodes.append({
+                    "id": node_id,
+                    "lat": float(data['y']),
+                    "lon": float(data['x']),
+                    "distance": float(dist),
+                    "distance_km": float(dist * 111) 
+                })
+    
+    nearby_nodes.sort(key=lambda x: x["distance"])
+    
+    nearby_nodes = nearby_nodes[:limit]
+    
+    return jsonify({
+        "success": True,
+        "query": {
+            "lat": lat,
+            "lon": lon,
+            "radius": radius
+        },
+        "nodes": nearby_nodes,
+        "count": len(nearby_nodes)
+    })
+
+@app.route('/api/network/congestion-hotspots', methods=['GET'])
+def get_congestion_hotspots():
+    """Get the most congested areas in the network"""
+    system = initialize_system()
+    G = system["G"]
+    congestion_risk = system["congestion_risk"]
+    
+    limit = int(request.args.get('limit', 10))
+    
+    high_risk_edges = [(u, v) for (u, v), risk in congestion_risk.items() if risk == 2]
+    
+    node_risk_count = {}
+    for u, v in high_risk_edges:
+        if u in node_risk_count:
+            node_risk_count[u] += 1
+        else:
+            node_risk_count[u] = 1
+            
+        if v in node_risk_count:
+            node_risk_count[v] += 1
+        else:
+            node_risk_count[v] = 1
+    
+    hotspot_nodes = sorted(node_risk_count.items(), key=lambda x: x[1], reverse=True)[:limit]
+    
+    hotspots = []
+    for node_id, risk_count in hotspot_nodes:
+        if node_id in G.nodes():
+            hotspots.append({
+                "id": node_id,
+                "lat": float(G.nodes[node_id].get('y', 0)),
+                "lon": float(G.nodes[node_id].get('x', 0)),
+                "high_risk_road_count": risk_count,
+                "connected_roads": list(G.edges(node_id))[:5]  
+            })
+    
+    return jsonify({
+        "success": True,
+        "hotspots": hotspots,
+        "count": len(hotspots)
+    })
+
+@app.route('/api/system/reload', methods=['POST'])
+def reload_system():
+    """Force reload of the road network and models (admin use)"""
+    global G, edge_ids, traffic_predictor, congestion_classifier, travel_predictor, router, congestion_risk
+    
+    G = None
+    edge_ids = None
+    traffic_predictor = None
+    congestion_classifier = None
+    travel_predictor = None
+    router = None
+    congestion_risk = None
+    
+    system = initialize_system()
+    
+    return jsonify({
+        "success": True,
+        "message": "System reloaded successfully",
+        "network_nodes": len(system["G"].nodes()),
+        "network_edges": len(system["G"].edges())
+    })
+
+@app.route('/api/user-location', methods=['POST'])
+def user_location_selection():
+    """Process user-selected locations for routing"""
+    system = initialize_system()
+    G = system["G"]
+    router = system["router"]
+    travel_predictor = system["travel_predictor"]
+    traffic_predictor = system["traffic_predictor"]
+    congestion_risk = system["congestion_risk"]
+    
+    data = request.json
+    locations = data.get('locations', [])
+    hour = data.get('hour', datetime.now().hour)
+    day_of_week = data.get('day_of_week', datetime.now().weekday())
+    is_weekend = day_of_week >= 5
+    
+    if not locations or len(locations) < 2:
+        return jsonify({
+            "error": "At least 2 locations are required",
+            "success": False
+        }), 400
+    
+    # Find nearest nodes to selected coordinates
+    selected_nodes = []
+    for loc in locations:
+        lat = loc.get('lat')
+        lon = loc.get('lon')
+        if lat is None or lon is None:
+            continue
+            
+        # Find nearest node
+        nearest_node = None
+        min_dist = float('inf')
+        for node_id, data in G.nodes(data=True):
+            if 'y' in data and 'x' in data:
+                dist = ((data['y'] - lat)**2 + (data['x'] - lon)**2)**0.5
+                if dist < min_dist:
+                    min_dist = dist
+                    nearest_node = node_id
+        
+        if nearest_node:
+            selected_nodes.append(nearest_node)
+    
+    if len(selected_nodes) < 2:
+        return jsonify({
+            "error": "Could not map at least 2 locations to network nodes",
+            "success": False
+        }), 400
+    
+    # Update traffic conditions
+    traffic_multipliers = traffic_predictor.predict_for_time(hour, day_of_week)
+    router.update_edge_speeds(traffic_multipliers)
+    
+    route = router.optimize_route(selected_nodes)
+    
+    if not route:
+        return jsonify({
+            "error": "Failed to find a valid route between selected locations",
+            "success": False
+        }), 400
+    
+    time_matrix = router.calculate_time_matrix(selected_nodes, hour=hour, is_weekend=is_weekend)
+    
+    time_period_name = f"User_Selected_Route_{hour}h"
+    route_map = create_enhanced_route_map(G, selected_nodes, route, time_period_name, congestion_risk)
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp:
+        route_map.save(tmp.name)
+        tmp_filename = tmp.name
+    
+    return send_file(tmp_filename, mimetype='text/html')
+
+if __name__ == '__main__':
+    initialize_system()
+    app.run(debug=False, host='0.0.0.0', port=7860)

dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.10-slim
+
+
+WORKDIR /backend
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:app"]

requirements.txt

@@ -0,0 +1,13 @@
+Flask
+flask-cors
+joblib==1.4.2
+numpy==2.0.0
+networkx
+folium
+osmnx
+tensorflow
+ortools
+scikit-learn==1.5.0
+pickle-mixin
+pandas==2.2.2
+gunicorn>=20.1.0

route_optimizer.py

@@ -0,0 +1,717 @@
+import osmnx as ox
+import numpy as np
+import tensorflow as tf
+from ortools.constraint_solver import pywrapcp, routing_enums_pb2
+import folium
+from sklearn.preprocessing import MinMaxScaler
+import random
+from sklearn.ensemble import RandomForestRegressor
+from datetime import datetime, timedelta
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.ensemble import RandomForestClassifier
+import pickle
+import joblib
+import networkx as nx
+import os
+
+ox.settings.use_cache = True  
+ox.settings.log_console = True
+ox.settings.timeout=180
+
+def get_simplified_road_network():
+    """Get only major roads in Chandigarh for cleaner visualization"""
+    try:
+        custom_filter = '["highway"~"primary|secondary|tertiary"]'
+        G = ox.graph_from_place("Chandigarh, India", 
+                                network_type="drive", 
+                                simplify=True,
+                                custom_filter=custom_filter)
+        
+        G = ox.add_edge_speeds(G)  
+        G = ox.add_edge_travel_times(G) 
+        print(f"Road Network successfully loaded with {len(G.nodes)} nodes and {len(G.edges)} edges")
+        
+        sector_17_point = (30.7417, 76.7875)  
+        
+
+        G_simplified = nx.DiGraph()
+        
+        for node, data in G.nodes(data=True):
+            if 'y' in data and 'x' in data:
+                dist = ((data['y'] - sector_17_point[0])**2 + 
+                        (data['x'] - sector_17_point[1])**2)**0.5
+                dist_km = dist * 111  
+                if dist_km <= 2:  
+                    G_simplified.add_node(node, **data)
+        
+        for u, v, data in G.edges(data=True):
+            if G_simplified.has_node(u) and G_simplified.has_node(v):
+                G_simplified.add_edge(u, v, **data)
+        
+        print(f"Simplified road network created with {len(G_simplified.nodes)} nodes")
+        
+        largest_cc = max(nx.weakly_connected_components(G_simplified), key=len)
+        G_simplified = G_simplified.subgraph(largest_cc).copy()
+        
+        print(f"Final connected graph has {len(G_simplified.nodes)} nodes and {len(G_simplified.edges)} edges")
+        return G_simplified
+    
+    except Exception as e:
+        print(f"Error obtaining road network: {str(e)}")
+        return create_synthetic_network()
+
+def create_synthetic_network():
+    """Create a synthetic road network as a fallback"""
+    print("Creating synthetic grid network that resembles Chandigarh's sector layout...")
+    
+    rows, cols = 6, 6
+    G = nx.DiGraph()
+    
+    base_lat, base_lon = 30.72, 76.76  
+    grid_spacing = 0.01  
+    
+    for i in range(rows):
+        for j in range(cols):
+            node_id = i * cols + j
+            lat_offset = random.uniform(-0.0005, 0.0005)
+            lon_offset = random.uniform(-0.0005, 0.0005)
+            
+            G.add_node(node_id, 
+                       y=base_lat + i * grid_spacing + lat_offset, 
+                       x=base_lon + j * grid_spacing + lon_offset) 
+    
+    for i in range(rows):
+        for j in range(cols):
+            node_id = i * cols + j
+            
+            if j < cols - 1:
+                target = i * cols + (j + 1)
+                length = random.uniform(900, 1100) 
+                G.add_edge(node_id, target, 
+                           length=length,
+                           speed_kph=50.0,
+                           highway="secondary",
+                           travel_time=length/1000/50.0*60,
+                           base_speed=50.0)
+                G.add_edge(target, node_id,  
+                           length=length,
+                           speed_kph=50.0,
+                           highway="secondary",
+                           travel_time=length/1000/50.0*60,
+                           base_speed=50.0)
+            
+            if i < rows - 1:
+                target = (i + 1) * cols + j
+                length = random.uniform(900, 1100)  
+                G.add_edge(node_id, target, 
+                           length=length,
+                           speed_kph=50.0,
+                           highway="secondary",
+                           travel_time=length/1000/50.0*60,
+                           base_speed=50.0)
+                G.add_edge(target, node_id,  
+                           length=length,
+                           speed_kph=50.0,
+                           highway="secondary",
+                           travel_time=length/1000/50.0*60,
+                           base_speed=50.0)
+                
+    for i in range(rows - 1):
+        for j in range(cols - 1):
+            if random.random() < 0.3:  
+                node_id = i * cols + j
+                target = (i + 1) * cols + (j + 1)
+                length = random.uniform(1200, 1400)  
+                G.add_edge(node_id, target, 
+                          length=length,
+                          speed_kph=40.0,
+                          highway="tertiary",
+                          travel_time=length/1000/40.0*60,
+                          base_speed=40.0)
+    
+    print(f"Created synthetic grid network with {len(G.nodes)} nodes and {len(G.edges)} edges")
+    return G
+
+
+class MLTrafficPredictor:
+    def __init__(self, edge_ids, num_time_periods=24):
+        self.edge_ids = edge_ids
+        self.model = None
+    
+    def predict_for_time(self, hour, day_of_week):
+        """Predict traffic multipliers for a specific time"""
+        time_features = [
+            hour,
+            day_of_week,
+            1 if hour in [7, 8, 9, 17, 18, 19] else 0,  
+            1 if day_of_week < 5 else 0                
+            ]
+        
+        predictions = self.model.predict([time_features])[0]
+        return predictions
+    
+    def predict_for_time_period(self, time_period):
+        """Compatible with original interface for easy integration"""
+        if time_period == 0:  
+            hour, day = 8, 1  
+        elif time_period == 1:  
+            hour, day = 12, 1  
+        elif time_period == 2: 
+            hour, day = 18, 1  
+        else:  
+            hour, day = 23, 1 
+            
+        return self.predict_for_time(hour, day)
+
+    @staticmethod
+    def load(filepath, edge_ids):
+        predictor = MLTrafficPredictor(edge_ids)
+        predictor.model = joblib.load(filepath)
+        print(f"Traffic prediction model loaded from {filepath}")
+        return predictor
+
+
+class RoadCongestionClassifier:
+    def __init__(self, G):
+        self.G = G
+        self.model = None
+    
+    def classify_roads(self):
+        """Classify all roads by congestion risk"""
+        congestion_risk = {}
+        
+        for u, v, data in self.G.edges(data=True):
+            features = [
+                data.get('length', 0) / 1000,
+                1 if data.get('highway') == 'primary' else 0,
+                1 if data.get('highway') == 'secondary' else 0,
+                1 if data.get('highway') == 'tertiary' else 0,
+                data.get('lanes', 1) if isinstance(data.get('lanes'), int) else 1,
+                1 if 'oneway' in data and data['oneway'] else 0
+            ]
+            
+            risk = self.model.predict([features])[0]
+            congestion_risk[(u, v)] = risk
+            
+        return congestion_risk
+
+    @staticmethod
+    def load(filepath, G):
+        classifier = RoadCongestionClassifier(G)
+        classifier.model = joblib.load(filepath)
+        print(f"Road congestion classifier loaded from {filepath}")
+        return classifier
+
+class TravelTimePredictor:
+    def __init__(self, G):
+        self.G = G
+        self.model = None
+    
+    def predict_travel_time(self, u, v, hour, is_weekend=False):
+        """Predict travel time between two nodes"""
+        if not self.G.has_edge(u, v):
+            return float('inf')
+            
+        data = self.G[u][v]
+        distance = data.get('length', 0) / 1000
+        base_speed = data.get('base_speed', 40.0)
+        
+        features = [
+            distance,
+            base_speed,
+            1 if data.get('highway') == 'primary' else 0,
+            1 if data.get('highway') == 'secondary' else 0,
+            1 if data.get('highway') == 'tertiary' else 0,
+            hour,
+            1 if hour in [7, 8, 9, 17, 18, 19] else 0, 
+            1 if is_weekend else 0
+        ]
+        
+        travel_time = self.model.predict([features])[0]
+        return travel_time
+
+    @staticmethod
+    def load(filepath, G):
+        predictor = TravelTimePredictor(G)
+        predictor.model = joblib.load(filepath)
+        print(f"Travel time prediction model loaded from {filepath}")
+        return predictor
+    
+def user_location_selection_feature(G):
+    center_y = G.nodes[list(G.nodes)[0]]['y']
+    center_x = G.nodes[list(G.nodes)[0]]['x']
+    
+    m = folium.Map(location=[center_y, center_x], zoom_start=13)
+    
+    
+    user_selected_coords = [
+        (30.74, 76.78), 
+        (30.73, 76.77),
+        (30.72, 76.79),
+        # etc.
+    ]
+    
+    selected_nodes = []
+    for lat, lon in user_selected_coords:
+        nearest_node = ox.distance.nearest_nodes(G, lon, lat)
+        selected_nodes.append(nearest_node)
+    
+    depot = selected_nodes[0]
+    all_stops = selected_nodes
+    
+    edge_ids = list(G.edges())
+    traffic_predictor = MLTrafficPredictor.load("traffic_model.pkl", edge_ids)
+    travel_predictor = TravelTimePredictor.load("travel_time_predictor.pkl", G)
+    congestion_classifier = RoadCongestionClassifier.load("congestion_classifier.pkl", G)
+    
+    now = datetime.now()
+    hour = now.hour
+    is_weekend = now.weekday() >= 5  
+    
+    traffic_multipliers = traffic_predictor.predict_for_time(hour, now.weekday())
+    congestion_risk = congestion_classifier.classify_roads()
+    
+    router = EnhancedDynamicRouter(G, edge_ids, travel_predictor)
+    router.update_edge_speeds(traffic_multipliers)
+    
+    route = router.optimize_route(all_stops)
+    
+    time_matrix = router.calculate_time_matrix(all_stops, hour=hour, is_weekend=is_weekend)
+    
+    route_map = create_enhanced_route_map(G, all_stops, route, f"User_Selected_Route_{hour}h", congestion_risk)
+    
+    return route_map
+
+class EnhancedDynamicRouter:
+    def __init__(self, G, edge_ids, travel_predictor):
+        self.G = G
+        self.edge_ids = edge_ids
+        self.travel_predictor = travel_predictor
+        
+    def update_edge_speeds(self, traffic_multipliers):
+        """Update road network with traffic multipliers"""
+        for i, (u, v) in enumerate(self.edge_ids):
+            if i < len(traffic_multipliers) and self.G.has_edge(u, v):
+                self.G[u][v]["current_speed"] = max(5.0, traffic_multipliers[i] * self.G[u][v]["base_speed"])
+                
+    def calculate_time_matrix(self, stops, hour=8, is_weekend=False):
+        """Compute travel time matrix using ML prediction"""
+        time_matrix = np.zeros((len(stops), len(stops)))
+        
+        for i, source in enumerate(stops):
+            for j, target in enumerate(stops):
+                if i != j:
+                    try:
+                        path = nx.shortest_path(self.G, source, target, weight="travel_time")
+                        
+                        travel_time = 0
+                        for idx in range(len(path)-1):
+                            u, v = path[idx], path[idx+1]
+                            segment_time = self.travel_predictor.predict_travel_time(u, v, hour, is_weekend)
+                            travel_time += segment_time
+                            
+                        time_matrix[i][j] = travel_time
+                    except (nx.NetworkXNoPath, nx.NodeNotFound):
+                        print(f"Warning: No path found between stops {i} and {j} (nodes {source} and {target})")
+                        time_matrix[i][j] = 60.0  
+        
+        return time_matrix
+    
+    def optimize_route(self, stops):
+        """Solve VRP using OR-Tools"""
+        time_matrix = self.calculate_time_matrix(stops)
+        
+        manager = pywrapcp.RoutingIndexManager(len(stops), 1, 0)
+        routing = pywrapcp.RoutingModel(manager)
+        
+        def time_callback(from_index, to_index):
+            from_node = manager.IndexToNode(from_index)
+            to_node = manager.IndexToNode(to_index)
+            return int(time_matrix[from_node][to_node] * 1000)  
+        
+        transit_callback_index = routing.RegisterTransitCallback(time_callback)
+        routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
+        
+        search_parameters = pywrapcp.DefaultRoutingSearchParameters()
+        search_parameters.first_solution_strategy = (
+            routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
+        )
+        
+        solution = routing.SolveWithParameters(search_parameters)
+        if solution:
+            return self._extract_route(stops, manager, routing, solution)
+        return None
+    
+    def _extract_route(self, stops, manager, routing, solution):
+        index = routing.Start(0)
+        route = []
+        while not routing.IsEnd(index):
+            node = manager.IndexToNode(index)
+            route.append(stops[node])
+            index = solution.Value(routing.NextVar(index))
+        route.append(stops[manager.IndexToNode(index)])
+        return route
+
+def check_graph_connectivity(G, stops):
+    """Verify that all stops are reachable from each other"""
+    problems = []
+    
+    for i, source in enumerate(stops):
+        for j, target in enumerate(stops):
+            if i != j:
+                try:
+                    path = nx.shortest_path(G, source, target)
+                except (nx.NetworkXNoPath, nx.NodeNotFound):
+                    problems.append((i, j, source, target))
+    
+    if problems:
+        print("WARNING: The following stop pairs are not connected in the graph:")
+        for i, j, source, target in problems:
+            print(f"  - Stop {i} (Node {source}) to Stop {j} (Node {target})")
+        
+        print("\nPossible solutions:")
+        print("1. Check if these nodes exist in the graph")
+        print("2. Ensure the graph is fully connected")
+        print("3. Pick alternative nearby locations for problematic stops")
+        
+        return False
+    
+    return True
+
+def find_nearest_accessible_node(G, original_node, max_distance=0.001):
+    """Find the nearest node that is well-connected to the network"""
+    if not G.has_node(original_node):
+        print(f"Node {original_node} not found in graph!")
+        return None
+    
+    orig_y = G.nodes[original_node]['y']
+    orig_x = G.nodes[original_node]['x']
+    
+    largest_cc = max(nx.weakly_connected_components(G), key=len)
+    
+    connected_nodes = []
+    for node in largest_cc:
+        if node == original_node:
+            continue  
+            
+        node_y = G.nodes[node]['y']
+        node_x = G.nodes[node]['x']
+        
+        dist = ((node_y - orig_y)**2 + (node_x - orig_x)**2)**0.5
+        connected_nodes.append((node, dist))
+    
+    connected_nodes.sort(key=lambda x: x[1])
+    
+    for node, dist in connected_nodes:
+        if dist <= max_distance:
+            print(f"Found alternative for {original_node}: {node} at distance {dist*111:.2f} km")
+            return node
+    
+    if connected_nodes:
+        closest_node, dist = connected_nodes[0]
+        print(f"WARNING: Closest alternative to {original_node} is {closest_node} at {dist*111:.2f} km away")
+        return closest_node
+    
+    return None
+
+def create_enhanced_route_map(G, stops, route, time_period_name, congestion_risk):   
+    center_y = G.nodes[list(G.nodes)[0]]['y']  
+    center_x = G.nodes[list(G.nodes)[0]]['x']  
+    
+    m = folium.Map(location=[center_y, center_x], zoom_start=13)
+    
+    for u, v, data in G.edges(data=True):
+        u_y = G.nodes[u].get('y', 0)
+        u_x = G.nodes[u].get('x', 0)
+        v_y = G.nodes[v].get('y', 0)
+        v_x = G.nodes[v].get('x', 0)
+        
+        risk = congestion_risk.get((u, v), 0)
+        
+        if risk == 0:
+            color = "green" 
+            weight = 3
+        elif risk == 1:
+            color = "orange" 
+            weight = 4
+        else:
+            color = "red"  
+            weight = 5
+        
+        popup = f"""
+        <b>Road Type:</b> {data.get('highway', 'Unknown')}<br>
+        <b>Current Speed:</b> {data.get('current_speed', 0):.1f} km/h<br>
+        <b>Base Speed:</b> {data.get('base_speed', 0):.1f} km/h<br>
+        <b>ML Congestion Risk:</b> {"Low" if risk == 0 else "Medium" if risk == 1 else "High"}<br>
+        <b>Congestion:</b> {(1-data.get('current_speed', 0)/data.get('base_speed', 1))*100:.1f}%
+        """
+        
+        folium.PolyLine(
+            locations=[(u_y, u_x), (v_y, v_x)],
+            color=color,
+            weight=weight,
+            opacity=0.7,
+            popup=popup
+        ).add_to(m)
+    
+    for i, node in enumerate(stops):
+        node_y = G.nodes[node]['y']
+        node_x = G.nodes[node]['x']
+        
+        if i == 0:  
+            folium.Marker(
+                location=[node_y, node_x],
+                tooltip="Depot",
+                popup="<b>Depot</b><br>Starting point for delivery route",
+                icon=folium.Icon(color="green", icon="home")
+            ).add_to(m)
+        else:  
+            folium.Marker(
+                location=[node_y, node_x],
+                tooltip=f"Delivery Stop {i}",
+                popup=f"<b>Delivery Stop {i}</b>",
+                icon=folium.Icon(color="blue", icon="info-sign")
+            ).add_to(m)
+    
+    if route:
+        route_coords = []
+        for node in route:
+            point = [G.nodes[node]['y'], G.nodes[node]['x']]
+            route_coords.append(point)
+        
+        route_line = folium.PolyLine(
+            locations=route_coords,
+            color="purple",
+            weight=4,
+            opacity=0.8,
+            popup="Optimized Delivery Route"
+        ).add_to(m)
+        
+        for i in range(len(route_coords) - 1):
+            midpoint = [(route_coords[i][0] + route_coords[i+1][0]) / 2,
+                       (route_coords[i][1] + route_coords[i+1][1]) / 2]
+            
+            folium.RegularPolygonMarker(
+                location=midpoint,
+                number_of_sides=3,
+                radius=6,
+                rotation=45,
+                color="purple",
+                fill_color="purple",
+                fill_opacity=0.7,
+                popup=f"Segment {i+1}"
+            ).add_to(m)
+    
+    title_html = f'''
+        <div style="position: fixed; top: 10px; left: 50%; transform: translateX(-50%); 
+                   z-index:9999; font-size:18px; background-color:white; padding:10px;
+                   border-radius:5px; box-shadow: 0 0 5px rgba(0,0,0,0.3);">
+            <h3 style="margin:0;">Optimized Delivery Route - {time_period_name}</h3>
+        </div>
+    '''
+    
+    legend_html = '''
+    <div style="position: fixed; bottom: 50px; left: 50px; width: 200px; 
+               background-color:white; padding:10px; border-radius:5px;
+               box-shadow: 0 0 5px rgba(0,0,0,0.3); z-index:9999; font-size:12px;">
+        <h4 style="margin-top:0;">Legend</h4>
+        <div><span style="color:green; font-size:16px;">━━</span> Light Traffic (< 10% slowdown)</div>
+        <div><span style="color:orange; font-size:16px;">━━</span> Moderate Traffic (10-30% slowdown)</div>
+        <div><span style="color:red; font-size:16px;">━━</span> Heavy Traffic (> 30% slowdown)</div>
+        <div><span style="color:purple; font-size:16px;">━━</span> Optimized Route</div>
+        <div><span style="color:green;">●</span> Depot</div>
+        <div><span style="color:blue;">●</span> Delivery Stops</div>
+    </div>
+    '''
+    
+    m.get_root().html.add_child(folium.Element(title_html))
+    m.get_root().html.add_child(folium.Element(legend_html))
+    
+    return m
+def get_or_load_road_network():
+    """Get road network from cache or download if not available"""
+    GRAPH_CACHE_FILE = 'saved_maps/chandigarh_network.pkl'
+    
+    # Create directory if it doesn't exist
+    os.makedirs('saved_maps', exist_ok=True)
+    
+    # Try to load cached graph
+    if os.path.exists(GRAPH_CACHE_FILE):
+        try:
+            print(f"Loading road network from {GRAPH_CACHE_FILE}")
+            with open(GRAPH_CACHE_FILE, 'rb') as f:
+                G = pickle.load(f)
+            print(f"Loaded road network with {len(G.nodes)} nodes and {len(G.edges)} edges")
+            return G
+        except Exception as e:
+            print(f"Error loading cached road network: {str(e)}")
+    
+    # Download and create new graph
+    print("Downloading road network...")
+    G = get_simplified_road_network()
+    
+    # Save for future use
+    try:
+        print(f"Saving road network to {GRAPH_CACHE_FILE}")
+        with open(GRAPH_CACHE_FILE, 'wb') as f:
+            pickle.dump(G, f)
+    except Exception as e:
+        print(f"Error saving road network: {str(e)}")
+    
+    return G
+
+def create_route_focused_map(G, stops, route, time_matrix):
+    """Create a map focused just on the optimal route with time estimates"""
+    center_y = G.nodes[route[0]]['y']
+    center_x = G.nodes[route[0]]['x']
+    
+    m = folium.Map(location=[center_y, center_x], zoom_start=13)
+    
+    total_time = 0
+    
+    for i in range(len(route) - 1):
+        start_node = route[i]
+        end_node = route[i+1]
+        
+        start_idx = route.index(start_node)
+        end_idx = route.index(end_node)
+        
+        segment_time = time_matrix[start_idx][end_idx]
+        total_time += segment_time
+        
+        start_y = G.nodes[start_node]['y']
+        start_x = G.nodes[start_node]['x']
+        end_y = G.nodes[end_node]['y']
+        end_x = G.nodes[end_node]['x']
+        
+        popup_text = f"""
+        <b>Segment {i+1}:</b> Stop {i} → Stop {i+1}<br>
+        <b>Travel Time:</b> {segment_time:.1f} minutes<br>
+        <b>Running Total:</b> {total_time:.1f} minutes
+        """
+        
+        folium.PolyLine(
+            locations=[(start_y, start_x), (end_y, end_x)],
+            color="blue",
+            weight=5,
+            opacity=0.8,
+            popup=popup_text
+        ).add_to(m)
+        
+        midpoint = [(start_y + end_y) / 2, (start_x + end_x) / 2]
+        folium.RegularPolygonMarker(
+            location=midpoint,
+            number_of_sides=3,
+            radius=6,
+            rotation=45,
+            color="blue",
+            fill_color="blue",
+            fill_opacity=0.7
+        ).add_to(m)
+    
+    for i, node in enumerate(route):
+        node_y = G.nodes[node]['y']
+        node_x = G.nodes[node]['x']
+        
+        if i == 0:
+            popup_text = "<b>Depot</b><br>Starting Point"
+            icon = folium.Icon(color="green", icon="home")
+        else:
+            cumulative_time = sum(time_matrix[route.index(route[j])][route.index(route[j+1])] 
+                                 for j in range(i))
+            popup_text = f"""
+            <b>Stop {i}</b><br>
+            <b>Estimated Arrival:</b> {cumulative_time:.1f} minutes from start
+            """
+            icon = folium.Icon(color="red", icon="info-sign")
+        
+        folium.Marker(
+            location=[node_y, node_x],
+            tooltip=f"Stop {i}",
+            popup=popup_text,
+            icon=icon
+        ).add_to(m)
+    
+    title_html = f'''
+        <div style="position: fixed; top: 10px; left: 50%; transform: translateX(-50%); 
+                   z-index:9999; font-size:18px; background-color:white; padding:10px;
+                   border-radius:5px; box-shadow: 0 0 5px rgba(0,0,0,0.3);">
+            <h3 style="margin:0;">Optimized Delivery Route</h3>
+            <div style="text-align:center; margin-top:5px; font-weight:bold;">
+                Total Time: {total_time:.1f} minutes
+            </div>
+        </div>
+    '''
+    
+    m.get_root().html.add_child(folium.Element(title_html))
+    
+    return m
+
+def add_base_speeds_to_graph(G):
+    """Add base_speed attribute to all edges if it doesn't exist"""
+    print("Adding base speeds to graph edges...")
+    for u, v, data in G.edges(data=True):
+        if 'speed_kph' in data:
+            data['base_speed'] = data['speed_kph']
+        elif 'maxspeed' in data and data['maxspeed'] is not None:
+            try:
+                speed_str = data['maxspeed'].split()[0]
+                speed = float(speed_str)
+                if 'mph' in data['maxspeed']:
+                    speed = speed * 1.60934
+                data['base_speed'] = speed
+            except (ValueError, IndexError):
+                data['base_speed'] = 40.0  
+        else:
+            if data.get('highway') == 'primary':
+                data['base_speed'] = 50.0
+            elif data.get('highway') == 'secondary':
+                data['base_speed'] = 40.0
+            elif data.get('highway') == 'tertiary':
+                data['base_speed'] = 30.0
+            else:
+                data['base_speed'] = 40.0  
+    
+    print("Base speeds added to all edges")
+    return G
+
+def display_route_details(G, route, time_matrix):
+    """Display the optimal route and estimated arrival times clearly"""
+    total_time = 0
+    print("\n===== OPTIMIZED DELIVERY ROUTE =====")
+    print(f"Starting from depot at Node {route[0]}")
+    
+    for i in range(1, len(route)):
+        prev_stop = route[i-1]
+        curr_stop = route[i]
+        
+        prev_idx = route.index(prev_stop)
+        curr_idx = route.index(curr_stop)
+        
+        segment_time = time_matrix[prev_idx][curr_idx]
+        
+        if segment_time > 1000:  
+            print(f"\nWARNING: Unrealistic travel time detected for segment {i-1} to {i}")
+            print(f"Stop {i}: Node {curr_stop}")
+            print(f"  Travel time calculation error - please check connectivity")
+            prev_lat = G.nodes[prev_stop]['y']
+            prev_lon = G.nodes[prev_stop]['x']
+            curr_lat = G.nodes[curr_stop]['y']  
+            curr_lon = G.nodes[curr_stop]['x']
+            
+            dist_km = ((prev_lat - curr_lat)**2 + (prev_lon - curr_lon)**2)**0.5 * 111
+            
+            estimated_time = (dist_km / 30) * 60
+            print(f"  Estimated travel time based on distance: {estimated_time:.1f} minutes")
+            
+            total_time += estimated_time
+        else:
+            total_time += segment_time
+            print(f"\nStop {i}: Node {curr_stop} ({G.nodes[curr_stop]['y']:.4f}, {G.nodes[curr_stop]['x']:.4f})")
+            print(f"  Travel from previous stop: {segment_time:.1f} minutes")
+            print(f"  Cumulative travel time: {total_time:.1f} minutes")
+    
+    print(f"\nTotal route time: {total_time:.1f} minutes")
+    print("==================================")
+    
+    return total_time

saved_maps/chandigarh_network.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8708e7a3cc12107943c48a0b0f923a7834209e965d3dbf2fec8b3bb9187cff71
+size 104727

saved_models/congestion_classifier.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45048a5e01617b0f1340c0c070d38d818b4d2ba22f68be899217dfbe6265eb8f
+size 1458529

saved_models/congestion_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ae576914985bf6548fa641d2c12d6b0a1759da801af9ef51071a1e74be3d952
+size 1505505

saved_models/time_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b44047f31eb859e4c9aa55c2b8498c643f9d82d8409c828a45130ebbe6c85f2b
+size 195080

saved_models/traffic_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fdcdf1ea909407065aa1443bf96115a6a6336f2e7bb2fc58ef89f1d5d4493c41
+size 73876329

saved_models/traffic_predictor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1186100cc20940e0a7535ad241137ee39aa01f536f163e12f5476910fbbecfb2
+size 73876329

saved_models/travel_time_predictor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca888201b6c230b286aa89fcc7a11dd21a1302777df07aa2dacf413bc0694a6e
+size 189468

wsgi.py

@@ -0,0 +1,18 @@
+import os
+import sys
+
+if not os.path.exists('route_optimizer.py'):
+    print("Error: route_optimizer.py file not found!")
+    print("Please save your original code as 'route_optimizer.py' before running this application.")
+    sys.exit(1)
+import app
+
+if __name__ == '__main__':
+    print("Starting Route Optimization API Server...")
+    
+    from app import app, initialize_system
+    print("Initializing route optimization system...")
+    system = initialize_system()
+    print(f"System initialized with {len(system['G'].nodes())} nodes and {len(system['G'].edges())} edges")
+    
+    app.run()