Refactor flight route UI and main script

Old/flight_route_ui.py

@@ -1,67 +0,0 @@
-import gradio as gr
-import pandas as pd
-from Old.optimizer import *
-from weather import *
-from flight_distance import *  # Assuming this function is defined in your aircraft capabilities module
-
-# Load airport data and aircraft data from CSV files
-airport_df = pd.read_csv(r'airport.csv')  # Adjust the path to your CSV file
-aircraft_df = pd.read_csv(r'aircraft.csv')  # Adjust the path to your CSV file
-
-# Create a combined option list with both IATA codes and airport names
-airport_options = [f"{row['IATA']} - {row['Airport_Name']}" for _, row in airport_df.iterrows()]
-
-# Ensure the correct column is used for aircraft types
-aircraft_type_column = 'Aircraft'  # Adjust if your column name is different
-if aircraft_type_column not in aircraft_df.columns:
-    raise ValueError(f"Column '{aircraft_type_column}' not found in aircraft_types.csv. Available columns: {aircraft_df.columns}")
-
-aircraft_options = aircraft_df[aircraft_type_column].tolist()
-
-# Function to determine if a route can be flown
-def check_route(airport_selections, aircraft_type):
-    # Extract IATA codes from the selected options
-    airports = [selection.split(" - ")[0] for selection in airport_selections]
-    
-    # Get coordinates for selected airports as a dictionary {IATA: (latitude, longitude)}
-    lat_long_dict = get_airport_lat_long(airports)  # Ensure this function returns a dictionary in the expected format
-    
-    # Pass only the required details in the expected format for the weather function
-    raw_weather = fetch_weather_for_all_routes(airports, lat_long_dict)  # This should receive the correct lat_long_dict
-    
-    # Extract route factors (e.g., conditions impacting the route)
-    route_factors = extract_route_factors(raw_weather)
-
-    # Calculate distances between selected airports
-    trip_distance = calculate_distances(airports)
-
-    # Ensure the graph is bidirectional
-    for (a, b), dist in list(trip_distance.items()):
-        trip_distance[(b, a)] = dist
-
-    # Find the optimal route
-    optimal_route, optimal_distance = find_optimal_route(airports, trip_distance, route_factors)
-
-    # Check if the aircraft can fly the route without refueling
-    result = can_fly_route(aircraft_type, airports)
-
-    # Convert all dictionary keys to strings for JSON compatibility
-    return {
-        "Optimal Route": " -> ".join(optimal_route) + f" -> {optimal_route[0]}",
-        "Total Round Trip Distance": str(optimal_distance),  # Convert to string if necessary
-        "Can Fly Route": str(result)  # Convert to string if necessary
-    }
-
-# Gradio Interface
-with gr.Blocks() as demo:
-    gr.Markdown("## Airport Route Feasibility Checker")
-    airport_selector = gr.Dropdown(airport_options, multiselect=True, label="Select Airports (IATA - Name)")
-    aircraft_selector = gr.Dropdown(aircraft_options, label="Select Aircraft Type")
-    check_button = gr.Button("Check Route Feasibility")
-    
-    result_output = gr.JSON(label="Result")
-
-    check_button.click(fn=check_route, inputs=[airport_selector, aircraft_selector], outputs=result_output)
-
-# Launch the Gradio app
-demo.launch()

Old/main.py

@@ -1,36 +0,0 @@
-import pandas as pd
-from flight_distance import *
-from Old.optimizer import *
-from weather import *
-
-airport_identifiers = ['CCU', 'CDG', 'SIN']  # Replace with actual identifiers
-
-#Get Airport Coordinates
-lat_long_dict = get_airport_lat_long(airport_identifiers)
-# print("Coordinates: \n",lat_long_dict)
-
-#Get Distance between each node (airports)
-trip_distance = calculate_distances(airport_identifiers)
-# print("Distance b/w Airports: \n",trip_distance)
-
-#Get onroute weather
-raw_weather = fetch_weather_for_all_routes(airport_identifiers, lat_long_dict)
-route_factors = extract_route_factors(raw_weather)
-# print("On Route weather: \n", raw_weather)
-
-# # Ensure the graph is bidirectional (undirected)
-for (a, b), dist in list(trip_distance.items()):
-    trip_distance[(b, a)] = dist
-
-# Find the optimal route with the new cost metric
-optimal_route, optimal_distance = find_optimal_route(airport_identifiers, trip_distance, route_factors)
-
-# Display the optimal route and the total adjusted distance/cost
-print("Optimal Route:", " -> ".join(optimal_route) + f" -> {optimal_route[0]}")
-print("Total Round Trip Distance:", optimal_distance)
-
-aircraft_type = "Airbus A350-900"
-
-# Check if the aircraft can fly the route without refuel
-result = can_fly_route(aircraft_type, airport_identifiers)
-print(result)

Old/optimizer.py

@@ -1,103 +0,0 @@
-import itertools
-
-def extract_route_factors(raw_weather):
-    """
-    Extracts route factors from raw weather data by breaking down routes into individual segments.
-
-    Parameters:
-    - raw_weather (dict): The raw weather data with routes and corresponding weather details.
-
-    Returns:
-    - dict: A dictionary with segments as keys (in tuple format) and a list of weather and temperature data.
-    """
-    route_factors = {}
-    for route, segments in raw_weather.items():
-        for segment in segments:
-            segment_key = tuple(segment['segment'].split(' -> '))
-            if segment_key not in route_factors:
-                route_factors[segment_key] = []
-            route_factors[segment_key].append({
-                'weather': segment['weather'],
-                'temperature': segment['temperature']
-            })
-    return route_factors
-
-def weather_risk(weather):
-    risk_factors = {
-        "clear sky": 0.1,
-        "few clouds": 0.2,
-        "scattered clouds": 0.3,
-        "broken clouds": 0.4,
-        "overcast clouds": 0.5,
-        "light rain": 0.6,
-        "rain": 0.7,
-        "storm": 0.9
-    }
-    return risk_factors.get(weather, 0.5)  # Default risk factor if not listed
-
-# Function to normalize temperature impact
-def temperature_impact(temperature):
-    # Assuming ideal temperature for fuel efficiency is around 20-25°C
-    if temperature < 20 or temperature > 25:
-        return abs(temperature - 22.5) / 30  # Normalize to a value between 0 and 1
-    return 0.1  # Low impact in the ideal range
-
-# Calculate the adjusted cost for each route segment
-def calculate_adjusted_cost(segment, base_distance, route_factors):
-    # Handle both directions of the segment
-    if segment in route_factors:
-        factors = route_factors[segment]
-    elif (segment[1], segment[0]) in route_factors:
-        factors = route_factors[(segment[1], segment[0])]
-    else:
-        raise ValueError(f"Segment {segment} not found in route factors.")
-
-    # Aggregate weather and temperature data if there are multiple entries for the segment
-    weather_descriptions = [factor["weather"] for factor in factors]
-    temperatures = [factor["temperature"] for factor in factors]
-
-    most_common_weather = max(set(weather_descriptions), key=weather_descriptions.count)
-    avg_temperature = sum(temperatures) / len(temperatures)
-    
-    weather_cost = weather_risk(most_common_weather) * 100  # Weight for weather impact
-    temperature_cost = temperature_impact(avg_temperature) * 50  # Weight for temperature impact
-    
-    total_cost = base_distance + weather_cost + temperature_cost
-    return total_cost
-
-# Update the distance function to include additional factors
-def calculate_route_distance(route, distances, route_factors):
-    """Calculate the total cost for a given route, including additional factors."""
-    total_distance = 0
-    for i in range(len(route) - 1):
-        segment = (route[i], route[i + 1])
-        if segment not in distances:
-            segment = (route[i + 1], route[i])
-        base_distance = distances[segment]
-        total_distance += calculate_adjusted_cost(segment, base_distance, route_factors)
-    
-    # Add distance to return to the starting point
-    last_segment = (route[-1], route[0])
-    if last_segment not in distances:
-        last_segment = (route[0], route[-1])
-    base_distance = distances[last_segment]
-    total_distance += calculate_adjusted_cost(last_segment, base_distance, route_factors)
-    
-    return total_distance
-
-def find_optimal_route(airports, distances, route_factors):
-    """Find the optimal route that covers all airports."""
-    best_route = None
-    min_distance = float('inf')
-
-    # Generate all possible permutations of the route
-    for route in itertools.permutations(airports):
-        try:
-            current_distance = calculate_route_distance(route, distances, route_factors)
-            if current_distance < min_distance:
-                min_distance = round(current_distance,2)
-                best_route = route
-        except ValueError as e:
-            print(e)  # Log the error to debug missing segments
-
-    return best_route, min_distance

README.md

@@ -12,6 +12,8 @@ license: mit
 
 # Flight Route Optimization
 
+## Check out the demo here -  [HuggingFace Space](https://huggingface.co/spaces/souvik0306/Flight_Route_Planner)
+
 ## Overview
 
 This project focuses on optimizing flight routes to minimize travel time and costs using advanced algorithms and data analysis techniques.
@@ -20,8 +22,6 @@ This project focuses on optimizing flight routes to minimize travel time and cos
 
 - Efficient route calculation
 - Cost optimization
-- Real-time data integration
-- User-friendly interface
 
 ## Installation
 
@@ -42,9 +42,7 @@ This project focuses on optimizing flight routes to minimize travel time and cos
 
 1. Run the main script:
    ```bash
-   python main.py
+   python app.py
    ```
-2. Follow the on-screen instructions to input your flight details.
-
-
+2. Check out the [live demo](https://huggingface.co/spaces/souvik0306/Flight_Route_Planner) to see the project in action.
 ---

app.py

@@ -16,101 +16,39 @@ aircraft_type_column = 'Aircraft'
 aircraft_options = aircraft_df[aircraft_type_column].tolist()
 
 def check_route(airport_selections, aircraft_type):
-    # Extract IATA codes from the selected options
     airports = [selection.split(" - ")[0] for selection in airport_selections]
-    
-    # Step 1: Get Airport Coordinates
     lat_long_dict = get_airport_lat_long(airports)
-    
-    # Step 2: Calculate Distances between each node (airports)
     trip_distance = calculate_distances(airports)
-    
-    # Step 3: Get on-route weather
     raw_weather = fetch_weather_for_all_routes(airports, lat_long_dict)
     route_factors = extract_route_factors(raw_weather)
     
-    # Step 4: Ensure the graph is bidirectional (undirected)
     for (a, b), dist in list(trip_distance.items()):
         trip_distance[(b, a)] = dist
     
-    # Step 5: Find the optimal route based on weather, temperature, and distance
     optimal_route, optimal_distance = find_optimal_route(airports, trip_distance, route_factors)
-    
-    # Step 6: Fetch Aircraft Details
     aircraft_specs = get_aircraft_details(aircraft_type)
     
-    # Check if aircraft details were retrieved successfully
     if isinstance(aircraft_specs, str):
-        return {"Error": aircraft_specs}, ""  # Return error message if aircraft not found
-    
-    # Step 7: Check if the aircraft can fly the route
-    route_feasibility = check_route_feasibility(optimal_route, trip_distance, aircraft_specs)
-    
-    # Collect sectors needing refuel
-    refuel_sectors = set()  # Track sectors that require refueling
-    sector_details = []
-    refuel_required = False  # Flag to track if refueling is required
-    
-    for i in range(len(optimal_route) - 1):
-        segment = (optimal_route[i], optimal_route[i + 1])
-        segment_distance = trip_distance.get(segment) or trip_distance.get((segment[1], segment[0]))
-        
-        # Calculate fuel and time for this sector
-        fuel, time = calculate_fuel_and_time_for_segment(segment_distance, aircraft_specs)
-        sector_info = {
-            "Sector": f"{optimal_route[i]} -> {optimal_route[i+1]}",
-            "Fuel Required (kg)": round(fuel, 2),
-            "Flight Time (hrs)": round(time, 2)
-        }
-        
-        # Check if refueling is required for this sector
-        if fuel > aircraft_specs['Max_Fuel_Capacity_kg']:
-            sector_info["Refuel Required"] = "Yes"
-            refuel_sectors.add((optimal_route[i], optimal_route[i + 1]))  # Add to refuel sectors
-            refuel_required = True
-        else:
-            sector_info["Refuel Required"] = "No"
-        
-        sector_details.append(sector_info)
-
-    # Check the final leg (return to the starting point)
-    last_segment = (optimal_route[-1], optimal_route[0])
-    last_segment_distance = trip_distance.get(last_segment) or trip_distance.get((last_segment[1], last_segment[0]))
-    fuel, time = calculate_fuel_and_time_for_segment(last_segment_distance, aircraft_specs)
-    
-    # Add final leg details
-    final_leg_info = {
-        "Sector": f"{optimal_route[-1]} -> {optimal_route[0]}",
-        "Fuel Required (kg)": round(fuel, 2),
-        "Flight Time (hrs)": round(time, 2)
-    }
-    
-    if fuel > aircraft_specs['Max_Fuel_Capacity_kg']:
-        final_leg_info["Refuel Required"] = "Yes"
-        refuel_sectors.add((optimal_route[-1], optimal_route[0]))  # Add final leg to refuel sectors
-        refuel_required = True
-    else:
-        final_leg_info["Refuel Required"] = "No"
-    
-    sector_details.append(final_leg_info)
+        return {"Error": aircraft_specs}, ""
     
-    # Step 8: Create the route map with refuel sectors highlighted
-    map_html = create_route_map(airports_dict, lat_long_dict, optimal_route, refuel_sectors)
+    feasibility_result = check_route_feasibility(optimal_route, trip_distance, aircraft_specs)
+    map_html = create_route_map(airports_dict, lat_long_dict, optimal_route, feasibility_result["Refuel Sectors"])
     
-    # Step 9: Prepare and return result
-    if refuel_required:
+    if feasibility_result["Can Fly Entire Route"]:
         result = {
             "Optimal Route": " -> ".join(optimal_route) + f" -> {optimal_route[0]}",
-            "Total Round Trip Distance": str(optimal_distance) + " km",
-            "Can Fly Each Sector": "No, refueling required in one or more sectors.",
-            "Sector Details": sector_details
+            "Total Round Trip Distance": f"{optimal_distance} km",
+            "Total Fuel Required": feasibility_result["Total Fuel Required (kg)"],
+            "Total Flight Time": feasibility_result["Total Flight Time (hrs)"],
+            "Can Fly Entire Route": "Yes",
+            "Sector Details": feasibility_result["Sector Details"]
         }
     else:
         result = {
             "Optimal Route": " -> ".join(optimal_route) + f" -> {optimal_route[0]}",
-            "Total Round Trip Distance": str(optimal_distance) + " km",
-            "Can Fly Each Sector": "Yes, no refueling required.",
-            "Sector Details": sector_details
+            "Total Round Trip Distance": f"{optimal_distance} km",
+            "Can Fly Entire Route": "No, refueling required in one or more sectors.",
+            "Sector Details": feasibility_result["Sector Details"]
         }
     
     return result, map_html
@@ -125,14 +63,18 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
             airport_selector = gr.Dropdown(airport_options, multiselect=True, label="Select Airports (IATA - Name)")
             aircraft_selector = gr.Dropdown(aircraft_options, label="Select Aircraft Type")
             check_button = gr.Button("Check Route Feasibility")
-            result_output = gr.JSON(label="Result")
+            result_output = gr.JSON(label="Feasibility Result (Route, Fuel, Refueling Info)")
         
         with gr.Column():
             gr.Markdown("## Route Map")
-            map_output = gr.HTML(label="Route Map")
+            map_output = gr.HTML(label="Interactive Route Map with Refueling Sectors")
 
     # Connect the button click to the check_route function
-    check_button.click(fn=check_route, inputs=[airport_selector, aircraft_selector], outputs=[result_output, map_output])
+    check_button.click(
+        fn=check_route, 
+        inputs=[airport_selector, aircraft_selector], 
+        outputs=[result_output, map_output]
+    )
 
 # Launch the Gradio app
 demo.launch()

doc.md

@@ -1,38 +0,0 @@
-# Flight Route Optimization
-
-## Overview
-
-This project focuses on optimizing flight routes to minimize travel time and costs using advanced algorithms and data analysis techniques.
-
-## Features
-
-- Efficient route calculation
-- Cost optimization
-- Real-time data integration
-- User-friendly interface
-
-## Installation
-
-1. Clone the repository:
-   ```bash
-   git clone https://github.com/yourusername/Flight_Route_Optimization.git
-   ```
-2. Navigate to the project directory:
-   ```bash
-   cd Flight_Route_Optimization
-   ```
-3. Install the required dependencies:
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-## Usage
-
-1. Run the main script:
-   ```bash
-   python main.py
-   ```
-2. Follow the on-screen instructions to input your flight details.
-
-
----

map_generator.py

@@ -57,8 +57,8 @@ def create_route_map(airports, lat_long_dict, optimal_route, refuel_sectors):
      bottom: 50px; left: 50px; width: 250px; height: 90px; 
      background-color: white; border:2px solid grey; z-index:9999; font-size:14px;">
      &nbsp; <strong>Legend</strong><br>
-     &nbsp; <i class="fa fa-circle" style="color:red"></i> Solid line: No refuel required<br>
-     &nbsp; <i class="fa fa-circle--" style="color:red"></i> Dotted line: Refuel required
+     &nbsp; <i class="fa fa-minus" style="color:red"></i> Solid line: No refuel required<br>
+     &nbsp; <i class="fa fa-ellipsis-h" style="color:red"></i> Dotted line: Refuel required
      </div>
     '''
     route_map.get_root().html.add_child(folium.Element(legend_html))

optimize.py

@@ -2,9 +2,6 @@ import itertools
 from flight_distance import *
 
 def extract_route_factors(raw_weather):
-    """
-    Extract weather and temperature factors for each route segment.
-    """
     route_factors = {}
     for route, segments in raw_weather.items():
         for segment in segments:
@@ -17,32 +14,20 @@ def extract_route_factors(raw_weather):
             })
     return route_factors
 
-
 def weather_risk(weather):
-    """
-    Return the risk factor associated with weather conditions.
-    """
     risk_factors = {
         "clear sky": 0.1, "few clouds": 0.2, "scattered clouds": 0.3,
         "broken clouds": 0.4, "overcast clouds": 0.5, "light rain": 0.6,
         "rain": 0.7, "storm": 0.9
     }
-    return risk_factors.get(weather, 0.5)  # Default risk factor
-
+    return risk_factors.get(weather, 0.5)
 
 def temperature_impact(temperature):
-    """
-    Calculate the impact of temperature on fuel efficiency.
-    """
     if temperature < 20 or temperature > 25:
-        return abs(temperature - 22.5) / 30  # Normalize impact to a value between 0 and 1
-    return 0.1  # Low impact in the ideal range
-
+        return abs(temperature - 22.5) / 30
+    return 0.1
 
 def calculate_adjusted_cost(segment, base_distance, route_factors):
-    """
-    Calculate the adjusted cost of a segment considering weather and temperature.
-    """
     if segment in route_factors:
         factors = route_factors[segment]
     elif (segment[1], segment[0]) in route_factors:
@@ -52,21 +37,13 @@ def calculate_adjusted_cost(segment, base_distance, route_factors):
     
     weather_descriptions = [factor["weather"] for factor in factors]
     temperatures = [factor["temperature"] for factor in factors]
-
     most_common_weather = max(set(weather_descriptions), key=weather_descriptions.count)
     avg_temperature = sum(temperatures) / len(temperatures)
-
-    weather_cost = weather_risk(most_common_weather) * 100  # Weather impact weight
-    temperature_cost = temperature_impact(avg_temperature) * 50  # Temperature impact weight
-
-    total_cost = base_distance + weather_cost + temperature_cost
-    return total_cost
-
+    weather_cost = weather_risk(most_common_weather) * 100
+    temperature_cost = temperature_impact(avg_temperature) * 50
+    return base_distance + weather_cost + temperature_cost
 
 def find_optimal_route(airports, distances, route_factors):
-    """
-    Find the optimal route between airports considering distance and weather factors.
-    """
     best_route, min_distance = None, float('inf')
     for route in itertools.permutations(airports):
         total_distance = 0
@@ -74,45 +51,38 @@ def find_optimal_route(airports, distances, route_factors):
             segment = (route[i], route[i + 1])
             base_distance = distances.get(segment) or distances.get((segment[1], segment[0]))
             total_distance += calculate_adjusted_cost(segment, base_distance, route_factors)
-
         last_segment = (route[-1], route[0])
         base_distance = distances.get(last_segment) or distances.get((last_segment[1], last_segment[0]))
         total_distance += calculate_adjusted_cost(last_segment, base_distance, route_factors)
-
         if total_distance < min_distance:
             min_distance, best_route = round(total_distance, 2), route
-
     return best_route, min_distance
 
-
-### Modular Route Feasibility Checking Functions ###
-
 def check_segment_feasibility(segment, trip_distance, aircraft_specs):
-    """
-    Check if the aircraft can fly a single segment without refueling.
-    """
     segment_distance = trip_distance.get(segment) or trip_distance.get((segment[1], segment[0]))
     fuel_required, flight_time = calculate_fuel_and_time_for_segment(segment_distance, aircraft_specs)
-
-    if fuel_required > aircraft_specs['Max_Fuel_Capacity_kg']:
-        return False, fuel_required, flight_time
-    return True, fuel_required, flight_time
-
+    can_fly = fuel_required <= aircraft_specs['Max_Fuel_Capacity_kg']
+    return can_fly, fuel_required, flight_time
 
 def check_route_feasibility(optimal_route, trip_distance, aircraft_specs):
-    """
-    Check if the aircraft can fly the entire optimal route without refueling.
-    """
-    total_fuel = 0
-    total_time = 0
-    can_fly_entire_route = True  # Flag to check if entire route is feasible
+    total_fuel, total_time = 0, 0
+    refuel_sectors, sector_details = [], []
+    can_fly_entire_route = True
 
     for i in range(len(optimal_route) - 1):
         segment = (optimal_route[i], optimal_route[i + 1])
         can_fly, fuel, time = check_segment_feasibility(segment, trip_distance, aircraft_specs)
+        sector_info = {
+            "Sector": f"{optimal_route[i]} -> {optimal_route[i+1]}",
+            "Fuel Required (kg)": round(fuel, 2),
+            "Flight Time (hrs)": round(time, 2),
+            "Refuel Required": "Yes" if not can_fly else "No"
+        }
+        sector_details.append(sector_info)
         if not can_fly:
             print(f"Cannot fly the sector {optimal_route[i]} -> {optimal_route[i+1]} without refueling.")
             print(f"Fuel required: {round(fuel, 2)} kg, capacity: {aircraft_specs['Max_Fuel_Capacity_kg']} kg")
+            refuel_sectors.append((optimal_route[i], optimal_route[i+1]))
             can_fly_entire_route = False
         else:
             print(f"Fuel required for {optimal_route[i]} -> {optimal_route[i+1]}: {round(fuel, 2)} kg")
@@ -122,9 +92,17 @@ def check_route_feasibility(optimal_route, trip_distance, aircraft_specs):
 
     last_segment = (optimal_route[-1], optimal_route[0])
     can_fly, fuel, time = check_segment_feasibility(last_segment, trip_distance, aircraft_specs)
+    final_leg_info = {
+        "Sector": f"{optimal_route[-1]} -> {optimal_route[0]}",
+        "Fuel Required (kg)": round(fuel, 2),
+        "Flight Time (hrs)": round(time, 2),
+        "Refuel Required": "Yes" if not can_fly else "No"
+    }
+    sector_details.append(final_leg_info)
     if not can_fly:
         print(f"Cannot fly the sector {optimal_route[-1]} -> {optimal_route[0]} without refueling.")
         print(f"Fuel required: {round(fuel, 2)} kg, capacity: {aircraft_specs['Max_Fuel_Capacity_kg']} kg")
+        refuel_sectors.append((optimal_route[-1], optimal_route[0]))
         can_fly_entire_route = False
     else:
         print(f"Fuel required for {optimal_route[-1]} -> {optimal_route[0]}: {round(fuel, 2)} kg")
@@ -136,7 +114,13 @@ def check_route_feasibility(optimal_route, trip_distance, aircraft_specs):
         return {
             "Total Fuel Required (kg)": round(total_fuel, 2),
             "Total Flight Time (hrs)": round(total_time, 2),
-            "Can Fly Entire Route": True
+            "Can Fly Entire Route": True,
+            "Sector Details": sector_details,
+            "Refuel Sectors": refuel_sectors
         }
     else:
-        return {"Can Fly Entire Route": False}
+        return {
+            "Can Fly Entire Route": False,
+            "Sector Details": sector_details,
+            "Refuel Sectors": refuel_sectors
+        }

requirements.txt

@@ -3,3 +3,4 @@ pandas
 geopy
 folium
 requests
+gradio