Cars_in_Hours.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "import pytz\n",
    "import urllib as ur\n",
    "import json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funções para auxiliar a manipulação do tempo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def convert_datetime_timezone(dt, tz1, tz2):\n",
    "    \"\"\"\n",
    "    Converte uma hora no fuso UTC ou São Paulo para um provável fuso de Vancouver.\n",
    "    \n",
    "    Parameters\n",
    "    ------------\n",
    "    dt : unix timestamp\n",
    "        Timestamp a ser convertido para outro fuso horário.\n",
    "    \n",
    "    tz1, tz2 : Timezone String\n",
    "        Time zone atual e a que a hora irá ser convertida.\n",
    "    \n",
    "    Returns\n",
    "    ----------\n",
    "    dt : unix timestamp\n",
    "        Timestamp já convertida para o fuso de Vancouver.\n",
    "    \n",
    "    \"\"\"    \n",
    "    \n",
    "    tz1 = pytz.timezone(tz1)\n",
    "    tz2 = pytz.timezone(tz2)\n",
    "\n",
    "    dt = datetime.datetime.fromtimestamp(dt)\n",
    "    dt = datetime.datetime.strptime(str(dt),\"%Y-%m-%d %H:%M:%S\")\n",
    "    dt = tz1.localize(dt)\n",
    "    dt = dt.astimezone(tz2)\n",
    "    \n",
    "    try:\n",
    "        # Fuso horário comum de Vancouver\n",
    "        dt = datetime.datetime.strptime(str(dt),\"%Y-%m-%d %H:%M:%S-08:00\")\n",
    "    except:\n",
    "        # Fuso horário característico de horário de verão em Vancouver\n",
    "        dt = datetime.datetime.strptime(str(dt),\"%Y-%m-%d %H:%M:%S-07:00\")\n",
    "    \n",
    "    dt = int(dt.timestamp())\n",
    "\n",
    "    return dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def Hour_Diff(h1,h2):\n",
    "    \"\"\"\n",
    "    Faz a diferença entre duas horas dadas e retorna em minutos\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    h1, h2 : unix timestamp\n",
    "        Hora inicio e fim para ser feito o cálculo da diferença\n",
    "        \n",
    "    Returns\n",
    "    ---------\n",
    "    diff : float\n",
    "        Diferença entre as duas horas dadas em minutos\n",
    "        \n",
    "    \"\"\"\n",
    "    \n",
    "    h1Aux = datetime.datetime.fromtimestamp(h1)\n",
    "    h2Aux = datetime.datetime.fromtimestamp(h2)\n",
    "    diff = abs((h1Aux - h2Aux)).total_seconds()/60\n",
    "    \n",
    "    return diff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Requisitando Estacionamentos, carros e coordenadas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "response = ur.request.urlopen('https://bookit.modo.coop/api/v2/car_list').read().decode('UTF-8')\n",
    "json_cars = json.loads(response)\n",
    "\n",
    "response = ur.request.urlopen('https://bookit.modo.coop/api/v2/location_list').read().decode('UTF-8')\n",
    "json_location = json.loads(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_coord = pd.DataFrame(list(json_cars['Response']['Cars'].keys()), columns=['car_id'], dtype='int')\n",
    "car_coord['location'] = [0] * len(car_coord)\n",
    "car_coord['lat'] = [0] * len(car_coord)\n",
    "car_coord['lon'] = [0] * len(car_coord)\n",
    "\n",
    "for i in range(len(car_coord)):\n",
    "    car_coord['location'].iloc[i] = int(json_cars['Response']['Cars'][str(car_coord['car_id'].iloc[i])]['Location'][0]['LocationID'])\n",
    "    car_coord['lat'].iloc[i] = float(json_location['Response']['Locations'][str(car_coord['location'].iloc[i])]['Latitude'])\n",
    "    car_coord['lon'].iloc[i] = float(json_location['Response']['Locations'][str(car_coord['location'].iloc[i])]['Longitude'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fazendo a média da quantidade de viagens para cada hora"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# CSV criado a partir dos dados coletados do arquivo ModoApi_Data_Filter\n",
    "dfTravels = pd.read_csv('travels_v2.csv')\n",
    "dfTravels = dfTravels.sort_values(by='car_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def cont_travels(df):\n",
    "    \"\"\"\n",
    "    Função para calcular a quantidade de viagens por hora de cada carro\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    df : pandas.DataFrame\n",
    "        DataFrame com dados das viagens registradas\n",
    "        \n",
    "    Returns\n",
    "    ---------\n",
    "    df_count : pandas.DataFrame\n",
    "        DataFrame com os dados organizados com horas como colunas e linhas sendo id dos veículos.\n",
    "        Os seus valores representam a quantidade de viagens efetuadas em dada hora por tal veículo.\n",
    "    \n",
    "    \"\"\"\n",
    "    df_cont = []\n",
    "    id_prox = df['car_id'].iloc[1]\n",
    "    id_atual = df['car_id'].iloc[0]\n",
    "    tempo = []\n",
    "\n",
    "    for i in range(len(df)):\n",
    "        try:\n",
    "            id_prox = df['car_id'].iloc[i+1]\n",
    "            id_atual = df['car_id'].iloc[i]\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        # Se irá mudar de id então é registrado o somatório dos intervalos de tempo estacionado\n",
    "        # i == len(df)-1 para não pular o ultimo\n",
    "        if (id_prox != id_atual or i == len(df)-1):\n",
    "            \n",
    "            hour = datetime.datetime.fromtimestamp(df['start'].iloc[i]).hour\n",
    "            \n",
    "            auxHour = [0] * 24\n",
    "            auxHour[hour] += 1\n",
    "            tempo.append(auxHour)\n",
    "            \n",
    "            #Somando todas a quantidade de ocorrências de cada horário\n",
    "            tempo = pd.DataFrame(tempo)\n",
    "            \n",
    "            tempo = list(pd.Series.sum(tempo))\n",
    "            \n",
    "            tempo = [id_atual] + tempo\n",
    "            \n",
    "            df_cont.append(tempo)\n",
    "            tempo = []\n",
    "        else:\n",
    "            # Verificando a hora de inicio da viagem e somando em uma lista que representa as 24h\n",
    "            # Evita mais de uma viagen por hora\n",
    "            hour = datetime.datetime.fromtimestamp(df['start'].iloc[i]).hour\n",
    "            hour_anterior = datetime.datetime.fromtimestamp(df['start'].iloc[i-1]).hour\n",
    "            \n",
    "            if (hour == hour_anterior):\n",
    "                continue\n",
    "            \n",
    "            auxHour = [0] * 24\n",
    "            auxHour[hour] += 1\n",
    "            #Armazenando a quantidade de viagens em dada hora\n",
    "            tempo.append(auxHour)\n",
    "    \n",
    "    #Labels das colunas\n",
    "    labels = list(range(-1,24))\n",
    "    [format(x,'02d') for x in labels]\n",
    "    labels[0] = 'car_id'\n",
    "    \n",
    "    df_cont = pd.DataFrame(df_cont, columns=labels)\n",
    "    df_cont = df_cont.sort_values(by=['car_id'])\n",
    "    \n",
    "    return df_cont"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "hours = cont_travels(dfTravels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Preparando o dataframe para colocar a location, latitude ,longitude e numero de carros\n",
    "hours['lat'] = [0]*len(hours)\n",
    "hours['lon'] = [0]*len(hours)\n",
    "hours['location'] = [0]*len(hours)\n",
    "hours['n_cars'] = [1]*len(hours)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Colocando as coordenadas de cada carro\n",
    "for i in range(len(hours)):\n",
    "    try:\n",
    "        coord = car_coord[car_coord['car_id'] == hours['car_id'].iloc[i]]\n",
    "        hours['lat'].iloc[i] = coord['lat'].iloc[0]\n",
    "        hours['lon'].iloc[i] = coord['lon'].iloc[0]\n",
    "        hours['location'].iloc[i] = coord['location'].iloc[0]\n",
    "    except Exception as e:\n",
    "        # Carros que sairam da frota\n",
    "        print(e)\n",
    "        print('id:'+str(hours['car_id'].iloc[i]))\n",
    "\n",
    "hours = hours.sort_values(by='location')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Somando todos os valores para cada estação\n",
    "# A cada loop verifica se ainda existe repetições de id\n",
    "while(True in list(hours.duplicated(subset=['location']))):\n",
    "    i = 0\n",
    "    while i < len(hours):\n",
    "        try:\n",
    "            if (hours['location'].iloc[i] == hours['location'].iloc[i+1]):\n",
    "                print('Antes:')\n",
    "                print(len(hours))\n",
    "                \n",
    "                # Percorre todas as 24 somando a quantidade de viagens de cada carro da estação\n",
    "                for j in range(24):\n",
    "                    hours[j].iloc[i] = hours[j].iloc[i] + hours[j].iloc[i+1]\n",
    "                \n",
    "                # Adicionando mais um ao numero de carros da estação\n",
    "                hours['n_cars'].iloc[i] = hours['n_cars'].iloc[i] + 1 \n",
    "                \n",
    "                # Retirando a linha já analisada\n",
    "                hours = hours.drop(hours.index[i+1])\n",
    "                hours.index = range(len(hours))\n",
    "                \n",
    "                print('Depois:')\n",
    "                print(len(hours))\n",
    "        except Exception as e:\n",
    "            print(e)\n",
    "            break\n",
    "        i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ordenando por estacionamento\n",
    "hours = hours.sort_values(by='location')\n",
    "\n",
    "# Dividindo pela quantidade de dias e numero de carros\n",
    "for i in range(len(hours)):\n",
    "    for j in range(24):\n",
    "        hours[j].iloc[i] = hours[j].iloc[i] / (31*hours['n_cars'].iloc[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "aux_csv = hours\n",
    "aux_csv.dropna(how='any', axis=0, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(24):\n",
    "    aux_csv[['lat', 'lon', i]].to_csv('CarrosPorHora/Hour'+str(i)+'_v2.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotagem em mapas de calor de cada hora"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import geoplotlib as gpl\n",
    "from geoplotlib.utils import read_csv, BoundingBox, DataAccessObject"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Imprimindo todas as 24 horas\n",
    "for i in range(0,24):\n",
    "    \n",
    "    hora = str(i)\n",
    "    \n",
    "    # Lendo csv com dados de tempo estacionado médio, latitude, longitude de cada estacionamento\n",
    "    location = pd.read_csv('CarrosPorHora/Hour'+hora+'_v2.csv', usecols=[1,2,3])\n",
    "    data = location\n",
    "    # Multiplicando os valores por um escalar para se tornarem mais visíveis\n",
    "    location[hora] = location[hora] * 100\n",
    "    location_aux = []\n",
    "    \n",
    "    \n",
    "    # Utilizando um auxiliar para gerar repetições de incidencias para a plotagem no mapa de calor\n",
    "    for i in range(len(location)):\n",
    "        for j in range(int(location[hora].iloc[i])):\n",
    "            location_aux.append([location['lat'].iloc[i], location['lon'].iloc[i]])\n",
    "    \n",
    "    location_aux = pd.DataFrame(location_aux, columns=['lat', 'lon'])\n",
    "    \n",
    "    # Vancouver    \n",
    "    \n",
    "    gpl.kde(location_aux, bw=3, cut_below=1e-4, cmap='jet', alpha=150 )\n",
    "#     data = DataAccessObject(pd.DataFrame({'lat': [],'lon': []}))\n",
    "#     gpl.hist(data, scalemin=0, scalemax=100, cmap='jet', colorscale='lin', alpha=190)\n",
    "    \n",
    "    # Coordenadas para o mapa focar em Vancouver\n",
    "    lat = pd.DataFrame([49.246292, 49.262428, 49.24966])\n",
    "    lon = pd.DataFrame([-123.11554, -123.116226, -123.04464])\n",
    "    \n",
    "    gpl.set_bbox(BoundingBox.from_points(lon[0], lat[0]))\n",
    "    gpl.request_zoom(12)\n",
    "    gpl.set_window_size(1280,700)\n",
    "    gpl.savefig('CarrosPorHora/CarrosPorHoraPNGs/vanc_'+hora+'_v2')\n",
    "    \n",
    "    # Victoria\n",
    "    \n",
    "    gpl.kde(location_aux, bw=3, cut_below=1e-4, cmap='jet', alpha=150 )\n",
    "#     data = DataAccessObject(pd.DataFrame({'lat': [],'lon': []}))\n",
    "#     gpl.hist(data, scalemin=0, scalemax=100, cmap='jet', colorscale='lin', alpha=190)\n",
    "    \n",
    "    # Coordenadas para o mapa focar em Victoria\n",
    "    lat = pd.DataFrame([48.42666, 48.44344, 48.44560])\n",
    "    lon = pd.DataFrame([-123.36027,-123.35853,-123.33673])\n",
    "    \n",
    "    gpl.set_bbox(BoundingBox.from_points(lon[0], lat[0]))\n",
    "    gpl.request_zoom(13)\n",
    "    gpl.set_window_size(1280,700)\n",
    "    \n",
    "    gpl.savefig('CarrosPorHora/CarrosPorHoraPNGs/vic_'+hora+'_v2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}