{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd, numpy as np\n",
    "from scipy import stats\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "stations=pd.read_csv('data/stations.csv').set_index('ID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setup plot params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.collections import PolyCollection\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.font_manager as font_manager\n",
    "path = 'KulimPark-Regular.ttf'\n",
    "path2 = 'Symbola.ttf'\n",
    "prop = font_manager.FontProperties(fname=path)\n",
    "prop2 = font_manager.FontProperties(fname=path2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_ax='#E7CFBC'\n",
    "color_bg='#FFF4EC'\n",
    "color_obs_right0='#F2B880'\n",
    "color_obs_left0=color_ax\n",
    "color_pred_right0='#C98686'\n",
    "color_pred_left0='#966B9D'\n",
    "color_pred_talalt0='#59c687'\n",
    "color_pred_nem_talalt0='#c95498'\n",
    "font_size=12\n",
    "s=40\n",
    "obs_talalt_glyph0='★'\n",
    "obs_nem_talalt_glyph0='☆'\n",
    "pred_talalt_glyph0='✔️'\n",
    "pred_nem_talalt_glyph0='✖️'\n",
    "title_icon_right={'Temp':'☼','Wind':'🌀','Hail':'⭕️','Snow':'☃️','Snow Depth':'⛄️','Rain':'☔️','Visib':'☀️'}\n",
    "title_icon_left={'Temp':'✨️','Wind':'☘','Hail':'⚪️','Snow':'⚪️','Snow Depth':'⚪️','Rain':'🌂','Visib':'⛈️'}\n",
    "title_icon={'Temp':'♨️','Rain':'☂️','Hail':'✴️','Snow':'❄️','Snow Depth':'⛷️','Wind':'⛵️','Cloud':'☁️','Visib':'⛅️'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data(data,th):\n",
    "    a1=pd.DataFrame(data[data<=th])\n",
    "    a1['g']='left'\n",
    "    a2=pd.DataFrame(data[data>th])\n",
    "    a2['g']='right'\n",
    "    a3=pd.concat([a1,a2])\n",
    "    a3['x']='x'\n",
    "    return a1,a2,a3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def violin_plot(data,th,ax,color_left,color_right):\n",
    "    a=0.3\n",
    "    a1,a2,a3=get_data(data,th)\n",
    "    a1_augment=True\n",
    "    a2_augment=True\n",
    "    if len(a1)==0:\n",
    "        a1=a3.loc[[a3.index[0]]]\n",
    "        a1['g']='left'\n",
    "        a1[a1.columns[0]]=5\n",
    "    if len(a2)==0:\n",
    "        a2=a3.loc[[a3.index[0]]]\n",
    "        a2['g']='right'\n",
    "        a2[a2.columns[0]]=5\n",
    "    if len(a1)>1: a1_augment=False\n",
    "    if not a1_augment:\n",
    "        if a1.nunique()[a1.columns[0]]==1: \n",
    "            a1_augment=True\n",
    "    if a1_augment:\n",
    "        a11=a1.copy().loc[[a1.index[0]]]\n",
    "        a11[a11.columns[0]]+=random.random()*0.1*th\n",
    "        a11['x']='x'\n",
    "        a12=a1.copy().loc[[a1.index[0]]]\n",
    "        a12[a12.columns[0]]-=random.random()*0.1*th\n",
    "        a12['x']='x'\n",
    "        a3=pd.concat([a3,a11,a12])\n",
    "    if len(a2)>1: a2_augment=False\n",
    "    if not a2_augment:\n",
    "        if a2.nunique()[a2.columns[0]]==1: \n",
    "            a2_augment=True\n",
    "    if a2_augment:\n",
    "        a21=a2.copy().loc[[a2.index[0]]]\n",
    "        a21[a21.columns[0]]+=random.random()*0.1*th\n",
    "        a21['x']='x'\n",
    "        a22=a2.copy().loc[[a2.index[0]]]\n",
    "        a22[a22.columns[0]]-=random.random()*0.1*th\n",
    "        a22['x']='x'\n",
    "        a3=pd.concat([a3,a21,a22])\n",
    "    a3=a3.sort_values('g')\n",
    "    ax.axvline(0,color=color_ax)\n",
    "    if a3.nunique()['g']>1:\n",
    "        sns.violinplot(y=a1.columns[0], x='x',hue='g', data=a3, split=True, ax=ax,\n",
    "                      inner=None,linewidth=1, scale=\"count\", saturation=1)\n",
    "\n",
    "        ax.get_children()[0].set_color(mpl.colors.colorConverter.to_rgba(color_left, alpha=a))\n",
    "        ax.get_children()[0].set_edgecolor(color_left)\n",
    "        ax.get_children()[1].set_color(mpl.colors.colorConverter.to_rgba(color_right, alpha=a))\n",
    "        ax.get_children()[1].set_edgecolor(color_right)\n",
    "        ax.legend().remove()\n",
    "    else:\n",
    "        if len(a1)>0: \n",
    "            w=a1\n",
    "            c=color_left\n",
    "        else: \n",
    "            w=a2\n",
    "            c=color_right\n",
    "        sns.violinplot(y=w.columns[0], data=w, ax=ax, \n",
    "                       inner=None,linewidth=1, scale=\"count\", saturation=1)\n",
    "        ax.set_xlim([-1,0])\n",
    "        ax.get_children()[0].set_color(mpl.colors.colorConverter.to_rgba(c, alpha=a))\n",
    "        ax.get_children()[0].set_edgecolor(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setup_axes():\n",
    "    fig,axes=plt.subplots(1,3,figsize=(8,5),gridspec_kw={'width_ratios': [1, 3, 1]})\n",
    "    axi_top= axes[2].inset_axes([0.1, 0.65, 1, 0.3])\n",
    "    axi_top.axis('off')\n",
    "    axi_bottom= axes[2].inset_axes([0.1, 0, 1, 0.5])\n",
    "    axi_bottom.axis('off')\n",
    "    axes[0].axis('off')\n",
    "    axes[1].axis('off')\n",
    "    axes[2].axis('off')\n",
    "    axes[0]=axes[0].inset_axes([0, 0.15, 1, 0.85])\n",
    "    axes[1]=axes[1].inset_axes([0, 0.15, 1, 0.85])\n",
    "    axes[0].axis('off')\n",
    "    axes[1].axis('off')\n",
    "    return fig, axes, axi_top, axi_bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stem_plot(data,ax,color,s=s):\n",
    "    data=pd.DataFrame(data)\n",
    "    x=data.index\n",
    "    y=data[data.columns[0]].values\n",
    "    for i,e in enumerate(y):\n",
    "        ax.plot([0,e],[x[i],x[i]],color=color)\n",
    "    ax.scatter(y,x,s,color=color,zorder=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stem2_plot(data,th,ax,color_left,color_right,s=s,axv_color=None):\n",
    "    if axv_color==None:axv_color=color_right\n",
    "    a1,a2,a3=get_data(data,th)\n",
    "    stem_plot(a1,ax,color_left,s)\n",
    "    stem_plot(a2,ax,color_right,s)\n",
    "    ax.axvline(0,color=color_ax)\n",
    "    #if th!=0:\n",
    "    if True:\n",
    "        ax.axvline(th,color=axv_color,ls='--',zorder=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def icons_plot(axes,kondicio,mennyiseg,observation_th,prediction_th):\n",
    "    ylim=axes[0].get_ylim()\n",
    "    xlim=axes[1].get_xlim()\n",
    "    y_max_coord=ylim[0]+(ylim[1]-ylim[0])*1.05\n",
    "    y_max_coord2=ylim[0]+(ylim[1]-ylim[0])*1.05 #1.04\n",
    "    x_icon_coord_shift=(xlim[1]-xlim[0])*0.1\n",
    "    axes[0].text(observation_th, y_max_coord, title_icon[kondicio], \n",
    "            horizontalalignment='center', color=color_obs_right0, fontproperties=prop2, fontsize=font_size*1.5)\n",
    "    axes[1].text(prediction_th, y_max_coord, title_icon[mennyiseg], \n",
    "            horizontalalignment='center', color=color_ax, fontproperties=prop2, fontsize=font_size*1.5)\n",
    "    axes[1].text(prediction_th+x_icon_coord_shift, y_max_coord2, title_icon_right[mennyiseg], \n",
    "            horizontalalignment='center', color=color_pred_right, fontproperties=prop2, fontsize=font_size*1.5)\n",
    "    axes[1].text(prediction_th-x_icon_coord_shift, y_max_coord2, title_icon_left[mennyiseg], \n",
    "            horizontalalignment='center', color=color_pred_left, fontproperties=prop2, fontsize=font_size*1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def talalat_plot_line(axes,n_prediction_ts_good,n_prediction_ts_bad,\n",
    "                        n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt,\n",
    "                      observation_th,prediction_th):\n",
    "    ylim=axes[0].get_ylim()\n",
    "    xlim=axes[0].get_xlim()\n",
    "    y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.07)\n",
    "    x_icon_coord_shift=(xlim[1]-xlim[0])*0.1\n",
    "    x_icon_coord_shift2=(xlim[1]-xlim[0])*0.27\n",
    "    axes[0].text(observation_th+x_icon_coord_shift, y_max_coord, obs_talalt_glyph, \n",
    "            horizontalalignment='center', color=color_obs_right, fontproperties=prop2)\n",
    "    axes[0].text(observation_th-x_icon_coord_shift, y_max_coord, obs_nem_talalt_glyph, \n",
    "            horizontalalignment='center', color=color_obs_left, fontproperties=prop2)\n",
    "    axes[0].text(observation_th+x_icon_coord_shift2, y_max_coord, n_prediction_ts_good, \n",
    "            horizontalalignment='center', color=color_obs_right, fontproperties=prop)\n",
    "    axes[0].text(observation_th-x_icon_coord_shift2, y_max_coord, n_prediction_ts_bad, \n",
    "            horizontalalignment='center', color=color_obs_left, fontproperties=prop)\n",
    "    axes[0].text(observation_th, y_max_coord, '|', \n",
    "            horizontalalignment='center', color=color_obs_right0, fontproperties=prop,fontsize=19)\n",
    "\n",
    "    xlim=axes[1].get_xlim()\n",
    "    x_icon_coord_shift=(xlim[1]-xlim[0])*0.04\n",
    "    x_icon_coord_shift2=(xlim[1]-xlim[0])*0.1\n",
    "    axes[1].text(prediction_th+x_icon_coord_shift, y_max_coord, pred_talalt_glyph, \n",
    "            horizontalalignment='center', color=color_pred_talalt, fontproperties=prop2)\n",
    "    axes[1].text(prediction_th-x_icon_coord_shift, y_max_coord, pred_nem_talalt_glyph, \n",
    "            horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop2)\n",
    "    axes[1].text(prediction_th+x_icon_coord_shift2, y_max_coord, n_prediction_ts_good_talalt, \n",
    "            horizontalalignment='center', color=color_pred_talalt, fontproperties=prop)\n",
    "    axes[1].text(prediction_th-x_icon_coord_shift2, y_max_coord, n_prediction_ts_good_nem_talalt, \n",
    "            horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop)\n",
    "    axes[1].text(prediction_th, y_max_coord, '|', \n",
    "            horizontalalignment='center', color=color_pred_right, fontproperties=prop,fontsize=19)\n",
    "    \n",
    "    y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.14)\n",
    "    axes[0].text(observation_th, y_max_coord, 'feltétel', \n",
    "            horizontalalignment='center', color=color_obs_right0, fontproperties=prop)\n",
    "    axes[1].text(prediction_th, y_max_coord, 'jóslat', \n",
    "            horizontalalignment='center', color=color_pred_right, fontproperties=prop)\n",
    "    y_max_coord=ylim[0]+(ylim[1]-ylim[0])*(-0.13)\n",
    "    x_coord_shift=prediction_th+(prediction_th-xlim[0])*(-0.4)\n",
    "    axes[1].annotate('', xy=(x_coord_shift, y_max_coord),xycoords='data',annotation_clip=False,\n",
    "             xytext=(xlim[0], y_max_coord),arrowprops=dict(arrowstyle= '->',color=color_obs_right0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def talalat_plot_violin(axes,n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt):\n",
    "    y_icon_obs=0.65\n",
    "    y_icon_pred=0.5\n",
    "    if color_obs_right==color_obs_right0: x=0.72\n",
    "    else: x=0.47\n",
    "    axes[2].text(0.72, y_icon_obs, obs_talalt_glyph, \n",
    "            horizontalalignment='center', color=color_obs_right, fontproperties=prop2)\n",
    "    axes[2].text(0.9, y_icon_obs,n_prediction_ts_good, \n",
    "            horizontalalignment='center', color=color_obs_right, fontproperties=prop)\n",
    "    axes[2].text(0.47, y_icon_obs, obs_nem_talalt_glyph, \n",
    "            horizontalalignment='center', color=color_obs_left, fontproperties=prop2)\n",
    "    axes[2].text(0.29, y_icon_obs, n_prediction_ts_bad, \n",
    "            horizontalalignment='center', color=color_obs_left, fontproperties=prop)\n",
    "    \n",
    "    axes[2].text(0.72, y_icon_pred, pred_talalt_glyph,\n",
    "            horizontalalignment='center', color=color_pred_talalt, fontproperties=prop2)\n",
    "    axes[2].text(0.9, y_icon_pred, n_prediction_ts_good_talalt, \n",
    "            horizontalalignment='center', color=color_pred_talalt, fontproperties=prop)\n",
    "    axes[2].text(0.47, y_icon_pred, pred_nem_talalt_glyph, \n",
    "            horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop2)\n",
    "    axes[2].text(0.29, y_icon_pred, n_prediction_ts_good_nem_talalt,\n",
    "            horizontalalignment='center', color=color_pred_nem_talalt, fontproperties=prop)\n",
    "    \n",
    "    axes[2].annotate('', xy=(0.59, y_icon_pred*1.04),xycoords='data',\n",
    "             xytext=(x, y_icon_obs*0.98),arrowprops=dict(arrowstyle= '->',color=color_obs_right0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def talalat_plot(axes,ns,observation_th,prediction_th):\n",
    "    n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt=ns\n",
    "    talalat_plot_line(axes,n_prediction_ts_good,n_prediction_ts_bad,\n",
    "                        n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt,\n",
    "                      observation_th,prediction_th)\n",
    "    talalat_plot_violin(axes,n_prediction_ts_good,n_prediction_ts_bad,\n",
    "                        n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def year_plot(data,ax,k):\n",
    "    y=data.values\n",
    "    x=data.index\n",
    "    ex=max(y)-min(y)\n",
    "    text_off=abs(ex*k)\n",
    "    text_align='left'\n",
    "    if y[0]<0:\n",
    "        text_off=-text_off\n",
    "        text_align='right'\n",
    "    ax.text(y[0]+text_off, x[0], str(int(x[0])), \n",
    "            horizontalalignment=text_align, verticalalignment='center', \n",
    "            color=color_ax, fontproperties=prop)\n",
    "    text_off=abs(text_off)\n",
    "    text_align='left'\n",
    "    if y[-1]<0:\n",
    "        text_off=-text_off\n",
    "        text_align='right'\n",
    "    ax.text(y[-1]+text_off, x[-1], str(int(x[-1])), \n",
    "            horizontalalignment=text_align, verticalalignment='center', \n",
    "            color=color_ax, fontproperties=prop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spine_plot(datum,title,mondas,jelentes,kondicio,mennyiseg,\n",
    "               observation_ts,observation_th,prediction_ts,prediction_th,c):\n",
    "    \n",
    "    #data\n",
    "    prediction_ts_good=prediction_ts.loc[observation_ts[observation_ts>observation_th].index]\n",
    "    prediction_ts_bad=prediction_ts.loc[observation_ts[observation_ts<=observation_th].index]\n",
    "    n_prediction_ts_good=len(prediction_ts_good)\n",
    "    n_prediction_ts_bad=len(prediction_ts_bad)\n",
    "    \n",
    "    if color_obs_right0!=color_obs_right:\n",
    "        prediction_ts_good,prediction_ts_bad=prediction_ts_bad,prediction_ts_good\n",
    "    prediction_ts_good_nem_talalt,prediction_ts_good_talalt,\\\n",
    "        prediction_ts_good_joined=get_data(prediction_ts_good,prediction_th)\n",
    "    n_prediction_ts_good_talalt=len(prediction_ts_good_talalt)\n",
    "    n_prediction_ts_good_nem_talalt=len(prediction_ts_good_nem_talalt)\n",
    "    ns=[n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt]\n",
    "    \n",
    "    #plots\n",
    "    fig, axes, axi_top, axi_bottom=setup_axes()\n",
    "    \n",
    "    stem2_plot(observation_ts,observation_th,axes[0],color_obs_left,color_obs_right,s/2,color_obs_right0)\n",
    "    stem2_plot(prediction_ts_good,prediction_th,axes[1],color_pred_left,color_pred_right)\n",
    "    stem_plot(prediction_ts_bad,axes[1],color_ax)\n",
    "    \n",
    "    violin_plot(observation_ts,observation_th,axi_top,color_obs_left,color_obs_right)\n",
    "    violin_plot(prediction_ts_good,prediction_th,axi_bottom,color_pred_left,color_pred_right)\n",
    "    \n",
    "    #icons\n",
    "    icons_plot(axes,kondicio,mennyiseg,observation_th,prediction_th)\n",
    "    \n",
    "    #talalat\n",
    "    talalat_plot(axes,ns,observation_th,prediction_th)\n",
    "    \n",
    "    #years\n",
    "    obs_year_index=observation_data[[obs_key,'pyear']].dropna().groupby('pyear').mean().index\n",
    "    pred_year_index=prediction_data[[pred_key,'pyear']].dropna().groupby('pyear').mean().index\n",
    "    pred_year_index_filt=prediction_ts.loc[pred_year_index].dropna().index\n",
    "    obs_year_index_filt=observation_ts.loc[obs_year_index].dropna().index\n",
    "    pred_year_index2=max(min(pred_year_index_filt),min(obs_year_index_filt))\n",
    "    pred_year_index=range(pred_year_index2,max(pred_year_index_filt)+1)\n",
    "    year_plot(observation_ts.loc[obs_year_index].dropna(),axes[0],0.09)\n",
    "    year_plot(prediction_ts.loc[pred_year_index].dropna(),axes[1],0.03)\n",
    "    \n",
    "    #titles\n",
    "    len_ratio=0.15*(-1+(len(jelentes.split(',')[0])/len(jelentes.split(',')[1])))\n",
    "    fig.text(0.5+len_ratio,0.04,jelentes.split(',')[0]+',',color=color_obs_right0,\n",
    "             fontproperties=prop,fontsize=font_size*0.7,horizontalalignment='right')\n",
    "    if color_pred_talalt==color_pred_talalt0: color_pred_side=color_pred_right\n",
    "    else: color_pred_side=color_pred_left\n",
    "    fig.text(0.5+len_ratio,0.04,jelentes.split(',')[1],color=color_pred_side,\n",
    "             fontproperties=prop,fontsize=font_size*0.7,horizontalalignment='left')\n",
    "    if n_prediction_ts_good_nem_talalt>=n_prediction_ts_good_talalt:\n",
    "        color_title=color_pred_nem_talalt\n",
    "    else: \n",
    "        color_title=color_pred_talalt\n",
    "    verdict=int(100*n_prediction_ts_good_talalt/(n_prediction_ts_good_talalt+n_prediction_ts_good_nem_talalt))\n",
    "    if color_pred_talalt!=color_pred_talalt0: verdict=100-verdict\n",
    "    return_verdict=int(verdict)\n",
    "    verdict=str(verdict)+'%'\n",
    "    plt.suptitle(title,y=0.11,color=color_title,fontproperties=prop,fontsize=font_size)\n",
    "    fig.text(0.97,0.04,verdict, fontproperties=prop,\n",
    "            horizontalalignment='right', color=color_title, fontsize=font_size*2, )\n",
    "    fig.text(0.03,0.04, datum, fontproperties=prop,\n",
    "            horizontalalignment='left', color=color_obs_right0, fontsize=font_size*2, )\n",
    "    \n",
    "    plt.savefig(c+'/a1/'+str(mondas)+'.png',dpi=300, facecolor=color_bg)\n",
    "    plt.show()\n",
    "    return return_verdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_data(dz,observation_range,prediction_range):\n",
    "    dgs=[]\n",
    "    dhs=[]\n",
    "    for year in range(int(dz.min()['year']),int(dz.max()['year'])):\n",
    "        k=0\n",
    "        from_date=pd.to_datetime(str(year)+'-'+str(observation_range[k].month)+'-'+str(observation_range[k].day))\n",
    "        from_pred=pd.to_datetime(str(year)+'-'+str(prediction_range[k].month)+'-'+str(prediction_range[k].day))\n",
    "        k=1\n",
    "        to_date=pd.to_datetime(str(year)+'-'+str(observation_range[k].month)+'-'+str(observation_range[k].day))\n",
    "        to_pred=pd.to_datetime(str(year)+'-'+str(prediction_range[k].month)+'-'+str(prediction_range[k].day))\n",
    "        if to_pred<to_date:\n",
    "            to_pred+=pd.to_timedelta('1Y')\n",
    "        dg=dz.loc[from_date:]\n",
    "        dg=dg[:to_date]\n",
    "        dg['pyear']=year\n",
    "        dgs.append(dg)\n",
    "        dh=dz.loc[from_pred:]\n",
    "        dh=dh[:to_pred]\n",
    "        dh['pyear']=year\n",
    "        dhs.append(dh)\n",
    "    return pd.concat(dgs),pd.concat(dhs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_direction(kondicio, mennyiseg):\n",
    "    if kondicio:\n",
    "        color_obs_right=color_obs_right0\n",
    "        color_obs_left=color_obs_left0\n",
    "        obs_talalt_glyph='★'\n",
    "        obs_nem_talalt_glyph='☆'\n",
    "    else:\n",
    "        color_obs_right=color_obs_left0\n",
    "        color_obs_left=color_obs_right0\n",
    "        obs_talalt_glyph='☆'\n",
    "        obs_nem_talalt_glyph='★'\n",
    "    if mennyiseg:\n",
    "        color_pred_talalt=color_pred_talalt0\n",
    "        color_pred_nem_talalt=color_pred_nem_talalt0\n",
    "        pred_talalt_glyph='✔️'\n",
    "        pred_nem_talalt_glyph='✖️'\n",
    "    else:\n",
    "        color_pred_talalt=color_pred_nem_talalt0\n",
    "        color_pred_nem_talalt=color_pred_talalt0\n",
    "        pred_talalt_glyph='✖️'\n",
    "        pred_nem_talalt_glyph='✔️'\n",
    "    return color_obs_right,color_obs_left,obs_talalt_glyph,obs_nem_talalt_glyph,\\\n",
    "        color_pred_talalt,color_pred_nem_talalt,pred_talalt_glyph,pred_nem_talalt_glyph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_sign(sign,key):\n",
    "    positive=True\n",
    "    if (('-' in sign) or ('+' in sign)):\n",
    "        if sign=='-':\n",
    "            positive=False\n",
    "        elif sign=='+':\n",
    "            positive=True\n",
    "    elif (('<' in sign) or ('>' in sign)):\n",
    "        if '<' in sign:\n",
    "            positive=False\n",
    "        elif '>' in sign:\n",
    "            positive=True\n",
    "    return positive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "universal_normalize=['XTEMP','XVSB','XSPD']\n",
    "\n",
    "def get_ts_data(data,key,sign):\n",
    "    ts=data.groupby('year').mean()[key]\n",
    "    if (('-' in sign) or ('+' in sign)):\n",
    "        th=ts.mean()\n",
    "    else:\n",
    "        th=float(sign[1:])\n",
    "    if key in universal_normalize:\n",
    "        th-=ts.mean()        \n",
    "        ts-=ts.mean()\n",
    "    return ts,th"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_comp_data(observation_data,obs_key,obs_sign,prediction_data,pred_key,pred_sign):\n",
    "    ertek_sign=True\n",
    "    irany_sign=True\n",
    "    observation_ts=observation_data.groupby('year').mean()[obs_key]\n",
    "    prediction_ts=prediction_data.groupby('year').mean()[pred_key]\n",
    "    prediction_th=observation_ts.mean()\n",
    "    observation_ts-=observation_ts.mean()\n",
    "    observation_th=observation_ts.min()*1.01\n",
    "    prediction_th-=prediction_ts.mean()\n",
    "    prediction_ts-=prediction_ts.mean() \n",
    "    if obs_sign=='A':\n",
    "        if pred_sign=='A':\n",
    "            observation_th=0\n",
    "            prediction_th=0\n",
    "    else:\n",
    "        irany_sign=False\n",
    "    return observation_ts,observation_th,prediction_ts,prediction_th,ertek_sign,irany_sign"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "mennyiseg_key={'Temp':'XTEMP','Snow Depth':'XSD','Wind':'XSPD','Rain':'YPCP','Visib':'XVSB',\n",
    "              'Snow':'YSNW','Hail':'YHAL'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "stations_to_include={'ro':[150040,151700,151450,152600,152470,150800,152300,150100,151200,152000],\n",
    "                    'hu':[128820,128120,127720,128600,128390,128920,128430,128250,128220,128050,\n",
    "                         129150,129420,129600,129700,129820,129920,129350,129100]}\n",
    "stations_to_include['huro']=stations_to_include['hu']+stations_to_include['ro']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_country(c,h='ds',plot=False):\n",
    "    if c=='huro':\n",
    "        hu=pd.read_csv('data/'+'hu'+'_'+h+'.csv') #daily data\n",
    "        ro=pd.read_csv('data/'+'ro'+'_'+h+'.csv') #daily data\n",
    "        df=pd.concat([hu,ro])\n",
    "    else:\n",
    "        df=pd.read_csv('data/'+c+'_'+h+'.csv') #daily data\n",
    "        # df=pd.read_csv('data/'+c+'_hs.csv') #high_res data\n",
    "    df=df[df['ID'].isin(stations_to_include[c])]\n",
    "    df['time']=pd.to_datetime(df['time'])\n",
    "    df['year']=df['time'].dt.year\n",
    "    df['month']=df['time'].dt.month\n",
    "    df['day']=df['time'].dt.day\n",
    "    df['hour']=df['time'].dt.hour\n",
    "    df=df.set_index('time')\n",
    "    df=df.sort_index()\n",
    "    if plot: df.groupby('year').nunique()['ID'].plot()\n",
    "    nepi=pd.read_excel(c+'/idojaras_'+c+'.xlsx')\n",
    "    return df,nepi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "c='huro'\n",
    "df,nepi=get_country(c)\n",
    "dz=df.groupby(['time']).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_pred_left=color_pred_left0\n",
    "color_pred_right=color_pred_right0\n",
    "mondasok=nepi['ID'].values\n",
    "# mondasok=[1,6]\n",
    "shares=[]\n",
    "for mondas in mondasok:\n",
    "    nep=nepi.loc[mondas]\n",
    "    if str(nep['Mennyiség'])!='nan':\n",
    "        obs_key=mennyiseg_key[nep['Kondíció']]\n",
    "        pred_key=mennyiseg_key[nep['Mennyiség']]\n",
    "        observation_range=[nep['Dátum:mettől']+pd.to_timedelta('-1D'),nep['Dátum:meddig']+pd.to_timedelta('+2D')]\n",
    "        prediction_range=[nep['Periódus:mettől'],nep['Periódus:meddig']+pd.to_timedelta('+1D')]\n",
    "        observation_data,prediction_data=filter_data(dz,observation_range,prediction_range)\n",
    "\n",
    "        #comparison\n",
    "        if str(nep['Érték']) in ['A','B']:\n",
    "            print('comp',mondas)\n",
    "            observation_ts,observation_th,prediction_ts,prediction_th,ertek_sign,irany_sign=\\\n",
    "                get_comp_data(observation_data,obs_key,nep['Érték'],\\\n",
    "                          prediction_data,pred_key,nep['Irány'])\n",
    "        #time series\n",
    "        else:\n",
    "            print('ts',mondas)\n",
    "            ertek_sign=get_sign(nep['Érték'],obs_key)\n",
    "            irany_sign=get_sign(nep['Irány'],pred_key)\n",
    "            observation_ts,observation_th=get_ts_data(observation_data,obs_key,nep['Érték'])\n",
    "            prediction_ts,prediction_th=get_ts_data(prediction_data,pred_key,nep['Irány'])\n",
    "\n",
    "        color_obs_right,color_obs_left,obs_talalt_glyph,obs_nem_talalt_glyph,\\\n",
    "            color_pred_talalt,color_pred_nem_talalt,pred_talalt_glyph,pred_nem_talalt_glyph=\\\n",
    "            set_direction(ertek_sign, irany_sign)\n",
    "\n",
    "        #datum=str(nep['Dátums'])[:3]+'. '+str(nep['Dátum:mettől'].day)\n",
    "        datum=nep['DS']\n",
    "        shares.append(spine_plot(datum,nep['Mondás'].strip(),mondas,nep['Jelentés'].strip(),nep['Kondíció'],nep['Mennyiség'],\n",
    "               observation_ts,observation_th,prediction_ts,prediction_th,c))\n",
    "print(np.mean(shares))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.set_index('ID').loc[stations_to_include['huro']].groupby('ID').nunique()[['year']].join(stations.loc[stations_to_include['huro']]).to_csv('huro/huro_stations.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.set_index('ID').loc[stations_to_include['huro']].groupby('ID').min()[['year']].to_csv('huro/huro_stations_years.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(stations_to_include['ro'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "White"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setup_axes2():\n",
    "    fig,axes=plt.subplots(1,3,figsize=(8,5),gridspec_kw={'width_ratios': [1, 3, 1]})\n",
    "    axi_top= axes[2].inset_axes([0.1, 0.65, 1, 0.3])\n",
    "    axi_top.axis('off')\n",
    "    axi_bottom= axes[2].inset_axes([0.1, 0, 1, 0.5])\n",
    "    axi_bottom.axis('off')\n",
    "    axes[0].axis('off')\n",
    "    axes[1].axis('off')\n",
    "    axes[2].axis('off')\n",
    "    axes[0]=axes[0].inset_axes([0, 0.15, 1, 0.85])\n",
    "    axes[1]=axes[1].inset_axes([0, 0.15, 1, 0.85])\n",
    "    axes[0].axis('off')\n",
    "    axes[1].axis('off')\n",
    "    return fig, axes, axi_top, axi_bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spine_plot2(datum,title,mondas,jelentes,kondicio,mennyiseg,\n",
    "               observation_ts,observation_th,prediction_ts,prediction_th,c):\n",
    "    \n",
    "    #data\n",
    "    prediction_ts_good=prediction_ts.loc[observation_ts[observation_ts>observation_th].index]\n",
    "    prediction_ts_bad=prediction_ts.loc[observation_ts[observation_ts<=observation_th].index]\n",
    "    n_prediction_ts_good=len(prediction_ts_good)\n",
    "    n_prediction_ts_bad=len(prediction_ts_bad)\n",
    "    \n",
    "    if color_obs_right0!=color_obs_right:\n",
    "        prediction_ts_good,prediction_ts_bad=prediction_ts_bad,prediction_ts_good\n",
    "    prediction_ts_good_nem_talalt,prediction_ts_good_talalt,\\\n",
    "        prediction_ts_good_joined=get_data(prediction_ts_good,prediction_th)\n",
    "    n_prediction_ts_good_talalt=len(prediction_ts_good_talalt)\n",
    "    n_prediction_ts_good_nem_talalt=len(prediction_ts_good_nem_talalt)\n",
    "    ns=[n_prediction_ts_good,n_prediction_ts_bad,n_prediction_ts_good_talalt,n_prediction_ts_good_nem_talalt]\n",
    "    \n",
    "    #plots\n",
    "    fig, axes, axi_top, axi_bottom=setup_axes2()\n",
    "    \n",
    "    stem2_plot(observation_ts,observation_th,axes[0],color_obs_left,color_obs_right,s/2,color_obs_right0)\n",
    "    stem2_plot(prediction_ts_good,prediction_th,axes[1],color_pred_left,color_pred_right)\n",
    "    stem_plot(prediction_ts_bad,axes[1],color_ax)\n",
    "    \n",
    "    violin_plot(observation_ts,observation_th,axi_top,color_obs_left,color_obs_right)\n",
    "    violin_plot(prediction_ts_good,prediction_th,axi_bottom,color_pred_left,color_pred_right)\n",
    "    \n",
    "    #icons\n",
    "    icons_plot(axes,kondicio,mennyiseg,observation_th,prediction_th)\n",
    "    \n",
    "    #talalat\n",
    "    talalat_plot(axes,ns,observation_th,prediction_th)\n",
    "    \n",
    "    #years\n",
    "    obs_year_index=observation_data[[obs_key,'pyear']].dropna().groupby('pyear').mean().index\n",
    "    pred_year_index=prediction_data[[pred_key,'pyear']].dropna().groupby('pyear').mean().index\n",
    "    pred_year_index_filt=prediction_ts.loc[pred_year_index].dropna().index\n",
    "    obs_year_index_filt=observation_ts.loc[obs_year_index].dropna().index\n",
    "    pred_year_index2=max(min(pred_year_index_filt),min(obs_year_index_filt))\n",
    "    pred_year_index=range(pred_year_index2,max(pred_year_index_filt)+1)\n",
    "    year_plot(observation_ts.loc[obs_year_index].dropna(),axes[0],0.09)\n",
    "    year_plot(prediction_ts.loc[pred_year_index].dropna(),axes[1],0.03)\n",
    "    \n",
    "    #titles\n",
    "    len_ratio=0.15*(-1+(len(jelentes.split(',')[0])/len(jelentes.split(',')[1])))\n",
    "    fig.text(0.5+len_ratio,0.04,jelentes.split(',')[0]+',',color=color_obs_right0,\n",
    "             fontproperties=prop,fontsize=font_size*0.7,horizontalalignment='right')\n",
    "    if color_pred_talalt==color_pred_talalt0: color_pred_side=color_pred_right\n",
    "    else: color_pred_side=color_pred_left\n",
    "    fig.text(0.5+len_ratio,0.04,jelentes.split(',')[1],color=color_pred_side,\n",
    "             fontproperties=prop,fontsize=font_size*0.7,horizontalalignment='left')\n",
    "    if n_prediction_ts_good_nem_talalt>=n_prediction_ts_good_talalt:\n",
    "        color_title=color_pred_nem_talalt\n",
    "    else: \n",
    "        color_title=color_pred_talalt\n",
    "    verdict=int(100*n_prediction_ts_good_talalt/(n_prediction_ts_good_talalt+n_prediction_ts_good_nem_talalt))\n",
    "    if color_pred_talalt!=color_pred_talalt0: verdict=100-verdict\n",
    "    return_verdict=int(verdict)\n",
    "    verdict=str(verdict)+'%'\n",
    "    plt.suptitle(title,y=0.11,color=color_title,fontproperties=prop,fontsize=font_size)\n",
    "    fig.text(0.97,0.04,verdict, fontproperties=prop,\n",
    "            horizontalalignment='right', color=color_title, fontsize=font_size*2, )\n",
    "    fig.text(0.03,0.04, datum, fontproperties=prop,\n",
    "            horizontalalignment='left', color=color_obs_right0, fontsize=font_size*2, )\n",
    "    \n",
    "    plt.savefig(c+'/a1/'+str(mondas)+'.png',dpi=300)#, facecolor=color_bg)\n",
    "    plt.show()\n",
    "    return return_verdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ts 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:42: FutureWarning: \n",
      "Passing list-likes to .loc or [] with any missing label will raise\n",
      "KeyError in the future, you can use .reindex() as an alternative.\n",
      "\n",
      "See the documentation here:\n",
      "https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#deprecate-loc-reindex-listlike\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ts 6\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "79.0\n"
     ]
    }
   ],
   "source": [
    "color_pred_left=color_pred_left0\n",
    "color_pred_right=color_pred_right0\n",
    "mondasok=nepi['ID'].values\n",
    "mondasok=[1,6]\n",
    "shares=[]\n",
    "for mondas in mondasok:\n",
    "    nep=nepi.loc[mondas]\n",
    "    if str(nep['Mennyiség'])!='nan':\n",
    "        obs_key=mennyiseg_key[nep['Kondíció']]\n",
    "        pred_key=mennyiseg_key[nep['Mennyiség']]\n",
    "        observation_range=[nep['Dátum:mettől']+pd.to_timedelta('-1D'),nep['Dátum:meddig']+pd.to_timedelta('+2D')]\n",
    "        prediction_range=[nep['Periódus:mettől'],nep['Periódus:meddig']+pd.to_timedelta('+1D')]\n",
    "        observation_data,prediction_data=filter_data(dz,observation_range,prediction_range)\n",
    "\n",
    "        #comparison\n",
    "        if str(nep['Érték']) in ['A','B']:\n",
    "            print('comp',mondas)\n",
    "            observation_ts,observation_th,prediction_ts,prediction_th,ertek_sign,irany_sign=\\\n",
    "                get_comp_data(observation_data,obs_key,nep['Érték'],\\\n",
    "                          prediction_data,pred_key,nep['Irány'])\n",
    "        #time series\n",
    "        else:\n",
    "            print('ts',mondas)\n",
    "            ertek_sign=get_sign(nep['Érték'],obs_key)\n",
    "            irany_sign=get_sign(nep['Irány'],pred_key)\n",
    "            observation_ts,observation_th=get_ts_data(observation_data,obs_key,nep['Érték'])\n",
    "            prediction_ts,prediction_th=get_ts_data(prediction_data,pred_key,nep['Irány'])\n",
    "\n",
    "        color_obs_right,color_obs_left,obs_talalt_glyph,obs_nem_talalt_glyph,\\\n",
    "            color_pred_talalt,color_pred_nem_talalt,pred_talalt_glyph,pred_nem_talalt_glyph=\\\n",
    "            set_direction(ertek_sign, irany_sign)\n",
    "\n",
    "        #datum=str(nep['Dátums'])[:3]+'. '+str(nep['Dátum:mettől'].day)\n",
    "        datum=nep['DS']\n",
    "        shares.append(spine_plot2(datum,nep['Mondás'].strip(),mondas,nep['Jelentés'].strip(),nep['Kondíció'],nep['Mennyiség'],\n",
    "               observation_ts,observation_th,prediction_ts,prediction_th,c))\n",
    "print(np.mean(shares))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}