main.py.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hybrid Multimodal Urban Routes\n",
    "\n",
    "The focus of this activity is to evaluate the impacts of using Hybrid Urban Routing to a set trips identified in the city of São Paulo using the Twitter API. We collected geo-located tweets, anonymized them and in the present experiment we will cluster these tweets in order to identify trip flows. After this identification of flows we will evaluate the impacts in terms of price, duration and walking distance in the trips in case they were performed using hybrid routing.\n",
    "\n",
    "## Record Linkage\n",
    "\n",
    "The first step consists in linking the individual tweets into trips. To do so we will link all time-sequenced tweets from the same user and take them as trips. After this initial linkage, some filters are applied in order to keep only valid trips. For example, we consider valid trips only trips started and finished in the same day, bounded between 2 Km/h and 100 Km/h. Other filters were also used in the following code.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw size: 690139\n",
      "user links filtered: 588760\n",
      "same day filtered: 94411\n",
      "length filtered: 40612\n",
      "0s filtered: 40567\n",
      "speed filtered: 15675\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "from haversine import haversine\n",
    "\n",
    "directory = 'data/anonym/'\n",
    "file = 'twitter-sao-paulo.csv'\n",
    "\n",
    "df = pd.read_csv(directory + file)\n",
    "print('raw size: %d' % len(df))\n",
    "\n",
    "if file == 'twitter-sp.csv':\n",
    "    df['layer'] = 'twitter_sp'\n",
    "\n",
    "df = df.sort_values(by=['uid', 'timestamp'], ascending=True)\n",
    "df = pd.concat([df.add_suffix('_departure'), df.shift(-1).add_suffix('_arrival')], axis=1)\n",
    "\n",
    "df = df[df.uid_departure == df.uid_arrival]\n",
    "print('user links filtered: %d' % len(df))\n",
    "\n",
    "df['day_diff'] = df.apply(lambda r: abs(int(r.timestamp_arrival / 24 / 60 / 60) - int(r.timestamp_departure / 24 / 60 / 60)), axis=1)\n",
    "df = df[df.day_diff == 0]\n",
    "print('same day filtered: %d' % len(df))\n",
    "\n",
    "df['distance'] = df.apply(lambda r: haversine((r.lat_departure, r.lon_departure), (r.lat_arrival, r.lon_arrival)), axis=1)\n",
    "df = df[df.distance > 0.1]\n",
    "print('length filtered: %d' % len(df))\n",
    "\n",
    "df = df[df.timestamp_arrival > df.timestamp_departure]\n",
    "print('0s filtered: %d' % len(df))\n",
    "\n",
    "df['speed'] = df.apply(lambda r: r.distance / (r.timestamp_arrival - r.timestamp_departure) * 60 * 60, axis=1)\n",
    "df = df[(df.speed > 2) & (df.speed < 100)]\n",
    "print('speed filtered: %d' % len(df))\n",
    "\n",
    "# formating\n",
    "df.drop(['layer_arrival', 'uid_arrival', 'day_diff'], axis=1, inplace=True)\n",
    "df.rename({'layer_departure': 'layer', 'uid_departure': 'uid'}, axis=1, inplace=True)\n",
    "\n",
    "if not os.path.exists('data/trips/'):\n",
    "    os.makedirs('data/trips/')\n",
    "df.to_csv('data/trips/' + file, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clustering\n",
    "\n",
    "Once the trips were linked, the next objective is to cluster the main flows in those trips. This is done due to the long time taken to evaluate routes. Using the main flows we can have an idea of the impacts of the hybrid routing without computing every route in the dataset.\n",
    "\n",
    "In this step we use the [SMAFramework](https://github.com/diegopso/smaframework), a urban mobility analisys tool. This framework counts with an algorithm to identify main flows in a trip dataset. The algorithm uses [HDBSCAN](https://github.com/scikit-learn-contrib/hdbscan) algorithm to identify functional departure and arraival zones in the dataset; after it computes the flows between those zones and classify them in trending or secondary. \n",
    "\n",
    "The output is produced using Google Maps API, thus some keys must be configurated. In this section only Google Maps API is used, however we will configure all the keys. To do so, create a file called `.env` at the root of the project containing the API keys, like:\n",
    "\n",
    "\n",
    "```\n",
    "UBER_SERVER_TOKEN=your-key-here\n",
    "GOOGLE_MAPS_KEY=your-key-here\n",
    "TOMTOM_KEY=your-key-here\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: running HDBSCAN\n",
      "INFO: finished HDBSCAN with nclusters(origin=827, destination=834)\n",
      "INFO: flow_thershold=28.000000 for file=data/results/twitter-sao-paulo\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>flow</th>\n",
       "      <th>lat_arrival</th>\n",
       "      <th>lat_departure</th>\n",
       "      <th>lon_arrival</th>\n",
       "      <th>lon_departure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1453</th>\n",
       "      <td>65</td>\n",
       "      <td>-23.636980</td>\n",
       "      <td>-23.451383</td>\n",
       "      <td>-46.560042</td>\n",
       "      <td>-46.642510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1456</th>\n",
       "      <td>54</td>\n",
       "      <td>-23.519881</td>\n",
       "      <td>-23.451383</td>\n",
       "      <td>-46.680803</td>\n",
       "      <td>-46.642510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1636</th>\n",
       "      <td>76</td>\n",
       "      <td>-23.451423</td>\n",
       "      <td>-23.636992</td>\n",
       "      <td>-46.642496</td>\n",
       "      <td>-46.560095</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1638</th>\n",
       "      <td>32</td>\n",
       "      <td>-23.565010</td>\n",
       "      <td>-23.636992</td>\n",
       "      <td>-46.626663</td>\n",
       "      <td>-46.560095</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1639</th>\n",
       "      <td>60</td>\n",
       "      <td>-23.519881</td>\n",
       "      <td>-23.636992</td>\n",
       "      <td>-46.680803</td>\n",
       "      <td>-46.560095</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1650</th>\n",
       "      <td>44</td>\n",
       "      <td>-23.558154</td>\n",
       "      <td>-23.627975</td>\n",
       "      <td>-46.608289</td>\n",
       "      <td>-46.555166</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2844</th>\n",
       "      <td>63</td>\n",
       "      <td>-23.451423</td>\n",
       "      <td>-23.519865</td>\n",
       "      <td>-46.642496</td>\n",
       "      <td>-46.680793</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2845</th>\n",
       "      <td>61</td>\n",
       "      <td>-23.636980</td>\n",
       "      <td>-23.519865</td>\n",
       "      <td>-46.560042</td>\n",
       "      <td>-46.680793</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2846</th>\n",
       "      <td>52</td>\n",
       "      <td>-23.565010</td>\n",
       "      <td>-23.519865</td>\n",
       "      <td>-46.626663</td>\n",
       "      <td>-46.680793</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2910</th>\n",
       "      <td>47</td>\n",
       "      <td>-23.636980</td>\n",
       "      <td>-23.565065</td>\n",
       "      <td>-46.560042</td>\n",
       "      <td>-46.626571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2911</th>\n",
       "      <td>72</td>\n",
       "      <td>-23.519881</td>\n",
       "      <td>-23.565065</td>\n",
       "      <td>-46.680803</td>\n",
       "      <td>-46.626571</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      flow  lat_arrival  lat_departure  lon_arrival  lon_departure\n",
       "1453    65   -23.636980     -23.451383   -46.560042     -46.642510\n",
       "1456    54   -23.519881     -23.451383   -46.680803     -46.642510\n",
       "1636    76   -23.451423     -23.636992   -46.642496     -46.560095\n",
       "1638    32   -23.565010     -23.636992   -46.626663     -46.560095\n",
       "1639    60   -23.519881     -23.636992   -46.680803     -46.560095\n",
       "1650    44   -23.558154     -23.627975   -46.608289     -46.555166\n",
       "2844    63   -23.451423     -23.519865   -46.642496     -46.680793\n",
       "2845    61   -23.636980     -23.519865   -46.560042     -46.680793\n",
       "2846    52   -23.565010     -23.519865   -46.626663     -46.680793\n",
       "2910    47   -23.636980     -23.565065   -46.560042     -46.626571\n",
       "2911    72   -23.519881     -23.565065   -46.680803     -46.626571"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from smaframework.common.env import env\n",
    "import smaframework.analyzer.clustering.flow as FlowClusterer\n",
    "\n",
    "if not os.path.exists('data/results/'):\n",
    "    os.makedirs('data/results/')\n",
    "\n",
    "directory = 'data/trips/'\n",
    "FlowClusterer.cluster_hdbscan(directory + file, ['lat_departure', 'lon_departure'], ['lat_arrival', 'lon_arrival'], output_file='data/results/%s' % file[0:-4], gmaps_key=env('GOOGLE_MAPS_KEY'), min_size=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check the [Map Output](/view/data/results/twitter-sao-paulo.html) to visualize the flows identified."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Routing\n",
    "\n",
    "In this step, still making use of the SMAFramework to aid us, we will compute the routes for those flows. The idea is to combine routes to avoid traffic congestions, thus we will first compute a Driving Route for the flows using the [TomTom Routing API](https://developer.tomtom.com/), this API provide us some information abou the traffic conditions that can be used to improve the path. After collecting the driving ways we will compute the hybrid routes avoiding congested areas. To compute the routes we will use [Uber](https://developer.uber.com/) and [Google Directions](https://developers.google.com/maps/documentation/directions/start) API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Options for flow 1 computed.\n",
      "Options for flow 2 computed.\n",
      "Options for flow 3 computed.\n",
      "Options for flow 4 computed.\n",
      "Options for flow 5 computed.\n",
      "Options for flow 6 computed.\n",
      "Options for flow 7 computed.\n",
      "Options for flow 8 computed.\n",
      "Options for flow 9 computed.\n",
      "Options for flow 10 computed.\n",
      "Options for flow 11 computed.\n",
      "Options for flow 12 computed.\n"
     ]
    }
   ],
   "source": [
    "import json, datetime\n",
    "import smaframework.extractor.tomtom.router as TomTomRouter\n",
    "import smaframework.extractor.uber as UberExtractor\n",
    "import smaframework.extractor.google.directions as GoogleDirectionsExtractor\n",
    "\n",
    "def route(start, end):\n",
    "    # transit pricing\n",
    "    prices = {'TRANSIT': 4.30}\n",
    "\n",
    "    # get driving way with traffic information\n",
    "    driving_ways = TomTomRouter.getRoute(start, end, env('TOMTOM_KEY'), 0, True, False)\n",
    "    \n",
    "    # for each requested option\n",
    "    for way in driving_ways:\n",
    "        if 'sections' not in way.keys() or 'section' not in way['sections'].keys():\n",
    "            continue\n",
    "\n",
    "        # combine section to cover all traffic-avoidance options\n",
    "        sections = way['sections']['section']\n",
    "        if len(sections) > 0:\n",
    "            combined_sections = []\n",
    "            for (i, s1) in enumerate(sections):\n",
    "                for (j, s2) in enumerate(sections):\n",
    "                    if i >= j:\n",
    "                        continue\n",
    "\n",
    "                    combined_sections.append({\n",
    "                      \"sectionType\": \"TRAFFIC\",\n",
    "                      \"effectiveSpeedInKmh\": (float(s1['effectiveSpeedInKmh']) + float(s2['effectiveSpeedInKmh'])) / 2,\n",
    "                      \"delayInSeconds\": s1['delayInSeconds'] + s2['delayInSeconds'],\n",
    "                      \"magnitudeOfDelay\": max(s1['magnitudeOfDelay'], s2['magnitudeOfDelay']),\n",
    "                      \"effectiveSpeed\": (s1['effectiveSpeed'] + s2['effectiveSpeed']) / 2,\n",
    "                      \"startPoint\": s1['startPoint'],\n",
    "                      \"endPoint\": s2['endPoint']\n",
    "                    })\n",
    "            sections.extend(combined_sections)\n",
    "\n",
    "        # for each section with traffic, get some hybrid options\n",
    "        options = []\n",
    "        for section in sections:\n",
    "            # evaluate an HPV started option\n",
    "            transition = (section['startPoint']['@latitude'], section['startPoint']['@longitude'])\n",
    "            estimate = UberExtractor.estimate(env('UBER_SERVER_TOKEN'), start, transition, 1, 'UberX')\n",
    "            estimate['travel_mode'] = 'UberX'\n",
    "            transit = GoogleDirectionsExtractor.extract_single(env('GOOGLE_MAPS_KEY'), transition, end, datetime.datetime.now(), 'transit', prices)\n",
    "            option = [estimate]\n",
    "            option.extend(transit[0])\n",
    "            options.append(option)\n",
    "\n",
    "            # evaluate an HPV ended option\n",
    "            transition = (section['endPoint']['@latitude'], section['endPoint']['@longitude'])\n",
    "            transit = GoogleDirectionsExtractor.extract_single(env('GOOGLE_MAPS_KEY'), start, transition, datetime.datetime.now(), 'transit', prices)\n",
    "            estimate = UberExtractor.estimate(env('UBER_SERVER_TOKEN'), transition, end, 1, 'UberX')\n",
    "            estimate['travel_mode'] = 'UberX'\n",
    "            option = [estimate]\n",
    "            option.extend(transit[0])\n",
    "            options.append(option)\n",
    "\n",
    "    full_hpv = [UberExtractor.estimate(env('UBER_SERVER_TOKEN'), start, end, 1, 'UberX')]\n",
    "    full_hpv[0]['travel_mode'] = 'UberX'\n",
    "    full_transit = GoogleDirectionsExtractor.extract_single(env('GOOGLE_MAPS_KEY'), start, end, datetime.datetime.now(), 'transit', prices)[0]\n",
    "    options.extend([full_hpv, full_transit])\n",
    "    \n",
    "    return options\n",
    "    \n",
    "flows = json.load(open('data/results/twitter-sao-paulo.json', 'r+'))\n",
    "\n",
    "for (i, flow) in enumerate(flows):\n",
    "    start = (flow['link'][0]['lat'], flow['link'][0]['lng'])\n",
    "    end = (flow['link'][1]['lat'], flow['link'][1]['lng'])\n",
    "    flow['options'] = route(start, end)\n",
    "    print('Options for flow %d computed.' % (i+1))\n",
    "\n",
    "json.dump(flows, open('data/results/options.json', 'w+'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the options were evaluated and saved to the `data\\results` folder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization of Routes\n",
    "\n",
    "Next, the algorithm shows the steps for generating 2D interactive maps. Initially, the algorithm initializes the map, which will be generated as output with the suggested route. Each section (also called step) of the route has a series of information, such as origin, destination, travel time, and the most important for generation of the visualization, the **overview polyline** and the **transport mode**. Then, the algorithm decodes the overview polyline and stores it in a coordinate list. Thus, the section is plotted on the map, where the line color is defined according to the transport mode. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from smaframework.common.env import env\n",
    "from bs4 import BeautifulSoup as bs\n",
    "from datetime import datetime\n",
    "import googlemaps\n",
    "import polyline as pline\n",
    "import gmplot\n",
    "import json\n",
    "\n",
    "colors = {}\n",
    "colors[\"driving\"]   = \"blue\"\n",
    "colors[\"transit\"]   = \"red\"\n",
    "colors[\"walking\"]   = \"green\"\n",
    "colors[\"bicycling\"] = \"yellow\"\n",
    "\n",
    "gmaps = googlemaps.Client(key=env('GOOGLE_MAPS_KEY'))\n",
    "\n",
    "\n",
    "def plotRoute(frm, to, travel_mode, fname):\n",
    "    # Get a Google Maps directions (route) based on params and plot it in a HTML file.\n",
    "    now = datetime.now()\n",
    "    output_map = gmplot.GoogleMapPlotter(-23.551615, -46.633611, 12)    \n",
    "    for i in range(len(frm)):\n",
    "        route = gmaps.directions(frm[i], to[i],                                              \n",
    "                            departure_time=now,\n",
    "                            traffic_model=\"best_guess\",\n",
    "                            mode=travel_mode[i]                         \n",
    "                            )\n",
    "\n",
    "        # Save the route to use in the future.\n",
    "        with open('data/results/maps/'+fname+'.json', 'a') as fileRoute:\n",
    "            json.dump(route, fileRoute, indent=2)\n",
    "\n",
    "        # If the overview polyline of each STEP were given as a parameter, the code should start HERE\n",
    "\n",
    "        # Plot the route into the map\n",
    "        path = pline.decode(route[0]['overview_polyline']['points'])\n",
    "        lats = []\n",
    "        lngs = []\n",
    "        for step in path:\n",
    "            step = list(step)       \n",
    "            lats.append(step[0])\n",
    "            lngs.append(step[1])\n",
    "                \n",
    "        output_map.plot(lats, lngs, colors[travel_mode[i]], edge_width=3)   \n",
    "    url = 'data/results/maps/'+fname+'.html'\n",
    "    output_map.draw(url)\n",
    "\n",
    "    # Add the API key into html file\n",
    "    page = open(url)\n",
    "    soup = bs(page.read(),\"html.parser\")\n",
    "    src = \"https://maps.googleapis.com/maps/api/js?libraries=visualization&sensor=true_or_false\"\n",
    "    src_key  = \"https://maps.googleapis.com/maps/api/js?key=\"\n",
    "    src_key += env('GOOGLE_MAPS_KEY')\n",
    "    src_key += \"&libraries=visualization&sensor=true_or_false\"\n",
    "    line = soup.find('script',{\"src\":src})\n",
    "    line['src'] = line['src'].replace(src, src_key)\n",
    "    with open(url, \"wb\") as f_output:\n",
    "        f_output.write(soup.prettify(\"utf-8\"))  \n",
    "\n",
    "    return\n",
    "\n",
    "\n",
    "def read(fname):    \n",
    "    with open(fname, 'r') as file:\n",
    "        docs = json.load(file)\n",
    "    return docs\n",
    "\n",
    "\n",
    "def write(dist, wdist, price, duration, wait, path):\n",
    "    with open(path+'distance.json', 'w') as file:\n",
    "        json.dump(dist, file)\n",
    "    \n",
    "    with open(path+'wdistance.json', 'w') as file:\n",
    "        json.dump(wdist, file)\n",
    "    \n",
    "    with open(path+'price.json', 'w') as file:\n",
    "        json.dump(price, file)\n",
    "    \n",
    "    with open(path+'duration.json', 'w') as file:\n",
    "        json.dump(duration, file)\n",
    "    \n",
    "    with open(path+'wait.json', 'w') as file:\n",
    "        json.dump(wait, file)\n",
    "    \n",
    "    return\n",
    "        \n",
    "    \n",
    "def grab(docs):\n",
    "    distance = {}\n",
    "    walking_dist = {}\n",
    "    price = {}\n",
    "    duration = {}\n",
    "    wait = {}\n",
    "    for i, doc in enumerate(docs):        \n",
    "        for j, option in enumerate(doc[\"options\"]):\n",
    "            idx = str(i)+'-'+str(j)\n",
    "            distance[idx] = 0\n",
    "            walking_dist[idx] = 0\n",
    "            price[idx]    = 0\n",
    "            duration[idx] = 0\n",
    "            wait[idx] = 0\n",
    "            frm = []\n",
    "            to  = []\n",
    "            mode = []\n",
    "            for step in option:                \n",
    "                frm.append(str(step[\"origin\"][0])+','+str(step[\"origin\"][1]))\n",
    "                to.append(str(step[\"destination\"][0])+','+str(step[\"destination\"][1]))\n",
    "                if step[\"travel_mode\"] == \"UberX\":\n",
    "                    m = \"driving\"\n",
    "                else:\n",
    "                    m = str(step[\"travel_mode\"].lower())\n",
    "                mode.append(m)\n",
    "                if m == \"walking\":\n",
    "                    walking_dist[idx] += step[\"distance\"]\n",
    "                else:\n",
    "                    distance[idx] += step[\"distance\"]\n",
    "                if m == \"transit\":\n",
    "                    price[idx] += 4.25\n",
    "                else:\n",
    "                    price[idx] += step[\"price\"]\n",
    "                duration[idx] += step[\"duration\"]\n",
    "                if \"wait\" in step:\n",
    "                    wait[idx] += step[\"wait\"]            \n",
    "            plotRoute(frm, to, mode, str(i)+'-'+str(j)+'-routes')\n",
    "    \n",
    "    return distance, walking_dist, price, duration, wait        \n",
    "        \n",
    "        \n",
    "def worker():\n",
    "    docs = read('data/results/options_manuscript.json')\n",
    "    dist, wdist, price, duration, wait = grab(docs)\n",
    "    write(dist, wdist, price, duration, wait, 'data/results/logs/')\n",
    "        \n",
    "if __name__ == '__main__':\n",
    "    worker()        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check all interactive maps on [the maps folder](/tree/data/results/maps/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparative Analysis of Routes\n",
    "\n",
    "With the logs calculated above, we can calculate the cost (in terms of distance, walking distance, duration, price and waiting time) of routes. We also can evaluate the average impact of the use of multimodal routes (Hybrid 1 and 2) in comparison to the traditional routes (Public Transport and Uber) in all flows studied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import json\n",
    "\n",
    "#### Results For each selected route ####\n",
    "\n",
    "def plotResults(distance, wdistance, price, duration, wait):\n",
    "    keys = [['0-21','2-7','1-3','4-7','7-3','8-7','10-3'],\n",
    "            ['0-20','2-6','1-2','4-6','7-2','8-6','10-2'],\n",
    "            ['0-0','2-5','1-0','4-5','7-0','8-0','10-1'],\n",
    "            ['0-1','2-2','1-1','4-2','7-1','8-1','10-0']]\n",
    "\n",
    "    labels = ['Public Transport', 'Uber', 'Hybrid 1', 'Hybrid 2']\n",
    "    fluxos = ['Flow 1', 'Flow 2', 'Flow 3', 'Flow 4', 'Flow 5', 'Flow 6', 'Flow 7']\n",
    "\n",
    "    bars1, bars2, bars3, bars4 = getData(distance, keys, 1000)\n",
    "    wbars1, wbars2, wbars3, wbars4 = getData(wdistance, keys, 1000)\n",
    "    plotDistance(bars1,bars2,bars3,bars4,wbars1,wbars2,wbars3,wbars4,\n",
    "                 'Distance (km)', labels, fluxos, 'distancia_fluxos.png')\n",
    "\n",
    "    bars1, bars2, bars3, bars4 = getData(price, keys, 1)\n",
    "    plotBars(bars1, bars2, bars3, bars4, 'Price (R$)', labels, fluxos, 'preco_fluxos.png')\n",
    "\n",
    "    bars1, bars2, bars3, bars4 = getData(duration, keys, 60)\n",
    "    plotBars(bars1, bars2, bars3, bars4, 'Time (min)', labels, fluxos, 'duracao_fluxos.png')\n",
    "\n",
    "    bars1, bars2, bars3, bars4 = getData(wait, keys, 60)\n",
    "    plotBars(bars1, bars2, bars3, bars4, 'Time (min)', labels, fluxos, 'espera_fluxos.png')\n",
    "\n",
    "    return\n",
    "\n",
    "\n",
    "def plotBars(bars1, bars2, bars3, bars4, ylabel, labels, fluxos, fname):\n",
    "    # set width of bar\n",
    "    barWidth = 0.2\n",
    "    sns.set(style=\"whitegrid\")\n",
    "\n",
    "    # Set position of bar on X axis\n",
    "    r1 = np.arange(len(bars1))\n",
    "    r2 = [x + barWidth for x in r1]\n",
    "    r3 = [x + barWidth for x in r2]\n",
    "    r4 = [x + barWidth for x in r3]\n",
    "\n",
    "    # Plot bars chart\n",
    "    plt.bar(r1, bars1, color='#557f2d', width=barWidth, edgecolor='white', label=labels[0])\n",
    "    plt.bar(r2, bars2, color='#B8860B', width=barWidth, edgecolor='white', label=labels[1])\n",
    "    plt.bar(r3, bars3, color='#2d7f5e', width=barWidth, edgecolor='white', label=labels[2])\n",
    "    plt.bar(r4, bars4, color='#7f6d5f', width=barWidth, edgecolor='white', label=labels[3])\n",
    "\n",
    "    # Add xticks on the middle of the group bars\n",
    "    plt.xlabel('Flows', fontweight='bold')\n",
    "    plt.ylabel(ylabel, fontweight='bold')\n",
    "    plt.xticks([r + 2*barWidth for r in range(len(bars1))], fluxos)\n",
    " \n",
    "    # Create legend & Show graphic\n",
    "    plt.legend(loc=\"upper center\",\n",
    "              bbox_to_anchor=(0.5,1.15),\n",
    "              fancybox=True,\n",
    "              shadow=True,\n",
    "              ncol=3)\n",
    "    plt.show()\n",
    "    #plt.savefig('data/results/plots/'+fname)\n",
    "    plt.close()\n",
    "    return\n",
    "\n",
    "\n",
    "def plotDistance(bars1,bars2,bars3,bars4,wbars1,wbars2,wbars3,wbars4,ylabel,labels,fluxos,fname):\n",
    "    # set width of bar\n",
    "    barWidth = 0.2\n",
    "    sns.set(style=\"whitegrid\")\n",
    "\n",
    "    # Set position of bar on X axis\n",
    "    r1 = np.arange(len(bars1))\n",
    "    r2 = [x + barWidth for x in r1]\n",
    "    r3 = [x + barWidth for x in r2]\n",
    "    r4 = [x + barWidth for x in r3]\n",
    "\n",
    "    plt.bar(r1, bars1, color='#557f2d', width=barWidth, edgecolor='white', label=labels[0])\n",
    "    plt.bar(r1, wbars1, color='#6495ED', width=barWidth, bottom=bars1, edgecolor='white',label='Walking')\n",
    "    plt.bar(r2, bars2, color='#B8860B', width=barWidth, edgecolor='white', label=labels[1])\n",
    "    plt.bar(r2, wbars2, color='#6495ED', width=barWidth, bottom=bars2, edgecolor='white')\n",
    "    plt.bar(r3, bars3, color='#2d7f5e', width=barWidth, edgecolor='white', label=labels[2])\n",
    "    plt.bar(r3, wbars3, color='#6495ED', width=barWidth, bottom=bars3, edgecolor='white')\n",
    "    plt.bar(r4, bars4, color='#7f6d5f', width=barWidth, edgecolor='white', label=labels[3])\n",
    "    plt.bar(r4, wbars4, color='#6495ED', width=barWidth, bottom=bars4, edgecolor='white')\n",
    "\n",
    "    # Add xticks on the middle of the group bars\n",
    "    plt.xlabel('Flows', fontweight='bold')\n",
    "    plt.ylabel(ylabel, fontweight='bold')\n",
    "    plt.xticks([r + 2*barWidth for r in range(len(bars1))], fluxos)\n",
    " \n",
    "    # Create legend & Show graphic\n",
    "    plt.legend(loc=\"upper center\",\n",
    "              bbox_to_anchor=(0.5,1.15),\n",
    "              fancybox=True,\n",
    "              shadow=True,\n",
    "              ncol=3)\n",
    "    \n",
    "    plt.show()\n",
    "    #plt.savefig('data/results/plots/'+fname)\n",
    "    plt.close()\n",
    "    return\n",
    "\n",
    "\n",
    "def getData(metric, keys, div):\n",
    "    bars1 = [metric[key]/div for key in keys[0]]\n",
    "    bars2 = [metric[key]/div for key in keys[1]]\n",
    "    bars3 = [metric[key]/div for key in keys[2]]\n",
    "    bars4 = [metric[key]/div for key in keys[3]]\n",
    "\n",
    "    return bars1, bars2, bars3, bars4\n",
    "\n",
    "\n",
    "def read(path):\n",
    "    with open(path+'distance.json', 'r') as file:\n",
    "        dist = json.load(file)\n",
    "    \n",
    "    with open(path+'wdistance.json', 'r') as file:\n",
    "        wdist = json.load(file)\n",
    "    \n",
    "    with open(path+'price.json', 'r') as file:\n",
    "        price = json.load(file)\n",
    "    \n",
    "    with open(path+'duration.json', 'r') as file:\n",
    "        duration = json.load(file)\n",
    "    \n",
    "    with open(path+'wait.json', 'r') as file:\n",
    "        wait = json.load(file)\n",
    "    \n",
    "    return dist, wdist, price, duration, wait\n",
    "\n",
    "\n",
    "def worker():\n",
    "    dist, wdist, price, duration, wait = read('data/results/logs/')\n",
    "    plotResults(dist, wdist, price, duration, wait)\n",
    "    \n",
    "        \n",
    "if __name__ == '__main__':\n",
    "    worker()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import json\n",
    "\n",
    "#### The average values of evaluated metrics ####\n",
    "def plotResults(distance, wdistance, price, duration, wait):\n",
    "    transit_keys = ['0-21','2-7','1-3','4-7','7-3','8-7','10-3']\n",
    "    uber_keys    = ['0-20','2-6','1-2','4-6','7-2','8-6','10-2']\n",
    "    hybrid_keys  = ['0-0','2-5','1-0','4-5','7-0','8-0','10-1',\n",
    "                    '0-1','2-2','1-1','4-2','7-1','8-1','10-0']\n",
    "    \n",
    "    df = getDataFrame(distance, transit_keys, uber_keys, hybrid_keys,\"Distance (km)\", 1000)\n",
    "    plotBoxPlots(df, \"Distance (km)\" , 'avg_distancia.png', 'Average Distance Travelled')\n",
    "\n",
    "    df = getDataFrame(wdistance, transit_keys, uber_keys, hybrid_keys, \"Distance (km)\", 1000)\n",
    "    plotBoxPlots(df, \"Distance (km)\" , 'avg_wdistancia.png', 'Average Walking Distance')\n",
    "\n",
    "    df = getDataFrame(price, transit_keys, uber_keys, hybrid_keys, \"Price (R$)\", 1)\n",
    "    plotBoxPlots(df, \"Price (R$)\" , 'avg_preco.png', 'Average Price')\n",
    "\n",
    "    df = getDataFrame(duration, transit_keys, uber_keys, hybrid_keys, \"Time (min)\", 60)\n",
    "    plotBoxPlots(df, \"Time (min)\" , 'avg_duracao.png', 'Average Trip Duration')\n",
    "\n",
    "    df = getDataFrame(wait, transit_keys, uber_keys, hybrid_keys, \"Time (min)\", 60)\n",
    "    plotBoxPlots(df, \"Time (min)\" , 'avg_wait.png', 'Average Waiting Time')\n",
    "    \n",
    "    return\n",
    "\n",
    "\n",
    "def getDataFrame(metric, transit_keys, uber_keys, hybrid_keys, ylabel, div):\n",
    "    data = []\n",
    "    for key, value in metric.items():\n",
    "        d = {}\n",
    "        d[\"File\"] = key\n",
    "        d[ylabel] = value/div\n",
    "        if key in transit_keys:\n",
    "            d[\"Modo\"] = \"Public Transport\"\n",
    "            data.append(d)\n",
    "        elif key in uber_keys:\n",
    "            d[\"Modo\"] = \"Uber\"\n",
    "            data.append(d)\n",
    "        elif key in hybrid_keys:\n",
    "            d[\"Modo\"] = \"Hybrid\"\n",
    "            data.append(d)\n",
    "        else:\n",
    "            pass\n",
    "    df = pd.DataFrame(data)\n",
    "    \n",
    "    return df\n",
    "\n",
    "\n",
    "def plotBoxPlots(df, ylabel, fname, title):\n",
    "    sns.set(style=\"whitegrid\")\n",
    "    ax = sns.boxplot(x=\"Modo\", y=ylabel, data=df)\n",
    "    plt.xlabel('')\n",
    "    plt.title(title)\n",
    "    plt.show()\n",
    "    plt.savefig('data/results/plots/'+fname)\n",
    "    plt.close()\n",
    "\n",
    "    return\n",
    "\n",
    "\n",
    "def read(path):\n",
    "    with open(path+'distance.json', 'r') as file:\n",
    "        dist = json.load(file)\n",
    "    \n",
    "    with open(path+'wdistance.json', 'r') as file:\n",
    "        wdist = json.load(file)\n",
    "    \n",
    "    with open(path+'price.json', 'r') as file:\n",
    "        price = json.load(file)\n",
    "    \n",
    "    with open(path+'duration.json', 'r') as file:\n",
    "        duration = json.load(file)\n",
    "    \n",
    "    with open(path+'wait.json', 'r') as file:\n",
    "        wait = json.load(file)\n",
    "    \n",
    "    return dist, wdist, price, duration, wait\n",
    "\n",
    "\n",
    "def worker():\n",
    "    dist, wdist, price, duration, wait = read('data/results/logs/')\n",
    "    plotResults(dist, wdist, price, duration, wait)\n",
    "    \n",
    "        \n",
    "if __name__ == '__main__':\n",
    "    worker()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discussion and Final Remarks\n",
    "\n",
    "The work \"[Hybrid Context-Aware Multimodal Routing](https://doi.org/10.1109/ITSC.2018.8570008)\" performs experiments similar to those performed here, where the scenario used is the city of New York, NY, USA, and propose an optimization function to calculate the user experience according to the same metrics presented in this section, in order to support the decision-making process. Here, we have chosen to present and analyze two examples of multimodal routes beyond traditional routes. However, the only selection criteria of the multimodal routes was their composition, beign the two extremes (i.e., one being mostly with the Uber transport medium and the other with Public Transport), but none of the metrics were used individually (e.g., the lowest price multimodal route or trip duration) or together (e.g., the lowest price route and the shortest walking distance) to select these routes. If the reader intends to select the \"best\" multimodal routes to be compared with the traditional routes, multiobjective optimization methods must be explored and incorporated into the application."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}