osrm-location-graph.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e1dab94b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import csv\n",
    "import re\n",
    "import time\n",
    "import base64\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import requests\n",
    "import folium\n",
    "import polyline\n",
    "import geopy.distance\n",
    "import geopandas as gpd\n",
    "from termcolor import colored\n",
    "from sklearn.cluster import DBSCAN\n",
    "from scipy.spatial import distance_matrix\n",
    "from scipy.optimize import minimize\n",
    "from sklearn.neighbors import KDTree\n",
    "from tsp_solver.greedy import solve_tsp\n",
    "import matplotlib.pyplot as plt\n",
    "from itertools import combinations\n",
    "from geopy.distance import geodesic\n",
    "from folium.plugins import MarkerCluster\n",
    "from folium.plugins import BeautifyIcon\n",
    "from folium.map import FeatureGroup\n",
    "from cachetools import cached, LRUCache\n",
    "from cachetools.keys import hashkey\n",
    "from functools import partial\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56bf68f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Validate locations from locations.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c76f36a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the region\n",
    "region = 'ssudan'\n",
    "\n",
    "# Set the path to for region's files\n",
    "locations_csv_path = 'ssudan'\n",
    "\n",
    "# Set the file name of the locations.csv file\n",
    "locations_csv = f'{region}-locations.csv'\n",
    "\n",
    "# Check if the CSV file exists\n",
    "locations_csv_file = os.path.join(locations_csv_path, locations_csv)\n",
    "if not os.path.exists(locations_csv_file):\n",
    "    print(f\"Error: {locations_csv} file not found.\")\n",
    "    exit(1)\n",
    "\n",
    "# Check if the CSV file exists\n",
    "if not os.path.exists(locations_csv_file):\n",
    "    print(f\"Error: {locations_csv} file not found.\")\n",
    "    exit(1)\n",
    "\n",
    "# Read the locations from CSV\n",
    "df = pd.read_csv(locations_csv_file)\n",
    "\n",
    "# List to keep track of invalid locations\n",
    "invalid_locations = []\n",
    "\n",
    "# Base URL for the OSRM nearest service\n",
    "# osrm_endpoint = 'http://localhost:5000/nearest/v1/driving/'\n",
    "osrm_endpoint = 'http://localhost:5000/nearest/v1/driving/'\n",
    "\n",
    "# Iterate through each location in the DataFrame\n",
    "for index, row in df.iterrows():\n",
    "    lat = row['latitude']\n",
    "    lon = row['longitude']\n",
    "    name = row['name']\n",
    "\n",
    "    # Prepare API request URL for the nearest service\n",
    "    request_url = f\"{osrm_endpoint}{lon},{lat}\"\n",
    "\n",
    "    # Send request to OSRM\n",
    "    response = requests.get(request_url)\n",
    "    data = response.json()\n",
    "\n",
    "    # Check if the response is valid and contains a way (road)\n",
    "    if response.status_code == 200 and data['code'] == 'Ok' and len(data['waypoints']) > 0:\n",
    "        # This means the location is valid and near a known road\n",
    "        print(f\"Valid location found for {name}.\")\n",
    "    else:\n",
    "        # The location is invalid or not near a known road\n",
    "        print(f\"Invalid location or not found: {name}.\")\n",
    "        invalid_locations.append(name)\n",
    "\n",
    "# Optional: Handle invalid locations\n",
    "if invalid_locations:\n",
    "    print(\"\\nInvalid locations or locations not found:\")\n",
    "    for name in invalid_locations:\n",
    "        print(f\" - {name}\")\n",
    "else:\n",
    "    print(\"\\nAll locations are valid.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7716ea4-a9c0-4bb4-a4e9-43da7dde1c3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Store visited location pairs pruning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9918d3c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the region \n",
    "region = 'ssudan'\n",
    "\n",
    "# Set the path to for region's files\n",
    "locations_csv_path = 'ssudan'\n",
    "\n",
    "# Set the file name of the locations.csv file\n",
    "locations_csv = f'{region}-small-locations.csv'\n",
    "\n",
    "# Check if the CSV file exists\n",
    "locations_csv_file = os.path.join(locations_csv_path, locations_csv)\n",
    "if not os.path.exists(locations_csv_file):\n",
    "    print(f\"Error: {locations_csv} file not found.\")\n",
    "    exit(1)\n",
    "\n",
    "# Read the locations from CSV\n",
    "df = pd.read_csv(locations_csv_file)\n",
    "\n",
    "# Create a map centered around the first location\n",
    "start_lat = df.loc[0, 'latitude']\n",
    "start_lon = df.loc[0, 'longitude']\n",
    "m = folium.Map(location=[start_lat, start_lon], zoom_start=7)\n",
    "\n",
    "# Create an empty list to store route instructions\n",
    "route_instructions = []\n",
    "\n",
    "# Create a set to store visited location pairs\n",
    "visited_pairs = set()\n",
    "\n",
    "distance_dict = {}\n",
    "\n",
    "# Iterate through each pair of locations in the DataFrame\n",
    "for i in range(len(df)):\n",
    "    for j in range(i + 1, len(df)):\n",
    "        # Extract location details\n",
    "        name1 = df.loc[i, 'name']\n",
    "        lat1 = df.loc[i, 'latitude']\n",
    "        lon1 = df.loc[i, 'longitude']\n",
    "        name2 = df.loc[j, 'name']\n",
    "        lat2 = df.loc[j, 'latitude']\n",
    "        lon2 = df.loc[j, 'longitude']\n",
    "\n",
    "        # Check if the pair has been visited before (or its reverse pair)\n",
    "        if (name1, name2) in visited_pairs or (name2, name1) in visited_pairs:\n",
    "            continue\n",
    "\n",
    "        # Prepare API request URL\n",
    "        osrm_endpoint = 'http://localhost:5000/route/v1/driving'\n",
    "        request_url = f\"{osrm_endpoint}/{lon1},{lat1};{lon2},{lat2}?steps=true&geometries=polyline\"\n",
    "\n",
    "        try:\n",
    "            # Send request to OSRM\n",
    "            response = requests.get(request_url)\n",
    "            response.raise_for_status()\n",
    "\n",
    "            # Extract route data from the response\n",
    "            route_data = response.json()\n",
    "\n",
    "            # Check if response contains a route\n",
    "            if 'routes' in route_data and len(route_data['routes']) > 0:\n",
    "                # Extract route steps\n",
    "                steps = route_data['routes'][0]['legs'][0]['steps']\n",
    "                distance_sum = 0\n",
    "                for step in steps:\n",
    "                    # Extract step instructions\n",
    "                    instruction = step['name']\n",
    "\n",
    "                    # Extract step distance and add to the distance sum\n",
    "                    distance = step['distance']\n",
    "                    distance_sum += distance\n",
    "\n",
    "                # Append step information to the route_instructions list\n",
    "                route_instructions.append((instruction, distance_sum))\n",
    "                \n",
    "                # Store distance between the pair in the dictionary\n",
    "                distance_dict[(name1, name2)] = round(distance_sum, 2)\n",
    "\n",
    "                # Extract route geometry\n",
    "                geometry = route_data['routes'][0]['geometry']\n",
    "\n",
    "                # Decode polyline string to get coordinates\n",
    "                coordinates = polyline.decode(geometry)\n",
    "\n",
    "                # Add the coordinates to the map as a PolyLine\n",
    "                folium.PolyLine(\n",
    "                    locations=coordinates,\n",
    "                    color='blue',\n",
    "                    weight=2,\n",
    "                    opacity=0.9\n",
    "                ).add_to(m)\n",
    "\n",
    "                # Add the pair to the visited set and its reverse pair\n",
    "                visited_pairs.add((name1, name2))\n",
    "                visited_pairs.add((name2, name1))\n",
    "\n",
    "        except requests.exceptions.RequestException as e:\n",
    "            print(f\"Error occurred during OSRM API request: {e}\")\n",
    "            continue\n",
    "\n",
    "        # Add markers for the start and end locations\n",
    "        folium.CircleMarker(\n",
    "            location=(lat1, lon1),\n",
    "            radius=6,\n",
    "            color='red',\n",
    "            fill=True,\n",
    "            fill_color='blue',\n",
    "            popup=name1\n",
    "        ).add_to(m)\n",
    "\n",
    "        folium.CircleMarker(\n",
    "            location=(lat2, lon2),\n",
    "            radius=6,\n",
    "            color='red',\n",
    "            fill=True,\n",
    "            fill_color='blue',\n",
    "            popup=name2\n",
    "        ).add_to(m)\n",
    "\n",
    "# Save the map as an HTML file\n",
    "map_file = os.path.join(f'{locations_csv_path}/{region}-visited-pairs-map.html')\n",
    "m.save(map_file)\n",
    "print(f\"Map saved as {map_file}\")\n",
    "\n",
    "# Save distances to a CSV file\n",
    "with open(f'{locations_csv_path}/{region}-visited-pairs-routes.csv', 'w', newline='') as csvfile:\n",
    "    writer = csv.writer(csvfile)\n",
    "    writer.writerow(['name1', 'name2', 'distance'])\n",
    "    for pair, distance in distance_dict.items():\n",
    "        writer.writerow([pair[0], pair[1], distance])\n",
    "\n",
    "print(f\"Distances saved as {locations_csv_path}/{region}-visited-pairs-routes.csv\")\n",
    "\n",
    "# Display the map\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4096d11b-438f-4be4-9672-0c8c7519e98c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/mghorbani/workspace/osrm-tutorial'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Get hospitals along the routes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7bbb9f6-c117-4989-ba36-f8cd52c8a10d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import subprocess\n",
    "import xml.etree.ElementTree as ET\n",
    "\n",
    "def run_overpass_query(query):\n",
    "    exec_dir = \"/home/mghorbani/workspace/overpass/bin\"\n",
    "    db_dir = \"/home/mghorbani/workspace/overpass/db\"\n",
    "    command = [f\"{exec_dir}/osm3s_query\", \"--db-dir=\" + db_dir]\n",
    "    \n",
    "    # Start the subprocess\n",
    "    process = subprocess.Popen(\n",
    "        command,\n",
    "        stdin=subprocess.PIPE,\n",
    "        stdout=subprocess.PIPE,\n",
    "        stderr=subprocess.PIPE,\n",
    "        text=True\n",
    "    )\n",
    "    \n",
    "    # Send the query and retrieve the results\n",
    "    try:\n",
    "        output, errors = process.communicate(input=query, timeout=30)  # Adjust timeout as necessary\n",
    "        if process.returncode != 0:\n",
    "            print(f\"Error in Overpass query: {errors}\")\n",
    "            return None\n",
    "        return output\n",
    "    except subprocess.TimeoutExpired:\n",
    "        process.kill()\n",
    "        print(\"Query timed out\")\n",
    "        return None\n",
    "\n",
    "def parse_hospitals(xml_data):\n",
    "    root = ET.fromstring(xml_data)\n",
    "    hospitals = []\n",
    "    for node in root.findall('node'):\n",
    "        hospital_data = {\n",
    "            'id': node.get('id'),\n",
    "            'lat': node.get('lat'),\n",
    "            'lon': node.get('lon'),\n",
    "            'name': None,\n",
    "            'operator': None\n",
    "        }\n",
    "        for tag in node.findall('tag'):\n",
    "            if tag.get('k') == 'name':\n",
    "                hospital_data['name'] = tag.get('v')\n",
    "            elif tag.get('k') == 'operator':\n",
    "                hospital_data['operator'] = tag.get('v')\n",
    "        hospitals.append(hospital_data)\n",
    "    return hospitals\n",
    "\n",
    "# Define your Overpass query\n",
    "query = \"\"\"\n",
    "<osm-script output=\"xml\">\n",
    "  <query type=\"node\">\n",
    "    <bbox-query n=\"4.96\" s=\"4.81\" w=\"31.47\" e=\"31.66\"/>\n",
    "    <has-kv k=\"amenity\" v=\"hospital\"/>\n",
    "  </query>\n",
    "  <print/>\n",
    "</osm-script>\n",
    "\"\"\"\n",
    "\n",
    "# Run the query\n",
    "xml_result = run_overpass_query(query)\n",
    "if xml_result:\n",
    "    hospitals = parse_hospitals(xml_result)\n",
    "    # Process or display the results\n",
    "    for hospital in hospitals:\n",
    "        print(hospital)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1689dac-b424-4f39-908c-059354cee412",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Create location graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78646835-3003-4e0a-9c3a-5e5d6a6f6969",
   "metadata": {},
   "outputs": [],
   "source": [
    "import base64\n",
    "import os\n",
    "import re\n",
    "import sys\n",
    "import csv\n",
    "import json\n",
    "import time\n",
    "import joblib\n",
    "import pandas as pd\n",
    "import requests\n",
    "import folium\n",
    "import geopy.distance\n",
    "import subprocess\n",
    "from geopy.distance import geodesic\n",
    "from folium.map import FeatureGroup\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "import xml.etree.ElementTree as ET\n",
    "\n",
    "\n",
    "def add_extra_text(map_object):\n",
    "    # Sample locations with names\n",
    "    locations = [\n",
    "        {'name': 'South Sudan', 'coordinates': [7.5, 32]},\n",
    "        {'name': 'CAR', 'coordinates': [6.00, 24]},\n",
    "        {'name': 'Ethiopia', 'coordinates': [8, 36]},\n",
    "        {'name': 'Kenya', 'coordinates': [3, 35]},\n",
    "        {'name': 'Sudan', 'coordinates': [15, 29]},\n",
    "        {'name': 'Uganda', 'coordinates': [1, 32]},\n",
    "        {'name': 'CRC', 'coordinates': [3, 29]},\n",
    "    ]\n",
    "\n",
    "    # Add markers with text labels\n",
    "    for loc in locations:\n",
    "        icon = folium.DivIcon(html=f\"\"\"\n",
    "            <div style=\"font-size:12pt; color: black;\">{loc['name']}</div>\n",
    "            \"\"\")\n",
    "        folium.Marker(\n",
    "            location=loc['coordinates'],\n",
    "            icon=icon\n",
    "        ).add_to(map_object)\n",
    "\n",
    "\n",
    "def add_location_texts(map_object, locations_df):\n",
    "    # Add markers with text labels\n",
    "    for index, row in locations_df.iterrows():\n",
    "        name = row['name']\n",
    "        lat = row['latitude']\n",
    "        lon = row['longitude']\n",
    "        icon = folium.DivIcon(html=f\"\"\"\n",
    "            <div style=\"font-size:10pt; color: black;\">{name}</div>\n",
    "            \"\"\")\n",
    "        folium.Marker(\n",
    "            location=(lat, lon),\n",
    "            icon=icon\n",
    "        ).add_to(map_object)\n",
    "\n",
    "\n",
    "def add_location_markers(map_object, locations_df):\n",
    "    for _, row in locations_df.iterrows():\n",
    "        # Extract details\n",
    "        name = row['name']\n",
    "        lat = row['latitude']\n",
    "        lon = row['longitude']\n",
    "        location_type = row['location_type']\n",
    "        color = 'green' if location_type == 'camp' else 'yellow' if location_type == 'town' else 'red'\n",
    "        # Add marker to the map\n",
    "        folium.CircleMarker(\n",
    "            location=(lat, lon),\n",
    "            radius=6,\n",
    "            color=color,\n",
    "            weight=2,\n",
    "            opacity=.9,\n",
    "            fill=True,\n",
    "            fill_color=color,\n",
    "            fill_opacity=.6,\n",
    "            popup=name\n",
    "        ).add_to(map_object)\n",
    "\n",
    "\n",
    "cache_dir = 'cachedir'\n",
    "if not os.path.exists(cache_dir):\n",
    "    os.makedirs(cache_dir)\n",
    "\n",
    "memory = joblib.Memory(\"cachedir\", verbose=0)\n",
    "\n",
    "\n",
    "@memory.cache\n",
    "def get_nearest_road_coordinate(coordinate):\n",
    "    \"\"\"Get the nearest road coordinate for a given point.\"\"\"\n",
    "    nearest_url = f'http://localhost:5000/nearest/v1/driving/{coordinate[1]},{coordinate[0]}'\n",
    "    response = requests.get(nearest_url)\n",
    "    if response.status_code == 200:\n",
    "        data = response.json()\n",
    "        if data['waypoints']:\n",
    "            return data['waypoints'][0]['location']  # Return lon, lat of nearest point\n",
    "    else:\n",
    "        print(f\"Failed to find nearest road: {response.status_code} {response.text}\")\n",
    "    return coordinate  # Return original coordinate if no road found\n",
    "\n",
    "\n",
    "@memory.cache\n",
    "def get_route(start, end):\n",
    "    \"\"\"Cached function to get route geometry.\"\"\"\n",
    "    # Get nearest road coordinates for start and end\n",
    "    start_road_coord = get_nearest_road_coordinate(start)\n",
    "    end_road_coord = get_nearest_road_coordinate(end)\n",
    "\n",
    "    # Use nearest road coordinates to get the route\n",
    "    osrm_route_url = f'http://localhost:5000/route/v1/driving/{start_road_coord[0]},{start_road_coord[1]};{end_road_coord[0]},{end_road_coord[1]}?steps=true&geometries=geojson'\n",
    "    response = requests.get(osrm_route_url)\n",
    "\n",
    "    if response.status_code != 200:\n",
    "        print(f\"Failed to get route: {response.status_code} {response.text}\")\n",
    "        return None\n",
    "\n",
    "    try:\n",
    "        data = response.json()\n",
    "        if 'routes' in data and data['routes']:\n",
    "            return data['routes'][0]['geometry']\n",
    "    except requests.exceptions.JSONDecodeError:\n",
    "        print(\"Failed to decode JSON from response\")\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "def calculate_total_distance(coordinates):\n",
    "    total_distance = 0\n",
    "    if len(coordinates) > 1:\n",
    "        for i in range(1, len(coordinates)):\n",
    "            total_distance += geopy.distance.geodesic(coordinates[i - 1][::-1], coordinates[i][::-1]).km\n",
    "    return total_distance\n",
    "\n",
    "\n",
    "def add_routes(map_object, locations_df):\n",
    "    executor = ThreadPoolExecutor(max_workers=10)\n",
    "    futures = []\n",
    "    coordinates = []\n",
    "    for i in range(len(locations_df)):\n",
    "        for j in range(i + 1, len(locations_df)):\n",
    "            loc1, loc2 = locations_df.iloc[i], locations_df.iloc[j]\n",
    "            # Start asynchronous requests\n",
    "            future = executor.submit(get_route, [loc1['latitude'], loc1['longitude']],\n",
    "                                     [loc2['latitude'], loc2['longitude']])\n",
    "            futures.append((future, loc1['name'], loc2['name']))\n",
    "\n",
    "    # Collecting results\n",
    "    for future, name1, name2 in futures:\n",
    "        geometry = future.result()\n",
    "        if geometry:\n",
    "            total_distance = calculate_total_distance(geometry['coordinates'])\n",
    "            polyline_obj = folium.PolyLine(\n",
    "                locations=[(xy[1], xy[0]) for xy in geometry['coordinates']],\n",
    "                color='darkorange',\n",
    "                weight=2,\n",
    "                opacity=0.9,\n",
    "                popup=f\"{name1} to {name2}\"\n",
    "            )\n",
    "            polyline_obj.add_to(map_object)\n",
    "            coordinates.append({'geometry': geometry, 'name1': name1, 'name2': name2, 'distance': total_distance})\n",
    "    return coordinates\n",
    "\n",
    "\n",
    "def add_direct_distance_routes(map_object, locations_df):\n",
    "    executor = ThreadPoolExecutor(max_workers=10)\n",
    "    futures = []\n",
    "    coordinates = []\n",
    "    processed_pairs = set()  # This will keep track of processed location pairs\n",
    "\n",
    "    # First, initiate all requests\n",
    "    for i in range(len(locations_df)):\n",
    "        for j in range(i + 1, len(locations_df)):\n",
    "            loc1, loc2 = locations_df.iloc[i], locations_df.iloc[j]\n",
    "            location_pair = frozenset([loc1['name'], loc2['name']])\n",
    "\n",
    "            # Skip this pair if it has already been processed\n",
    "            if location_pair in processed_pairs:\n",
    "                continue\n",
    "\n",
    "            # Mark this pair as processed\n",
    "            processed_pairs.add(location_pair)\n",
    "\n",
    "            # Start asynchronous requests\n",
    "            future = executor.submit(get_route, [loc1['latitude'], loc1['longitude']],\n",
    "                                     [loc2['latitude'], loc2['longitude']])\n",
    "            futures.append((future, loc1['name'], loc2['name']))\n",
    "\n",
    "    # Then, process all futures\n",
    "    for future, name1, name2 in futures:\n",
    "        geometry = future.result()\n",
    "        if geometry:\n",
    "            total_distance = calculate_total_distance(geometry['coordinates'])\n",
    "            folium.PolyLine(\n",
    "                locations=[(xy[1], xy[0]) for xy in geometry['coordinates']],\n",
    "                color='darkorange',\n",
    "                weight=2,\n",
    "                opacity=0.9,\n",
    "                popup=f\"{name1} to {name2}\"\n",
    "            ).add_to(map_object)\n",
    "            coordinates.append({'geometry': geometry, 'name1': name1, 'name2': name2, 'distance': total_distance})\n",
    "\n",
    "    return coordinates\n",
    "\n",
    "\n",
    "def add_visit_tracking_routes(map_object, locations_df):\n",
    "    executor = ThreadPoolExecutor(max_workers=10)\n",
    "    futures = []\n",
    "    visited_pairs = set()\n",
    "    processed_routes = []  # List to store processed route details\n",
    "\n",
    "    # First, initiate all requests\n",
    "    for i in range(len(locations_df)):\n",
    "        for j in range(i + 1, len(locations_df)):\n",
    "            loc1, loc2 = locations_df.iloc[i], locations_df.iloc[j]\n",
    "            name1, name2 = loc1['name'], loc2['name']\n",
    "            location_pair = (name1, name2)\n",
    "\n",
    "            # Check if pair has already been processed in either direction\n",
    "            if location_pair in visited_pairs or (name2, name1) in visited_pairs:\n",
    "                continue\n",
    "\n",
    "            # Mark both directions as processed\n",
    "            visited_pairs.add(location_pair)\n",
    "            visited_pairs.add((name2, name1))\n",
    "\n",
    "            # Start asynchronous route requests\n",
    "            future = executor.submit(get_route, [loc1['latitude'], loc1['longitude']],\n",
    "                                     [loc2['latitude'], loc2['longitude']])\n",
    "            futures.append((future, name1, name2))\n",
    "\n",
    "    # Then, process all futures for results\n",
    "    for future, name1, name2 in futures:\n",
    "        geometry = future.result()\n",
    "        if geometry:\n",
    "            total_distance = calculate_total_distance(geometry['coordinates'])\n",
    "            folium.PolyLine(\n",
    "                locations=[(xy[1], xy[0]) for xy in geometry['coordinates']],\n",
    "                color='darkorange',\n",
    "                weight=2,\n",
    "                opacity=0.9,\n",
    "                popup=f\"{name1} to {name2}\"\n",
    "            ).add_to(map_object)\n",
    "\n",
    "            # Store route information\n",
    "            processed_routes.append({'geometry': geometry, 'name1': name1, 'name2': name2, 'distance': total_distance})\n",
    "\n",
    "    return processed_routes\n",
    "\n",
    "\n",
    "def add_sequential_pruned_routes(map_object, locations_df):\n",
    "    executor = ThreadPoolExecutor(max_workers=10)\n",
    "    futures = []\n",
    "    processed_routes = []  # List to store processed route details\n",
    "\n",
    "    # Prepare all futures first\n",
    "    for i in range(len(locations_df)):\n",
    "        loc1 = locations_df.iloc[i]\n",
    "        if i == len(locations_df) - 1:\n",
    "            loc2 = locations_df.iloc[0]  # Wrap around to the first location\n",
    "        else:\n",
    "            loc2 = locations_df.iloc[i + 1]\n",
    "\n",
    "        name1, lat1, lon1 = loc1['name'], loc1['latitude'], loc1['longitude']\n",
    "        name2, lat2, lon2 = loc2['name'], loc2['latitude'], loc2['longitude']\n",
    "\n",
    "        # Start asynchronous requests\n",
    "        future = executor.submit(get_route, [lat1, lon1], [lat2, lon2])\n",
    "        futures.append((future, name1, name2))\n",
    "\n",
    "    # Process futures as they complete\n",
    "    for future, name1, name2 in futures:\n",
    "        geometry = future.result()\n",
    "        if geometry:\n",
    "            total_distance = calculate_total_distance(geometry['coordinates'])\n",
    "            folium.PolyLine(\n",
    "                locations=[(xy[1], xy[0]) for xy in geometry['coordinates']],\n",
    "                color='darkorange',\n",
    "                weight=2,\n",
    "                opacity=0.9,\n",
    "                popup=f\"{name1} to {name2}\"\n",
    "            ).add_to(map_object)\n",
    "\n",
    "            # Store route information\n",
    "            processed_routes.append({'geometry': geometry, 'name1': name1, 'name2': name2, 'distance': total_distance})\n",
    "\n",
    "    return processed_routes\n",
    "\n",
    "\n",
    "def add_triangle_pruned_routes(map_object, locations_df, num_neighbors=5):\n",
    "    executor = ThreadPoolExecutor(max_workers=10)\n",
    "    futures = []\n",
    "    all_routes = []\n",
    "\n",
    "    # Pre-calculate distances and sort neighbors for all locations\n",
    "    for idx, loc1 in locations_df.iterrows():\n",
    "        name1 = loc1['name']\n",
    "        lat1 = loc1['latitude']\n",
    "        lon1 = loc1['longitude']\n",
    "        distances_with_names = []\n",
    "\n",
    "        for idx2, loc2 in locations_df.iterrows():\n",
    "            if loc2['name'] != name1:\n",
    "                lat2 = loc2['latitude']\n",
    "                lon2 = loc2['longitude']\n",
    "                distance = geodesic((lat1, lon1), (lat2, lon2)).meters\n",
    "                distances_with_names.append((loc2['name'], lat2, lon2, distance))\n",
    "\n",
    "        # Sort distances and get nearest neighbors\n",
    "        sorted_neighbors = sorted(distances_with_names, key=lambda x: x[3])[:num_neighbors]\n",
    "\n",
    "        # Dispatch route calculation tasks for the nearest neighbors\n",
    "        for name2, lat2, lon2, _ in sorted_neighbors:\n",
    "            future = executor.submit(get_route, [lat1, lon1], [lat2, lon2])\n",
    "            futures.append((future, name1, name2))\n",
    "\n",
    "    # Collect results from futures\n",
    "    for future, name1, name2 in futures:\n",
    "        geometry = future.result()\n",
    "        if geometry:\n",
    "            total_distance = calculate_total_distance(geometry['coordinates'])\n",
    "            folium.PolyLine(\n",
    "                locations=[(xy[1], xy[0]) for xy in geometry['coordinates']],\n",
    "                color='darkorange',\n",
    "                weight=2,\n",
    "                opacity=0.9,\n",
    "                popup=f\"{name1} to {name2}\"\n",
    "            ).add_to(map_object)\n",
    "\n",
    "            all_routes.append({'geometry': geometry, 'name1': name1, 'name2': name2, 'distance': total_distance})\n",
    "\n",
    "    return all_routes\n",
    "\n",
    "\n",
    "def sample_route_points(geometry, num_samples=10):\n",
    "    \"\"\"Sample evenly spaced points along a route geometry.\"\"\"\n",
    "    if not isinstance(geometry, dict) or 'coordinates' not in geometry:\n",
    "        raise ValueError(\"Invalid geometry format. Expected a dictionary with a 'coordinates' key.\")\n",
    "\n",
    "    points = geometry['coordinates']\n",
    "    sampled_points = [points[i] for i in range(0, len(points), max(1, len(points) // num_samples))]\n",
    "    return sampled_points\n",
    "\n",
    "\n",
    "def run_overpass_query(query, exec_dir, db_dir):\n",
    "    command = [f\"{exec_dir}/osm3s_query\", \"--db-dir=\" + db_dir]\n",
    "    process = subprocess.Popen(\n",
    "        command,\n",
    "        stdin=subprocess.PIPE,\n",
    "        stdout=subprocess.PIPE,\n",
    "        stderr=subprocess.PIPE,\n",
    "        text=True\n",
    "    )\n",
    "    try:\n",
    "        output, errors = process.communicate(input=query, timeout=30)\n",
    "        if process.returncode != 0:\n",
    "            print(f\"Error in Overpass query: {errors}\")\n",
    "            return None\n",
    "        return output\n",
    "    except subprocess.TimeoutExpired:\n",
    "        process.kill()\n",
    "        print(\"Query timed out\")\n",
    "        return None\n",
    "\n",
    "\n",
    "def parse_pois_from_xml(xml_data):\n",
    "    root = ET.fromstring(xml_data)\n",
    "    pois = []\n",
    "    # Iterate over both nodes and ways\n",
    "    for element in root.findall('./*'):\n",
    "        tags = {tag.get('k'): tag.get('v') for tag in element.findall('tag')}\n",
    "        if 'amenity' in tags and tags['amenity'] == 'hospital':\n",
    "            # Common data extraction\n",
    "            poi_data = {\n",
    "                'type': tags.get('amenity', 'unknown'),\n",
    "                'name': tags.get('name', 'Unknown'),\n",
    "                'operator': tags.get('operator', 'Unknown')\n",
    "            }\n",
    "            # If it's a node, it will have latitude and longitude attributes directly\n",
    "            if element.tag == 'node':\n",
    "                poi_data.update({\n",
    "                    'latitude': element.get('lat'),\n",
    "                    'longitude': element.get('lon')\n",
    "                })\n",
    "            # If it's a way, we might need to compute the centroid or just take the first node's coordinates\n",
    "            elif element.tag == 'way':\n",
    "                # Retrieve the coordinates of the first referenced node\n",
    "                # This is a simplification, consider calculating the geometric center if needed\n",
    "                ref = element.find('nd').get('ref')\n",
    "                ref_node = root.find(f\".//node[@id='{ref}']\")\n",
    "                if ref_node is not None:\n",
    "                    poi_data.update({\n",
    "                        'latitude': ref_node.get('lat'),\n",
    "                        'longitude': ref_node.get('lon')\n",
    "                    })\n",
    "            pois.append(poi_data)\n",
    "    return pois\n",
    "\n",
    "\n",
    "\n",
    "def find_pois_along_route(points, amenity, search_radius=0):\n",
    "    exec_dir = \"/home/mghorbani/workspace/overpass/bin\"\n",
    "    db_dir = \"/home/mghorbani/workspace/overpass/db\"\n",
    "    all_pois = []\n",
    "\n",
    "    for point in points:\n",
    "        lat, lon = point[1], point[0]\n",
    "        query = f\"\"\"\n",
    "        <osm-script output=\"xml\">\n",
    "          <union>\n",
    "            <query type=\"node\">\n",
    "              <around radius=\"{search_radius}\" lat=\"{lat}\" lon=\"{lon}\"/>\n",
    "              <has-kv k=\"amenity\" v=\"{amenity}\"/>\n",
    "            </query>\n",
    "            <query type=\"way\">\n",
    "              <around radius=\"{search_radius}\" lat=\"{lat}\" lon=\"{lon}\"/>\n",
    "              <has-kv k=\"amenity\" v=\"{amenity}\"/>\n",
    "            </query>\n",
    "          </union>\n",
    "          <print mode=\"body\"/>\n",
    "          <recurse type=\"down\"/>\n",
    "          <print mode=\"meta\"/>\n",
    "        </osm-script>\n",
    "        \"\"\"\n",
    "        output = run_overpass_query(query, exec_dir, db_dir)\n",
    "        if output:\n",
    "            pois = parse_pois_from_xml(output)\n",
    "            all_pois.extend(pois)\n",
    "\n",
    "    return all_pois\n",
    "\n",
    "\n",
    "def add_amenities(map_object, coordinates, amenities, pruning_style):\n",
    "    # Define the CSV file path to store amenities data specific to the pruning algorithm\n",
    "    csv_file = f'ssudan/pruning/ssudan_amenities_data_{pruning_style}.csv'\n",
    "    seen_pois = set()  # Set to keep track of processed POIs\n",
    "\n",
    "    with open(csv_file, mode='a', newline='') as file:  # Use mode 'a' to append to the existing file\n",
    "        writer = csv.writer(file)\n",
    "        if os.stat(csv_file).st_size == 0:  # Check if file is empty to write the header\n",
    "            writer.writerow([\"amenity\", \"latitude\", \"longitude\", \"name\"])  # Write header only if file is empty\n",
    "\n",
    "        for route in coordinates:\n",
    "            route_geometry = route['geometry']\n",
    "            points = sample_route_points(route_geometry, num_samples=10)\n",
    "            for amenity in amenities:\n",
    "                pois = find_pois_along_route(points, amenity, search_radius=1000)\n",
    "                for poi in pois:\n",
    "                    poi_id = (poi['type'], poi['name'], poi['latitude'], poi['longitude'])\n",
    "                    lat = float(poi.get('latitude'))\n",
    "                    lon = float(poi.get('longitude'))\n",
    "                    if poi_id not in seen_pois:\n",
    "                        seen_pois.add(poi_id)  # Mark this POI as processed\n",
    "                        folium.Marker(\n",
    "                            location=(lat, lon),\n",
    "                            icon=folium.CustomIcon(icon_image=modify_and_apply_svg('cross.svg'), icon_size=(12, 12)),\n",
    "                            popup=f\"{poi['name']} ({poi['type']})\"\n",
    "                        ).add_to(map_object)\n",
    "                        writer.writerow([poi['type'], poi['latitude'], poi['longitude'], poi['name']])\n",
    "\n",
    "    print(f\"Amenities for {pruning_style} saved to {csv_file}\")\n",
    "\n",
    "\n",
    "def modify_and_apply_svg(svg_file_path):\n",
    "    # Read SVG file\n",
    "    with open(svg_file_path, 'r') as file:\n",
    "        svg_data = file.read()\n",
    "\n",
    "    # Define new colors\n",
    "    colors = {\n",
    "        'cross': '#FF0000',  # Red color for the circle\n",
    "    }\n",
    "\n",
    "    # Modify the SVG data by changing the fill attribute of specific paths\n",
    "    paths = re.findall(r'<path[^>]*>', svg_data)\n",
    "    if len(paths) > 0:\n",
    "        svg_data = svg_data.replace(paths[0], re.sub(r'fill=\"[^\"]*\"', f'fill=\"{colors[\"cross\"]}\"', paths[0]))\n",
    "\n",
    "    # Encode SVG data to base64\n",
    "    svg_base64 = base64.b64encode(svg_data.encode('utf-8')).decode('utf-8')\n",
    "    svg_url = f'data:image/svg+xml;base64,{svg_base64}'\n",
    "\n",
    "    return svg_url\n",
    "\n",
    "\n",
    "def write_routes_to_csv(routes_data, csv_file_path, pruning_style):\n",
    "    with open(csv_file_path, mode='w', newline='') as file:\n",
    "        writer = csv.writer(file)\n",
    "        writer.writerow([\"name1\", \"name2\", \"distance\"])\n",
    "        for route in routes_data:\n",
    "            name1 = route['name1']\n",
    "            name2 = route['name2']\n",
    "            distance = route['distance']\n",
    "            if name1 != name2:  # Optional: check if names are the same\n",
    "                writer.writerow([name1, name2, round(distance, 2)])\n",
    "        print(f\"Distances for {pruning_style} saved to {csv_file_path}\")\n",
    "\n",
    "\n",
    "def create_map_with_layers(locations_df, pruning_style='none'):\n",
    "    # m = folium.Map(\n",
    "    #     location=[locations_df.iloc[0]['latitude'], locations_df.iloc[0]['longitude']],\n",
    "    #     tiles='https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',\n",
    "    #     attr='Map data © <a href=\"https://openstreetmap.org\">OpenStreetMap</a> contributors',\n",
    "    #     zoom_start=6\n",
    "    # )\n",
    "\n",
    "    m = folium.Map(\n",
    "        location=[locations_df.iloc[0]['latitude']-2, locations_df.iloc[0]['longitude']],\n",
    "        tiles='CartoDB Positron',  # Use the shorthand for CartoDB Positron\n",
    "        attr='South Sudan Map',\n",
    "        zoom_start=6\n",
    "    )\n",
    "\n",
    "    # HTML for the floating legend\n",
    "    legend_html = '''\n",
    "    <div style=\"position: fixed;\n",
    "        top: 250px; right: 1000px; width: 160px; height: 160px;\n",
    "        background-color: white; border:2px solid grey; z-index:9999; font-size:14px;\n",
    "        padding: 10px;\n",
    "        \">&nbsp; Location Graph <br>\n",
    "        &nbsp; <i class=\"fa fa-circle fa-1x\" style=\"color:green\"></i>&nbsp; Camps <br>\n",
    "        &nbsp; <i class=\"fa fa-circle fa-1x\" style=\"color:yellow\"></i>&nbsp; Towns <br>\n",
    "        &nbsp; <i class=\"fa fa-circle fa-1x\" style=\"color:red\"></i>&nbsp; Conflict Zones <br>\n",
    "        &nbsp; <i class=\"fa fa-plus fa-1x\" style=\"color:red\"></i>&nbsp; Health Facilities <br>\n",
    "        &nbsp; <i class=\"fa fa-minus fa-1x\" style=\"color:orange\"></i>&nbsp; Routes <br>\n",
    "    </div>\n",
    "    '''\n",
    "\n",
    "    # Create a floating legend as an HTML element\n",
    "    legend_element = folium.Element(legend_html)\n",
    "\n",
    "    # Add the legend to the map\n",
    "    m.get_root().html.add_child(legend_element)\n",
    "\n",
    "    # Add feature groups for the map\n",
    "    extra_text_layer = FeatureGroup(name='Extra', show=True)\n",
    "    location_text_layer = FeatureGroup(name='Text', show=True)\n",
    "    location_layer = FeatureGroup(name='Locations', show=True)\n",
    "    routes_layer = FeatureGroup(name='Routes', show=True)\n",
    "    amenities_layer = FeatureGroup(name='Amenities', show=True)\n",
    "\n",
    "    # Add layers to the map\n",
    "    add_extra_text(extra_text_layer)\n",
    "    add_location_texts(location_text_layer, locations_df)\n",
    "    add_location_markers(location_layer, locations_df)\n",
    "\n",
    "    # Conditional selection of the pruning algorithm\n",
    "    if pruning_style == 'add_routes':\n",
    "        routes_data = add_routes(m, locations_df)\n",
    "    elif pruning_style == 'direct_distance':\n",
    "        routes_data = add_direct_distance_routes(m, locations_df)\n",
    "    elif pruning_style == 'visit_tracking':\n",
    "        routes_data = add_visit_tracking_routes(m, locations_df)\n",
    "    elif pruning_style == 'sequential':\n",
    "        routes_data = add_sequential_pruned_routes(m, locations_df)\n",
    "    elif pruning_style == 'triangle':\n",
    "        routes_data = add_triangle_pruned_routes(m, locations_df, num_neighbors=3)\n",
    "    else:\n",
    "        raise ValueError(\"Invalid pruning style specified\")\n",
    "\n",
    "    # Write routes to the CSV\n",
    "    csv_file_path = f'ssudan/pruning/ssudan_{pruning_style}_routes.csv'\n",
    "    write_routes_to_csv(routes_data, csv_file_path, pruning_style)\n",
    "\n",
    "    # Inquiry and add amenities to the map\n",
    "    amenities = ['hospital']\n",
    "    add_amenities(amenities_layer, routes_data, amenities, pruning_style)\n",
    "\n",
    "    # Map layers order\n",
    "    m.add_child(extra_text_layer, name='extra', index=0)\n",
    "    m.add_child(routes_layer, name='routes', index=1)\n",
    "    m.add_child(amenities_layer, name='amenities', index=2)\n",
    "    m.add_child(location_layer, name='locations', index=3)\n",
    "    m.add_child(location_text_layer, name='names', index=4)\n",
    "\n",
    "    m.save(f'ssudan/pruning/ssudan_location_graph_{pruning_style}.html')\n",
    "    print(f'Map for {pruning_style} saved to ssudan/pruning/ssudan_location_graph_{pruning_style}.html')\n",
    "\n",
    "\n",
    "def colored(r, g, b, text):\n",
    "    return f\"\\033[38;2;{r};{g};{b}m{text}\\033[0m\"\n",
    "\n",
    "\n",
    "def main():\n",
    "    # Set the file name of the locations.csv file\n",
    "    locations_csv = f'{os.getcwd()}/ssudan/pruning/ssudan-small-locations.csv'\n",
    "    # Load and prepare data\n",
    "    df = pd.read_csv(locations_csv)\n",
    "\n",
    "    # List of algorithms\n",
    "    # algorithms = ['add_routes', 'direct_distance', 'visit_tracking', 'sequential', 'triangle']\n",
    "    algorithms = ['add_routes']\n",
    "    total_algorithms = len(algorithms)\n",
    "\n",
    "    for i, alg in enumerate(algorithms):\n",
    "        # Simulate running the algorithm\n",
    "        create_map_with_layers(df, pruning_style=alg)\n",
    "\n",
    "        # Calculate the percentage of completion\n",
    "        percent_complete = ((i + 1) / total_algorithms) * 100\n",
    "\n",
    "        # Print with color\n",
    "        message = colored(0, 255, 255, f\"Algorithm {alg} finalised successfully! {percent_complete:.2f}% completed.\\n\")\n",
    "        sys.stdout.write(\"\\r\" + message)\n",
    "        sys.stdout.flush()\n",
    "        # Simulate some delay\n",
    "        time.sleep(1)\n",
    "\n",
    "    sys.stdout.write(\"\\n\" + colored(0, 255, 0, \"All algorithms processed successfully.\\n\"))\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3143e7af-d872-499b-ba10-3b2bc10e3eb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Create location graph manually"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e02d9362-d914-4cbb-a348-663c150edad8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_geojson(locations_df, routes_df):\n",
    "    geojson_data = {\n",
    "        \"type\": \"FeatureCollection\",\n",
    "        \"features\": []\n",
    "    }\n",
    "\n",
    "    # Add locations as features\n",
    "    for index, row in locations_df.iterrows():\n",
    "        feature = {\n",
    "            \"type\": \"Feature\",\n",
    "            \"geometry\": {\n",
    "                \"type\": \"Point\",\n",
    "                \"coordinates\": [row['longitude'], row['latitude']]\n",
    "            },\n",
    "            \"properties\": {\n",
    "                \"name\": row['name']\n",
    "            }\n",
    "        }\n",
    "        geojson_data[\"features\"].append(feature)\n",
    "\n",
    "    # Add routes as features\n",
    "    for index, row in routes_df.iterrows():\n",
    "        source_filtered = locations_df.loc[locations_df['name'] == row['name1']]\n",
    "        dest_filtered = locations_df.loc[locations_df['name'] == row['name2']]\n",
    "\n",
    "        if not source_filtered.empty and not dest_filtered.empty:\n",
    "            source = source_filtered.iloc[0]\n",
    "            dest = dest_filtered.iloc[0]\n",
    "            source_coords = [source['longitude'], source['latitude']]\n",
    "            dest_coords = [dest['longitude'], dest['latitude']]\n",
    "\n",
    "            # Request route from OSRM\n",
    "            route_geometry = request_osrm_route(source_coords, dest_coords)\n",
    "            if route_geometry:\n",
    "                feature = {\n",
    "                    \"type\": \"Feature\",\n",
    "                    \"geometry\": {\n",
    "                        \"type\": \"LineString\",\n",
    "                        \"coordinates\": route_geometry\n",
    "                    },\n",
    "                    \"properties\": {\n",
    "                        \"distance\": row['distance']\n",
    "                    }\n",
    "                }\n",
    "                geojson_data[\"features\"].append(feature)\n",
    "        else:\n",
    "            print(f\"Missing location data for route from {row['name1']} to {row['name2']}\")\n",
    "\n",
    "    with open(\"./ssudan/pruning/output_map.geojson\", \"w\") as geojson_file:\n",
    "        json.dump(geojson_data, geojson_file, indent=4)\n",
    "\n",
    "\n",
    "def request_osrm_route(source_coords, dest_coords):\n",
    "    osrm_url = f\"http://localhost:5000/route/v1/driving/{source_coords[0]},{source_coords[1]};{dest_coords[0]},{dest_coords[1]}?geometries=geojson&overview=full\"\n",
    "    response = requests.get(osrm_url)\n",
    "    if response.status_code == 200:\n",
    "        data = response.json()\n",
    "        if data['code'] == 'Ok':\n",
    "            return data['routes'][0]['geometry']['coordinates']\n",
    "    return None\n",
    "\n",
    "\n",
    "def create_html_map(locations_df, geojson_path):\n",
    "    # Load the GeoJSON file into a GeoDataFrame\n",
    "    gdf = gpd.read_file(geojson_path)\n",
    "\n",
    "    # Merge the GeoDataFrame with the locations DataFrame to get the location_type\n",
    "    gdf = gdf.merge(locations_df[['name', 'location_type']], on='name', how='left')\n",
    "\n",
    "    # Initialize the folium map\n",
    "    m = folium.Map(\n",
    "        location=[locations_df.iloc[0]['latitude']-2, locations_df.iloc[0]['longitude']],\n",
    "        tiles='CartoDB Positron',  # Use the shorthand for CartoDB Positron\n",
    "        attr='South Sudan Map',\n",
    "        zoom_start=6\n",
    "    )\n",
    "\n",
    "    # Handle lines (routes) separately\n",
    "    routes = gdf[gdf.geometry.type == 'LineString']\n",
    "    folium.GeoJson(routes,\n",
    "                   name=\"Routes\",\n",
    "                   style_function=lambda x: {'color': 'orange', 'weight': 3}\n",
    "                   ).add_to(m)\n",
    "\n",
    "    # Handle points (locations) separately\n",
    "    points = gdf[gdf.geometry.type == 'Point']\n",
    "    for idx, row in points.iterrows():\n",
    "        location_type = row['location_type']\n",
    "        # Determine color based on location_type\n",
    "        color = 'green' if location_type == 'camp' else 'yellow' if location_type == 'town' else 'red'\n",
    "\n",
    "        # Add CircleMarker for each location\n",
    "        folium.CircleMarker(\n",
    "            location=[row.geometry.y, row.geometry.x],\n",
    "            radius=6,\n",
    "            color=color,\n",
    "            weight=2,\n",
    "            opacity=0.9,\n",
    "            fill=True,\n",
    "            fill_color=color,\n",
    "            fill_opacity=0.6,\n",
    "            popup=row['name']\n",
    "        ).add_to(m)\n",
    "\n",
    "        # Add text labels for each location\n",
    "        icon = folium.DivIcon(html=f\"\"\"\n",
    "            <div style=\"font-size:10pt; color: black;\">{row['name']}</div>\n",
    "            \"\"\")\n",
    "        folium.Marker(\n",
    "            location=[row.geometry.y, row.geometry.x],\n",
    "            icon=icon,\n",
    "        ).add_to(m)\n",
    "\n",
    "    locations = [\n",
    "        {'name': 'South Sudan', 'coordinates': [7.5, 32]},\n",
    "        {'name': 'CAR', 'coordinates': [6.00, 24]},\n",
    "        {'name': 'Ethiopia', 'coordinates': [8, 36]},\n",
    "        {'name': 'Kenya', 'coordinates': [3, 35]},\n",
    "        {'name': 'Sudan', 'coordinates': [15, 29]},\n",
    "        {'name': 'Uganda', 'coordinates': [1, 32]},\n",
    "        {'name': 'CRC', 'coordinates': [3, 29]},\n",
    "    ]\n",
    "\n",
    "    # Add markers with text labels\n",
    "    for loc in locations:\n",
    "        icon = folium.DivIcon(html=f\"\"\"\n",
    "                <div style=\"font-size:12pt; color: black;\">{loc['name']}</div>\n",
    "                \"\"\")\n",
    "        folium.Marker(\n",
    "            location=loc['coordinates'],\n",
    "            icon=icon\n",
    "        ).add_to(m)\n",
    "\n",
    "    # HTML for the floating legend\n",
    "    legend_html = '''\n",
    "    <div style=\"position: fixed;\n",
    "        top: 250px; right: 1000px; width: 160px; height: 160px;\n",
    "        background-color: white; border:2px solid grey; z-index:9999; font-size:14px;\n",
    "        padding: 10px;\n",
    "        \">&nbsp; Location Graph <br>\n",
    "        &nbsp; <i class=\"fa fa-circle fa-1x\" style=\"color:green\"></i>&nbsp; Camps <br>\n",
    "        &nbsp; <i class=\"fa fa-circle fa-1x\" style=\"color:yellow\"></i>&nbsp; Towns <br>\n",
    "        &nbsp; <i class=\"fa fa-circle fa-1x\" style=\"color:red\"></i>&nbsp; Conflict Zones <br>\n",
    "        &nbsp; <i class=\"fa fa-plus fa-1x\" style=\"color:red\"></i>&nbsp; Health Facilities <br>\n",
    "        &nbsp; <i class=\"fa fa-minus fa-1x\" style=\"color:orange\"></i>&nbsp; Routes <br>\n",
    "    </div>\n",
    "    '''\n",
    "\n",
    "    # Create a floating legend as an HTML element\n",
    "    legend_element = folium.Element(legend_html)\n",
    "\n",
    "    # Add the legend to the map\n",
    "    m.get_root().html.add_child(legend_element)\n",
    "\n",
    "    # Save the map to an HTML file\n",
    "    m.save(\"./ssudan/pruning/output_map.html\")\n",
    "    return m\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    locations_csv = './ssudan/pruning/locations.csv'\n",
    "    routes_csv = './ssudan/pruning/routes.csv'\n",
    "\n",
    "    locations_df = pd.read_csv(locations_csv)\n",
    "    routes_df = pd.read_csv(routes_csv)\n",
    "\n",
    "    create_geojson(locations_df, routes_df)\n",
    "\n",
    "    map_object = create_html_map(locations_df, \"./ssudan/pruning/output_map.geojson\")\n",
    "    print(\"Map has been created successfully.\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}