proto.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some useful links\n",
    "# http://andrewgaidus.com/Analyzing_Race_Results_Part_2/\n",
    "# https://towardsdatascience.com/pandas-tips-and-tricks-33bcc8a40bb9\n",
    "# https://stackoverflow.com/questions/47303027/changing-axis-ticks-in-seaborn-stripplotwhere-x-value-is-a-time-stamp?rq=1\n",
    "# https://stackoverflow.com/questions/22408237/named-colors-in-matplotlib\n",
    "# https://shocksolution.com/2011/08/17/removing-an-axis-or-both-axes-from-a-matplotlib-plot/\n",
    "# http://www.datasciencemadesimple.com/rank-dataframe-python-pandas-min-max-dense-rank-group/\n",
    "# http://www.r-graph-gallery.com/38-rcolorbrewers-palettes/\n",
    "# https://seaborn.pydata.org/tutorial.html\n",
    "# https://jakevdp.github.io/PythonDataScienceHandbook/04.14-visualization-with-seaborn.html\n",
    "# http://colorbrewer2.org/#type=sequential&scheme=OrRd&n=3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from decimal import Decimal, ROUND_UP, ROUND_DOWN, ROUND_HALF_UP\n",
    "import seaborn as sns\n",
    "from colour import Color\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Widen display area to prevent column wrapping\n",
    "pd.set_option('display.width', 2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv( \"2018/dh3_leogang/dh3_leogang_m.merged.csv\" )\n",
    "df = df.dropna() # remove DNF/DNS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "event = 'dh'\n",
    "race = 3\n",
    "gender = 'm'\n",
    "topX = 20\n",
    "splits = 5 # Could detect this from dataset, or or they always 5? @todo\n",
    "image_gen = False\n",
    "dpi = 300"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "racename = 'race'\n",
    "raceName = 'race'\n",
    "chart_title_prefix = raceName + ( ', Men' if gender == 'm' else ', Women' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def colorList( col1, col2, cnt, pos1=0, pos2=1, pos3=2 ):\n",
    "    clrs = list( Color( col1 ).range_to( Color( col2 ) , cnt ) )\n",
    "    clrs = [ i.web for i in clrs ]\n",
    "    if pos1 < cnt:\n",
    "        clrs[pos1] = 'gold'\n",
    "    if pos2 < cnt:\n",
    "        clrs[pos2] = 'silver'\n",
    "    if pos3 < cnt:\n",
    "        clrs[pos3] = 'peru'\n",
    "\n",
    "    return clrs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df.set_index('Name')\n",
    "# df.rename(columns={'': 'A'}, inplace=True)\n",
    "# df.reindex_axis(sorted(df.columns), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Unnamed: 0  bib    id               name  q_rank  q_split1  q_split2  q_split3  q_split4  q_split5 ...   StartOrder  StartTime      UciCode  UciRank   UciRiderId  UciTeamCode  UciTeamId                   UciTeamName  WorldCupRank  Age\n",
      "1            1    1  1001         GWIN Aaron      13    48.361    85.469   124.547   169.081   200.424 ...            1   50400000  USA19871224        1  10006516663          YTM       1531                    THE YT MOB             1   30\n",
      "3            3    4  1004       BROSNAN Troy       7    47.002    83.781   122.684   166.936   197.748 ...            4   50490000  AUS19930713        2  10007307417          CFT       2162  CANYON FACTORY DOWNHILL TEAM             4   24\n",
      "10          10   17  1017         BRUNI Loic       4    46.232    82.965   122.055   165.441   196.647 ...           17   50880000  FRA19940513        4  10007544358          SGR       1667           SPECIALIZED GRAVITY            17   24\n",
      "15          15    5  1005  BLENKINSOP Samuel      15    48.919    86.300   125.913   169.854   200.892 ...            5   50520000  NZL19881028        7  10004485929          NFR       2013          NORCO FACTORY RACING             5   29\n",
      "\n",
      "[4 rows x 116 columns]\n"
     ]
    }
   ],
   "source": [
    "print( df.head() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from datetime import timedelta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46.746 45.525\n"
     ]
    }
   ],
   "source": [
    "print( df['split1'].max(), df.split1.min() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate split diff compared to split leader\n",
    "\n",
    "# df.insert( loc=4, column='s1b', value=df.split1 - df.split1.min() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( df.tail() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.Split1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate split diff compared to race winner\n",
    "df.insert( loc=5, column='s1w', value=df.Split1 - df.Split1[0] )\n",
    "# df['s1w'] = df.Split1 - df.Split1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( df.head() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.insert( loc=7, column='s2b', value=df.Split2 - df.Split2.min())\n",
    "df.insert( loc=8, column='s2w', value=df.Split2 - df.Split2[0] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.set_index('Name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = df.loc[df['Name'] == 'NEWELL Jake']['Split2']\n",
    "print( foo )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convertToSeconds( timestring ):\n",
    "    if \":\" in str(timestring):\n",
    "        minutes, seconds = timestring.split(':')\n",
    "        timestring = int(minutes)*60 + float(seconds)\n",
    "    if ( timestring in [ \"DNS\", \"DNF\" ] ):\n",
    "        timestring = float('NaN')\n",
    "    return float(timestring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convertToSeconds( \"01:18.9\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convertToSeconds( \"57.445\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['s1s'] = [ convertToSeconds(x) for x in df['Split1'] ]\n",
    "df['s2s'] = [ convertToSeconds(x) for x in df['Split2'] ]\n",
    "df['s3s'] = [ convertToSeconds(x) for x in df['Split3'] ]\n",
    "df['s4s'] = [ convertToSeconds(x) for x in df['Split4'] ]\n",
    "df['fs'] = [ convertToSeconds(x) for x in df['Time'] ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( df.tail() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if ( \"DS\" in [ \"DNS\", \"DNF\" ] ):\n",
    "    print (\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convertToDelta( timestring ):\n",
    "#     if ( timestring in [ \"DNS\", \"DNF\" ] ):\n",
    "#         timestring = \"0:0:0.0\"\n",
    "#         return timestring\n",
    "    timestring = str(timestring)\n",
    "\n",
    "    if \":\" not in timestring:\n",
    "        timestring = str(Decimal( timestring ).quantize( Decimal('.001' ), rounding=ROUND_HALF_UP ))\n",
    "        timestring = \"0:\" + timestring\n",
    "\n",
    "    timestring = \"0:\" + timestring\n",
    "\n",
    "    return pd.to_timedelta( timestring )\n",
    "#     return timestring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convertToDelta( \"01:18.9\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convertToDelta( 57.445 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rounding issues\n",
    "pd.to_timedelta( \"0:0:21.526999999999997\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Alternative to Decimal conversion to deal with floating point inaccuracy\n",
    "n = 21.526999999999997\n",
    "'%.3f' % round( n, 3 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convertToDelta( 21.527 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convertToDelta( 20.613 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['s1s'] = [ convertToDelta(x) for x in df['Split1'] ]\n",
    "df['s1cr'] = df.s1s.rank(method='dense')\n",
    "df['s1b'] = (df.s1s - df.s1s.min()).dt.total_seconds()\n",
    "df['s1w'] = (df.s1s - df.s1s[0]).dt.total_seconds()\n",
    "df['s2s'] = [ convertToDelta(x) for x in df['Split2'] ]\n",
    "df['s2c'] = df.s2s - df.s1s\n",
    "df['s2cr'] = df.s2c.rank(method='dense')\n",
    "df['s2b'] = (df.s2s - df.s2s.min()).dt.total_seconds()\n",
    "df['s2w'] = (df.s2s - df.s2s[0]).dt.total_seconds()\n",
    "df['s2cb'] = (df.s2c - df.s2c.min()).dt.total_seconds()\n",
    "df['s2cw'] = (df.s2c - df.s2c[0]).dt.total_seconds()\n",
    "df['s3s'] = [ convertToDelta(x) for x in df['Split3'] ]\n",
    "df['s3c'] = df.s3s - df.s2s\n",
    "df['s3cr'] = df.s3c.rank(method='dense')\n",
    "df['s3b'] = (df.s3s - df.s3s.min()).dt.total_seconds()\n",
    "df['s3w'] = (df.s3s - df.s3s[0]).dt.total_seconds()\n",
    "df['s3cb'] = (df.s3c - df.s3c.min()).dt.total_seconds()\n",
    "df['s3cw'] = (df.s3c - df.s3c[0]).dt.total_seconds()\n",
    "df['s4s'] = [ convertToDelta(x) for x in df['Split4'] ]\n",
    "df['s4c'] = df.s4s - df.s3s\n",
    "df['s4cr'] = df.s4c.rank(method='dense')\n",
    "df['s4b'] = (df.s4s - df.s4s.min()).dt.total_seconds()\n",
    "df['s4w'] = (df.s4s - df.s4s[0]).dt.total_seconds()\n",
    "df['s4cb'] = (df.s4c - df.s4c.min()).dt.total_seconds()\n",
    "df['s4cw'] = (df.s4c - df.s4c[0]).dt.total_seconds()\n",
    "df['fs'] = [ convertToDelta(x) for x in df['Time'] ]\n",
    "df['s5s'] = df['fs']\n",
    "df['s5c'] = df.fs - df.s4s\n",
    "df['s5cr'] = df.s5c.rank(method='dense')\n",
    "df['s5b'] = (df.s5s - df.s5s.min()).dt.total_seconds()\n",
    "df['s5w'] = (df.s5s - df.s5s[0]).dt.total_seconds()\n",
    "df['s5cb'] = (df.s5c - df.s5c.min()).dt.total_seconds()\n",
    "df['s5cw'] = (df.s5c - df.s5c[0]).dt.total_seconds()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "display( df.head(10) )\n",
    "# print( df.tail() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df['s1b'] = df.s1s - df.s1s.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.s1w.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drawScatter( col, title, xmin=7, xmax=-.5 ):\n",
    "    df2 = df.sort_values(col, ascending=True)\n",
    "    df2 = df2.reset_index(drop=True)\n",
    "    plt.subplots(figsize=(5,7))\n",
    "    \n",
    "#     colors = [\"gold\",\"silver\",\"peru\"] + [\"cornflowerblue\"]*(len(df2[col])-3)\n",
    "    colors = [\"cornflowerblue\"]*(len(df2[col]))\n",
    "    colors[int(df2.loc[df2['Rank'] == 1].index.values)] = \"gold\"\n",
    "    colors[int(df2.loc[df2['Rank'] == 2].index.values)] = \"silver\"\n",
    "    colors[int(df2.loc[df2['Rank'] == 3].index.values)] = \"peru\"\n",
    "    sizes = [40]*(len(df2[col]))\n",
    "    sizes[int(df2.loc[df2['Rank'] == 1].index.values)] = 100\n",
    "    sizes[int(df2.loc[df2['Rank'] == 2].index.values)] = 100\n",
    "    sizes[int(df2.loc[df2['Rank'] == 3].index.values)] = 100\n",
    "    \n",
    "#     print( colors )\n",
    "#     return\n",
    "    \n",
    "    plot = sns.regplot( y=df2.index.values[0:20], x=df2[col][0:20], fit_reg=False, scatter_kws={\"color\":colors, \"s\":sizes} )\n",
    "    plot.invert_yaxis()\n",
    "    plot.invert_xaxis()\n",
    "    plt.xlim( xmin, xmax )\n",
    "\n",
    "    # Chart formatting\n",
    "    sns.despine()\n",
    "#     plot.axis('off')\n",
    "    plot.yaxis.set_visible(False)\n",
    "    plot.set_frame_on(False)\n",
    "\n",
    "    sns.set_style('whitegrid')\n",
    "    plot.grid( color='#EEEEEE', linewidth=1.0 )\n",
    "    plot.set( xlabel=title )\n",
    "\n",
    "    # Name column\n",
    "    coln = \"s\" + col[1:2] + ( \"s\" if col[2:3] == \"b\" else \"c\" )\n",
    "    display( coln )\n",
    "\n",
    "    # Adding point labels\n",
    "    for row in range( 0, 20 ):\n",
    "        label = df2.Name[row] + \" \" + ( formatDelta( df2[coln][row] ) if row==0 else \"+\" + str(df2[col][row]) )\n",
    "        x = df2[col][row] + .2\n",
    "        y = df2.index.values[row] + 0.15\n",
    "        plot.text( x, y, label, horizontalalignment='right', size='small' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# int(df.loc[df['Rank'] == 2]['Number'])\n",
    "int(df2.loc[df2['Rank'] == 1].index.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def formatDelta( time ):\n",
    "    return ':'.join(str(time).split(':')[1:3])[:-3]\n",
    "\n",
    "# print( formatDelta( \"00:00:32.050000\" ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors =  [\"#91FF61\"]*25 + [\"#BA61FF\"]*25 + [\"#91FF61\"]*25 + [\"#BA61FF\"]*25\n",
    "colors = [\"blue\"]*len(df2[col])\n",
    "\n",
    "print( colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = df.sort_values('s1b', ascending=True)\n",
    "df2 = df2.reset_index(drop=True)\n",
    "plt.subplots(figsize=(5,7))\n",
    "plot = sns.regplot( y=df2.index.values[0:20], x=df2['s1b'][0:20], fit_reg=False )\n",
    "plot.invert_yaxis()\n",
    "plot.invert_xaxis()\n",
    "plt.xlim( 6, -.5 )\n",
    "# plt.ylim( 20, 0 )\n",
    "\n",
    "# Chart formatting\n",
    "sns.despine()\n",
    "plot.get_yaxis().set_visible(False)\n",
    "# plot.grid( b=True, which='major', color='#EEEEEE', linewidth=1.0 )\n",
    "sns.set_style('whitegrid')\n",
    "plot.grid( color='#EEEEEE', linewidth=1.0 )\n",
    "plot.set( xlabel=\"Split 1 Gaps\" )\n",
    "\n",
    "# Adding point labels\n",
    "# plot.text( df2.s1b.min() + 0.02, 0.2, df2.Name[0] + \" \" +str(df2.s1s.min().total_seconds() ), horizontalalignment='right', size='small' )\n",
    "for row in range( 0, 20 ):\n",
    "    plot.text( df2.s1b[row] + .2, df2.index.values[row] + 0.15, df2.Name[row] + \" \" + str( '%.3f' % round( df2.s1s[row].total_seconds(), 3 ) if row==0 else \"+\" + str(df2.s1b[row]) ) , horizontalalignment='right', size='small'  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's1b', 'Sector 1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = df.sort_values('s2cb', ascending=True)\n",
    "df2 = df2.reset_index(drop=True)\n",
    "plt.subplots(figsize=(5,7))\n",
    "plot = sns.regplot( y=df2.index.values[0:20], x=df2['s2cb'][0:20], fit_reg=False )\n",
    "plot.invert_yaxis()\n",
    "plot.invert_xaxis()\n",
    "plt.xlim( 6, -.5 )\n",
    "# plt.ylim( 20, 0 )\n",
    "\n",
    "# Chart formatting\n",
    "sns.despine()\n",
    "plot.get_yaxis().set_visible(False)\n",
    "# plot.grid( b=True, which='major', color='#EEEEEE', linewidth=1.0 )\n",
    "sns.set_style('whitegrid')\n",
    "plot.grid( color='#EEEEEE', linewidth=1.0 )\n",
    "plot.set( xlabel=\"Sector 2\" )\n",
    "\n",
    "# Adding point labels\n",
    "# plot.text( df2.s1b.min() + 0.02, 0.2, df2.Name[0] + \" \" +str(df2.s1s.min().total_seconds() ), horizontalalignment='right', size='small' )\n",
    "for row in range( 0, 20 ):\n",
    "    plot.text( df2.s2cb[row] + .2, df2.index.values[row] + 0.15, df2.Name[row] + \" \" + str( '%.3f' % round( df2.s2c[row].total_seconds(), 3 ) if row==0 else \"+\" + str(df2.s2cb[row]) ) , horizontalalignment='right', size='small'  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's2cb', 'Sector 2' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = df.sort_values('s2b', ascending=True)\n",
    "df2 = df2.reset_index(drop=True)\n",
    "plt.subplots(figsize=(5,7))\n",
    "plot = sns.regplot( y=df2.index.values[0:20], x=df2['s2b'][0:20], fit_reg=False )\n",
    "plot.invert_yaxis()\n",
    "plot.invert_xaxis()\n",
    "plt.xlim( 6, -.5 )\n",
    "# plt.ylim( 20, 0 )\n",
    "\n",
    "# Chart formatting\n",
    "sns.despine()\n",
    "plot.get_yaxis().set_visible(False)\n",
    "# plot.grid( b=True, which='major', color='#EEEEEE', linewidth=1.0 )\n",
    "sns.set_style('whitegrid')\n",
    "plot.grid( color='#EEEEEE', linewidth=1.0 )\n",
    "plot.set( xlabel=\"Split 2\" )\n",
    "\n",
    "# Adding point labels\n",
    "for row in range( 0, 20 ):\n",
    "    plot.text( df2.s2b[row] + .2, df2.index.values[row] + 0.15, df2.Name[row] + \" \" + str( '%.3f' % round( df2.s2s[row].total_seconds(), 3 ) if row==0 else \"+\" + str(df2.s2b[row]) ) , horizontalalignment='right', size='small'  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's2b', 'Split 2' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = df.sort_values('s3cb', ascending=True)\n",
    "df2 = df2.reset_index(drop=True)\n",
    "plt.subplots(figsize=(5,7))\n",
    "plot = sns.regplot( y=df2.index.values[0:20], x=df2['s3cb'][0:20], fit_reg=False )\n",
    "plot.invert_yaxis()\n",
    "plot.invert_xaxis()\n",
    "plt.xlim( 6, -.5 )\n",
    "# plt.ylim( 20, 0 )\n",
    "\n",
    "# Chart formatting\n",
    "sns.despine()\n",
    "plot.get_yaxis().set_visible(False)\n",
    "# plot.grid( b=True, which='major', color='#EEEEEE', linewidth=1.0 )\n",
    "sns.set_style('whitegrid')\n",
    "plot.grid( color='#EEEEEE', linewidth=1.0 )\n",
    "plot.set( xlabel=\"Sector 2\" )\n",
    "\n",
    "# Adding point labels\n",
    "# plot.text( df2.s1b.min() + 0.02, 0.2, df2.Name[0] + \" \" +str(df2.s1s.min().total_seconds() ), horizontalalignment='right', size='small' )\n",
    "for row in range( 0, 20 ):\n",
    "    plot.text( df2.s3cb[row] + .2, df2.index.values[row] + 0.15, df2.Name[row] + \" \" + str( '%.3f' % round( df2.s3c[row].total_seconds(), 3 ) if row==0 else \"+\" + str(df2.s3cb[row]) ) , horizontalalignment='right', size='small'  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's3cb', 'Sector 3' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = df.sort_values('s3b', ascending=True)\n",
    "df2 = df2.reset_index(drop=True)\n",
    "plt.subplots(figsize=(5,7))\n",
    "plot = sns.regplot( y=df2.index.values[0:20], x=df2['s3b'][0:20], fit_reg=False )\n",
    "plot.invert_yaxis()\n",
    "plot.invert_xaxis()\n",
    "plt.xlim( 6, -.5 )\n",
    "# plt.ylim( 20, 0 )\n",
    "\n",
    "# Chart formatting\n",
    "sns.despine()\n",
    "plot.get_yaxis().set_visible(False)\n",
    "# plot.grid( b=True, which='major', color='#EEEEEE', linewidth=1.0 )\n",
    "sns.set_style('whitegrid')\n",
    "plot.grid( color='#EEEEEE', linewidth=1.0 )\n",
    "plot.set( xlabel=\"Split 2\" )\n",
    "\n",
    "# Adding point labels\n",
    "col = 's3b'\n",
    "for row in range( 0, 20 ):\n",
    "    plot.text( df2[col][row] + .2, df2.index.values[row] + 0.15, df2.Name[row] + \" \" + str( '%.3f' % round( df2.s3s[row].total_seconds(), 3 ) if row==0 else \"+\" + str(df2.s3b[row]) ) , horizontalalignment='right', size='small'  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's3b', 'Split 3' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's4cb', 'Sector 4' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's4b', 'Split 4' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's5cb', 'Sector 5' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawScatter( 's5b', 'Finish' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfRank = df[['s1cr', 's2cr', 's3cr', 's4cr', 's5cr']][:20].copy()\n",
    "dfRank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://seaborn.pydata.org/generated/seaborn.heatmap.html\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "cmap = sns.cm.rocket_r\n",
    "map = sns.heatmap(dfRank, annot=True, yticklabels=df.Name[:20], xticklabels=[1,2,3,4,5], cmap=cmap)\n",
    "# viridis, YlOrRd\n",
    "# , annot_kws={\"size\": 20}\n",
    "# , linewidth=1\n",
    "map.set( xlabel=\"Sector\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "splits = 5\n",
    "topX = 20\n",
    "dfSplitRank = df[['s1cr', 's2cr', 's3cr', 's4cr', 's5cr']][:topX].copy()\n",
    "labelY = df['Name'][:topX].values.tolist()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cycler(color=['rgb']) * cycler(linestyle=['-','--',':'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "from cycler import cycler\n",
    "\n",
    "mpl.style.use('seaborn')\n",
    "# default_cycler = cycler('color', ['r', 'g', 'b', 'y']) + cycler('linestyle', ['-', '--', ':', '-.'])\n",
    "cyc = cycler(color='bgrcmykbgrcmykbgrcmy') + cycler(linestyle='-------:::::::------')\n",
    "\n",
    "cyc = cycler(color=['r']) * cycler(linestyle=['-','--',':'])\n",
    "\n",
    "mpl.rcParams['axes.prop_cycle'] = cyc\n",
    "\n",
    "# ax.set_prop_cycle(cycler(color=plt.get_cmap('tab20c').colors))\n",
    "\n",
    "pltX = 1.6 * splits\n",
    "pltY = 6 * ( topX / 10 )\n",
    "\n",
    "# fig, ax = plt.subplots()\n",
    "\n",
    "data = dfSplitRank.T\n",
    "fig = plt.figure( figsize=(pltX, pltY) )\n",
    "plt.plot( data, label=True )\n",
    "# plt.plot( data )\n",
    "ax = plt.gca()\n",
    "\n",
    "# ax.set_prop_cycle(None)\n",
    "\n",
    "ax.invert_yaxis()\n",
    "\n",
    "# plt.set_cmap(plt.get_cmap('OrRd'))\n",
    "\n",
    "\n",
    "plt.box(on=None)\n",
    "\n",
    "plt.xlabel( \"Split\")\n",
    "# locs, labels = plt.yticks()\n",
    "\n",
    "maxY = int(dfSplitRank['s1cr'].max()+1)\n",
    "plt.yticks( [1]+list(range( 5, maxY, 5 )), [1]+list(range( 5, maxY, 5 )) )\n",
    "\n",
    "plt.xticks( range( 0, splits ), range( 1, splits+1 ) )\n",
    "plt.grid( False, which='major', axis='y' )\n",
    "\n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "ax.legend( handles, labelY, loc=1, labelspacing=0.58, bbox_to_anchor=(1.4, 0.972)) #, handletextpad=1\n",
    "\n",
    "# n = 6w\n",
    "# color = plt.cm.coolwarm(np.linspace(0.1,0.9,n)) # This returns RGBA; convert:\n",
    "# hexcolor = map(lambda rgb:'#%02x%02x%02x' % (rgb[0]*255,rgb[1]*255,rgb[2]*255),tuple(color[:,0:-1]))\n",
    "# mpl.rcParams['axes.color_cycle'] = hexcolor\n",
    "\n",
    "# mpl.rcParams['image.cmap'] = 'jet'\n",
    "\n",
    "# from cycler import cycler\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# *Meant* to allow labellign each line on the chart\n",
    "for i in range( 1, splits+1 ):\n",
    "    col = 'split' + str(i) + ( '_sector' if i > 1 else '' )\n",
    "    display( df[col].min() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "r = lambda: random.randint(0,255)\n",
    "def rCol():\n",
    "    return ('#%02X%02X%02X' % (r(),r(),r()))\n",
    "\n",
    "cols = [ rCol() for i in range( 0, 60 ) ]\n",
    "cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Attemptin to overlay quali splits with race splits for topX in summary\n",
    "dfm = df\n",
    "\n",
    "# https://seaborn.pydata.org/examples/pairgrid_dotplot.html\n",
    "# display( list(dfm.columns ))\n",
    "data = dfm[[ 'name', 'rank', 'split1', 'split2_sector', 'split3_sector', 'split4_sector', 'split5_sector', 'q_split1', 'q_split2_sector', 'q_split3_sector', 'q_split4_sector', 'q_split5_sector' ]].copy()\n",
    "best = pd.DataFrame( [[ 'PERFECT Run', 0, dfm['split1'].min(), dfm['split2_sector'].min(), dfm['split3_sector'].min(), dfm['split4_sector'].min(), dfm['split5_sector'].min(), dfm['q_split1'].min(), dfm['q_split2_sector'].min(), dfm['q_split3_sector'].min(), dfm['q_split4_sector'].min(), dfm['q_split5_sector'].min() ]], columns=data.columns )\n",
    "data = data.append( best ).sort_values( 'rank' ).reset_index( drop=True )\n",
    "data['split1_sector'] = data['split1']\n",
    "data['q_split1_sector'] = data['q_split1']\n",
    "\n",
    "# Expand data set\n",
    "for pfx in [ '', 'q_' ]:\n",
    "#     data[pfx + 'split1_sector'] = data[pfx + 'split1']\n",
    "    for i in range( 1, splits+1 ):\n",
    "        split = pfx + 'split' + str(i)\n",
    "        sector = split + '_sector'\n",
    "\n",
    "        if 1 < i:\n",
    "            data[split] = data[pfx + 'split' + str(i-1)] + data[sector]\n",
    "\n",
    "        data[split + '_rank'] = data[split].rank(method='dense')\n",
    "\n",
    "        if 'q_' != pfx:\n",
    "            data[split + '_vs_best'] = ( data[split] - data[split].min() )\n",
    "        else:\n",
    "            # Difference back from race split to quali split\n",
    "            # q_splitX_vs_SELF = ( splitX - splitX.min ) + ( splitX - q_splitX )\n",
    "            data[split + '_vs_best'] = ( data[split[2:]] - data[split[2:]].min() ) + ( data[split] - data[split[2:]] )\n",
    "data['rank'] = data['split5_rank']\n",
    "\n",
    "# Rearrange columns\n",
    "data = data[list(data.columns[:2]) + list(sorted(data.columns[2:]))]\n",
    "\n",
    "# Make the PairGrid\n",
    "g = sns.PairGrid( data[:topX], x_vars=['split1_vs_best', 'split2_vs_best', 'split3_vs_best', 'split4_vs_best', 'split5_vs_best'], y_vars=[\"name\"], size=5, aspect=.4 )\n",
    "g1 = sns.PairGrid( data[:topX], x_vars=['q_split1_vs_best', 'q_split2_vs_best', 'q_split3_vs_best', 'q_split4_vs_best', 'q_split5_vs_best'], y_vars=[\"name\"], size=5, aspect=.4 )\n",
    "# g = sns.PairGrid( data[:topX], x_vars=['split1_vs_best','q_split1_vs_best', 'split2_vs_best','q_split2_vs_best', 'split3_vs_best','q_split3_vs_best', 'split4_vs_best','q_split4_vs_best', 'split5_vs_best','q_split5_vs_best'], y_vars='name', size=5, aspect=.4 )\n",
    "\n",
    "\n",
    "# Draw a dot plot using the stripplot function\n",
    "colors = colorList( '#6495ED', '#6495ED', len(data), 1, 2, 3 )\n",
    "colors[0] = 'mediumorchid'\n",
    "g.map( sns.stripplot, size=9, orient='h', palette=colors, edgecolor='gray', marker='o' )\n",
    "g1.map( sns.stripplot, size=9, orient='h', color='grey', edgecolor='gray', marker='s', alpha=0.5 )\n",
    "\n",
    "# Use the same x axis limits on all columns and add better labels\n",
    "g.set( xlim=(data[:topX]['split5_vs_best'].max()+1, -1), xlabel=\"Gap (s)\", ylabel=\"\" ) # xlim=(0, 25),\n",
    "g1.set( xlim=(data[:topX]['split5_vs_best'].max()+1, -1), xlabel=\"Gap (s)\", ylabel=\"\" ) # xlim=(0, 25),\n",
    "\n",
    "# Use semantically meaningful titles for the columns\n",
    "titles = [\"Split 1\", \"Split 2\", \"Split 3\", \"Split 4\", \"Split 5\"]\n",
    "\n",
    "for ax, title in zip(g.axes.flat, titles):\n",
    "    # Set a different title for each axes\n",
    "    ax.set(title=title)\n",
    "\n",
    "    # Make the grid horizontal instead of vertical\n",
    "    ax.xaxis.grid( False )\n",
    "    ax.yaxis.grid( color='#EEEEEE' )\n",
    "\n",
    "# Chart Visuals\n",
    "sns.despine( left=True, bottom=True )\n",
    "plt.subplots_adjust( top=0.88 )\n",
    "g.fig.suptitle( chart_title_prefix + ': Split Summary' )\n",
    "\n",
    "# Image export\n",
    "if image_gen:\n",
    "    plt.gcf().subplots_adjust(left=0.22)\n",
    "    plt.savefig( file_prefix + '_split_summary.png', dpi=dpi )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "def get_data(n=266, s=[5,13]):\n",
    "    val = np.c_[np.random.poisson(lam=s[0], size=n),\n",
    "                np.random.poisson(lam=s[1], size=n)].T.flatten()\n",
    "    comp = [s[0]]*n +  [s[1]]*n\n",
    "    ov = np.random.choice(list(\"ABC\"), size=2*n)\n",
    "    return pd.DataFrame({\"val\":val, \"overlap\":ov, \"comp\":comp})\n",
    "\n",
    "data1 = get_data(s=[9,11])\n",
    "data2 = get_data(s=[7,19])\n",
    "data3 = get_data(s=[1,27])\n",
    "\n",
    "#option1 combine\n",
    "for i, df in enumerate([data1,data2,data3]):\n",
    "    df[\"data\"] = [\"data{}\".format(i+1)] * len(df)\n",
    "\n",
    "data = data1.append(data2)\n",
    "data = data.append(data3)\n",
    "\n",
    "bw = 2\n",
    "a = sns.FacetGrid(data, col=\"overlap\",  hue=\"comp\", row=\"data\")\n",
    "a = (a.map(sns.kdeplot, \"val\",bw=bw ))\n",
    "plt.show()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}