Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc": "true"
   },
   "source": [
    "# Table of Contents\n",
    "## plotly\n",
    "[1. Interactive vs static visualisation](#Interactive-vs-static-visualisation)  \n",
    "[2. Basics of Plotly](#Basics-of-plotly)  \n",
    "[3. Using pandas](#Using-pandas)  \n",
    "[4. Using cufflinks](#Using-cufflinks)  \n",
    "[5. Interactivity](#Interactivity)    \n",
    "[6. Plotting on Maps](#Plotting-on-maps)   \n",
    "[7. Exercise solutions](#Exercise-solutions)    \n",
    "[8. More Information](#More-information)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import plotly.graph_objs as go\n",
    "import plotly.offline as pltly\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "pltly.init_notebook_mode(connected=False)\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Interactive vs static visualisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Some existing packages\n",
    "* [Plotly](https://plot.ly/) - used in this tutorial  \n",
    "* [Bokeh](bokeh.pydata.org)\n",
    "* [mpld3](http://mpld3.github.io/)\n",
    "* [Holoviews](http://holoviews.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Basic comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# A simple matplotlib plot is quick to put together\n",
    "plt.plot([0, 1, 3], [0, 1, 5], color='red')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# As is a simple plotly plot!\n",
    "pltly.iplot([go.Scatter(x=[0, 1, 3], y=[0, 1, 5], line=dict(color='red'))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Actually, you can quickly see the possible benefits by \n",
    "# using your matplotlib figure to produce the plotly plot \n",
    "\n",
    "fig = plt.figure()\n",
    "plt.plot([0, 1, 3], [0, 1, 5], color='red')\n",
    "pltly.iplot_mpl(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More complex comparison\n",
    "We will return to plot this in [section 3](#Using-pandas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('./data/time_series_60min_singleindex.csv', index_col=0, parse_dates=True, low_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "de_solar = df.DE_solar_generation.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "de_solar.resample('7D').mean().plot(figsize=(12, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pltly.iplot([go.Scatter(x=de_solar.resample('7D').mean().index,\n",
    "                        y=de_solar.resample('7D').mean().values)\n",
    "            ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics of plotly\n",
    "\n",
    "Full API is available at: https://plot.ly/python/reference\n",
    "\n",
    "Keep this open to refer to during the session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [go.Scatter(x=[0, 1, 3], y=[0, 1, 5], line=dict(color='red'))] # define data\n",
    "pltly.iplot(data) # plot data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data  # `data` is just a list of dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data[0]['line']['color']='blue' # Update line colour by editing dictionary\n",
    "pltly.iplot(data) # Plot data\n",
    "data # See that the dictionary has been updated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [go.Scatter(x=[0, 1, 3], y=[0, 1, 5], \n",
    "                  line=dict(color='red', dash='dash', width='0.2'), # change line vis\n",
    "                  marker=dict(symbol='o', size=10, line=dict(width=2, color='black')) # change marker vis\n",
    "                  )]\n",
    "pltly.iplot(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [go.Scatter(x=[0, 1, 3], y=[0, 1, 5],\n",
    "                   line=dict(color='red', dash='dash', width='0.2'),\n",
    "                   marker=dict(symbol='o', size=10, line=dict(width=2, color='black')),\n",
    "                   name='red line'\n",
    "                  ), # trace 1\n",
    "        go.Scatter(x=[0, 1, 3], y=[5, 2, 0],\n",
    "                   line=dict(color='blue', dash='solid', width='0.1'),\n",
    "                   marker=dict(symbol='asterisk', size=10, line=dict(width=1, color='blue')),\n",
    "                   name='blue line'\n",
    "                  ) # trace 2\n",
    "       ]\n",
    "pltly.iplot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data and Layout\n",
    "\n",
    "Where data to be plotted is given within the `data` dictionary, information related to the axes is given in the `Layout` dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [\n",
    "    go.Scatter(\n",
    "        x=[0, 1, 3], y=[0, 1, 5],\n",
    "        line=dict(color='red', dash='dash', width='0.2'),\n",
    "        marker=dict(symbol='o', size=10, line=dict(width=2, color='black')),\n",
    "        name='red line'\n",
    "    )\n",
    "]\n",
    "layout = go.Layout(xaxis=dict(title='the x-axis', range=[0,100]), # give the x axis a title and a range that it must adhere to\n",
    "                   yaxis=dict(title='the y-axis'), # give the y axis a title\n",
    "                   height=300, width=800) # force a plot shape (300 x 800)\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subplots - plotly tools\n",
    "For more information, see https://plot.ly/python/subplots/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotly import tools # the tools module lets us do subplotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trace1 = go.Scatter(x=[0, 1, 3], y=[0, 1, 5], name='top line')\n",
    "trace2 = go.Scatter(x=[0, 1, 3], y=[4, 3, 2], name='bottom line')\n",
    "\n",
    "# create the subplots\n",
    "fig = tools.make_subplots(rows=2, cols=1, subplot_titles=('Top figure', 'Bottom figure'))\n",
    "\n",
    "# assign traces to the specific plots\n",
    "fig.append_trace(trace1, 1, 1)\n",
    "fig.append_trace(trace2, 2, 1)\n",
    "\n",
    "layout = dict(title='Multiple Subplots', \n",
    "              xaxis=dict(range=[0,4], \n",
    "                         title='x-axis')\n",
    "             )\n",
    "fig['layout'].update(layout)\n",
    "\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sharing Axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trace1 = go.Scatter(x=[0, 1, 3], y=[0, 1, 5], name='top line')\n",
    "trace2 = go.Scatter(x=[0, 1, 3], y=[4, 3, 2], name='bottom line')\n",
    "\n",
    "fig = tools.make_subplots(rows=2, cols=1, \n",
    "                          subplot_titles=('Top figure', 'Bottom figure'), \n",
    "                          shared_xaxes=True, # here we force a shared axis\n",
    "                          vertical_spacing=0.3)\n",
    "fig.append_trace(trace1, 1, 1)\n",
    "fig.append_trace(trace2, 2, 1) # second row is below first row\n",
    "\n",
    "layout = dict(title='Multiple Subplots', \n",
    "              xaxis=dict(range=[0, 4], \n",
    "                         title='shared x-axis')\n",
    "             )\n",
    "fig['layout'].update(layout)\n",
    "\n",
    "pltly.iplot(fig)\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subplots - Layout method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I prefer to explicitly set the subplots, rather than using `plotly.tools`. \n",
    "# This gives a bit more flexibility, in general\n",
    "\n",
    "trace1 = go.Scatter(x=[0, 1, 3], y=[0, 1, 5], name='top line', xaxis='x2', yaxis='y2')\n",
    "trace2 = go.Scatter(x=[0, 1, 3], y=[4, 3, 2], name='bottom line', xaxis='x1', yaxis='y1')\n",
    "\n",
    "layout = dict(title='Multiple Subplots',\n",
    "              xaxis1=dict(range=[0,4], \n",
    "                          title='x-axis 1'), \n",
    "              xaxis2=dict(anchor='y2', # anchor = the axis to which this axis aligns zero\n",
    "                          range=[0,4], \n",
    "                          title='x-axis 2'), \n",
    "              yaxis1=dict(domain=[0,0.4], # domain = the part of the plot that the axis will fill (0 to 1 range)\n",
    "                          range=[0,5], \n",
    "                          title='y-axis 1'), \n",
    "              yaxis2=dict(domain=[0.6,1], # giving a 20% vertical spacing between the two y axes (0.4 vs 0.6)\n",
    "                          range=[0,6], \n",
    "                          title='y-axis 2')\n",
    "                      \n",
    "             )\n",
    "\n",
    "fig = go.Figure(data=[trace1, trace2], layout=layout)\n",
    "\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sharing Axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trace1 = go.Scatter(x=[0, 1, 3], y=[0, 1, 5], name='top line', xaxis='x1', yaxis='y2') # xaxis = 'x1' in both\n",
    "trace2 = go.Scatter(x=[0, 1, 3], y=[4, 3, 2], name='bottom line', xaxis='x1', yaxis='y1') # but yaxis is different\n",
    "\n",
    "layout = dict(title='Multiple Subplots',\n",
    "              xaxis1=dict(anchor='y1',\n",
    "                          range=[0,4], \n",
    "                          title='x-axis 1'),\n",
    "              yaxis1=dict(domain=[0,0.4],\n",
    "                          range=[0,5], \n",
    "                          title='y-axis 1'), \n",
    "              yaxis2=dict(domain=[0.6,1],\n",
    "                          range=[0,6], \n",
    "                          title='y-axis 2')\n",
    "                      \n",
    "             )\n",
    "\n",
    "fig = go.Figure(data=[trace1, trace2], layout=layout)\n",
    "\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trace1 = go.Scatter(x=[0, 1, 3], y=[0, 1, 5], name='Line 1', xaxis='x1', yaxis='y2')\n",
    "trace2 = go.Scatter(x=[0, 1, 3], y=[4, 3, 2], name='Line 2', xaxis='x1', yaxis='y1')\n",
    "trace3 = go.Scatter(x=[0, 2, 3], y=[0, 2, 5], name='Line 3', xaxis='x2', yaxis='y2')\n",
    "trace4 = go.Scatter(x=[0, 0.5, 3.5], y=[5, 3, 1], name='Line 4', xaxis='x2', yaxis='y1')\n",
    "\n",
    "layout = dict(title='Even more Subplots',\n",
    "              xaxis1=dict(domain=[0,0.49], # left\n",
    "                          anchor='y1',\n",
    "                          range=[0,4], \n",
    "                          title='x-axis 1'),\n",
    "              xaxis2=dict(domain=[0.51,1], # right\n",
    "                          anchor='y1',\n",
    "                          range=[0,4], \n",
    "                          title='x-axis 1'),\n",
    "              yaxis1=dict(domain=[0,0.4], # bottom\n",
    "                          range=[0,6], \n",
    "                          title='y-axis 1'), \n",
    "              yaxis2=dict(domain=[0.6,1], # top\n",
    "                          range=[0,6], \n",
    "                          title='y-axis 2')\n",
    "                      \n",
    "             )\n",
    "\n",
    "fig = go.Figure(data=[trace1, trace2, trace3, trace4], layout=layout)\n",
    "\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: basics\n",
    "\n",
    "Try to plot the below image using the available data.\n",
    "\n",
    "Solution is available [here](#Exercise-solutions)    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ldc = [1, 0.8, 0.75, 0.7, 0.65, 0.64, 0.63, 0.62, 0.61, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1]\n",
    "coal = [0.43] * len(ldc)\n",
    "x_values = np.linspace(0, 8760, num=len(ldc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"web-based-1.png\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [go.Scatter(x=de_solar.resample('7D').mean().index,\n",
    "                   y=de_solar.resample('7D').mean().values)]\n",
    "layout = dict(height=400, width = 800)\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trace_week = go.Scatter(x=de_solar.resample('7D').mean().index,\n",
    "                        y=de_solar.resample('7D').mean().values,\n",
    "                        name='weekly')\n",
    "trace_month = go.Scatter(x=de_solar.resample('1M').mean().index,\n",
    "                         y=de_solar.resample('1M').mean().values,\n",
    "                         mode='markers', \n",
    "                         marker=dict(symbol='line-ew-open', color='orange', size=5), # symbol names given in API reference\n",
    "                         name='monthly')\n",
    "layout = dict(height=400, width = 800)\n",
    "fig = go.Figure(data=[trace_week, trace_month], layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trace_week = go.Scatter(x=de_solar.resample('7D').mean().index,\n",
    "                        y=de_solar.resample('7D').mean().values,\n",
    "                        name='weekly')\n",
    "trace_month = go.Bar(x=de_solar.resample('1M').mean().index,\n",
    "                     y=de_solar.resample('1M').mean().values,\n",
    "                     marker=dict(color='orange'), # symbol names given in API reference\n",
    "                     text=[str(i).split('-')[0] + '-' + str(i).split('-')[1] for i in de_solar.resample('1M').mean().index],\n",
    "                     name='monthly')\n",
    "layout = dict(height=400, width = 800)\n",
    "fig = go.Figure(data=[trace_week, trace_month], layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_wind = df.loc[:, [\n",
    "    'CZ_wind_onshore_generation',\n",
    "    'DK_wind_offshore_generation',\n",
    "    'DK_wind_onshore_generation',\n",
    "    'SE_wind_generation'\n",
    "]]\n",
    "\n",
    "df_wind = df_wind.rename(columns={\n",
    "    k: k.replace('_wind_', ' ').replace('generation', '') for k in df_wind.columns\n",
    "})\n",
    "\n",
    "data = [] # initialise the data list\n",
    "\n",
    "# Iterate over the columns, adding each scatter to our data list\n",
    "for column in df_wind.columns:\n",
    "    data.append(go.Scatter(x=df_wind.resample('1M').mean()[column].loc['2012':'2015-06'].index,\n",
    "                       y=df_wind.resample('1M').mean()[column].loc['2012':'2015-06'].values,\n",
    "                       name=column))\n",
    "layout = dict(height=400, width = 800)\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using cufflinks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cufflinks as cf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cf.set_config_file(offline=True, world_readable=True, theme='white')\n",
    "# notice that we don't need to iterate over the columns with cufflinks\n",
    "df_wind.resample('1M').mean().loc['2012':'2015-06'].iplot(kind='scatter') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "layout = cf.Layout(xaxis=dict(showgrid=False),yaxis=dict(showgrid=False))\n",
    "df_wind.resample('12M').mean().loc['2012':].iplot(kind='barh', \n",
    "                                                  barmode='stack', \n",
    "                                                  layout_update=layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colourmaps\n",
    "For more information, see https://plot.ly/pandas/colorlover/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import colorlover as cl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colormap = cl.scales[str(len(df_wind.columns))]['seq']['Blues']\n",
    "df_wind.resample('1M').mean().loc['2012':'2015-06'].iplot(kind='scatter', colors=colormap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interactivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# - Use `legendgroup` to group datasets, they will turn on/off together when legend entries are clicked - #\n",
    "data = []\n",
    "\n",
    "for column in df_wind.columns:\n",
    "    if 'DK' in column:\n",
    "        group = 'DK'\n",
    "    else:\n",
    "        group = column\n",
    "    data.append(go.Scatter(x=df_wind.resample('1M').mean()[column].loc['2012':'2015-06'].index,\n",
    "                           y=df_wind.resample('1M').mean()[column].loc['2012':'2015-06'].values,\n",
    "                           name=column,\n",
    "                           legendgroup=group))\n",
    "layout = dict(height=400, width = 800)\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# - Use `hoverinfo` to change the information given on hovering over the data - #\n",
    "data = []\n",
    "df_wind_monthly = df_wind.resample('1M').mean().loc['2012':'2015-06']\n",
    "for column in df_wind.columns:\n",
    "    data.append(go.Scatter(x=df_wind_monthly[column].index,\n",
    "                           y=df_wind_monthly[column].values,\n",
    "                           text=np.round(df_wind_monthly[column].values,0),\n",
    "                           name=column,\n",
    "                           hoverinfo='x+text'))\n",
    "layout = dict(height=400, width = 800)\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# - Use `rangeslider` to have a full timeseries outline below the main figure, \n",
    "# which is useful if you zoom in on your data by slicing the time domain\n",
    "\n",
    "data = []\n",
    "\n",
    "for column in df_wind.columns:\n",
    "    data.append(\n",
    "        go.Scatter(\n",
    "            x=df_wind.resample('1D').mean()[column].loc['2012':'2015-06'].index,\n",
    "            y=df_wind.resample('1D').mean()[column].loc['2012':'2015-06'].values,\n",
    "            name=column,\n",
    "        )\n",
    "    )\n",
    "layout = {\n",
    "    'height': 400, 'width': 800, \n",
    "    'xaxis': {'range': ['2014-01', '2014-02'], 'rangeslider': {}}\n",
    "}\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your task: visualise the monthly and annual means from the df_wind data from above, using subplots and connected layout.\n",
    "\n",
    "* You want to resample the data, e.g. with df_wind.resample('12M').mean()\n",
    "* As with go.Scatter(), you can plot bar charts with go.Bar()\n",
    "* Bars can be stacked by editing the layout function to include `barmode='stack'` \n",
    "* Try cufflinks and pure plotly to test their strengths and weaknesses\n",
    "\n",
    "Solution is available [here](#Exercise-solutions)    \n",
    "\n",
    "Your output might look something like:\n",
    "\n",
    "<img src=\"web-based-2.png\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding sliders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use buttons to create a dropdown of data\n",
    "# data_len is used to populate visibility of traces, for dropdown\n",
    "\n",
    "# sliders, dropdowns, buttons, etc. all work by preparing every single\n",
    "# dataset as we would if we plotted them seperately. Then, we add a\n",
    "# layer to switch on/off the visibility of these different datasets.\n",
    "\n",
    "# In this example we will be switching on/off 4 scatter plots at a time,\n",
    "# which correspond to the 4 data columns. We will be switching between \n",
    "# time frequencies, to see the effect of time resolution.\n",
    "def get_x_y(freq, column):\n",
    "    x = df_wind.resample(freq).mean().index,\n",
    "    y = df_wind.resample(freq).mean()[column].values\n",
    "    \n",
    "    return x, y\n",
    "\n",
    "\n",
    "data = []\n",
    "# only data from the first frequency will be visible by default, we switch this to False after\n",
    "visible = True\n",
    "steps = []\n",
    "num_columns = len(df_wind.columns)\n",
    "freqs = ['1H', '1D', '7D', '1M', '1Y']\n",
    "\n",
    "visible_data = [False] * len(freqs) * num_columns\n",
    "\n",
    "i = 0\n",
    "for freq in freqs:\n",
    "    for column in df_wind.columns:\n",
    "        x, y = get_x_y(freq, column)\n",
    "        # It might be better to view annual mean as a Bar, not scatter\n",
    "        plotter = go.Bar if freq == '1Y' else go.Scatter\n",
    "        data.append(plotter(x=x[0], y=y, name=column, visible=visible))\n",
    "        \n",
    "    # Only the plots associated with the first frequency have visible=True\n",
    "    visible=False\n",
    "    \n",
    "    step = {\n",
    "        'method': 'restyle', 'label': freq, 'args': ['visible', visible_data.copy()]\n",
    "    }\n",
    "    # Set the plots associated with this step as visible=True\n",
    "    step['args'][1][i * num_columns:(i + 1) * num_columns] = [True] * num_columns\n",
    "    steps.append(step)\n",
    "    i += 1\n",
    "\n",
    "# Put the slider above the main plot (y = 1.5)\n",
    "sliders = [{\n",
    "    'x': 0, 'y': 1.5,\n",
    "    'steps': steps\n",
    "}]\n",
    "\n",
    "layout = {'sliders': sliders, 'xaxis': {'rangeslider': {}}}\n",
    "\n",
    "pltly.iplot({'data': data, 'layout': layout})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting on maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_map = pd.read_csv('./data/conventional_power_plants_EU.csv')\n",
    "df_map = df_map.dropna(subset=['lat', 'lon'])\n",
    "data = []\n",
    "opacity = (df_map.capacity/df_map.capacity.max())/3 + 0.66\n",
    "text = df_map.energy_source + ' ' + df_map.capacity.astype(str) + 'MW' + ' ' + df_map.country\n",
    "colors = cl.scales['4']['qual']['Pastel1']\n",
    "energy_sources = set(df_map.energy_source_level_1)\n",
    "for source in energy_sources:\n",
    "    color = colors[list(energy_sources).index(source)]\n",
    "    data.append(\n",
    "        dict(\n",
    "            type='scattergeo',\n",
    "            lon=df_map.loc[df_map.energy_source_level_1==source].lon,\n",
    "            lat=df_map.loc[df_map.energy_source_level_1==source].lat,\n",
    "            text= text.loc[df_map.energy_source_level_1==source],\n",
    "            hoverinfo='text',\n",
    "            name=source,\n",
    "            mode='marker',\n",
    "            marker=dict(\n",
    "                opacity=opacity.loc[df_map.energy_source_level_1==source], \n",
    "                color=color,\n",
    "                size=5, \n",
    "                line=dict(width=1, color='black')\n",
    "            )\n",
    "        )\n",
    "    )\n",
    "layout=dict(geo=dict(resolution=50,\n",
    "                     scope='europe',\n",
    "                     projection=dict(type='mercator'),\n",
    "                     showocean=True,\n",
    "                     oceancolor='rgb(151,182,225)',\n",
    "                     showcoastlines=True,\n",
    "                     coastlinecolor='red'))\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# minor edits required to plot over a Mapbox base map. \n",
    "mapbox_access_token = '' # If you have a mapbox token (free from mapbox.com) then place it here.\n",
    "if mapbox_access_token:\n",
    "    for i in range(len(energy_sources)):\n",
    "        data[i]['type'] = 'scattermapbox'\n",
    "        # delete the marker 'line' attribute, as scattermapbox doesn't support it \n",
    "        data[i]['marker'].pop('line', {})\n",
    "    layout = dict(\n",
    "        mapbox=dict(\n",
    "            accesstoken=mapbox_access_token, \n",
    "            style='satellite-streets',\n",
    "            center=dict(\n",
    "                lat=df_map.lat.mean(),\n",
    "                lon=df_map.lon.mean()\n",
    "            )\n",
    "        )\n",
    "    )\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [\n",
    "    go.Scatter(x=x_values, y=ldc, name='Load duration curve', line=dict(color='blue'), mode='lines'),\n",
    "    go.Scatter(x=x_values, y=coal, name='Coal generation', line=dict(color='orange'), mode='lines')\n",
    "]\n",
    "layout = go.Layout(\n",
    "    yaxis=dict(title='Capacity Requirement', range=(0, 1)),\n",
    "    xaxis=dict(title='Hours per year', showgrid=False, range=(0, 8760))\n",
    ")\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "colors = cl.scales[str(len(df_wind.columns))]['div']['Spectral']\n",
    "# or perhaps colors = sns.color_palette('bright', len(df_wind.columns)).as_hex()\n",
    "color_index = 0\n",
    "for column in df_wind.columns:\n",
    "    data.append(go.Scatter(x=df_wind.resample('1M').mean()[column].loc['2012':'2016'].index,\n",
    "                           y=df_wind.resample('1M').mean()[column].loc['2012':'2016'].values,\n",
    "                           name=column,\n",
    "                           xaxis='x1',\n",
    "                           yaxis='y1',\n",
    "                           line=dict(color=colors[color_index]),\n",
    "                           legendgroup=column))\n",
    "    data.append(go.Bar(x=df_wind.resample('12M').sum()[column].loc['2012':'2016'].index,\n",
    "                       y=df_wind.resample('12M').sum()[column].loc['2012':'2016'].values,\n",
    "                       name=column,\n",
    "                       xaxis='x2',\n",
    "                       yaxis='y2',\n",
    "                       marker=dict(color=colors[color_index]),\n",
    "                       showlegend=False,\n",
    "                       legendgroup=column,\n",
    "                       text=['%.2E' % i for i in df_wind.resample('12M').sum()[column].loc['2012':'2016'].values],\n",
    "                       hoverinfo='text'))\n",
    "    color_index += 1\n",
    "layout = dict(barmode='stack', height=400, width=800,\n",
    "              xaxis1=dict(domain=[0,0.49], title='Monthly variation'),\n",
    "              xaxis2=dict(domain=[0.51,1], title='Annual variation'),\n",
    "              yaxis1=dict(range=[0,3500]),\n",
    "              yaxis2=dict(anchor='x2', range=[0, 35e6], side='right'),\n",
    "              legend=dict(orientation='h', xanchor='center',yanchor='bottom', x=0.5, y=1))\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "pltly.iplot(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More information\n",
    "\n",
    "See https://plot.ly/python/reference for the full plotly API library "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:vis-tutorial]",
   "language": "python",
   "name": "conda-env-vis-tutorial-py"
  },
  "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.5"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "68px",
    "width": "323px"
   },
   "navigate_menu": true,
   "number_sections": false,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": true,
   "toc_section_display": "block",
   "toc_window_display": true,
   "widenNotebook": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}