E2SFCA WorldPoP-Local Model 2.1-Func.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "675eb1c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages\n",
    "import geopandas as gpd\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import libpysal\n",
    "import networkx as nx\n",
    "import osmnx as ox\n",
    "import time\n",
    "import os\n",
    "from shapely import geometry\n",
    "from shapely.geometry import Point, MultiLineString, LineString, Polygon, MultiPolygon\n",
    "from shapely.ops import nearest_points, polygonize\n",
    "import shapely\n",
    "from itertools import product, combinations\n",
    "import math\n",
    "import warnings\n",
    "import socket\n",
    "from wpgpDownload.utils.dl import wpFtp\n",
    "from wpgpDownload.utils.isos import Countries\n",
    "from wpgpDownload.utils.convenience_functions import download_country_covariates as dl\n",
    "from wpgpDownload.utils.wpcsv import Product\n",
    "import georasters as gr\n",
    "from wpgpDownload.utils.convenience_functions import refresh_csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "50e92f97",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Block 0 cities and assumptions\n",
    "\n",
    "start = time.time()\n",
    "\n",
    "cities = ['Tel Aviv','Dhaka Metropolitan','Philadelphia','Washington DC','Ghent']\n",
    "\n",
    "# idea to convert to dask-pandas and dask-geopandas\n",
    "# https://towardsdatascience.com/pandas-with-dask-for-an-ultra-fast-notebook-e2621c3769f\n",
    "# Or with Koalas (Spark-like pandas)\n",
    "\n",
    "# Assumptions\n",
    "thresholds = [300, 600, 1000] # route threshold in metres. WHO guideline speaks of access within 300m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d841a73e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "if prefer dwnl from terminal: \n",
      "wpgpDownload download -i ISR --id 5089\n",
      "wpgpDownload download -i BGD --id 5004\n",
      "wpgpDownload download -i USA --id 4983\n",
      "wpgpDownload download -i BEL --id 5007\n",
      " \n",
      "downloaded:\n",
      "ISR downloaded 0.01 mns\n",
      "BGD downloaded 0.02 mns\n",
      "USA downloaded 1.21 mns\n",
      "BEL downloaded 1.21 mns\n"
     ]
    }
   ],
   "source": [
    "# 1. Required preprocess for information extraction\n",
    "\n",
    "# Let's ignore depreciation warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "# Get the city boundaries\n",
    "bound_df = ox.geocoder.geocode_to_gdf(cities) # gets city boundaries from OSM\n",
    "\n",
    "# Get unique iso-codes of selected cities (only load country raster once)\n",
    "unique_iso = iso_countries(bound_df, # Finding the country of the bounded city\n",
    "                           cities)\n",
    "print(' ')\n",
    "\n",
    "print('downloaded:')\n",
    "# Get raster of countries (if automatic download is preferred (standard))\n",
    "raster = countries_grids(unique_iso,\n",
    "                         r'D:\\Dumps\\WorldPoP_Grids') # custom path, where grid files can be stored without downloading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9e396ef0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100m resolution grids extraction\n",
      "Tel Aviv 0.04 mns\n",
      "Dhaka Metropolitan 0.16 mns\n",
      "Philadelphia 0.35 mns\n",
      "Washington DC 0.44 mns\n",
      "Ghent 0.56 mns\n",
      " \n",
      "get road networks from OSM\n",
      "Tel Aviv done 0.51 mns\n",
      "Dhaka Metropolitan done 1.38 mns\n",
      "Philadelphia done 3.72 mns\n",
      "Washington DC done 5.7 mns\n",
      "Ghent done 6.38 mns\n",
      " \n",
      "get urban greenspaces from OSM\n",
      "Tel Aviv done\n",
      "Dhaka Metropolitan done\n",
      "Philadelphia done\n",
      "Washington DC done\n",
      "Ghent done\n"
     ]
    }
   ],
   "source": [
    "# 2. Information extraction\n",
    "\n",
    "# Clip cities from countries, format population grids\n",
    "population_grids = city_grids_format(bound_df, # city boundaries\n",
    "                                     unique_iso,\n",
    "                                     raster, # country raster\n",
    "                                     cities, \n",
    "                                     grid_size = 100)\n",
    "print(' ')\n",
    "\n",
    "# Get road networks\n",
    "road_network = road_networks(cities, # Get 'all' (drive,walk,bike) network\n",
    "                                 thresholds,\n",
    "                                 undirected = True)\n",
    "\n",
    "\n",
    "print(' ')\n",
    "# Extracting UGS\n",
    "UGS = urban_greenspace(cities, \n",
    "                       thresholds,\n",
    "                       one_UGS_buf = 25, # buffer at which UGS is seen as one\n",
    "                       min_UGS_size = 400) # WHO sees this as minimum UGS size (400m2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "eb027bb5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "get fake UGS entry points\n",
      "Tel Aviv 0.0 % done 0.0  mns\n",
      "Tel Aviv 23.9 % done 0.34  mns\n",
      "Tel Aviv 47.7 % done 0.62  mns\n",
      "Tel Aviv 71.6 % done 0.83  mns\n",
      "Tel Aviv 95.5 % done 1.02  mns\n",
      "Tel Aviv 100 % done 1.18  mns\n",
      "Dhaka Metropolitan 0.0 % done 1.18  mns\n",
      "Dhaka Metropolitan 59.5 % done 1.39  mns\n",
      "Dhaka Metropolitan 100 % done 1.54  mns\n",
      "Philadelphia 0.0 % done 1.55  mns\n",
      "Philadelphia 13.6 % done 2.75  mns\n",
      "Philadelphia 27.2 % done 3.91  mns\n",
      "Philadelphia 40.8 % done 5.47  mns\n",
      "Philadelphia 54.4 % done 6.21  mns\n",
      "Philadelphia 68.0 % done 6.9  mns\n",
      "Philadelphia 81.6 % done 7.65  mns\n",
      "Philadelphia 95.2 % done 8.43  mns\n",
      "Philadelphia 100 % done 8.81  mns\n",
      "Washington DC 0.0 % done 8.86  mns\n",
      "Washington DC 14.0 % done 9.5  mns\n",
      "Washington DC 28.0 % done 10.34  mns\n",
      "Washington DC 42.0 % done 11.22  mns\n",
      "Washington DC 55.9 % done 12.06  mns\n",
      "Washington DC 69.9 % done 12.67  mns\n",
      "Washington DC 83.9 % done 13.52  mns\n",
      "Washington DC 97.9 % done 14.26  mns\n",
      "Washington DC 100 % done 14.5  mns\n",
      "Ghent 0.0 % done 14.51  mns\n",
      "Ghent 80.6 % done 14.86  mns\n",
      "Ghent 100 % done 14.97  mns\n",
      " \n",
      "get potential (Euclidean) suitible combinations\n",
      "Tel Aviv\n",
      "in chunk 1 / 5 395680 suitible comb.\n",
      "in chunk 2 / 5 276962 suitible comb.\n",
      "in chunk 3 / 5 344458 suitible comb.\n",
      "in chunk 4 / 5 300346 suitible comb.\n",
      "in chunk 5 / 5 330928 suitible comb.\n",
      "total combinations within distance 1648374\n",
      "0.0 % gridentry done 0.0  mns\n",
      "15.2 % gridentry done 0.37  mns\n",
      "30.3 % gridentry done 0.74  mns\n",
      "45.5 % gridentry done 1.12  mns\n",
      "60.7 % gridentry done 1.49  mns\n",
      "75.8 % gridentry done 1.86  mns\n",
      "91.0 % gridentry done 2.23  mns\n",
      "100 % gridentry done 4.02  mns\n",
      "Dhaka Metropolitan\n",
      "in chunk 1 / 3 10110 suitible comb.\n",
      "in chunk 2 / 3 10563 suitible comb.\n",
      "in chunk 3 / 3 4454 suitible comb.\n",
      "total combinations within distance 25127\n",
      "0.0 % gridentry done 0.0  mns\n",
      "100 % gridentry done 4.53  mns\n",
      "Philadelphia\n",
      "in chunk 1 / 28 31798 suitible comb.\n",
      "in chunk 2 / 28 27602 suitible comb.\n",
      "in chunk 3 / 28 35498 suitible comb.\n",
      "in chunk 4 / 28 53443 suitible comb.\n",
      "in chunk 5 / 28 54425 suitible comb.\n",
      "in chunk 6 / 28 55750 suitible comb.\n",
      "in chunk 7 / 28 60383 suitible comb.\n",
      "in chunk 8 / 28 46851 suitible comb.\n",
      "in chunk 9 / 28 41147 suitible comb.\n",
      "in chunk 10 / 28 21031 suitible comb.\n",
      "in chunk 11 / 28 19727 suitible comb.\n",
      "in chunk 12 / 28 26040 suitible comb.\n",
      "in chunk 13 / 28 39938 suitible comb.\n",
      "in chunk 14 / 28 33989 suitible comb.\n",
      "in chunk 15 / 28 40599 suitible comb.\n",
      "in chunk 16 / 28 67890 suitible comb.\n",
      "in chunk 17 / 28 96826 suitible comb.\n",
      "in chunk 18 / 28 52784 suitible comb.\n",
      "in chunk 19 / 28 34113 suitible comb.\n",
      "in chunk 20 / 28 39576 suitible comb.\n",
      "in chunk 21 / 28 8189 suitible comb.\n",
      "in chunk 22 / 28 15461 suitible comb.\n",
      "in chunk 23 / 28 17529 suitible comb.\n",
      "in chunk 24 / 28 24092 suitible comb.\n",
      "in chunk 25 / 28 20984 suitible comb.\n",
      "in chunk 26 / 28 16300 suitible comb.\n",
      "in chunk 27 / 28 25439 suitible comb.\n",
      "in chunk 28 / 28 33503 suitible comb.\n",
      "total combinations within distance 1040907\n",
      "0.0 % gridentry done 0.0  mns\n",
      "24.0 % gridentry done 0.38  mns\n",
      "48.0 % gridentry done 0.75  mns\n",
      "72.1 % gridentry done 1.12  mns\n",
      "96.1 % gridentry done 1.5  mns\n",
      "100 % gridentry done 16.3  mns\n",
      "Washington DC\n",
      "in chunk 1 / 15 73908 suitible comb.\n",
      "in chunk 2 / 15 85315 suitible comb.\n",
      "in chunk 3 / 15 106170 suitible comb.\n",
      "in chunk 4 / 15 83776 suitible comb.\n",
      "in chunk 5 / 15 34822 suitible comb.\n",
      "in chunk 6 / 15 22679 suitible comb.\n",
      "in chunk 7 / 15 12485 suitible comb.\n",
      "in chunk 8 / 15 36067 suitible comb.\n",
      "in chunk 9 / 15 38652 suitible comb.\n",
      "in chunk 10 / 15 39432 suitible comb.\n",
      "in chunk 11 / 15 45646 suitible comb.\n",
      "in chunk 12 / 15 35296 suitible comb.\n",
      "in chunk 13 / 15 32924 suitible comb.\n",
      "in chunk 14 / 15 46744 suitible comb.\n",
      "in chunk 15 / 15 55715 suitible comb.\n",
      "total combinations within distance 749631\n",
      "0.0 % gridentry done 0.0  mns\n",
      "33.3 % gridentry done 0.38  mns\n",
      "66.7 % gridentry done 0.76  mns\n",
      "100 % gridentry done 22.45  mns\n",
      "Ghent\n",
      "in chunk 1 / 7 110292 suitible comb.\n",
      "in chunk 2 / 7 213877 suitible comb.\n",
      "in chunk 3 / 7 339971 suitible comb.\n",
      "in chunk 4 / 7 303767 suitible comb.\n",
      "in chunk 5 / 7 120797 suitible comb.\n",
      "in chunk 6 / 7 18965 suitible comb.\n",
      "in chunk 7 / 7 10950 suitible comb.\n",
      "total combinations within distance 1118619\n",
      "0.0 % gridentry done 0.0  mns\n",
      "22.3 % gridentry done 0.38  mns\n",
      "44.7 % gridentry done 0.75  mns\n",
      "67.0 % gridentry done 1.13  mns\n",
      "89.4 % gridentry done 1.51  mns\n",
      "100 % gridentry done 26.4  mns\n",
      " \n",
      "Check grids within UGS\n",
      "0 0.0  mns\n",
      "100 0.27  mns\n",
      "200 0.42  mns\n",
      "300 0.5  mns\n",
      "400 0.57  mns\n",
      "Check grids within UGS\n",
      "0 0.6  mns\n",
      "100 0.85  mns\n",
      "Check grids within UGS\n",
      "0 1.02  mns\n",
      "100 1.75  mns\n",
      "200 2.34  mns\n",
      "300 3.66  mns\n",
      "400 3.97  mns\n",
      "500 4.26  mns\n",
      "600 4.58  mns\n",
      "700 4.9  mns\n",
      "Check grids within UGS\n",
      "0 5.12  mns\n",
      "100 5.34  mns\n",
      "200 5.82  mns\n",
      "300 6.19  mns\n",
      "400 6.47  mns\n",
      "500 6.67  mns\n",
      "600 6.9  mns\n",
      "700 7.07  mns\n",
      "Check grids within UGS\n",
      "0 7.12  mns\n",
      "100 7.64  mns\n"
     ]
    }
   ],
   "source": [
    "# 3. Preprocess information for route finding\n",
    "\n",
    "# Get fake entry points (between UGS and buffer limits)\n",
    "UGS_entry = UGS_fake_entry(UGS, \n",
    "                           road_network['nodes'], \n",
    "                           cities, \n",
    "                           UGS_entry_buf = 25, # road nodes within 25 meters are seen as fake entry points\n",
    "                           walk_radius = 500, # assume that the average person only views a UGS up to 500m in radius\n",
    "                                                # more attractive\n",
    "                           entry_point_merge = 0) # merges closeby fake UGS entry points within X meters \n",
    "                                                    # what may be done for performance\n",
    "print(' ')\n",
    "# Checks all potential suitible combinations (points that fall within max threshold Euclidean distance from the ego)\n",
    "suitible = suitible_combinations(UGS_entry, \n",
    "                                 population_grids, \n",
    "                                 road_network['nodes'], # For finding nearest grid entry points\n",
    "                                 thresholds,\n",
    "                                 cities,\n",
    "                                 chunk_size = 10000000) # calculating per chunk of num UGS entry points * num pop_grids\n",
    "                                                        # Preventing normal PC meltdown, set lower if PC gets stuck\n",
    "print(' ')\n",
    "# Checks if grids are already in a UGS\n",
    "suitible_InOut_UGS = grids_in_UGS (suitible, UGS, population_grids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "40c30628",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tel Aviv 1 / 7 range 0 - 250000\n",
      "0.0 % done 0.01 mns\n",
      "0.63 % done 0.34 mns\n",
      "1.26 % done 0.61 mns\n",
      "1.89 % done 0.88 mns\n",
      "2.52 % done 1.18 mns\n",
      "3.15 % done 1.41 mns\n",
      "3.78 % done 1.67 mns\n",
      "4.41 % done 1.9 mns\n",
      "5.04 % done 2.08 mns\n",
      "5.67 % done 2.22 mns\n",
      "6.29 % done 2.36 mns\n",
      "6.92 % done 2.5 mns\n",
      "7.55 % done 2.64 mns\n",
      "8.18 % done 2.77 mns\n",
      "8.81 % done 2.91 mns\n",
      "9.44 % done 3.06 mns\n",
      "10.07 % done 3.25 mns\n",
      "10.7 % done 3.4 mns\n",
      "11.33 % done 3.54 mns\n",
      "11.96 % done 3.7 mns\n",
      "12.59 % done 3.87 mns\n",
      "13.22 % done 4.06 mns\n",
      "13.85 % done 4.23 mns\n",
      "14.48 % done 4.45 mns\n",
      "15.11 % done 4.62 mns\n",
      "for 39 routes nearest nodes found\n",
      "15.74 % pathfinding done 4.79 mns\n",
      "formatting done 6.26 mns\n",
      "dissolving done 7.66 mns\n",
      "Tel Aviv 2 / 7 range 250000 - 500000\n",
      "15.74 % done 7.66 mns\n",
      "16.37 % done 7.81 mns\n",
      "17.0 % done 8.06 mns\n",
      "17.63 % done 8.31 mns\n",
      "18.25 % done 8.54 mns\n",
      "18.88 % done 8.74 mns\n",
      "19.51 % done 8.93 mns\n",
      "20.14 % done 9.1 mns\n",
      "20.77 % done 9.25 mns\n",
      "21.4 % done 9.46 mns\n",
      "22.03 % done 9.7 mns\n",
      "22.66 % done 9.9 mns\n",
      "23.29 % done 10.08 mns\n",
      "23.92 % done 10.26 mns\n",
      "24.55 % done 10.5 mns\n",
      "25.18 % done 11.85 mns\n",
      "25.81 % done 12.19 mns\n",
      "26.44 % done 12.37 mns\n",
      "27.07 % done 12.53 mns\n",
      "27.7 % done 12.67 mns\n",
      "28.33 % done 12.81 mns\n",
      "28.96 % done 12.96 mns\n",
      "29.59 % done 13.1 mns\n",
      "30.21 % done 13.22 mns\n",
      "30.84 % done 13.36 mns\n",
      "for 569 routes nearest nodes found\n",
      "31.47 % pathfinding done 13.53 mns\n",
      "formatting done 15.03 mns\n",
      "dissolving done 16.46 mns\n",
      "Tel Aviv 3 / 7 range 500000 - 750000\n",
      "31.47 % done 16.47 mns\n",
      "32.1 % done 16.6 mns\n",
      "32.73 % done 16.73 mns\n",
      "33.36 % done 16.85 mns\n",
      "33.99 % done 16.97 mns\n",
      "34.62 % done 17.1 mns\n",
      "35.25 % done 17.27 mns\n",
      "35.88 % done 17.43 mns\n",
      "36.51 % done 17.54 mns\n",
      "37.14 % done 17.68 mns\n",
      "37.77 % done 17.83 mns\n",
      "38.4 % done 17.97 mns\n",
      "39.03 % done 18.11 mns\n",
      "39.66 % done 18.24 mns\n",
      "40.29 % done 19.45 mns\n",
      "40.92 % done 19.62 mns\n",
      "41.55 % done 19.79 mns\n",
      "42.17 % done 19.93 mns\n",
      "42.8 % done 20.07 mns\n",
      "43.43 % done 20.22 mns\n",
      "44.06 % done 20.36 mns\n",
      "44.69 % done 20.51 mns\n",
      "45.32 % done 20.66 mns\n",
      "45.95 % done 20.94 mns\n",
      "46.58 % done 21.12 mns\n",
      "for 569 routes nearest nodes found\n",
      "47.21 % pathfinding done 21.31 mns\n",
      "formatting done 22.82 mns\n",
      "dissolving done 24.23 mns\n",
      "Tel Aviv 4 / 7 range 750000 - 1000000\n",
      "47.21 % done 24.24 mns\n",
      "47.84 % done 24.38 mns\n",
      "48.47 % done 24.53 mns\n",
      "49.1 % done 24.67 mns\n",
      "49.73 % done 24.83 mns\n",
      "50.36 % done 24.98 mns\n",
      "50.99 % done 25.13 mns\n",
      "51.62 % done 25.3 mns\n",
      "52.25 % done 25.44 mns\n",
      "52.88 % done 25.57 mns\n",
      "53.51 % done 25.7 mns\n",
      "54.13 % done 25.93 mns\n",
      "54.76 % done 26.09 mns\n",
      "55.39 % done 26.22 mns\n",
      "56.02 % done 26.37 mns\n",
      "56.65 % done 26.59 mns\n",
      "57.28 % done 26.79 mns\n",
      "57.91 % done 26.94 mns\n",
      "58.54 % done 27.1 mns\n",
      "59.17 % done 27.24 mns\n",
      "59.8 % done 27.37 mns\n",
      "60.43 % done 27.56 mns\n",
      "61.06 % done 27.71 mns\n",
      "61.69 % done 27.99 mns\n",
      "62.32 % done 28.1 mns\n",
      "for 0 routes nearest nodes found\n",
      "62.95 % pathfinding done 28.23 mns\n",
      "formatting done 29.75 mns\n",
      "dissolving done 31.14 mns\n",
      "Tel Aviv 5 / 7 range 1000000 - 1250000\n",
      "62.95 % done 31.16 mns\n",
      "63.58 % done 31.34 mns\n",
      "64.21 % done 31.51 mns\n",
      "64.84 % done 38.53 mns\n",
      "65.47 % done 42.46 mns\n",
      "66.09 % done 42.61 mns\n",
      "66.72 % done 42.76 mns\n",
      "67.35 % done 42.88 mns\n",
      "67.98 % done 43.06 mns\n",
      "68.61 % done 43.2 mns\n",
      "69.24 % done 43.35 mns\n",
      "69.87 % done 43.52 mns\n",
      "70.5 % done 43.69 mns\n",
      "71.13 % done 43.84 mns\n",
      "71.76 % done 44.01 mns\n",
      "72.39 % done 44.2 mns\n",
      "73.02 % done 44.39 mns\n",
      "73.65 % done 44.56 mns\n",
      "74.28 % done 44.7 mns\n",
      "74.91 % done 44.82 mns\n",
      "75.54 % done 44.96 mns\n",
      "76.17 % done 45.1 mns\n",
      "76.8 % done 45.33 mns\n",
      "77.43 % done 45.44 mns\n",
      "78.05 % done 45.54 mns\n",
      "for 1020 routes nearest nodes found\n",
      "78.68 % pathfinding done 45.68 mns\n",
      "formatting done 47.19 mns\n",
      "dissolving done 48.61 mns\n",
      "Tel Aviv 6 / 7 range 1250000 - 1500000\n",
      "78.68 % done 48.63 mns\n",
      "79.31 % done 48.76 mns\n",
      "79.94 % done 49.01 mns\n",
      "80.57 % done 49.21 mns\n",
      "81.2 % done 49.38 mns\n",
      "81.83 % done 49.55 mns\n",
      "82.46 % done 49.71 mns\n",
      "83.09 % done 49.88 mns\n",
      "83.72 % done 50.05 mns\n",
      "84.35 % done 50.23 mns\n",
      "84.98 % done 50.44 mns\n",
      "85.61 % done 50.7 mns\n",
      "86.24 % done 50.92 mns\n",
      "86.87 % done 51.12 mns\n",
      "87.5 % done 51.34 mns\n",
      "88.13 % done 51.59 mns\n",
      "88.76 % done 51.83 mns\n",
      "89.39 % done 52.1 mns\n",
      "90.01 % done 52.41 mns\n",
      "90.64 % done 52.68 mns\n",
      "91.27 % done 52.99 mns\n",
      "91.9 % done 53.16 mns\n",
      "92.53 % done 53.32 mns\n",
      "93.16 % done 53.48 mns\n",
      "93.79 % done 53.66 mns\n",
      "for 66 routes nearest nodes found\n",
      "94.42 % pathfinding done 53.87 mns\n",
      "formatting done 55.31 mns\n",
      "dissolving done 56.7 mns\n",
      "Tel Aviv 7 / 7 range 1500000 - 1588629\n",
      "94.42 % done 56.73 mns\n",
      "95.05 % done 56.97 mns\n",
      "95.68 % done 57.46 mns\n",
      "96.31 % done 57.71 mns\n",
      "96.94 % done 57.93 mns\n",
      "97.57 % done 58.14 mns\n",
      "98.2 % done 58.4 mns\n",
      "98.83 % done 58.7 mns\n",
      "99.46 % done 58.86 mns\n",
      "for 259 routes nearest nodes found\n",
      "100.0 % pathfinding done 59.02 mns\n",
      "formatting done 59.58 mns\n",
      "dissolving done 60.09 mns\n",
      "Dhaka Metropolitan 1 / 1 range 0 - 24120\n",
      "0.0 % done 60.2 mns\n",
      "41.46 % done 60.24 mns\n",
      "82.92 % done 60.31 mns\n",
      "for 0 routes nearest nodes found\n",
      "100.0 % pathfinding done 60.32 mns\n",
      "formatting done 60.41 mns\n",
      "dissolving done 60.6 mns\n",
      "Philadelphia 1 / 4 range 0 - 250000\n",
      "0.0 % done 60.94 mns\n",
      "1.0 % done 61.08 mns\n",
      "2.01 % done 61.19 mns\n",
      "3.01 % done 61.28 mns\n",
      "4.02 % done 61.38 mns\n",
      "5.02 % done 61.47 mns\n",
      "6.03 % done 61.59 mns\n",
      "7.03 % done 61.8 mns\n",
      "8.04 % done 61.9 mns\n",
      "9.04 % done 62.01 mns\n",
      "10.05 % done 62.16 mns\n",
      "11.05 % done 62.33 mns\n",
      "12.06 % done 62.56 mns\n",
      "13.06 % done 62.69 mns\n",
      "14.07 % done 62.79 mns\n",
      "15.07 % done 62.92 mns\n",
      "16.08 % done 63.19 mns\n",
      "17.08 % done 63.38 mns\n",
      "18.09 % done 63.54 mns\n",
      "19.09 % done 63.62 mns\n",
      "20.1 % done 63.74 mns\n",
      "21.1 % done 63.93 mns\n",
      "22.11 % done 64.55 mns\n",
      "23.11 % done 64.69 mns\n",
      "24.12 % done 64.79 mns\n",
      "for 93 routes nearest nodes found\n",
      "25.12 % pathfinding done 64.91 mns\n",
      "formatting done 66.22 mns\n",
      "dissolving done 67.58 mns\n",
      "Philadelphia 2 / 4 range 250000 - 500000\n",
      "25.12 % done 67.59 mns\n",
      "26.13 % done 68.8 mns\n",
      "27.13 % done 69.65 mns\n",
      "28.14 % done 69.77 mns\n",
      "29.14 % done 69.93 mns\n",
      "30.14 % done 70.05 mns\n",
      "31.15 % done 70.17 mns\n",
      "32.15 % done 70.28 mns\n",
      "33.16 % done 70.36 mns\n",
      "34.16 % done 70.48 mns\n",
      "35.17 % done 70.6 mns\n",
      "36.17 % done 70.74 mns\n",
      "37.18 % done 70.83 mns\n",
      "38.18 % done 70.91 mns\n",
      "39.19 % done 71.01 mns\n",
      "40.19 % done 71.08 mns\n",
      "41.2 % done 71.16 mns\n",
      "42.2 % done 71.25 mns\n",
      "43.21 % done 71.31 mns\n",
      "44.21 % done 71.44 mns\n",
      "45.22 % done 71.61 mns\n",
      "46.22 % done 71.68 mns\n",
      "47.23 % done 71.78 mns\n",
      "48.23 % done 71.91 mns\n",
      "49.24 % done 72.03 mns\n",
      "for 403 routes nearest nodes found\n",
      "50.24 % pathfinding done 72.12 mns\n",
      "formatting done 73.27 mns\n",
      "dissolving done 74.61 mns\n",
      "Philadelphia 3 / 4 range 500000 - 750000\n",
      "50.24 % done 74.62 mns\n",
      "51.25 % done 74.73 mns\n",
      "52.25 % done 74.85 mns\n",
      "53.26 % done 74.96 mns\n",
      "54.26 % done 75.09 mns\n",
      "55.27 % done 75.21 mns\n",
      "56.27 % done 75.29 mns\n",
      "57.28 % done 75.4 mns\n",
      "58.28 % done 75.54 mns\n",
      "59.29 % done 75.72 mns\n",
      "60.29 % done 75.96 mns\n",
      "61.29 % done 76.17 mns\n",
      "62.3 % done 76.36 mns\n",
      "63.3 % done 76.53 mns\n",
      "64.31 % done 76.64 mns\n",
      "65.31 % done 76.8 mns\n",
      "66.32 % done 77.01 mns\n",
      "67.32 % done 77.23 mns\n",
      "68.33 % done 77.44 mns\n",
      "69.33 % done 77.6 mns\n",
      "70.34 % done 77.89 mns\n",
      "71.34 % done 78.11 mns\n",
      "72.35 % done 78.29 mns\n",
      "73.35 % done 78.45 mns\n",
      "74.36 % done 78.61 mns\n",
      "for 6 routes nearest nodes found\n",
      "75.36 % pathfinding done 78.72 mns\n",
      "formatting done 80.12 mns\n",
      "dissolving done 81.48 mns\n",
      "Philadelphia 4 / 4 range 750000 - 995190\n",
      "75.36 % done 81.5 mns\n",
      "76.37 % done 81.62 mns\n",
      "77.37 % done 81.72 mns\n",
      "78.38 % done 81.82 mns\n",
      "79.38 % done 82.04 mns\n",
      "80.39 % done 82.14 mns\n",
      "81.39 % done 82.24 mns\n",
      "82.4 % done 82.57 mns\n",
      "83.4 % done 82.69 mns\n",
      "84.41 % done 82.78 mns\n",
      "848868 No route 10\n",
      "848869 No route 10\n",
      "848970 No route 10\n",
      "849258 No route 10\n",
      "849298 No route 10\n",
      "849341 No route 10\n",
      "849390 No route 10\n",
      "849518 No route 10\n",
      "849519 No route 10\n",
      "849520 No route 10\n",
      "849521 No route 10\n",
      "849524 No route 10\n",
      "849525 No route 10\n",
      "849526 No route 10\n",
      "849528 No route 10\n",
      "849529 No route 10\n",
      "849530 No route 10\n",
      "849531 No route 10\n",
      "849532 No route 10\n",
      "849533 No route 10\n",
      "849534 No route 10\n",
      "849536 No route 10\n",
      "849537 No route 10\n",
      "849538 No route 10\n",
      "849542 No route 10\n",
      "849543 No route 10\n",
      "849545 No route 10\n",
      "849546 No route 10\n",
      "849547 No route 10\n",
      "849548 No route 10\n",
      "849549 No route 10\n",
      "849550 No route 10\n",
      "849551 No route 10\n",
      "849552 No route 10\n",
      "849553 No route 10\n",
      "849554 No route 10\n",
      "849555 No route 10\n",
      "849556 No route 10\n",
      "849557 No route 10\n",
      "849558 No route 10\n",
      "849559 No route 10\n",
      "849560 No route 10\n",
      "849565 No route 10\n",
      "849566 No route 10\n",
      "849567 No route 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "849568 No route 10\n",
      "849569 No route 10\n",
      "849570 No route 10\n",
      "849571 No route 10\n",
      "849572 No route 10\n",
      "849573 No route 10\n",
      "849576 No route 10\n",
      "849577 No route 10\n",
      "849578 No route 10\n",
      "849579 No route 10\n",
      "849580 No route 10\n",
      "849581 No route 10\n",
      "849582 No route 10\n",
      "849583 No route 10\n",
      "849584 No route 10\n",
      "849585 No route 10\n",
      "849586 No route 10\n",
      "849587 No route 10\n",
      "849588 No route 10\n",
      "849589 No route 10\n",
      "849590 No route 10\n",
      "849591 No route 10\n",
      "849592 No route 10\n",
      "849593 No route 10\n",
      "849596 No route 10\n",
      "849597 No route 10\n",
      "849598 No route 10\n",
      "849599 No route 10\n",
      "849600 No route 10\n",
      "849601 No route 10\n",
      "849608 No route 10\n",
      "849609 No route 10\n",
      "849610 No route 10\n",
      "849611 No route 10\n",
      "849614 No route 10\n",
      "849615 No route 10\n",
      "849616 No route 10\n",
      "849617 No route 10\n",
      "849618 No route 10\n",
      "849619 No route 10\n",
      "849620 No route 10\n",
      "849621 No route 10\n",
      "849622 No route 10\n",
      "849623 No route 10\n",
      "849624 No route 10\n",
      "849625 No route 10\n",
      "849626 No route 10\n",
      "849627 No route 10\n",
      "849628 No route 10\n",
      "849629 No route 10\n",
      "849630 No route 10\n",
      "849631 No route 10\n",
      "849632 No route 10\n",
      "849633 No route 10\n",
      "849634 No route 10\n",
      "849635 No route 10\n",
      "849636 No route 10\n",
      "849637 No route 10\n",
      "849638 No route 10\n",
      "849639 No route 10\n",
      "849640 No route 10\n",
      "849641 No route 10\n",
      "849642 No route 10\n",
      "849645 No route 10\n",
      "849646 No route 10\n",
      "849647 No route 10\n",
      "849648 No route 10\n",
      "849649 No route 10\n",
      "849650 No route 10\n",
      "849651 No route 10\n",
      "849652 No route 10\n",
      "849653 No route 10\n",
      "849655 No route 10\n",
      "849656 No route 10\n",
      "849657 No route 10\n",
      "849658 No route 10\n",
      "849659 No route 10\n",
      "849660 No route 10\n",
      "849661 No route 10\n",
      "849663 No route 10\n",
      "849664 No route 10\n",
      "849665 No route 10\n",
      "849666 No route 10\n",
      "849670 No route 10\n",
      "849671 No route 10\n",
      "849673 No route 10\n",
      "849674 No route 10\n",
      "849675 No route 10\n",
      "849676 No route 10\n",
      "849677 No route 10\n",
      "849678 No route 10\n",
      "849679 No route 10\n",
      "849680 No route 10\n",
      "849681 No route 10\n",
      "849682 No route 10\n",
      "849683 No route 10\n",
      "849684 No route 10\n",
      "849687 No route 10\n",
      "849688 No route 10\n",
      "849689 No route 10\n",
      "849690 No route 10\n",
      "849691 No route 10\n",
      "849692 No route 10\n",
      "849693 No route 10\n",
      "849694 No route 10\n",
      "849695 No route 10\n",
      "849697 No route 10\n",
      "849698 No route 10\n",
      "849699 No route 10\n",
      "849700 No route 10\n",
      "849701 No route 10\n",
      "849702 No route 10\n",
      "849703 No route 10\n",
      "849704 No route 10\n",
      "849706 No route 10\n",
      "849707 No route 10\n",
      "849708 No route 10\n",
      "849709 No route 10\n",
      "849713 No route 10\n",
      "849714 No route 10\n",
      "849716 No route 10\n",
      "849717 No route 10\n",
      "849718 No route 10\n",
      "849719 No route 10\n",
      "849720 No route 10\n",
      "849721 No route 10\n",
      "85.41 % done 89.81 mns\n",
      "850099 No route 10\n",
      "850100 No route 10\n",
      "850101 No route 10\n",
      "850102 No route 10\n",
      "850105 No route 10\n",
      "850106 No route 10\n",
      "850107 No route 10\n",
      "850108 No route 10\n",
      "850109 No route 10\n",
      "850110 No route 10\n",
      "850111 No route 10\n",
      "850112 No route 10\n",
      "850114 No route 10\n",
      "850115 No route 10\n",
      "850116 No route 10\n",
      "850117 No route 10\n",
      "850118 No route 10\n",
      "850119 No route 10\n",
      "850120 No route 10\n",
      "850121 No route 10\n",
      "850122 No route 10\n",
      "850123 No route 10\n",
      "850125 No route 10\n",
      "850126 No route 10\n",
      "850127 No route 10\n",
      "850128 No route 10\n",
      "850132 No route 10\n",
      "850133 No route 10\n",
      "850135 No route 10\n",
      "850136 No route 10\n",
      "850137 No route 10\n",
      "850138 No route 10\n",
      "850139 No route 10\n",
      "850140 No route 10\n",
      "850141 No route 10\n",
      "850142 No route 10\n",
      "850143 No route 10\n",
      "850144 No route 10\n",
      "850145 No route 10\n",
      "850146 No route 10\n",
      "850147 No route 10\n",
      "850148 No route 10\n",
      "850149 No route 10\n",
      "850150 No route 10\n",
      "850151 No route 10\n",
      "850152 No route 10\n",
      "850153 No route 10\n",
      "850156 No route 10\n",
      "850157 No route 10\n",
      "850158 No route 10\n",
      "850159 No route 10\n",
      "850160 No route 10\n",
      "850161 No route 10\n",
      "850162 No route 10\n",
      "850163 No route 10\n",
      "850164 No route 10\n",
      "850166 No route 10\n",
      "850167 No route 10\n",
      "850168 No route 10\n",
      "850169 No route 10\n",
      "850170 No route 10\n",
      "850171 No route 10\n",
      "850172 No route 10\n",
      "850173 No route 10\n",
      "850174 No route 10\n",
      "850175 No route 10\n",
      "850176 No route 10\n",
      "850177 No route 10\n",
      "850179 No route 10\n",
      "850180 No route 10\n",
      "850181 No route 10\n",
      "850182 No route 10\n",
      "850186 No route 10\n",
      "850187 No route 10\n",
      "850189 No route 10\n",
      "850190 No route 10\n",
      "850191 No route 10\n",
      "850192 No route 10\n",
      "850193 No route 10\n",
      "850194 No route 10\n",
      "850195 No route 10\n",
      "850196 No route 10\n",
      "850197 No route 10\n",
      "850198 No route 10\n",
      "850199 No route 10\n",
      "850200 No route 10\n",
      "850201 No route 10\n",
      "850202 No route 10\n",
      "850203 No route 10\n",
      "850204 No route 10\n",
      "850205 No route 10\n",
      "850206 No route 10\n",
      "850207 No route 10\n",
      "850212 No route 10\n",
      "850213 No route 10\n",
      "850214 No route 10\n",
      "850215 No route 10\n",
      "850216 No route 10\n",
      "850217 No route 10\n",
      "850218 No route 10\n",
      "850219 No route 10\n",
      "850220 No route 10\n",
      "850221 No route 10\n",
      "850222 No route 10\n",
      "850223 No route 10\n",
      "850224 No route 10\n",
      "850225 No route 10\n",
      "850226 No route 10\n",
      "850227 No route 10\n",
      "850228 No route 10\n",
      "850229 No route 10\n",
      "850232 No route 10\n",
      "850233 No route 10\n",
      "850234 No route 10\n",
      "850235 No route 10\n",
      "850236 No route 10\n",
      "850237 No route 10\n",
      "850238 No route 10\n",
      "850239 No route 10\n",
      "850240 No route 10\n",
      "850241 No route 10\n",
      "850242 No route 10\n",
      "850243 No route 10\n",
      "850244 No route 10\n",
      "850245 No route 10\n",
      "850246 No route 10\n",
      "850247 No route 10\n",
      "850248 No route 10\n",
      "850249 No route 10\n",
      "850252 No route 10\n",
      "850253 No route 10\n",
      "850254 No route 10\n",
      "850255 No route 10\n",
      "850256 No route 10\n",
      "850257 No route 10\n",
      "850258 No route 10\n",
      "850259 No route 10\n",
      "850266 No route 10\n",
      "850267 No route 10\n",
      "850268 No route 10\n",
      "850269 No route 10\n",
      "850272 No route 10\n",
      "850273 No route 10\n",
      "850274 No route 10\n",
      "850275 No route 10\n",
      "850276 No route 10\n",
      "850277 No route 10\n",
      "850278 No route 10\n",
      "850279 No route 10\n",
      "850280 No route 10\n",
      "850281 No route 10\n",
      "850282 No route 10\n",
      "850283 No route 10\n",
      "850284 No route 10\n",
      "850285 No route 10\n",
      "850286 No route 10\n",
      "850287 No route 10\n",
      "850288 No route 10\n",
      "850289 No route 10\n",
      "850290 No route 10\n",
      "850293 No route 10\n",
      "850294 No route 10\n",
      "850295 No route 10\n",
      "850296 No route 10\n",
      "850297 No route 10\n",
      "850298 No route 10\n",
      "850299 No route 10\n",
      "850300 No route 10\n",
      "850301 No route 10\n",
      "850303 No route 10\n",
      "850304 No route 10\n",
      "850305 No route 10\n",
      "850306 No route 10\n",
      "850307 No route 10\n",
      "850308 No route 10\n",
      "850309 No route 10\n",
      "850310 No route 10\n",
      "850312 No route 10\n",
      "850313 No route 10\n",
      "850314 No route 10\n",
      "850315 No route 10\n",
      "850319 No route 10\n",
      "850320 No route 10\n",
      "850322 No route 10\n",
      "850323 No route 10\n",
      "850324 No route 10\n",
      "850325 No route 10\n",
      "850326 No route 10\n",
      "850327 No route 10\n",
      "850328 No route 10\n",
      "850329 No route 10\n",
      "850492 No route 10\n",
      "850493 No route 10\n",
      "850494 No route 10\n",
      "850495 No route 10\n",
      "850498 No route 10\n",
      "850499 No route 10\n",
      "850500 No route 10\n",
      "850501 No route 10\n",
      "850502 No route 10\n",
      "850503 No route 10\n",
      "850504 No route 10\n",
      "850506 No route 10\n",
      "850507 No route 10\n",
      "850508 No route 10\n",
      "850509 No route 10\n",
      "850510 No route 10\n",
      "850511 No route 10\n",
      "850512 No route 10\n",
      "850513 No route 10\n",
      "850514 No route 10\n",
      "850515 No route 10\n",
      "850517 No route 10\n",
      "850518 No route 10\n",
      "850519 No route 10\n",
      "850523 No route 10\n",
      "850524 No route 10\n",
      "850526 No route 10\n",
      "850527 No route 10\n",
      "850528 No route 10\n",
      "850529 No route 10\n",
      "850530 No route 10\n",
      "850531 No route 10\n",
      "850532 No route 10\n",
      "850533 No route 10\n",
      "850534 No route 10\n",
      "850535 No route 10\n",
      "850536 No route 10\n",
      "850537 No route 10\n",
      "850538 No route 10\n",
      "850539 No route 10\n",
      "850540 No route 10\n",
      "850541 No route 10\n",
      "850542 No route 10\n",
      "850543 No route 10\n",
      "850544 No route 10\n",
      "850545 No route 10\n",
      "850546 No route 10\n",
      "850547 No route 10\n",
      "850550 No route 10\n",
      "850551 No route 10\n",
      "850552 No route 10\n",
      "850553 No route 10\n",
      "850554 No route 10\n",
      "850555 No route 10\n",
      "850556 No route 10\n",
      "850557 No route 10\n",
      "850558 No route 10\n",
      "850560 No route 10\n",
      "850561 No route 10\n",
      "850562 No route 10\n",
      "850563 No route 10\n",
      "850564 No route 10\n",
      "850565 No route 10\n",
      "850566 No route 10\n",
      "850567 No route 10\n",
      "850568 No route 10\n",
      "850569 No route 10\n",
      "850570 No route 10\n",
      "850572 No route 10\n",
      "850573 No route 10\n",
      "850574 No route 10\n",
      "850575 No route 10\n",
      "850579 No route 10\n",
      "850580 No route 10\n",
      "850582 No route 10\n",
      "850583 No route 10\n",
      "850584 No route 10\n",
      "850585 No route 10\n",
      "850586 No route 10\n",
      "850587 No route 10\n",
      "850588 No route 10\n",
      "850589 No route 10\n",
      "850590 No route 10\n",
      "850591 No route 10\n",
      "850592 No route 10\n",
      "850593 No route 10\n",
      "850594 No route 10\n",
      "850595 No route 10\n",
      "850596 No route 10\n",
      "850597 No route 10\n",
      "850598 No route 10\n",
      "850599 No route 10\n",
      "850600 No route 10\n",
      "850601 No route 10\n",
      "850604 No route 10\n",
      "850605 No route 10\n",
      "850606 No route 10\n",
      "850607 No route 10\n",
      "850608 No route 10\n",
      "850609 No route 10\n",
      "850610 No route 10\n",
      "850611 No route 10\n",
      "850612 No route 10\n",
      "850614 No route 10\n",
      "850615 No route 10\n",
      "850616 No route 10\n",
      "850617 No route 10\n",
      "850618 No route 10\n",
      "850619 No route 10\n",
      "850620 No route 10\n",
      "850621 No route 10\n",
      "850622 No route 10\n",
      "850623 No route 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "850624 No route 10\n",
      "850625 No route 10\n",
      "850627 No route 10\n",
      "850628 No route 10\n",
      "850629 No route 10\n",
      "850630 No route 10\n",
      "850634 No route 10\n",
      "850635 No route 10\n",
      "850637 No route 10\n",
      "850638 No route 10\n",
      "850639 No route 10\n",
      "850640 No route 10\n",
      "850641 No route 10\n",
      "850642 No route 10\n",
      "850643 No route 10\n",
      "850644 No route 10\n",
      "850645 No route 10\n",
      "850646 No route 10\n",
      "850647 No route 10\n",
      "850648 No route 10\n",
      "850649 No route 10\n",
      "850650 No route 10\n",
      "850651 No route 10\n",
      "850652 No route 10\n",
      "850653 No route 10\n",
      "850654 No route 10\n",
      "850655 No route 10\n",
      "850658 No route 10\n",
      "850659 No route 10\n",
      "850660 No route 10\n",
      "850661 No route 10\n",
      "850662 No route 10\n",
      "850663 No route 10\n",
      "850664 No route 10\n",
      "850665 No route 10\n",
      "850666 No route 10\n",
      "850668 No route 10\n",
      "850669 No route 10\n",
      "850670 No route 10\n",
      "850671 No route 10\n",
      "850672 No route 10\n",
      "850673 No route 10\n",
      "850674 No route 10\n",
      "850675 No route 10\n",
      "850676 No route 10\n",
      "850677 No route 10\n",
      "850678 No route 10\n",
      "850680 No route 10\n",
      "850681 No route 10\n",
      "850682 No route 10\n",
      "850683 No route 10\n",
      "850687 No route 10\n",
      "850688 No route 10\n",
      "850690 No route 10\n",
      "850691 No route 10\n",
      "850692 No route 10\n",
      "850693 No route 10\n",
      "850694 No route 10\n",
      "850695 No route 10\n",
      "850696 No route 10\n",
      "850697 No route 10\n",
      "850698 No route 10\n",
      "850699 No route 10\n",
      "850700 No route 10\n",
      "850701 No route 10\n",
      "850702 No route 10\n",
      "850703 No route 10\n",
      "850704 No route 10\n",
      "850705 No route 10\n",
      "850706 No route 10\n",
      "850709 No route 10\n",
      "850710 No route 10\n",
      "850711 No route 10\n",
      "850712 No route 10\n",
      "850713 No route 10\n",
      "850714 No route 10\n",
      "850715 No route 10\n",
      "850716 No route 10\n",
      "850717 No route 10\n",
      "850719 No route 10\n",
      "850720 No route 10\n",
      "850721 No route 10\n",
      "850722 No route 10\n",
      "850723 No route 10\n",
      "850724 No route 10\n",
      "850725 No route 10\n",
      "850726 No route 10\n",
      "850727 No route 10\n",
      "850728 No route 10\n",
      "850730 No route 10\n",
      "850731 No route 10\n",
      "850732 No route 10\n",
      "850733 No route 10\n",
      "850737 No route 10\n",
      "850738 No route 10\n",
      "850740 No route 10\n",
      "850741 No route 10\n",
      "850742 No route 10\n",
      "850743 No route 10\n",
      "850744 No route 10\n",
      "850745 No route 10\n",
      "850746 No route 10\n",
      "850747 No route 10\n",
      "850748 No route 10\n",
      "850749 No route 10\n",
      "850750 No route 10\n",
      "850751 No route 10\n",
      "850759 No route 10\n",
      "850800 No route 10\n",
      "850892 No route 10\n",
      "850895 No route 10\n",
      "850937 No route 10\n",
      "850938 No route 10\n",
      "850939 No route 10\n",
      "850940 No route 10\n",
      "850941 No route 10\n",
      "850942 No route 10\n",
      "850943 No route 10\n",
      "850944 No route 10\n",
      "850945 No route 10\n",
      "850946 No route 10\n",
      "850947 No route 10\n",
      "850948 No route 10\n",
      "850949 No route 10\n",
      "850951 No route 10\n",
      "850952 No route 10\n",
      "850953 No route 10\n",
      "850954 No route 10\n",
      "850955 No route 10\n",
      "850956 No route 10\n",
      "850957 No route 10\n",
      "850958 No route 10\n",
      "850959 No route 10\n",
      "850960 No route 10\n",
      "850962 No route 10\n",
      "850963 No route 10\n",
      "850964 No route 10\n",
      "850968 No route 10\n",
      "850969 No route 10\n",
      "850971 No route 10\n",
      "850972 No route 10\n",
      "850973 No route 10\n",
      "850974 No route 10\n",
      "850975 No route 10\n",
      "850976 No route 10\n",
      "850977 No route 10\n",
      "850978 No route 10\n",
      "850979 No route 10\n",
      "850980 No route 10\n",
      "850981 No route 10\n",
      "850982 No route 10\n",
      "850983 No route 10\n",
      "850984 No route 10\n",
      "850985 No route 10\n",
      "850986 No route 10\n",
      "850987 No route 10\n",
      "850988 No route 10\n",
      "850989 No route 10\n",
      "850990 No route 10\n",
      "850991 No route 10\n",
      "850992 No route 10\n",
      "850993 No route 10\n",
      "850996 No route 10\n",
      "850997 No route 10\n",
      "850998 No route 10\n",
      "850999 No route 10\n",
      "851000 No route 10\n",
      "851001 No route 10\n",
      "851002 No route 10\n",
      "851003 No route 10\n",
      "851004 No route 10\n",
      "851006 No route 10\n",
      "851007 No route 10\n",
      "851008 No route 10\n",
      "851009 No route 10\n",
      "851010 No route 10\n",
      "851011 No route 10\n",
      "851012 No route 10\n",
      "851013 No route 10\n",
      "851014 No route 10\n",
      "851015 No route 10\n",
      "851016 No route 10\n",
      "851018 No route 10\n",
      "851019 No route 10\n",
      "851020 No route 10\n",
      "851021 No route 10\n",
      "851025 No route 10\n",
      "851026 No route 10\n",
      "851028 No route 10\n",
      "851029 No route 10\n",
      "851030 No route 10\n",
      "851031 No route 10\n",
      "851032 No route 10\n",
      "851033 No route 10\n",
      "851034 No route 10\n",
      "851035 No route 10\n",
      "851036 No route 10\n",
      "851037 No route 10\n",
      "851038 No route 10\n",
      "851039 No route 10\n",
      "851040 No route 10\n",
      "851041 No route 10\n",
      "851042 No route 10\n",
      "851043 No route 10\n",
      "851044 No route 10\n",
      "851045 No route 10\n",
      "851104 No route 10\n",
      "851107 No route 10\n",
      "851149 No route 10\n",
      "851150 No route 10\n",
      "851155 No route 10\n",
      "851156 No route 10\n",
      "851157 No route 10\n",
      "851161 No route 10\n",
      "851162 No route 10\n",
      "851164 No route 10\n",
      "851165 No route 10\n",
      "851166 No route 10\n",
      "851169 No route 10\n",
      "851170 No route 10\n",
      "851172 No route 10\n",
      "851173 No route 10\n",
      "851174 No route 10\n",
      "851176 No route 10\n",
      "851177 No route 10\n",
      "851178 No route 10\n",
      "851182 No route 10\n",
      "851183 No route 10\n",
      "851185 No route 10\n",
      "851186 No route 10\n",
      "851187 No route 10\n",
      "851190 No route 10\n",
      "851191 No route 10\n",
      "851192 No route 10\n",
      "851193 No route 10\n",
      "851195 No route 10\n",
      "851196 No route 10\n",
      "851197 No route 10\n",
      "851198 No route 10\n",
      "851199 No route 10\n",
      "851200 No route 10\n",
      "851202 No route 10\n",
      "851203 No route 10\n",
      "851204 No route 10\n",
      "851208 No route 10\n",
      "851209 No route 10\n",
      "851211 No route 10\n",
      "851212 No route 10\n",
      "851213 No route 10\n",
      "851214 No route 10\n",
      "851215 No route 10\n",
      "851218 No route 10\n",
      "851219 No route 10\n",
      "851220 No route 10\n",
      "851221 No route 10\n",
      "851222 No route 10\n",
      "851223 No route 10\n",
      "851224 No route 10\n",
      "851225 No route 10\n",
      "851226 No route 10\n",
      "851228 No route 10\n",
      "851229 No route 10\n",
      "851230 No route 10\n",
      "851231 No route 10\n",
      "851232 No route 10\n",
      "851233 No route 10\n",
      "851234 No route 10\n",
      "851235 No route 10\n",
      "851237 No route 10\n",
      "851238 No route 10\n",
      "851239 No route 10\n",
      "851240 No route 10\n",
      "851244 No route 10\n",
      "851245 No route 10\n",
      "851247 No route 10\n",
      "851248 No route 10\n",
      "851249 No route 10\n",
      "851250 No route 10\n",
      "851251 No route 10\n",
      "851252 No route 10\n",
      "851253 No route 10\n",
      "851258 No route 10\n",
      "851259 No route 10\n",
      "851260 No route 10\n",
      "851261 No route 10\n",
      "851262 No route 10\n",
      "851263 No route 10\n",
      "851264 No route 10\n",
      "851265 No route 10\n",
      "851266 No route 10\n",
      "851267 No route 10\n",
      "851268 No route 10\n",
      "851269 No route 10\n",
      "851270 No route 10\n",
      "851271 No route 10\n",
      "851272 No route 10\n",
      "851273 No route 10\n",
      "851274 No route 10\n",
      "851275 No route 10\n",
      "851278 No route 10\n",
      "851279 No route 10\n",
      "851280 No route 10\n",
      "851281 No route 10\n",
      "851282 No route 10\n",
      "851283 No route 10\n",
      "851284 No route 10\n",
      "851285 No route 10\n",
      "851286 No route 10\n",
      "851287 No route 10\n",
      "851288 No route 10\n",
      "851289 No route 10\n",
      "851290 No route 10\n",
      "851291 No route 10\n",
      "851292 No route 10\n",
      "851293 No route 10\n",
      "851296 No route 10\n",
      "851297 No route 10\n",
      "851298 No route 10\n",
      "851299 No route 10\n",
      "851300 No route 10\n",
      "851301 No route 10\n",
      "851302 No route 10\n",
      "851303 No route 10\n",
      "851310 No route 10\n",
      "851311 No route 10\n",
      "851312 No route 10\n",
      "851313 No route 10\n",
      "851316 No route 10\n",
      "851317 No route 10\n",
      "851318 No route 10\n",
      "851319 No route 10\n",
      "851320 No route 10\n",
      "851321 No route 10\n",
      "851322 No route 10\n",
      "851325 No route 10\n",
      "851326 No route 10\n",
      "851327 No route 10\n",
      "851328 No route 10\n",
      "851329 No route 10\n",
      "851330 No route 10\n",
      "851331 No route 10\n",
      "851332 No route 10\n",
      "851333 No route 10\n",
      "851335 No route 10\n",
      "851336 No route 10\n",
      "851337 No route 10\n",
      "851338 No route 10\n",
      "851339 No route 10\n",
      "851340 No route 10\n",
      "851342 No route 10\n",
      "851343 No route 10\n",
      "851344 No route 10\n",
      "851345 No route 10\n",
      "851349 No route 10\n",
      "851350 No route 10\n",
      "851352 No route 10\n",
      "851353 No route 10\n",
      "851354 No route 10\n",
      "851355 No route 10\n",
      "851356 No route 10\n",
      "851363 No route 10\n",
      "851364 No route 10\n",
      "851365 No route 10\n",
      "851366 No route 10\n",
      "851367 No route 10\n",
      "851368 No route 10\n",
      "851369 No route 10\n",
      "851370 No route 10\n",
      "851371 No route 10\n",
      "851372 No route 10\n",
      "851373 No route 10\n",
      "851374 No route 10\n",
      "851375 No route 10\n",
      "851376 No route 10\n",
      "851377 No route 10\n",
      "851378 No route 10\n",
      "851379 No route 10\n",
      "851380 No route 10\n",
      "851381 No route 10\n",
      "851382 No route 10\n",
      "851383 No route 10\n",
      "851384 No route 10\n",
      "851385 No route 10\n",
      "851386 No route 10\n",
      "851387 No route 10\n",
      "851388 No route 10\n",
      "851389 No route 10\n",
      "851393 No route 10\n",
      "851394 No route 10\n",
      "851395 No route 10\n",
      "851396 No route 10\n",
      "851397 No route 10\n",
      "851398 No route 10\n",
      "851399 No route 10\n",
      "851400 No route 10\n",
      "851401 No route 10\n",
      "851402 No route 10\n",
      "851403 No route 10\n",
      "851404 No route 10\n",
      "851405 No route 10\n",
      "851406 No route 10\n",
      "851407 No route 10\n",
      "851408 No route 10\n",
      "851409 No route 10\n",
      "851410 No route 10\n",
      "851411 No route 10\n",
      "851412 No route 10\n",
      "851413 No route 10\n",
      "851414 No route 10\n",
      "851415 No route 10\n",
      "851416 No route 10\n",
      "851420 No route 10\n",
      "851421 No route 10\n",
      "851422 No route 10\n",
      "851423 No route 10\n",
      "851424 No route 10\n",
      "851425 No route 10\n",
      "851426 No route 10\n",
      "851427 No route 10\n",
      "851428 No route 10\n",
      "851429 No route 10\n",
      "851430 No route 10\n",
      "851440 No route 10\n",
      "851441 No route 10\n",
      "851442 No route 10\n",
      "851443 No route 10\n",
      "851444 No route 10\n",
      "851448 No route 10\n",
      "851449 No route 10\n",
      "851450 No route 10\n",
      "851451 No route 10\n",
      "851452 No route 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "851453 No route 10\n",
      "851486 No route 10\n",
      "851487 No route 10\n",
      "851488 No route 10\n",
      "851489 No route 10\n",
      "851490 No route 10\n",
      "851491 No route 10\n",
      "851492 No route 10\n",
      "851528 No route 10\n",
      "851529 No route 10\n",
      "851530 No route 10\n",
      "851531 No route 10\n",
      "851532 No route 10\n",
      "851533 No route 10\n",
      "851534 No route 10\n",
      "851668 No route 10\n",
      "851674 No route 10\n",
      "851702 No route 10\n",
      "851708 No route 10\n",
      "851742 No route 10\n",
      "851767 No route 10\n",
      "851808 No route 10\n",
      "851834 No route 10\n",
      "851840 No route 10\n",
      "851868 No route 10\n",
      "851874 No route 10\n",
      "851906 No route 10\n",
      "851931 No route 10\n",
      "851937 No route 10\n",
      "851971 No route 10\n",
      "851972 No route 10\n",
      "851973 No route 10\n",
      "851989 No route 10\n",
      "851990 No route 10\n",
      "851991 No route 10\n",
      "852058 No route 10\n",
      "852059 No route 10\n",
      "852062 No route 10\n",
      "852066 No route 10\n",
      "852067 No route 10\n",
      "852068 No route 10\n",
      "852069 No route 10\n",
      "852070 No route 10\n",
      "852071 No route 10\n",
      "852072 No route 10\n",
      "852073 No route 10\n",
      "852074 No route 10\n",
      "852078 No route 10\n",
      "852079 No route 10\n",
      "852080 No route 10\n",
      "852081 No route 10\n",
      "852082 No route 10\n",
      "852083 No route 10\n",
      "852084 No route 10\n",
      "852085 No route 10\n",
      "852086 No route 10\n",
      "852087 No route 10\n",
      "852088 No route 10\n",
      "852089 No route 10\n",
      "852093 No route 10\n",
      "852094 No route 10\n",
      "852095 No route 10\n",
      "852096 No route 10\n",
      "852097 No route 10\n",
      "852098 No route 10\n",
      "852099 No route 10\n",
      "852104 No route 10\n",
      "852106 No route 10\n",
      "852107 No route 10\n",
      "852108 No route 10\n",
      "852109 No route 10\n",
      "852112 No route 10\n",
      "852113 No route 10\n",
      "852114 No route 10\n",
      "852115 No route 10\n",
      "852116 No route 10\n",
      "852117 No route 10\n",
      "852118 No route 10\n",
      "852119 No route 10\n",
      "852120 No route 10\n",
      "852122 No route 10\n",
      "852123 No route 10\n",
      "852124 No route 10\n",
      "852125 No route 10\n",
      "852126 No route 10\n",
      "852127 No route 10\n",
      "852129 No route 10\n",
      "852130 No route 10\n",
      "852131 No route 10\n",
      "852135 No route 10\n",
      "852137 No route 10\n",
      "852138 No route 10\n",
      "852150 No route 10\n",
      "852151 No route 10\n",
      "852152 No route 10\n",
      "852168 No route 10\n",
      "852169 No route 10\n",
      "852170 No route 10\n",
      "852223 No route 10\n",
      "852228 No route 10\n",
      "852251 No route 10\n",
      "852276 No route 10\n",
      "852281 No route 10\n",
      "852282 No route 10\n",
      "852311 No route 10\n",
      "852312 No route 10\n",
      "852323 No route 10\n",
      "852324 No route 10\n",
      "852357 No route 10\n",
      "852363 No route 10\n",
      "852381 No route 10\n",
      "852387 No route 10\n",
      "852405 No route 10\n",
      "852411 No route 10\n",
      "852432 No route 10\n",
      "852433 No route 10\n",
      "852444 No route 10\n",
      "852445 No route 10\n",
      "852487 No route 10\n",
      "852488 No route 10\n",
      "852535 No route 10\n",
      "852536 No route 10\n",
      "852537 No route 10\n",
      "852553 No route 10\n",
      "852554 No route 10\n",
      "852555 No route 10\n",
      "852609 No route 10\n",
      "852615 No route 10\n",
      "852681 No route 10\n",
      "852687 No route 10\n",
      "852713 No route 10\n",
      "852760 No route 10\n",
      "852761 No route 10\n",
      "852762 No route 10\n",
      "852828 No route 10\n",
      "852829 No route 10\n",
      "852875 No route 10\n",
      "852892 No route 10\n",
      "852893 No route 10\n",
      "852894 No route 10\n",
      "852896 No route 10\n",
      "852900 No route 10\n",
      "852901 No route 10\n",
      "852902 No route 10\n",
      "852904 No route 10\n",
      "852905 No route 10\n",
      "852907 No route 10\n",
      "852910 No route 10\n",
      "852911 No route 10\n",
      "852912 No route 10\n",
      "852913 No route 10\n",
      "852914 No route 10\n",
      "852916 No route 10\n",
      "852926 No route 10\n",
      "852951 No route 10\n",
      "852975 No route 10\n",
      "853002 No route 10\n",
      "853022 No route 10\n",
      "853028 No route 10\n",
      "853053 No route 10\n",
      "853083 No route 10\n",
      "853084 No route 10\n",
      "853085 No route 10\n",
      "853086 No route 10\n",
      "853183 No route 10\n",
      "853214 No route 10\n",
      "853241 No route 10\n",
      "853263 No route 10\n",
      "853269 No route 10\n",
      "853293 No route 10\n",
      "853332 No route 10\n",
      "853333 No route 10\n",
      "853334 No route 10\n",
      "853335 No route 10\n",
      "853336 No route 10\n",
      "853362 No route 10\n",
      "853471 No route 10\n",
      "853472 No route 10\n",
      "853528 No route 10\n",
      "853529 No route 10\n",
      "853583 No route 10\n",
      "853584 No route 10\n",
      "853595 No route 10\n",
      "853596 No route 10\n",
      "853647 No route 10\n",
      "853648 No route 10\n",
      "853659 No route 10\n",
      "853660 No route 10\n",
      "853787 No route 10\n",
      "853900 No route 10\n",
      "853901 No route 10\n",
      "853957 No route 10\n",
      "853958 No route 10\n",
      "853993 No route 10\n",
      "854014 No route 10\n",
      "854041 No route 10\n",
      "854061 No route 10\n",
      "854076 No route 10\n",
      "854098 No route 10\n",
      "854113 No route 10\n",
      "854114 No route 10\n",
      "854582 No route 10\n",
      "854605 No route 10\n",
      "855484 No route 10\n",
      "855485 No route 10\n",
      "855486 No route 10\n",
      "855487 No route 10\n",
      "855488 No route 10\n",
      "855489 No route 10\n",
      "855490 No route 10\n",
      "855491 No route 10\n",
      "855492 No route 10\n",
      "855493 No route 10\n",
      "855494 No route 10\n",
      "855495 No route 10\n",
      "855496 No route 10\n",
      "855497 No route 10\n",
      "855498 No route 10\n",
      "855499 No route 10\n",
      "855500 No route 10\n",
      "855501 No route 10\n",
      "855502 No route 10\n",
      "855503 No route 10\n",
      "855504 No route 10\n",
      "855505 No route 10\n",
      "855506 No route 10\n",
      "855507 No route 10\n",
      "855508 No route 10\n",
      "855509 No route 10\n",
      "855510 No route 10\n",
      "855511 No route 10\n",
      "855512 No route 10\n",
      "855513 No route 10\n",
      "855514 No route 10\n",
      "855515 No route 10\n",
      "855516 No route 10\n",
      "855517 No route 10\n",
      "855518 No route 10\n",
      "855519 No route 10\n",
      "855520 No route 10\n",
      "855521 No route 10\n",
      "855522 No route 10\n",
      "855523 No route 10\n",
      "855599 No route 10\n",
      "86.42 % done 132.33 mns\n",
      "862648 No route 10\n",
      "862884 No route 10\n",
      "862926 No route 10\n",
      "863070 No route 10\n",
      "863110 No route 10\n",
      "863151 No route 10\n",
      "863196 No route 10\n",
      "863245 No route 10\n",
      "863294 No route 10\n",
      "863328 No route 10\n",
      "863356 No route 10\n",
      "863378 No route 10\n",
      "863397 No route 10\n",
      "87.42 % done 132.99 mns\n",
      "88.43 % done 133.1 mns\n",
      "89.43 % done 133.19 mns\n",
      "90.43 % done 133.31 mns\n",
      "91.44 % done 133.45 mns\n",
      "92.44 % done 134.53 mns\n",
      "93.45 % done 134.61 mns\n",
      "94.45 % done 134.7 mns\n",
      "95.46 % done 134.84 mns\n",
      "96.46 % done 134.95 mns\n",
      "97.47 % done 135.06 mns\n",
      "98.47 % done 135.22 mns\n",
      "99.48 % done 135.29 mns\n",
      "for 1468 routes nearest nodes found\n",
      "100.0 % pathfinding done 135.35 mns\n",
      "formatting done 136.53 mns\n",
      "dissolving done 137.87 mns\n",
      "Washington DC 1 / 3 range 0 - 250000\n",
      "0.0 % done 138.39 mns\n",
      "1.39 % done 138.53 mns\n",
      "2.79 % done 138.68 mns\n",
      "4.18 % done 138.8 mns\n",
      "5.57 % done 138.93 mns\n",
      "6.97 % done 139.21 mns\n",
      "8.36 % done 139.47 mns\n",
      "9.75 % done 139.73 mns\n",
      "11.15 % done 139.91 mns\n",
      "12.54 % done 140.03 mns\n",
      "13.93 % done 140.37 mns\n",
      "15.32 % done 140.63 mns\n",
      "16.72 % done 140.84 mns\n",
      "18.11 % done 140.95 mns\n",
      "19.5 % done 141.08 mns\n",
      "20.9 % done 141.29 mns\n",
      "22.29 % done 141.51 mns\n",
      "23.68 % done 141.79 mns\n",
      "25.08 % done 142.07 mns\n",
      "26.47 % done 142.29 mns\n",
      "27.86 % done 142.43 mns\n",
      "29.26 % done 142.51 mns\n",
      "30.65 % done 142.61 mns\n",
      "32.04 % done 142.72 mns\n",
      "33.44 % done 142.86 mns\n",
      "for 29 routes nearest nodes found\n",
      "34.83 % pathfinding done 142.99 mns\n",
      "formatting done 144.39 mns\n",
      "dissolving done 145.8 mns\n",
      "Washington DC 2 / 3 range 250000 - 500000\n",
      "34.83 % done 145.8 mns\n",
      "36.22 % done 145.94 mns\n",
      "37.62 % done 146.12 mns\n",
      "39.01 % done 146.23 mns\n",
      "40.4 % done 146.36 mns\n",
      "41.79 % done 146.51 mns\n",
      "43.19 % done 146.64 mns\n",
      "44.58 % done 146.74 mns\n",
      "45.97 % done 146.84 mns\n",
      "47.37 % done 146.99 mns\n",
      "48.76 % done 147.07 mns\n",
      "50.15 % done 147.15 mns\n",
      "51.55 % done 147.25 mns\n",
      "52.94 % done 147.36 mns\n",
      "54.33 % done 147.44 mns\n",
      "55.73 % done 147.55 mns\n",
      "57.12 % done 147.63 mns\n",
      "58.51 % done 147.78 mns\n",
      "59.91 % done 147.88 mns\n",
      "61.3 % done 147.95 mns\n",
      "62.69 % done 148.03 mns\n",
      "64.09 % done 148.14 mns\n",
      "65.48 % done 148.24 mns\n",
      "66.87 % done 148.32 mns\n",
      "68.26 % done 148.41 mns\n",
      "for 0 routes nearest nodes found\n",
      "69.66 % pathfinding done 148.51 mns\n",
      "formatting done 149.65 mns\n",
      "dissolving done 150.96 mns\n",
      "Washington DC 3 / 3 range 500000 - 717793\n",
      "69.66 % done 150.97 mns\n",
      "71.05 % done 151.07 mns\n",
      "72.44 % done 151.17 mns\n",
      "73.84 % done 151.27 mns\n",
      "75.23 % done 151.4 mns\n",
      "76.62 % done 151.56 mns\n",
      "78.02 % done 151.65 mns\n",
      "79.41 % done 151.76 mns\n",
      "80.8 % done 151.94 mns\n",
      "82.2 % done 152.03 mns\n",
      "83.59 % done 152.12 mns\n",
      "84.98 % done 152.24 mns\n",
      "86.38 % done 152.32 mns\n",
      "87.77 % done 152.39 mns\n",
      "89.16 % done 152.49 mns\n",
      "90.56 % done 152.59 mns\n",
      "91.95 % done 152.67 mns\n",
      "93.34 % done 152.79 mns\n",
      "94.73 % done 152.88 mns\n",
      "96.13 % done 152.97 mns\n",
      "97.52 % done 153.12 mns\n",
      "98.91 % done 153.32 mns\n",
      "for 0 routes nearest nodes found\n",
      "100.0 % pathfinding done 153.47 mns\n",
      "formatting done 154.53 mns\n",
      "dissolving done 155.69 mns\n",
      "Ghent 1 / 5 range 0 - 250000\n",
      "0.0 % done 156.84 mns\n",
      "0.93 % done 156.97 mns\n",
      "1.87 % done 157.11 mns\n",
      "2.8 % done 157.23 mns\n",
      "3.73 % done 157.35 mns\n",
      "4.66 % done 157.45 mns\n",
      "5.6 % done 157.52 mns\n",
      "6.53 % done 157.67 mns\n",
      "7.46 % done 157.81 mns\n",
      "8.39 % done 158.27 mns\n",
      "9.33 % done 158.81 mns\n",
      "10.26 % done 159.02 mns\n",
      "11.19 % done 159.34 mns\n",
      "12.12 % done 159.5 mns\n",
      "13.06 % done 159.69 mns\n",
      "13.99 % done 159.96 mns\n",
      "14.92 % done 160.17 mns\n",
      "15.86 % done 160.28 mns\n",
      "16.79 % done 160.44 mns\n",
      "17.72 % done 160.59 mns\n",
      "18.65 % done 160.75 mns\n",
      "19.59 % done 160.88 mns\n",
      "20.52 % done 161.0 mns\n",
      "21.45 % done 161.13 mns\n",
      "22.38 % done 161.3 mns\n",
      "for 623 routes nearest nodes found\n",
      "23.32 % pathfinding done 161.38 mns\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "formatting done 162.94 mns\n",
      "dissolving done 164.53 mns\n",
      "Ghent 2 / 5 range 250000 - 500000\n",
      "23.32 % done 164.53 mns\n",
      "24.25 % done 164.66 mns\n",
      "25.18 % done 164.82 mns\n",
      "26.11 % done 164.95 mns\n",
      "27.05 % done 165.09 mns\n",
      "27.98 % done 165.16 mns\n",
      "28.91 % done 165.21 mns\n",
      "29.85 % done 165.4 mns\n",
      "30.78 % done 165.65 mns\n",
      "31.71 % done 165.92 mns\n",
      "32.64 % done 166.13 mns\n",
      "33.58 % done 166.33 mns\n",
      "34.51 % done 166.56 mns\n",
      "35.44 % done 166.81 mns\n",
      "36.37 % done 166.99 mns\n",
      "37.31 % done 167.11 mns\n",
      "38.24 % done 167.24 mns\n",
      "39.17 % done 167.47 mns\n",
      "40.1 % done 167.7 mns\n",
      "41.04 % done 167.95 mns\n",
      "41.97 % done 168.28 mns\n",
      "42.9 % done 168.62 mns\n",
      "43.83 % done 168.85 mns\n",
      "44.77 % done 169.11 mns\n",
      "45.7 % done 169.37 mns\n",
      "for 54 routes nearest nodes found\n",
      "46.63 % pathfinding done 169.6 mns\n",
      "formatting done 171.21 mns\n",
      "dissolving done 172.78 mns\n",
      "Ghent 3 / 5 range 500000 - 750000\n",
      "46.63 % done 172.8 mns\n",
      "47.57 % done 172.99 mns\n",
      "48.5 % done 173.25 mns\n",
      "49.43 % done 173.48 mns\n",
      "50.36 % done 173.74 mns\n",
      "51.3 % done 174.01 mns\n",
      "52.23 % done 174.3 mns\n",
      "53.16 % done 174.58 mns\n",
      "54.09 % done 174.85 mns\n",
      "55.03 % done 175.23 mns\n",
      "55.96 % done 175.51 mns\n",
      "56.89 % done 175.78 mns\n",
      "57.82 % done 176.03 mns\n",
      "58.76 % done 176.2 mns\n",
      "59.69 % done 176.31 mns\n",
      "60.62 % done 176.45 mns\n",
      "61.56 % done 176.69 mns\n",
      "62.49 % done 176.91 mns\n",
      "63.42 % done 177.17 mns\n",
      "64.35 % done 177.41 mns\n",
      "65.29 % done 177.66 mns\n",
      "66.22 % done 177.92 mns\n",
      "67.15 % done 178.22 mns\n",
      "68.08 % done 178.51 mns\n",
      "69.02 % done 178.79 mns\n",
      "for 0 routes nearest nodes found\n",
      "69.95 % pathfinding done 179.05 mns\n",
      "formatting done 180.75 mns\n",
      "dissolving done 182.35 mns\n",
      "Ghent 4 / 5 range 750000 - 1000000\n",
      "69.95 % done 182.36 mns\n",
      "70.88 % done 182.61 mns\n",
      "71.81 % done 182.86 mns\n",
      "72.75 % done 183.1 mns\n",
      "73.68 % done 183.34 mns\n",
      "74.61 % done 183.5 mns\n",
      "75.55 % done 183.69 mns\n",
      "76.48 % done 183.96 mns\n",
      "77.41 % done 184.24 mns\n",
      "78.34 % done 184.49 mns\n",
      "79.28 % done 184.79 mns\n",
      "80.21 % done 185.15 mns\n",
      "81.14 % done 185.49 mns\n",
      "82.07 % done 185.84 mns\n",
      "83.01 % done 186.15 mns\n",
      "83.94 % done 186.55 mns\n",
      "908711 No route 10\n",
      "908712 No route 10\n",
      "908713 No route 10\n",
      "908714 No route 10\n",
      "908715 No route 10\n",
      "908716 No route 10\n",
      "908717 No route 10\n",
      "908718 No route 10\n",
      "908719 No route 10\n",
      "908720 No route 10\n",
      "908721 No route 10\n",
      "908722 No route 10\n",
      "908723 No route 10\n",
      "908724 No route 10\n",
      "908725 No route 10\n",
      "908726 No route 10\n",
      "908727 No route 10\n",
      "908728 No route 10\n",
      "908729 No route 10\n",
      "908730 No route 10\n",
      "908731 No route 10\n",
      "908732 No route 10\n",
      "908733 No route 10\n",
      "908734 No route 10\n",
      "908735 No route 10\n",
      "908736 No route 10\n",
      "908737 No route 10\n",
      "908738 No route 10\n",
      "908739 No route 10\n",
      "908740 No route 10\n",
      "908741 No route 10\n",
      "908742 No route 10\n",
      "908743 No route 10\n",
      "908744 No route 10\n",
      "908745 No route 10\n",
      "908746 No route 10\n",
      "908747 No route 10\n",
      "908748 No route 10\n",
      "908749 No route 10\n",
      "908750 No route 10\n",
      "908751 No route 10\n",
      "908752 No route 10\n",
      "908753 No route 10\n",
      "908754 No route 10\n",
      "908755 No route 10\n",
      "908756 No route 10\n",
      "908757 No route 10\n",
      "908758 No route 10\n",
      "908759 No route 10\n",
      "908760 No route 10\n",
      "908761 No route 10\n",
      "908762 No route 10\n",
      "908763 No route 10\n",
      "908764 No route 10\n",
      "908765 No route 10\n",
      "908766 No route 10\n",
      "908767 No route 10\n",
      "908768 No route 10\n",
      "908769 No route 10\n",
      "908770 No route 10\n",
      "908771 No route 10\n",
      "908772 No route 10\n",
      "908773 No route 10\n",
      "908774 No route 10\n",
      "908775 No route 10\n",
      "908776 No route 10\n",
      "908777 No route 10\n",
      "908778 No route 10\n",
      "908779 No route 10\n",
      "908780 No route 10\n",
      "908781 No route 10\n",
      "908782 No route 10\n",
      "908783 No route 10\n",
      "908784 No route 10\n",
      "908785 No route 10\n",
      "908786 No route 10\n",
      "908787 No route 10\n",
      "908788 No route 10\n",
      "908789 No route 10\n",
      "908790 No route 10\n",
      "908791 No route 10\n",
      "908792 No route 10\n",
      "908793 No route 10\n",
      "908794 No route 10\n",
      "908795 No route 10\n",
      "908796 No route 10\n",
      "908797 No route 10\n",
      "908798 No route 10\n",
      "908799 No route 10\n",
      "908800 No route 10\n",
      "84.87 % done 188.45 mns\n",
      "85.8 % done 188.67 mns\n",
      "86.74 % done 193.7 mns\n",
      "87.67 % done 197.04 mns\n",
      "88.6 % done 197.21 mns\n",
      "89.54 % done 197.37 mns\n",
      "90.47 % done 197.56 mns\n",
      "91.4 % done 197.85 mns\n",
      "92.33 % done 198.08 mns\n",
      "for 1995 routes nearest nodes found\n",
      "93.27 % pathfinding done 198.81 mns\n",
      "formatting done 200.56 mns\n",
      "dissolving done 202.21 mns\n",
      "Ghent 5 / 5 range 1000000 - 1072203\n",
      "93.27 % done 202.23 mns\n",
      "94.2 % done 202.48 mns\n",
      "95.13 % done 202.71 mns\n",
      "96.06 % done 202.79 mns\n",
      "97.0 % done 202.88 mns\n",
      "97.93 % done 203.31 mns\n",
      "98.86 % done 203.38 mns\n",
      "99.79 % done 205.27 mns\n",
      "for 446 routes nearest nodes found\n",
      "100.0 % pathfinding done 205.32 mns\n",
      "formatting done 205.75 mns\n",
      "dissolving done 206.18 mns\n"
     ]
    }
   ],
   "source": [
    "# 4. Finding shortest routes.\n",
    "Routes = route_finding (road_network['graphs'], # graphs of the road networks\n",
    "               suitible_InOut_UGS, # potential suitible routes with grid-UGS comb. separated in or out UGS.\n",
    "               road_network['nodes'], \n",
    "               road_network['edges'], \n",
    "               cities, \n",
    "               block_size = 250000, # Chunk to spread dataload.\n",
    "               nn_iter = 10) # max amount of nearest nodes to be found (both for UGS entry and grid-centroid road entries)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08decce9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300 Tel Aviv\n",
      "600 Tel Aviv\n",
      "1000 Tel Aviv\n",
      "300 Dhaka Metropolitan\n",
      "600 Dhaka Metropolitan\n",
      "1000 Dhaka Metropolitan\n",
      "300 Philadelphia\n",
      "600 Philadelphia\n",
      "1000 Philadelphia\n"
     ]
    }
   ],
   "source": [
    "# 5. summarize scores\n",
    "min_gridUGS = min_gridUGS_comb (Routes, population_grids, UGS)\n",
    "\n",
    "E2SCFA_score = E2SCFA_scores(min_gridUGS, population_grids, thresholds, cities)\n",
    "\n",
    "E2SCFA_score['score summary']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d90c64ad",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'start' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_2728\\998875151.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mround\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mstart\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m60\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'mns'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'start' is not defined"
     ]
    }
   ],
   "source": [
    "print(round((time.time() - start) / 60,2),'mns')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3e7c8c5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def iso_countries(bounds, cities):\n",
    "    # bound_df = ox.geocoder.geocode_to_gdf(cities)\n",
    "    # The 'Countries' is a list of iso-countries and descriptions from the package wpgpDownload.utils.isos\n",
    "    C = pd.DataFrame(Countries)\n",
    "    start_time = time.time()\n",
    "    iso_countries = []\n",
    "    print('if prefer dwnl from terminal: ')\n",
    "    \n",
    "    # Check the display name in the city boundaries to get the country name (enabling only specifying city in front)\n",
    "    for i in bounds['display_name']:\n",
    "        country = i.rsplit(',')[-1][1:]\n",
    "        iso = C[C['name'] == country].iloc[0,1]\n",
    "        # Get unique ISO countries, so all country-grids are only loaded once\n",
    "        if iso not in iso_countries:\n",
    "            iso_countries.append(iso)\n",
    "            \n",
    "            # List data and extract raster file download string with 2020 population (if download manually is preferred)\n",
    "            products = Product(iso)\n",
    "            Results = products.description_contains('people per grid-cell 2020')\n",
    "            list1 = []\n",
    "            for p in Results:\n",
    "                prints = '%s/%s\\t%s\\t%s' % (p.idx, p.country_name,p.dataset_name,p.path)\n",
    "                list1.append(prints)\n",
    "            print('wpgpDownload download -i',iso,'--id',list1[0].split(\"\\t\")[0].split('/')[0])\n",
    "    \n",
    "    return(iso_countries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c68fbf7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def countries_grids(iso_countries, download_dir = ' '):\n",
    "    start_time = time.time()\n",
    "    blocks = []\n",
    "    for iso in iso_countries:\n",
    "        # Check if raster files already exist on the system path or a manually specified path\n",
    "        path1 = os.getcwd() +'\\\\'+ iso.lower() + '_ppp_2020.tif'\n",
    "        path2 = download_dir +'\\\\'+ iso.lower() + '_ppp_2020.tif'\n",
    "        # First check the manual path\n",
    "        if os.path.exists(path2): \n",
    "            block = gr.from_file(path2)\n",
    "            blocks.append(block)\n",
    "        else:\n",
    "            # Then the system path\n",
    "            if os.path.exists(path1): \n",
    "                block = gr.from_file(path1)\n",
    "                blocks.append(block)\n",
    "            else:\n",
    "                # Otherwise run a suprocess (spr.run) command to download via the terminal in notebook.\n",
    "                runstr = 'wpgpDownload download -i '+ iso+ ' -f people --datasets'\n",
    "                p1 = spr.run('wpgpDownload download -i '+ iso+ ' -f people --datasets', \n",
    "                                    shell = True, \n",
    "                                    capture_output = True)\n",
    "                # decode the output to a list of available datasets from WorldPoP\n",
    "                datasets = p1.stdout.decode().rsplit('\\n')\n",
    "\n",
    "                # The first population raster grid (id-sorted) is the general one, without specifying to demographic groups\n",
    "                for i in enumerate(datasets):\n",
    "                    if '2020' in i[1]:\n",
    "                        ds = datasets[i[0]].rsplit('\\t')[0]\n",
    "                        print(ds)\n",
    "                        # if we found the file, we can stop the loop (we don't need the demograhically specified files)\n",
    "                        break\n",
    "                # Construct the download string\n",
    "                dwnl = 'wpgpDownload download -i '+iso+' --id '+str(ds)\n",
    "                # Get the specified file (terminal)\n",
    "                spr.run(dwnl, shell = True)\n",
    "                # Extract the file\n",
    "                block = gr.from_file(path1)\n",
    "                blocks.append(block)\n",
    "        print(iso,'downloaded', round((time.time() - start_time)/60,2),'mns')\n",
    "    return(blocks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a44b205a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Block 2 population grids extraction\n",
    "def city_grids_format(bounds, iso_countries, country_grids, cities, grid_size = 100):\n",
    "    start_time = time.time()\n",
    "    grids = []\n",
    "    print(str(grid_size) + 'm resolution grids extraction')\n",
    "    for i in range(len(cities)):\n",
    "        C = pd.DataFrame(Countries)\n",
    "        iso = C[bounds['display_name'][i].rsplit(',')[-1][1:] == C['name']].iloc[0,1]\n",
    "        contains = [j for j, x in enumerate(iso_countries) if x == iso][0]\n",
    "\n",
    "        # Clip the city from the country\n",
    "        clipped = country_grids[contains].clip(bounds['geometry'][i])\n",
    "        clipped = clipped[0].to_geopandas()\n",
    "\n",
    "        # Get dissolvement_key for dissolvement. \n",
    "        clipped['row3'] = np.floor(clipped['row']/(grid_size/100)).astype(int)\n",
    "        clipped['col3'] = np.floor(clipped['col']/(grid_size/100)).astype(int)\n",
    "        clipped['dissolve_key'] = clipped['row3'].astype(str) +'-'+ clipped['col3'].astype(str)\n",
    "\n",
    "        # Dissolve into block by block grids\n",
    "        popgrid = clipped[['dissolve_key','geometry','row3','col3']].dissolve('dissolve_key')\n",
    "\n",
    "        # Get those grids populations and area. Only blocks with population and full blocks\n",
    "        popgrid['population'] = round(clipped.groupby('dissolve_key')['value'].sum()).astype(int)\n",
    "        popgrid['area_m'] = round(gpd.GeoSeries(popgrid['geometry'], crs = 4326).to_crs(3043).area).astype(int)\n",
    "        popgrid = popgrid[popgrid['population'] > 0]\n",
    "        popgrid = popgrid[popgrid['area_m'] / popgrid['area_m'].max() > 0.95]\n",
    "\n",
    "        # Get centroids and coords\n",
    "        popgrid['centroid'] = popgrid['geometry'].centroid\n",
    "        popgrid['centroid_m'] = gpd.GeoSeries(popgrid['centroid'], crs = 4326).to_crs(3043)\n",
    "        popgrid['grid_lon'] = popgrid['centroid_m'].x\n",
    "        popgrid['grid_lat'] = popgrid['centroid_m'].y\n",
    "        popgrid = popgrid.reset_index()\n",
    "\n",
    "        minx = popgrid.bounds['minx']\n",
    "        maxx = popgrid.bounds['maxx']\n",
    "        miny = popgrid.bounds['miny']\n",
    "        maxy = popgrid.bounds['maxy']\n",
    "\n",
    "        # Some geometries result in a multipolygon when dissolving (like i.e. 0.05 meters) which is in my mind an coords error\n",
    "        # I therefore create one polygon\n",
    "        Poly = []\n",
    "        for k in range(len(popgrid)):\n",
    "            Poly.append(Polygon([(minx[k],maxy[k]),(maxx[k],maxy[k]),(maxx[k],miny[k]),(minx[k],miny[k])]))\n",
    "        popgrid['geometry'] = Poly\n",
    "\n",
    "        grids.append(popgrid)\n",
    "\n",
    "        print(cities[i].rsplit(',')[0], round((time.time() - start_time)/60,2),'mns')\n",
    "    return(grids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5bc1aa68",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Block 3 Road networks\n",
    "def road_networks (cities, thresholds, undirected = False):\n",
    "    print('get road networks from OSM')\n",
    "    start_time = time.time()\n",
    "    graphs = list()\n",
    "    road_nodes = list()\n",
    "    road_edges = list()\n",
    "    road_conn = list()\n",
    "\n",
    "    for i in cities:\n",
    "        # Get graph, road nodes and edges\n",
    "        graph = ox.graph_from_place(i, network_type = \"all\", buffer_dist = (np.max(thresholds)+1000))\n",
    "        #graphs.append(graph)\n",
    "\n",
    "        road_node, road_edge = ox.graph_to_gdfs(graph)\n",
    "\n",
    "        # Road nodes format\n",
    "        road_node = road_node.to_crs(4326)\n",
    "        road_node['geometry_m'] = gpd.GeoSeries(road_node['geometry'], crs = 4326).to_crs(3043)\n",
    "        road_node['osmid_var'] = road_node.index\n",
    "        road_node = gpd.GeoDataFrame(road_node, geometry = 'geometry', crs = 4326)\n",
    "\n",
    "        # format road edges\n",
    "        road_edge = road_edge.to_crs(4326)\n",
    "        road_edge['geometry_m'] = gpd.GeoSeries(road_edge['geometry'], crs = 4326).to_crs(3043)\n",
    "        road_edge = road_edge.reset_index()\n",
    "        road_edge.rename(columns={'u':'from', 'v':'to', 'key':'keys'}, inplace=True)\n",
    "        road_edge['key'] = road_edge['from'].astype(str) + '-' + road_edge['to'].astype(str)\n",
    "        \n",
    "        if undirected == True:\n",
    "            # Apply one-directional to both for walking\n",
    "            both = road_edge[road_edge['oneway'] == False]\n",
    "            one = road_edge[road_edge['oneway'] == True]\n",
    "            rev = pd.DataFrame()\n",
    "            rev[['from','to']] = one[['to','from']]\n",
    "            rev = pd.concat([rev,one.iloc[:,2:]],axis = 1)\n",
    "            edge_bidir = pd.concat([both, one, rev])\n",
    "            edge_bidir = edge_bidir.reset_index()\n",
    "            edge_bidir['oneway'] = False\n",
    "        else:\n",
    "            edge_bidir = road_edge\n",
    "\n",
    "        # Exclude highways and ramps on edges    \n",
    "        edge_filter = edge_bidir[(edge_bidir['highway'].str.contains('motorway') | \n",
    "              (edge_bidir['highway'].str.contains('trunk') & \n",
    "               edge_bidir['maxspeed'].astype(str).str.contains(\n",
    "                   '40 mph|45 mph|50 mph|55 mph|60 mph|65|70|75|80|85|90|95|100|110|120|130|140'))) == False]\n",
    "        road_edges.append(edge_filter)\n",
    "\n",
    "        # Exclude isolated nodes\n",
    "        fltrnodes = pd.Series(list(edge_filter['from']) + list(edge_filter['to'])).unique()\n",
    "        newnodes = road_node[road_node['osmid_var'].isin(fltrnodes)]\n",
    "        road_nodes.append(newnodes)\n",
    "\n",
    "        # Get only necessary road connections columns for network performance\n",
    "        road_con = edge_filter[['osmid','key','length','geometry']]\n",
    "        road_con = road_con.set_index('key')\n",
    "\n",
    "        road_conn.append(road_con)\n",
    "\n",
    "        # formatting to graph again.\n",
    "        newnodes = newnodes.loc[:, ~newnodes.columns.isin(['geometry_m', 'osmid_var'])]\n",
    "        edge_filter = edge_filter.set_index(['from','to','keys'])\n",
    "        edge_filter = edge_filter.loc[:, ~edge_filter.columns.isin(['geometry_m', 'key'])]\n",
    "\n",
    "        graph2 = ox.graph_from_gdfs(newnodes, edge_filter)\n",
    "\n",
    "        graphs.append(graph2)\n",
    "        print(i.rsplit(',')[0], 'done', round((time.time() - start_time) / 60,2),'mns')\n",
    "    return({'graphs':graphs,'nodes':road_nodes,'edges':road_conn,'edges long':road_edges})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3d3ceef5",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Block 4 city greenspace\n",
    "def urban_greenspace (cities, thresholds, one_UGS_buf = 25, min_UGS_size = 400):\n",
    "    print('get urban greenspaces from OSM')\n",
    "    parks_in_range = list()\n",
    "    for i in cities:\n",
    "        gdf = gpd.read_file('D:/Dumps/Greenspace/' + i.rsplit(',')[0] + '/' + i.rsplit(',')[0] + '_Greenspace.gpkg')\n",
    "        gdf = gdf[(gdf.geom_type == 'Polygon') | (gdf.geom_type == 'MultiPolygon')]\n",
    "        greenspace = gdf.reset_index()    \n",
    "        warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "        green_buffer = gpd.GeoDataFrame(geometry = greenspace.to_crs(3043).buffer(one_UGS_buf).to_crs(4326))\n",
    "        greenspace['geometry_w_buffer'] = green_buffer\n",
    "        greenspace['geometry_w_buffer'] = gpd.GeoSeries(greenspace['geometry_w_buffer'], crs = 4326)\n",
    "        greenspace['geom buffer diff'] = greenspace['geometry_w_buffer'].difference(greenspace['geometry'])\n",
    "\n",
    "        # This function group components in itself that overlap (with the buffer set of 25 metres)\n",
    "        # https://stackoverflow.com/questions/68036051/geopandas-self-intersection-grouping\n",
    "        W = libpysal.weights.fuzzy_contiguity(greenspace['geometry_w_buffer'])\n",
    "        greenspace['components'] = W.component_labels\n",
    "        parks = greenspace.dissolve('components')\n",
    "\n",
    "        # Exclude parks below 0.04 ha.\n",
    "        parks = parks[parks.to_crs(3043).area > min_UGS_size]\n",
    "        print(i, 'done')\n",
    "        parks = parks.reset_index()\n",
    "        parks['geometry_m'] = parks['geometry'].to_crs(3043)\n",
    "        parks['park_area'] = parks['geometry_m'].area\n",
    "        parks_in_range.append(parks)\n",
    "    return(parks_in_range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cdc51e59",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Block 5 park entry points\n",
    "def UGS_fake_entry(UGS, road_nodes, cities, UGS_entry_buf = 25, walk_radius = 500, entry_point_merge = 0):\n",
    "    print('get fake UGS entry points')\n",
    "    start_time = time.time()\n",
    "    ParkRoads = list()\n",
    "    for j in range(len(cities)):\n",
    "        ParkRoad = pd.DataFrame()\n",
    "        mat = list()\n",
    "        # For all\n",
    "        for i in range(len(UGS[j])):\n",
    "            dist = road_nodes[j]['geometry'].to_crs(3043).distance(UGS[j]['geometry'].to_crs(\n",
    "                3043)[i])\n",
    "            buf_nodes = road_nodes[j][(dist < UGS_entry_buf) & (dist > 0)]\n",
    "            mat.append(list(np.repeat(i, len(buf_nodes))))\n",
    "            ParkRoad = pd.concat([ParkRoad, buf_nodes])\n",
    "            if i % 100 == 0: print(cities[j].rsplit(',')[0], round(i/len(UGS[j])*100,1),'% done', \n",
    "                                  round((time.time() - start_time) / 60,2),' mns')\n",
    "        # Park no list conversion\n",
    "        mat_u = [i for b in map(lambda x:[x] if not isinstance(x, list) else x, mat) for i in b]\n",
    "\n",
    "        # Format\n",
    "        ParkRoad['Park_No'] = mat_u\n",
    "        ParkRoad = ParkRoad.reset_index()\n",
    "        ParkRoad['park_lon'] = ParkRoad['geometry_m'].x\n",
    "        ParkRoad['park_lat'] = ParkRoad['geometry_m'].y\n",
    "        \n",
    "        # Get the road nodes intersecting with the parks' buffer\n",
    "        ParkRoad = pd.merge(ParkRoad, UGS[j][['geometry','park_area']], left_on = 'Park_No', right_index = True)\n",
    "\n",
    "        # Get the walkable park size\n",
    "        ParkRoad['park_size_walkable'] = ParkRoad['geometry_m'].buffer(walk_radius).to_crs(4326).intersection(ParkRoad['geometry_y'].to_crs(4326))\n",
    "        ParkRoad['walk_area'] = ParkRoad['park_size_walkable'].to_crs(3043).area\n",
    "        #ParkRoad['park_area'] = ParkRoad['geometry_y'].to_crs(3043).area\n",
    "        ParkRoad['share_walked'] = ParkRoad['walk_area'] / ParkRoad['park_area']\n",
    "                \n",
    "        # Merge fake UGS entry points if within X meters of each other for better system performance\n",
    "        # Standard no merging\n",
    "        ParkRoad = simplify_UGS_entry(ParkRoad, entry_point_merge = 0)\n",
    "                \n",
    "        ParkRoads.append(ParkRoad)\n",
    "\n",
    "        print(cities[j].rsplit(',')[0],'100 % done', \n",
    "                                  round((time.time() - start_time) / 60,2),' mns')\n",
    "    return(ParkRoads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "af76feed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Block 5.5 (not in use, buffer is 0, thus retains all the park entry points as is)\n",
    "def simplify_UGS_entry(fake_UGS_entry, entry_point_merge = 0):\n",
    "    # Get buffer of nodes close to each other.\n",
    "    # Get the buffer\n",
    "    ParkComb = fake_UGS_entry\n",
    "    ParkComb['geometry_m_buffer'] = ParkComb['geometry_m'].buffer(entry_point_merge)\n",
    "\n",
    "    # Get and merge components\n",
    "    M = libpysal.weights.fuzzy_contiguity(ParkComb['geometry_m_buffer'])\n",
    "    ParkComb['components'] = M.component_labels\n",
    "\n",
    "    # Take centroid of merged components\n",
    "    centr = gpd.GeoDataFrame(ParkComb, geometry = 'geometry_x', crs = 4326).dissolve('components')['geometry_x'].centroid\n",
    "    centr = gpd.GeoDataFrame(centr)\n",
    "    centr.columns = ['comp_centroid']\n",
    "\n",
    "    # Get node closest to the centroid of all merged nodes, which accesses the road network.\n",
    "    ParkComb = pd.merge(ParkComb, centr, left_on = 'components', right_index = True)\n",
    "    ParkComb['centr_dist'] = ParkComb['geometry_x'].distance(ParkComb['comp_centroid'])\n",
    "    ParkComb = ParkComb.iloc[ParkComb.groupby('components')['centr_dist'].idxmin()]\n",
    "    return(ParkComb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "19711d72",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Block 6 grid-parkentry combinations within euclidean threshold distance\n",
    "def suitible_combinations(UGS_entry, pop_grids, road_nodes, thresholds, cities, chunk_size = 10000000):\n",
    "    print('get potential (Euclidean) suitible combinations')\n",
    "    start_time = time.time()\n",
    "    RoadComb = list()\n",
    "    for l in range(len(cities)):\n",
    "        #blockA = block_combinations\n",
    "        print(cities[l])\n",
    "        len1 = len(pop_grids[l])\n",
    "        len2 = len(UGS_entry[l])\n",
    "\n",
    "        # Reduce the size of combinations per iteration\n",
    "        len4 = 1\n",
    "        len5 = len1 * len2\n",
    "        blockC = len5\n",
    "        while blockC > chunk_size:\n",
    "            blockC = len5 / len4\n",
    "            #print(blockC, len4)\n",
    "            len4 = len4+1\n",
    "\n",
    "        # Amount of grids taken per iteration block\n",
    "        block = round(len1 / len4)\n",
    "\n",
    "        output = pd.DataFrame()\n",
    "        # Checking all the combinations at once is too performance intensive, it is broken down per 1000 (or what you want)\n",
    "        for i in range(len4):\n",
    "            # Check all grid-park combinations per block\n",
    "            l1, l2 = range(i*block,(i+1)*block), range(0,len2)\n",
    "            listed = pd.DataFrame(list(product(l1, l2)))\n",
    "\n",
    "            # Merge grid and park information\n",
    "            grid_merged = pd.merge(listed, \n",
    "                                   pop_grids[l][['grid_lon','grid_lat','centroid','centroid_m']],\n",
    "                                   left_on = 0, right_index = True)\n",
    "            node_merged = pd.merge(grid_merged, \n",
    "                                   UGS_entry[l][['Park_No','osmid','geometry_x','geometry_y','geometry_m','park_lon','park_lat',\n",
    "                                       'share_walked','park_area','walk_area']], \n",
    "                                   left_on = 1, right_index = True)\n",
    "\n",
    "            # Preset index for merging\n",
    "            node_merged['key'] = range(0,len(node_merged))\n",
    "            node_merged = node_merged.set_index('key')\n",
    "            node_merged = node_merged.loc[:, ~node_merged.columns.isin(['index'])]\n",
    "\n",
    "            # Create lists for better computational performance\n",
    "            glon = list(node_merged['grid_lon'])\n",
    "            glat = list(node_merged['grid_lat'])\n",
    "            plon = list(node_merged['park_lon'])\n",
    "            plat = list(node_merged['park_lat'])\n",
    "\n",
    "            # Get the euclidean distances\n",
    "            mat = list()\n",
    "            for j in range(len(node_merged)):\n",
    "                mat.append(math.sqrt(abs(plon[j] - glon[j])**2 + abs(plat[j] - glat[j])**2))\n",
    "\n",
    "            # Check if distances are within 1000m and join remaining info and concat in master df per 1000.\n",
    "            mat_df = pd.DataFrame(mat)[(np.array(mat) <= np.max(thresholds))]\n",
    "\n",
    "            # join the other gravity euclidean scores and other information\n",
    "            mat_df.columns = ['Euclidean']    \n",
    "            mat_df = mat_df.join(node_merged)\n",
    "\n",
    "            output = pd.concat([output, mat_df])\n",
    "\n",
    "            print('in chunk',(i+1),'/',len4,len(mat_df),'suitible comb.')\n",
    "        # Renaming columns\n",
    "        print('total combinations within distance',len(output))\n",
    "\n",
    "        output.columns = ['Euclidean','Grid_No','Park_entry_No','grid_lon','grid_lat','Grid_coords_centroid','Grid_m_centroid',\n",
    "                      'Park_No','Parkroad_osmid','Park_geom','Parkroad_coords_centroid','Parkroad_m_centroid','park_lon',\n",
    "                      'park_lat','parkshare_walked','park_area','walk_area_m2']\n",
    "\n",
    "        output = output[['Euclidean','Grid_No','Park_entry_No','Grid_coords_centroid','Grid_m_centroid','walk_area_m2',\n",
    "                     'Park_No','Parkroad_osmid','Park_geom','Parkroad_coords_centroid','Parkroad_m_centroid','park_area']]\n",
    "\n",
    "        # Reinstate geographic elements\n",
    "        output = gpd.GeoDataFrame(output, geometry = 'Grid_coords_centroid', crs = 4326)\n",
    "        output['Grid_m_centroid'] = gpd.GeoSeries(output['Grid_m_centroid'], crs = 3043)\n",
    "        output['Parkroad_coords_centroid'] = gpd.GeoSeries(output['Parkroad_coords_centroid'], crs = 4326)\n",
    "        output['Parkroad_m_centroid'] = gpd.GeoSeries(output['Parkroad_m_centroid'], crs = 3043)\n",
    "\n",
    "        # Get the nearest entrance point for the grid centroids\n",
    "        output = gridroad_entry(output, road_nodes[l])\n",
    "\n",
    "        print('100 % gridentry done', round((time.time() - start_time) / 60,2),' mns')\n",
    "        RoadComb.append(output)\n",
    "    return (RoadComb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e9d2c955",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gridroad_entry (suitible_comb, road_nodes):    \n",
    "    start_time = time.time()\n",
    "    mat5 = list()\n",
    "    for i in range(len(suitible_comb)):\n",
    "        try:\n",
    "            nearest = int(road_nodes['geometry'].sindex.nearest(suitible_comb['Grid_coords_centroid'].iloc[i])[1])\n",
    "            mat5.append(road_nodes['osmid_var'].iloc[nearest])\n",
    "        except: \n",
    "            # sometimes two nodes are the exact same distance, then the first in the list is taken.\n",
    "            nearest = int(road_nodes['geometry'].sindex.nearest(suitible_comb['Grid_coords_centroid'].iloc[i])[1][0])\n",
    "            mat5.append(road_nodes['osmid_var'].iloc[nearest])\n",
    "        if i % 250000 == 0: print(round(i/len(suitible_comb)*100,1),'% gridentry done', round((time.time() - start_time) / 60,2),' mns')\n",
    "    # format resulting dataframe\n",
    "    suitible_comb['grid_osm'] = mat5\n",
    "    suitible_comb = pd.merge(suitible_comb, road_nodes['geometry'], left_on = 'grid_osm', right_index = True)\n",
    "    suitible_comb['geometry_m'] = gpd.GeoSeries(suitible_comb['geometry'], crs = 4326).to_crs(3043)\n",
    "    suitible_comb = suitible_comb.reset_index()\n",
    "    return(suitible_comb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a8f10468",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check grids in or out of UGS\n",
    "def grids_in_UGS (suitible_comb, UGS, pop_grid): \n",
    "    start_time = time.time()\n",
    "    RoadInOut = list()\n",
    "    for i in range(len(suitible_comb)):\n",
    "        UGS_geoms = UGS[i]['geometry'].to_crs(4326)\n",
    "        grid = pop_grid[i]['centroid']\n",
    "        lst = list()\n",
    "        print('Check grids within UGS')\n",
    "        for l in enumerate(UGS_geoms):\n",
    "            lst.append(grid.intersection(l[1]).is_empty == False)\n",
    "            if l[0] % 100 == 0: print(l[0], round((time.time() - start_time) / 60,2),' mns')\n",
    "\n",
    "        dfGrUGS = pd.DataFrame(pd.DataFrame(np.array(lst)).unstack())\n",
    "        dfGrUGS.columns = ['in_out_UGS']\n",
    "        merged = pd.merge(suitible_comb[i], dfGrUGS, left_on = ['Grid_No','Park_No'], right_index = True, how = 'left')\n",
    "        RoadInOut.append(merged)\n",
    "    return(RoadInOut)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b44555aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Block 7 calculate route networks of all grid-parkentry combinations within euclidean threshold distance\n",
    "def route_finding (graphs, combinations, road_nodes, road_edges, cities, block_size = 250000, nn_iter = 10):\n",
    "\n",
    "    warnings.filterwarnings(\"ignore\")\n",
    "    start_time = time.time()\n",
    "\n",
    "    Routes = list()\n",
    "    Routes_detail = list()\n",
    "    for j in range(len(cities)):\n",
    "        Graph = graphs[j]\n",
    "        suit_raw = combinations[j] # iloc to test the iteration speed.\n",
    "        nodes = road_nodes[j]\n",
    "\n",
    "        In_UGS = suit_raw[suit_raw['in_out_UGS'] == True] # Check if a grid centroid is in an UGS\n",
    "        suitible = suit_raw[suit_raw['in_out_UGS'] == False].reset_index(drop = True) # recreate a subsequential index\n",
    "                                                                                      # for the other grids outside UGS\n",
    "        block = block_size # Execute with chunks for performance improvement.\n",
    "\n",
    "        Route_parts = pd.DataFrame()\n",
    "        Route_dparts = pd.DataFrame()\n",
    "        len2 = int(np.ceil(len(suitible)/block))\n",
    "        # Divide in chunks of block for computational load\n",
    "        for k in range(len2):    \n",
    "            suitible_chunk = suitible.iloc[k*block:k*block+block] # Select chunk\n",
    "\n",
    "            parknode = list(suitible_chunk['Parkroad_osmid'])\n",
    "            gridnode = list(suitible_chunk['grid_osm'])\n",
    "\n",
    "            s_mat = list([]) # origin (normally grid) osmid\n",
    "            s_mat1 = list([]) # destination (normally UGS) osmid\n",
    "            s_mat2 = list([]) # route id\n",
    "            s_mat3 = list([]) # step id\n",
    "            s_mat4 = list([]) # way calculated\n",
    "            s_mat5 = list([]) # way calculated id\n",
    "            mat_nn = [] # found nearest nodes by block\n",
    "            len1 = len(suitible_chunk)\n",
    "\n",
    "            print(cities[j].rsplit(',')[0], k+1,'/',len2,'range',k*block,'-',k*block+np.where(k*block+block >= len1,len1,block))\n",
    "            for i in range(len(suitible_chunk)):\n",
    "                try: \n",
    "                    # from grid to UGS.\n",
    "                    shortest = nx.shortest_path(Graph, gridnode[i], parknode[i], 'travel_dist', method = 'dijkstra')\n",
    "                    s_mat.append(shortest)\n",
    "                    shortest_to = list(shortest[1:len(shortest)])\n",
    "                    shortest_to.append(-1)\n",
    "                    s_mat1.append(shortest_to)\n",
    "                    s_mat2.append(list(np.repeat(i+block*k, len(shortest))))\n",
    "                    s_mat3.append(list(np.arange(0, len(shortest))))\n",
    "                    s_mat4.append('normal way')\n",
    "                    s_mat5.append(1)\n",
    "                except:\n",
    "                    try:\n",
    "                        # Check the reverse\n",
    "                        shortest = nx.shortest_path(Graph, parknode[i], gridnode[i], 'travel_dist', method = 'dijkstra')\n",
    "                        s_mat.append(shortest)\n",
    "                        shortest_to = list(shortest[1:len(shortest)])\n",
    "                        shortest_to.append(-1)\n",
    "                        s_mat1.append(shortest_to)\n",
    "                        s_mat2.append(list(np.repeat(i+block*k, len(shortest))))\n",
    "                        s_mat3.append(list(np.arange(0, len(shortest))))\n",
    "                        s_mat4.append('reverse way')\n",
    "                        s_mat5.append(0)\n",
    "                    except:\n",
    "                        # Otherwise find nearest nodes (grid and UGS) and try to find routes between them\n",
    "                        nn_route_finding(Graph, suitible_chunk, nodes, s_mat, s_mat1, s_mat2, s_mat3,\n",
    "                                             s_mat4, s_mat5, mat_nn, i, block, k, nn_iter)\n",
    "                        \n",
    "                if i % 10000 == 0: print(round((i+block*k)/len(suitible)*100,2),'% done',\n",
    "                                         round((time.time() - start_time) / 60,2),'mns')\n",
    "            print('for', len(mat_nn),'routes nearest nodes found')\n",
    "\n",
    "            print(round((i+block*k)/len(suitible)*100,2),'% pathfinding done', round((time.time() - start_time) / 60,2),'mns')\n",
    "\n",
    "            # Formats route information by route and step (detailed)\n",
    "            routes = route_formatting(s_mat, s_mat1, s_mat2, s_mat3, road_edges[j]) # Formats lists to routes detail.\n",
    "            print('formatting done', round((time.time() - start_time) / 60,2), 'mns')\n",
    "            \n",
    "            # Summarizes information by route\n",
    "            routes2 = route_summarization(routes, suitible_chunk, road_nodes[j], s_mat4, s_mat5) # formats routes to summary\n",
    "            print('dissolving done', round((time.time() - start_time) / 60,2), 'mns')\n",
    "            \n",
    "            Route_parts = pd.concat([Route_parts, routes2])\n",
    "            Route_dparts = pd.concat([Route_dparts, routes])\n",
    "\n",
    "        # Format grids in UGS to enable smooth df concat\n",
    "        In_UGS = In_UGS.set_geometry(In_UGS['Grid_coords_centroid'])\n",
    "        In_UGS = In_UGS[['geometry','Grid_No','grid_osm','Park_No','Park_entry_No','Parkroad_osmid',\n",
    "                                   'Grid_m_centroid','walk_area_m2',\n",
    "                                   'Euclidean','geometry_m']]\n",
    "\n",
    "        In_UGS['realG_osmid'] = suit_raw['Parkroad_osmid']\n",
    "        In_UGS['realP_osmid'] = suit_raw['grid_osm']\n",
    "        In_UGS['way_calc'] = 'grid in UGS'\n",
    "\n",
    "        Route_parts = pd.concat([Route_parts,In_UGS])\n",
    "        Route_parts = Route_parts.reset_index(drop = True)\n",
    "\n",
    "        Route_parts['gridpark_no'] = Route_parts['Grid_No'].astype(str) +'-'+ Route_parts['Park_No'].astype(str)\n",
    "\n",
    "        # All fill value 0 because no routes are calculated for grid centroids in UGSs\n",
    "        to_fill = ['way-id','route_cost','steps','real_G-entry','Tcost']                                   \n",
    "        Route_parts[to_fill] = Route_parts[to_fill].fillna(0)  \n",
    "            \n",
    "        Routes.append(Route_parts)\n",
    "        Routes_detail.append(Route_dparts)\n",
    "    return(Routes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a680b152",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nn_route_finding(graph, suitible_chunk, nodes, mat_from, mat_to, mat_route, mat_step,\n",
    "                                             mat_way, mat_wbin, mat_nn, i, block, k, nn_iter):\n",
    "                        \n",
    "    # Order in route for nearest node:\n",
    "    # 1. gridnode to nearest to the original failed parknode\n",
    "    # 2. The reverse of 1.\n",
    "    # 3. nearest gridnode to the failed one and route to park\n",
    "    # 4. The reverse of 3.\n",
    "                        \n",
    "    gridosm = suitible_chunk['grid_osm'] # grid osmid\n",
    "    UGSosm = suitible_chunk['Parkroad_osmid'] # UGS osmid\n",
    "    nodeosm = nodes['osmid_var'] # road node osmid\n",
    "    nodegeom = nodes['geometry'] # road node geometry\n",
    "                        \n",
    "    len3 = 0\n",
    "    alt_route = list([])\n",
    "    while len3 < nn_iter and len(alt_route) < 1: # If a route is found (alt_route == 1) or until max iterations\n",
    "\n",
    "        len3 = len3 +1\n",
    "                            \n",
    "        nn = nn_finding(gridosm, UGSosm, nodeosm, nodegeom, nodes, i, len3) # finds nearest node.\n",
    "\n",
    "        nn_routing (graph, nn['currUGS'], nn['nearUGS'], nn['currgrid'], nn['neargrid'], \n",
    "                                        mat_way, mat_wbin, len3, alt_route) # executes route finding in try order.\n",
    "    if len(alt_route) == 0: \n",
    "        alt = alt_route \n",
    "    else: \n",
    "        alt = alt_route[0]\n",
    "    len4 = len(alt)\n",
    "    if len4 > 0: # If a route is found\n",
    "        mat_nn.append(i+block*k)\n",
    "        mat_from.append(alt)\n",
    "        shortest_to = list(alt[1:len(alt)])\n",
    "        shortest_to.append(-1)\n",
    "        mat_to.append(shortest_to)\n",
    "        mat_route.append(list(np.repeat(i+block*k,len4)))\n",
    "        mat_step.append(list(np.arange(0, len4)))\n",
    "    else: # If a route is not found\n",
    "        mat_from.append(-1)\n",
    "        mat_to.append(-1)\n",
    "        mat_route.append(i+block*k)\n",
    "        mat_step.append(-1)\n",
    "        mat_way.append('no way')\n",
    "        mat_wbin.append(2)\n",
    "        print(i+block*k,'No route',nn_iter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "695e9681",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nn_finding (gridosm, UGSosm, nodeosm, nodegeom, nodes, i, nn_i): \n",
    "    # Grid nearest\n",
    "    g_geom = nodegeom[nodeosm == int(gridosm[i:i+1])] # Get geom of current node UGS\n",
    "    g_nearest = pd.DataFrame((abs(float(g_geom.x) - nodegeom.x)**2 # Check distance UGS\n",
    "    +abs(float(g_geom.y) - nodegeom.y)**2)**(1/2)\n",
    "                            ).join(nodeosm).sort_values(0) # sort by distance ascending UGS\n",
    "\n",
    "    g_grid = g_nearest.iloc[nn_i,1] # get the nearest node according to the nn_iter UGS entry\n",
    "    g_park = list(UGSosm)[i] # current node\n",
    "        \n",
    "    p_geom = nodegeom[nodeosm == int(UGSosm[i:i+1])] # get the geom of the current node grid\n",
    "    p_nearest = pd.DataFrame((abs(float(p_geom.x) - nodegeom.x)**2 # Check distance grid\n",
    "    +abs(float(p_geom.y) - nodegeom.y)**2)**(1/2)\n",
    "                            ).join(nodeosm).sort_values(0) # sort by distance ascending grid\n",
    "\n",
    "    p_grid = list(gridosm)[i] # current node\n",
    "    p_park = p_nearest.iloc[nn_i,1] # get the nearest node to the nn_iter grid\n",
    "    return({'currUGS':p_grid, 'nearUGS':p_park,'currgrid':g_park, 'neargrid':g_grid})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "65f7c352",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nn_routing (graph, curr_UGS, near_UGS, curr_grid, near_grid, mat_way, mat_wbin, nn_i, found_route):\n",
    "    try:\n",
    "        found_route.append(nx.shortest_path(graph, curr_UGS, near_UGS, \n",
    "                                          'travel_dist', method = 'dijkstra'))\n",
    "        mat_way.append(str(nn_i)+'grid > n-park') # grid to nearest unseen UGS node\n",
    "        mat_wbin.append(1)\n",
    "    except:\n",
    "        try:\n",
    "            found_route.append(nx.shortest_path(graph, near_UGS, curr_UGS, \n",
    "                                              'travel_dist', method = 'dijkstra'))\n",
    "            mat_way.append(str(nn_i)+'n-park > grid') # nearest unseen UGS node to grid\n",
    "            mat_wbin.append(0)\n",
    "        except:\n",
    "            try:\n",
    "                found_route.append(nx.shortest_path(graph, curr_grid, near_grid, \n",
    "                                                  'travel_dist', method = 'dijkstra'))\n",
    "                mat_way.append(str(nn_i)+'n-grid > park') # nearest grid node to UGS\n",
    "                mat_wbin.append(1)\n",
    "            except:\n",
    "                try:\n",
    "                    found_route.append(nx.shortest_path(graph, near_grid, curr_grid, \n",
    "                                                      'travel_dist', method = 'dijkstra'))\n",
    "                    mat_way.append(str(nn_i)+'park > n-grid') # UGS to nearest grid node\n",
    "                    mat_wbin.append(0)\n",
    "                except:\n",
    "                    try:\n",
    "                        found_route.append(nx.shortest_path(graph, near_grid, near_UGS, \n",
    "                                                      'travel_dist', method = 'dijkstra'))\n",
    "                        mat_way.append(str(nn_i)+'park > n-grid') # UGS to nearest grid node\n",
    "                        mat_wbin.append(0)\n",
    "                    except:\n",
    "                        try:\n",
    "                            found_route.append(nx.shortest_path(graph, near_UGS, near_grid, \n",
    "                                                      'travel_dist', method = 'dijkstra'))\n",
    "                            mat_way.append(str(nn_i)+'park > n-grid') # UGS to nearest grid node\n",
    "                            mat_wbin.append(1)\n",
    "                        except:\n",
    "                            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9dd0bea7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def route_formatting(mat_from, mat_to, mat_route, mat_step, road_edges):\n",
    "    # Unpack lists\n",
    "    s_mat_u = [i for b in map(lambda x:[x] if not isinstance(x, list) else x, mat_from) for i in b]\n",
    "    s_mat_u1 = [i for b in map(lambda x:[x] if not isinstance(x, list) else x, mat_to) for i in b]\n",
    "    s_mat_u2 = [i for b in map(lambda x:[x] if not isinstance(x, list) else x, mat_route) for i in b]\n",
    "    s_mat_u3 = [i for b in map(lambda x:[x] if not isinstance(x, list) else x, mat_step) for i in b]\n",
    "\n",
    "    # Format df\n",
    "    routes = pd.DataFrame([s_mat_u,s_mat_u1,s_mat_u2,s_mat_u3]).transpose()\n",
    "    routes.columns = ['from','to','route','step']\n",
    "    mat_key = list([])\n",
    "    for n in range(len(routes)): # get key of origin and destination\n",
    "        mat_key.append(str(int(s_mat_u[n])) + '-' + str(int(s_mat_u1[n])))\n",
    "    routes['key'] = mat_key\n",
    "    routes = routes.set_index('key')\n",
    "\n",
    "    # Add route information\n",
    "    routes = routes.join(road_edges, how = 'left') # to add road node information\n",
    "    routes = gpd.GeoDataFrame(routes, geometry = 'geometry', crs = 4326)\n",
    "    routes = routes.sort_values(by = ['route','step'])\n",
    "    return(routes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "84241ed6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def route_summarization(routes, suitible_comb, road_nodes, mat_way, mat_wbin):\n",
    "    # dissolve route\n",
    "    routes2 = routes[['route','geometry']].dissolve('route')\n",
    "\n",
    "    # get used grid- and parkosm. Differs at NN-route.\n",
    "    route_reset = routes.reset_index()\n",
    "    origin = route_reset['from'].iloc[list(route_reset.groupby('route')['step'].idxmin()),]\n",
    "    origin = origin.reset_index().iloc[:,-1]\n",
    "    dest = route_reset['from'].iloc[list(route_reset.groupby('route')['step'].idxmax()),]\n",
    "    dest = dest.reset_index().iloc[:,-1]\n",
    "\n",
    "    # grid > park = 1, park > grid = 0, no way = 2, detailed way in way_calc.\n",
    "    routes2['way-id'] = mat_wbin\n",
    "    routes2['realG_osmid'] = np.where(routes2['way-id'] == 1, origin, dest)\n",
    "    routes2['realP_osmid'] = np.where(routes2['way-id'] == 1, dest, origin)\n",
    "    routes2['way_calc'] = mat_way\n",
    "\n",
    "    # get route cost, steps, additional information.\n",
    "    routes2['route_cost'] = routes.groupby('route')['length'].sum()\n",
    "    routes2['steps'] = routes.groupby('route')['step'].max()\n",
    "    routes2['index'] = suitible_comb.index\n",
    "    routes2 = routes2.set_index(['index'])\n",
    "    routes2.index = routes2.index.astype(int)\n",
    "    routes2 = pd.merge(routes2, suitible_comb[['Grid_No','grid_osm','Park_No','Park_entry_No','Parkroad_osmid',\n",
    "                                          'Grid_m_centroid','walk_area_m2','Euclidean']],\n",
    "                                            left_index = True, right_index = True)\n",
    "    routes2 = pd.merge(routes2, road_nodes['geometry_m'], how = 'left', left_on = 'realG_osmid', right_index = True)\n",
    "    # calculate distance of used road-entry for grid-centroid.\n",
    "    routes2['real_G-entry'] = round(gpd.GeoSeries(routes2['Grid_m_centroid'], crs = 3043).distance(routes2['geometry_m']),3)\n",
    "                                    \n",
    "    # Calculcate total route cost for the four gravity variants\n",
    "    routes2['Tcost'] = routes2['route_cost'] + routes2['real_G-entry']\n",
    "    return(routes2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e355b43e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def min_gridUGS_comb (routes, grids, UGS):\n",
    "    gp_nearest = []\n",
    "    for i in range(len(routes)):\n",
    "        gp_nn = routes[i][routes[i]['Tcost'] <= max(thresholds)]\n",
    "        gp_nn = pd.merge(gp_nn, grids[i]['population'], left_on='Grid_No', right_index = True)\n",
    "        gp_nn = pd.merge(gp_nn, UGS[i]['park_area'], left_on = 'Park_No', right_index = True)\n",
    "        gp_nn = gp_nn.reset_index()\n",
    "\n",
    "        gp_nn = gp_nn.iloc[gp_nn.groupby('gridpark_no')['Tcost'].idxmin()]\n",
    "        gp_nn.index.name = 'idx'\n",
    "        gp_nn = gp_nn.sort_values('idx')\n",
    "        gp_nn = gp_nn.reset_index()\n",
    "        gp_nearest.append(gp_nn)\n",
    "    gp_nearest[0].sort_values('Grid_No')\n",
    "    return(gp_nearest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ebb4c053",
   "metadata": {},
   "outputs": [],
   "source": [
    "def E2SCFA_scores(min_gridUGS_comb, grids, thresholds, cities):\n",
    "    pd.options.display.float_format = '{:20,.2f}'.format\n",
    "    E2SFCA_cities = []\n",
    "    E2SFCA_summary = pd.DataFrame()\n",
    "    for i in range(len(cities)):\n",
    "        E2SFCA_score = grids[i][['population','geometry']]\n",
    "        for j in range(len(thresholds)):\n",
    "            subset = min_gridUGS_comb[i][min_gridUGS_comb[i]['Tcost'] <= thresholds[j]]\n",
    "\n",
    "            # use gussian distribution: let v= 923325, then the weight for 800m is 0.5\n",
    "            v = -thresholds[j]**2/np.log(0.5)\n",
    "\n",
    "            # add a column of weight: apply the decay function on distance\n",
    "            subset['weight'] = np.exp(-(subset['Tcost']**2/v)).astype(float)\n",
    "            subset['pop_weight'] = subset['weight'] * subset['population']\n",
    "\n",
    "            # get the sum of weighted population each green space has to serve.\n",
    "            s_w_p = pd.DataFrame(subset.groupby('Park_No').sum('pop_weight')['pop_weight'])\n",
    "\n",
    "            # delete other columns, because they are useless after groupby\n",
    "            s_w_p = s_w_p.rename({'pop_weight':'pop_weight_sum'},axis = 1)\n",
    "            middle = pd.merge(subset,s_w_p, how = 'left', on = 'Park_No' )\n",
    "\n",
    "            # calculate the supply-demand ratio for each green space\n",
    "            middle['green_supply'] = middle['park_area']/middle['pop_weight_sum']\n",
    "\n",
    "            # caculate the accessbility score for each green space that each population grid cell could reach\n",
    "            middle['Sc-access'] = middle['weight'] * middle['green_supply']\n",
    "            # add the scores for each population grid cell\n",
    "            pop_score_df = pd.DataFrame(middle.groupby('Grid_No').sum('Sc-access')['Sc-access'])\n",
    "\n",
    "            # calculate the mean distance of all the green space each population grid cell could reach\n",
    "            mean_dist = middle.groupby('Grid_No').mean('Tcost')['Tcost']\n",
    "            pop_score_df['M-dist'] = mean_dist\n",
    "\n",
    "            # calculate the mean area of all the green space each population grid cell could reach\n",
    "            mean_area = middle.groupby('Grid_No').mean('park_area')['park_area']\n",
    "            pop_score_df['M-area'] = mean_area\n",
    "\n",
    "            # calculate the mean supply_demand ratio of all the green space each population grid cell could reach\n",
    "            mean_supply = middle.groupby('Grid_No').mean('green_supply')['green_supply']\n",
    "            pop_score_df['M-supply'] = mean_supply\n",
    "\n",
    "            pop_score = pop_score_df\n",
    "\n",
    "            pop_score_df = pop_score_df.join(grids[i]['population'], how = 'right')\n",
    "            pop_score_df['Sc-norm'] = pop_score_df['Sc-access'] / pop_score_df['population']\n",
    "\n",
    "            pop_score_df = pop_score_df.loc[:, pop_score_df.columns != 'population']\n",
    "            pop_score_df = pop_score_df.add_suffix(' '+str(thresholds[j]))\n",
    "            E2SFCA_score = E2SFCA_score.join(pop_score_df, how = 'left')\n",
    "\n",
    "            print(thresholds[j], cities[i])\n",
    "\n",
    "        E2SFCA_score = E2SFCA_score.fillna(0)\n",
    "        \n",
    "        if not os.path.exists('D:Dumps/E2SFCA-OD/Scores local/grid_geoms/'):\n",
    "            os.makedirs('D:Dumps/E2SFCA-OD/Scores local/grid_geoms/')\n",
    "            \n",
    "        E2SFCA_score.to_file('D:Dumps/E2SFCA-OD/Scores local/grid_geoms/'+cities[i]+'.shp') # Detailed scores\n",
    "        pop_sum = pd.Series(E2SFCA_score['population'].sum()).astype(int)\n",
    "        pop_sum.index = ['population']\n",
    "        mean_metrics = E2SFCA_score.loc[:, E2SFCA_score.columns != 'population'].mean()\n",
    "        E2SFCA_sum = pd.concat([pop_sum, mean_metrics])\n",
    "        E2SFCA_summary = pd.concat([E2SFCA_summary, E2SFCA_sum], axis = 1) # summarized results\n",
    "        E2SFCA_cities.append(E2SFCA_score)\n",
    "        \n",
    "        if not os.path.exists('D:/Dumps/E2SFCA-OD/Scores local/'):\n",
    "            os.makedirs('D:/Dumps/E2SFCA-OD/Scores local/')\n",
    "        \n",
    "        E2SFCA_score.loc[:, E2SFCA_score.columns != 'geometry'].to_csv('D:/Dumps/E2SFCA-OD/Scores local/'+cities[i]+'.csv')\n",
    "    E2SFCA_summary.columns = cities\n",
    "    \n",
    "    if not os.path.exists('D:/Dumps/E2SFCA-OD/Scores local/'):\n",
    "        os.makedirs('D:/Dumps/E2SFCA-OD/Scores local/')\n",
    "    \n",
    "    E2SFCA_summary.to_csv('D:/Dumps/E2SFCA-OD/Scores local/all_cities.csv')\n",
    "    E2SFCA_summary\n",
    "    return({'score summary':E2SFCA_summary,'score detail':E2SFCA_cities})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82686f3c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}