data_exploration/figure/figureClustering.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "817904f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#dataframes\n",
    "import pandas as pd\n",
    "import h5py\n",
    "\n",
    "import sys\n",
    "sys.path.append('../')\n",
    "import odor_statistics_lib as osm\n",
    "\n",
    "# user defined functions\n",
    "\n",
    "#speedup\n",
    "import multiprocessing as mp\n",
    "\n",
    "#suppress warnings\n",
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "pd.TimeSeries = pd.Series \n",
    "\n",
    "#math\n",
    "import numpy as np\n",
    "import math\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf\n",
    "from scipy import signal\n",
    "import scipy \n",
    "import scipy.stats as st\n",
    "from scipy.stats import kurtosis\n",
    "from scipy.cluster import hierarchy\n",
    "from scipy.spatial.distance import pdist, squareform\n",
    "\n",
    "#plots\n",
    "import pylab as plt\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "import matplotlib\n",
    "from figurefirst import FigureLayout,mpl_functions\n",
    "import figurefirst\n",
    "import matplotlib.image as mpimg\n",
    "import matplotlib.colors as mcolors\n",
    "\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable # for colorbar\n",
    "import seaborn as sns\n",
    "import figurefirst as fifi\n",
    "from IPython.display import display,SVG\n",
    "\n",
    "sns.set()\n",
    "sns.set_style(\"whitegrid\")\n",
    "\n",
    "\n",
    "#misc\n",
    "import cairosvg\n",
    "import time\n",
    "np.set_printoptions(suppress=True)\n",
    "import fly_plot_lib.plot as fpl\n",
    "FS=7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "02a95754",
   "metadata": {},
   "outputs": [],
   "source": [
    "dir = '~/DataAnalysis/data/Sprints/HighRes/'\n",
    "dataframe=pd.read_hdf(dir+'All_Datasets_Predictions.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ee3e3280",
   "metadata": {},
   "outputs": [],
   "source": [
    "dir1='~/DataAnalysis/data/Sprints/HighRes/R2_AIC/'\n",
    "df = pd.read_hdf(dir1+'all_Rsquared.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a9b2b424",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=[dataframe.mc_min,dataframe.mc_max, dataframe.mc_mean, dataframe.mc_std_dev, dataframe.mc_k,\n",
    "     dataframe.wf_min, dataframe.wf_max, dataframe.wf_mean, dataframe.wf_std_dev, dataframe.wf_k,\n",
    "     dataframe.wd_min, dataframe.wd_max, dataframe.wd_mean, dataframe.wd_std_dev, dataframe.wd_k,\n",
    "     dataframe.ma_min, dataframe.ma_max, dataframe.ma_mean, dataframe.ma_std_dev, dataframe.ma_k,\n",
    "     dataframe.st_min, dataframe.st_max, dataframe.st_mean, dataframe.st_std_dev, dataframe.st_k]\n",
    "\n",
    "REMOVE_Y_CORR = True\n",
    "y=dataframe.distance\n",
    "\n",
    "\n",
    "corr_mat = np.zeros([len(X), len(X)])\n",
    "for i in range(len(X)):\n",
    "    for j in range(len(X)):\n",
    "        \n",
    "        if not REMOVE_Y_CORR:\n",
    "            result = scipy.stats.linregress(X[i], X[j])\n",
    "        else:\n",
    "            result_iy = scipy.stats.linregress(y, X[i])\n",
    "            resid_i = X[i] - (y*result_iy.slope + result_iy.intercept)\n",
    "\n",
    "            result_jy = scipy.stats.linregress(y, X[j])\n",
    "            resid_j = X[j] - (y*result_jy.slope + result_jy.intercept)\n",
    "            \n",
    "            result = scipy.stats.linregress(resid_i, resid_j)\n",
    "            \n",
    "        corr_mat[i,j] = result.rvalue**2\n",
    "        \n",
    "        \n",
    "\n",
    "cn=['$min(WC)$','$max(WC)$','$\\mu(WC)$','$\\sigma(WC)$','$WC_k$',\n",
    "             '$min(WF)$','$max(WF)$','$\\mu(WF)$','$\\sigma(WF)$','$WF_k$',\n",
    "             '$min(WD)$','$max(WD)$','$\\mu(WD)$','$\\sigma(WD)$','$WD_k$',\n",
    "             '$min(WMA)$','$max(WMA)$','$\\mu(WMA)$','$\\sigma(WMA)$','$WMA_k$',\n",
    "             '$min(WSD)$','$max(WSD)$','$\\mu(WSD)$','$\\sigma(WSD)$','$WSD_k$']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "313429db",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the ndarray to a DataFrame\n",
    "corr_mat_df = pd.DataFrame(corr_mat)\n",
    "\n",
    "# Perform hierarchical clustering\n",
    "Z_row = hierarchy.linkage(corr_mat_df, method='ward')\n",
    "Z_col = hierarchy.linkage(corr_mat_df.T, method='ward')\n",
    "\n",
    "# Get the order of rows and columns based on hierarchical clustering\n",
    "row_order = hierarchy.leaves_list(Z_row)\n",
    "col_order = hierarchy.leaves_list(Z_col)\n",
    "\n",
    "# Reorder the data based on clustering\n",
    "ordered_data = corr_mat_df.iloc[row_order, col_order]\n",
    "ordered_data.index\n",
    "\n",
    "new_names_ = [cn[i] for i in ordered_data.index]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "92ccad87",
   "metadata": {},
   "outputs": [],
   "source": [
    "test=ordered_data.iloc[::-1]\n",
    "order=test.iloc[:,::-1].columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5e3695e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "newdf = df[[df.columns[i] for i in test.index]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f4cd6c02",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASoAAAFaCAYAAACpGBDuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAZqklEQVR4nO3dXWhUd/7H8U8ymiiaUhI0TuqK6Go61NWLCEIxxSbRRJ0YK6mBqNSKEdalCxZkddE8rOI2F71QV1kU1oem0DYsjWsaYhEv0izVtkGI2VSlMVaLo9EEcTc+ZDz5/S/8G0yjzjGZzPycvF8gGDkz/X4r582cyeQYZ4wxAgCLxUd7AAAIhVABsB6hAmA9QgXAeoQKgPUIFQDrhQxVZWWlsrKylJ6erosXLz71GMdxVFFRoZycHC1cuFDV1dVhHxTAyBUyVNnZ2fr000/12muvPfOY48eP68qVK/r666/1+eefa+/evfrll1/COiiAkWtUqAPmzp0b8knq6ur07rvvKj4+XsnJycrJyVF9fb3Wr1/vaoje3l51d3dr9OjRiouLc/UYAPYzxigYDGrcuHGKjx/8O00hQ+VGIBBQWlpa39der1fXr193/fju7u5nXlYCePnNnDlTSUlJg358WEI1VKNHj5b0aJmEhIQoTzN4LS0tmjVrVrTHGLJY2CMWdpBe/j16enp08eLFvnN8sMISKq/Xq2vXrmn27NmSBr7CCuXx5V5CQoISExPDMVLUvOzzPxYLe8TCDlJs7DHUt3TC8vGEvLw8VVdXq7e3V11dXTp58qRyc3PD8dQAEDpUO3fu1FtvvaXr16/r/fff19KlSyVJJSUlOnfunCSpoKBAkydP1qJFi7Ry5Ur94Q9/0G9+85vhnRzAiBHy0m/btm3atm3bgD8/ePBg3+89Ho8qKirCOxkA/D8+mQ7AeoQKgPUIFQDrESoA1iNUAKxHqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYb5Sbg9rb27Vlyxbdvn1br776qiorKzV16tR+x3R2dmrr1q0KBAJ6+PCh5s2bp23btmnUKFf/CQB4JlevqMrKylRcXKwTJ06ouLhYpaWlA475+9//runTp+v48eP617/+pf/85z/6+uuvwz4wgJEnZKg6OzvV2toqv98vSfL7/WptbVVXV1e/4+Li4tTd3a3e3l719PQoGAwqNTV1eKYGMKKEvC4LBAJKTU2Vx+ORJHk8Hk2cOFGBQEDJycl9x23cuFEffPCB5s+fr3v37mnVqlXKyMh4oWFaWlpecHz7NDU1RXuEsIiFPWJhByl29hiKsL2BVF9fr/T0dB05ckTd3d0qKSlRfX298vLyXD/HrFmzlJiYGK6RIq6pqemF42yjWNgjFnaQXv49Hjx4EJYXICEv/bxer27cuCHHcSRJjuOoo6NDXq+333FVVVVatmyZ4uPjlZSUpKysLJ05c2bIAwJAyFClpKTI5/OptrZWklRbWyufz9fvsk+SJk+erIaGBklST0+Pvv32W82YMWMYRgYw0rj6rl95ebmqqqqUm5urqqoqVVRUSJJKSkp07tw5SdKf//xnNTU1KT8/X8uXL9fUqVO1cuXK4ZscwIjh6j2q6dOnq7q6esCfHzx4sO/3U6ZM0aFDh8I3GQD8Pz6ZDsB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFjPVaja29tVVFSk3NxcFRUV6fLly089rq6uTvn5+fL7/crPz9etW7fCOSuAEWqUm4PKyspUXFysgoICHTt2TKWlpTp69Gi/Y86dO6e//e1vOnLkiCZMmKD//ve/SkhIGJahAYwsIV9RdXZ2qrW1VX6/X5Lk9/vV2tqqrq6ufscdPnxY69at04QJEyRJSUlJSkxMHIaRAYw0IV9RBQIBpaamyuPxSJI8Ho8mTpyoQCCg5OTkvuPa2to0efJkrVq1Snfv3tXChQv1+9//XnFxca6HaWlpGcQKdmlqaor2CGERC3vEwg5S7OwxFK4u/dxwHEcXLlzQoUOH1NPTo/Xr1ystLU3Lly93/RyzZs16qV+FNTU1KSMjI9pjDFks7BELO0gv/x4PHjwIywuQkJd+Xq9XN27ckOM4kh4FqaOjQ16vt99xaWlpysvLU0JCgsaPH6/s7Gw1NzcPeUAACBmqlJQU+Xw+1dbWSpJqa2vl8/n6XfZJj967amxslDFGwWBQp0+f1uuvvz48UwMYUVx9PKG8vFxVVVXKzc1VVVWVKioqJEklJSU6d+6cJGnp0qVKSUnRkiVLtHz5cv32t79VYWHh8E0OYMRw9R7V9OnTVV1dPeDPDx482Pf7+Ph4bd26VVu3bg3fdAAgPpkO4CVAqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYj1ABsB6hAmA9QgXAeoQKgPVchaq9vV1FRUXKzc1VUVGRLl++/MxjL126pDlz5qiysjJcMwIY4VyFqqysTMXFxTpx4oSKi4tVWlr61OMcx1FZWZlycnLCOiSAkS1kqDo7O9Xa2iq/3y9J8vv9am1tVVdX14BjDxw4oAULFmjq1KlhHxTAyDUq1AGBQECpqanyeDySJI/Ho4kTJyoQCCg5ObnvuPPnz6uxsVFHjx7V/v37BzVMS0vLoB5nk6ampmiPEBaxsEcs7CDFzh5DETJUbgSDQW3fvl1//etf+4I2GLNmzVJiYmI4RoqKpqYmZWRkRHuMIYuFPWJhB+nl3+PBgwdheQESMlRer1c3btyQ4zjyeDxyHEcdHR3yer19x9y8eVNXrlzRhg0bJEl37tyRMUb/+9//tGPHjiEPCWBkCxmqlJQU+Xw+1dbWqqCgQLW1tfL5fP0u+9LS0nTmzJm+r/fu3au7d+/qT3/60/BMDWBEcfVdv/LyclVVVSk3N1dVVVWqqKiQJJWUlOjcuXPDOiAAuHqPavr06aqurh7w5wcPHnzq8R988MHQpgKAJ/DJdADWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6o9wc1N7eri1btuj27dt69dVXVVlZqalTp/Y7Zt++faqrq1N8fLxGjx6tTZs2KTMzczhmBjDCuApVWVmZiouLVVBQoGPHjqm0tFRHjx7td8zs2bO1bt06jR07VufPn9fq1avV2NioMWPGDMvgAEaOkJd+nZ2dam1tld/vlyT5/X61traqq6ur33GZmZkaO3asJCk9PV3GGN2+fTv8EwMYcUK+ogoEAkpNTZXH45EkeTweTZw4UYFAQMnJyU99TE1NjaZMmaJJkya90DAtLS0vdLyNmpqaoj1CWMTCHrGwgxQ7ewyFq0u/F/Hdd99p9+7d+sc//vHCj501a5YSExPDPVLENDU1KSMjI9pjDFks7BELO0gv/x4PHjwIywuQkJd+Xq9XN27ckOM4kiTHcdTR0SGv1zvg2LNnz2rz5s3at2+fpk2bNuThAEByEaqUlBT5fD7V1tZKkmpra+Xz+QZc9jU3N2vTpk3as2eP3njjjeGZFsCI5OpzVOXl5aqqqlJubq6qqqpUUVEhSSopKdG5c+ckSRUVFbp//75KS0tVUFCggoICXbhwYfgmBzBiuHqPavr06aqurh7w5wcPHuz7/T//+c/wTQUAT+CT6QCsR6gAWI9QAbAeoQJgPUIFwHqECoD1CBUA6xEqANYjVACsR6gAWI9QAbAeoQJgPUIFwHqECoD1CBUA6xEqANYjVACsR6gAWI9QAbAeoQJgPUIFwHqECoD1CBUA6xEqANYjVACsR6gAWI9QAbAeoQJgPUIFwHqECoD1CBUA6xEqANYjVACsR6gAWI9QAbAeoQJgPUIFwHquQtXe3q6ioiLl5uaqqKhIly9fHnCM4ziqqKhQTk6OFi5cqOrq6nDPCmCEchWqsrIyFRcX68SJEyouLlZpaemAY44fP64rV67o66+/1ueff669e/fql19+CfvAAEaekKHq7OxUa2ur/H6/JMnv96u1tVVdXV39jqurq9O7776r+Ph4JScnKycnR/X19cMzNYARZVSoAwKBgFJTU+XxeCRJHo9HEydOVCAQUHJycr/j0tLS+r72er26fv26qyGMMZKknp6eFxreRg8ePIj2CGERC3vEwg7Sy73H43P68Tk+WCFDFQnBYFCSdPHixShPMnQtLS3RHiEsYmGPWNhBio09gsGgxowZM+jHhwyV1+vVjRs35DiOPB6PHMdRR0eHvF7vgOOuXbum2bNnSxr4Cut5xo0bp5kzZ2r06NGKi4sbxBoAbGSMUTAY1Lhx44b0PCFDlZKSIp/Pp9raWhUUFKi2tlY+n6/fZZ8k5eXlqbq6WosWLdLt27d18uRJffrpp66GiI+PV1JS0uA2AGC1obySeizOuLh4bGtr05YtW3Tnzh298sorqqys1LRp01RSUqI//vGP+t3vfifHcfSXv/xF//73vyVJJSUlKioqGvKAAOAqVAAQTXwyHYD1CBUA6xEqANYjVACsR6gAWC+ioYqVuzC42WPfvn1aunSp8vPztWLFCn3zzTeRH/Q53Ozw2KVLlzRnzhxVVlZGbkAX3O5QV1en/Px8+f1+5efn69atW5EdNAQ3e3R2dmrDhg3Kz8/X4sWLVV5erocPH0Z+2KeorKxUVlaW0tPTn/nTJUM+r00ErVmzxtTU1BhjjKmpqTFr1qwZcMyXX35p1q1bZxzHMZ2dnSYzM9NcvXo1kmOG5GaPhoYGc/fuXWOMMT/++KPJyMgw9+7di+icz+NmB2OMefjwoVm9erX58MMPzUcffRTJEUNys0Nzc7NZvHix6ejoMMYYc+fOHXP//v2IzhmKmz127tzZ9/+/p6fHFBYWmq+++iqicz7L999/b65du2befvttc+HChaceM9TzOmKvqGLlLgxu98jMzNTYsWMlSenp6TLG6Pbt25Ee96nc7iBJBw4c0IIFCzR16tQIT/l8bnc4fPiw1q1bpwkTJkiSkpKSlJiYGPF5n8XtHnFxceru7lZvb696enoUDAaVmpoajZEHmDt37oAfqfu1oZ7XEQvV8+7C8OvjBnsXhkhwu8eTampqNGXKFE2aNClSYz6X2x3Onz+vxsZGrV27NgpTPp/bHdra2nT16lWtWrVK77zzjvbv3z/kn+QPJ7d7bNy4Ue3t7Zo/f37fr4yMjGiMPChDPa95M32Yfffdd9q9e7c+/vjjaI/yQoLBoLZv366Kioq+k+hl5DiOLly4oEOHDumTTz5RQ0ODjh07Fu2xXlh9fb3S09PV2NiohoYG/fDDD1ZdaQy3iIXqybswSAp5F4bHAoGANa9EJPd7SNLZs2e1efNm7du3T9OmTYv0qM/kZoebN2/qypUr2rBhg7KysnTkyBF98cUX2r59e7TG7sft30NaWpry8vKUkJCg8ePHKzs7W83NzdEY+anc7lFVVaVly5b1/QB/VlaWzpw5E42RB2Wo53XEQvXkXRgkhbwLQ29vr7q6unTy5Enl5uZGasyQ3O7R3NysTZs2ac+ePXrjjTeiMeozudkhLS1NZ86c0alTp3Tq1Cm99957WrlypXbs2BGtsftx+/fg9/vV2NjYd7uR06dP6/XXX4/GyE/ldo/JkyeroaFB0qOb0X377beaMWNGxOcdrCGf12F529+ln376yRQWFppFixaZwsJC09bWZowxZv369aa5udkY8+i7TKWlpSY7O9tkZ2ebzz77LJIjuuJmjxUrVph58+aZZcuW9f06f/58NMfux80OT9qzZ4913/Vzs4PjOGbXrl0mLy/PLFmyxOzatcs4jhPNsQdws8fPP/9s1q5da/x+v1m8eLEpLy83wWAwmmP32bFjh8nMzDQ+n8+8+eabZsmSJcaY8J7X3D0BgPV4Mx2A9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9QgVAOsRKgDWI1QArEeoAFiPUAGwHqECYD1CBcB6hAqA9cIaqsrKSmVlZSk9PV0XL14M51MDGMHCGqrs7Gx9+umneu2118L5tABGuFHhfLK5c+cO6nG9vb3q7u7W6NGjFRcXF86RAESZMUbBYFDjxo1TfPzgXhuFNVSD1d3dzaUiEONmzpyppKSkQT3WilCNHj1a0qNFEhISojzN0LS0tGjWrFnRHmNIYmEHiT1s0dPTo4sXL/ad54NhRageX+4lJCQoMTExytMMHTvYgz3sMZS3dfh4AgDrhTVUO3fu1FtvvaXr16/r/fff19KlS8P59ABGqLBe+m3btk3btm0L51MCAJd+AOxHqABYj1ABsB6hAmA9QgXAeoQKgPUIFQDrESoA1iNUAKxHqABYL6yham9vV1FRkXJzc1VUVKTLly+H8+kBjFBhDVVZWZmKi4t14sQJFRcXq7S0NJxPD2CECtsPJXd2dqq1tVWHDh2SJPn9fu3YsUNdXV1KTk5+7mONMZIe3WArFjx48CDaIwxZLOwgsYcNHp/Xj8/zwQhbqAKBgFJTU+XxeCRJHo9HEydOVCAQCBmqYDAoSTFzO+KWlpZojzBksbCDxB42CQaDGjNmzKAea8UdPseNG6eZM2fyjzsAMejJf9xhsMIWKq/Xqxs3bshxHHk8HjmOo46ODnm93pCPjY+PH/RN3wHYb7CvpB4L25vpKSkp8vl8qq2tlSTV1tbK5/OFvOwDgFDizFDe4fqVtrY2bdmyRXfu3NErr7yiyspKTZs2LVxPD2CECmuoAGA48Ml0ANYjVACsR6gAWI9QAbAeoQJgvYiGys3dFRzHUUVFhXJycrRw4UJVV1dHckRX3Oyxb98+LV26VPn5+VqxYoW++eabyA8awovc7eLSpUuaM2eOKisrIzegC253qKurU35+vvx+v/Lz83Xr1q3IDhqCmz06Ozu1YcMG5efna/HixSovL9fDhw8jP+wzVFZWKisrS+np6c/8cbhBn98mgtasWWNqamqMMcbU1NSYNWvWDDjmyy+/NOvWrTOO45jOzk6TmZlprl69GskxQ3KzR0NDg7l7964xxpgff/zRZGRkmHv37kV0zlDc7GGMMQ8fPjSrV682H374ofnoo48iOWJIbnZobm42ixcvNh0dHcYYY+7cuWPu378f0TlDcbPHzp07+/7/9/T0mMLCQvPVV19FdM7n+f777821a9fM22+/bS5cuPDUYwZ7fkfsFdXjuyv4/X5Jj+6u0Nraqq6urn7H1dXV6d1331V8fLySk5OVk5Oj+vr6SI0Zkts9MjMzNXbsWElSenq6jDG6fft2pMd9Jrd7SNKBAwe0YMECTZ06NcJTPp/bHQ4fPqx169ZpwoQJkqSkpCQlJiZGfN5ncbtHXFycuru71dvbq56eHgWDQaWmpkZj5KeaO3duyB+ZG+z5HbFQPe/uCr8+Li0tre9rr9er69evR2rMkNzu8aSamhpNmTJFkyZNitSYIbnd4/z582psbNTatWujMOXzud2hra1NV69e1apVq/TOO+9o//79Q7rlSLi53WPjxo1qb2/X/Pnz+35lZGREY+RBG+z5zZvpw+y7777T7t279fHHH0d7lBcWDAa1fft2VVRU9J1ELyPHcXThwgUdOnRIn3zyiRoaGnTs2LFoj/XC6uvrlZ6ersbGRjU0NOiHH36w6mpjOEUsVE/eXUHSM++u4PV6de3atb6vA4GAVa9E3O4hSWfPntXmzZu1b98+637m0c0eN2/e1JUrV7RhwwZlZWXpyJEj+uKLL7R9+/Zojd2P27+LtLQ05eXlKSEhQePHj1d2draam5ujMfJTud2jqqpKy5Yt67vbSFZWls6cORONkQdtsOd3xELl9u4KeXl5qq6uVm9vr7q6unTy5Enl5uZGasyQ3O7R3NysTZs2ac+ePXrjjTeiMepzudkjLS1NZ86c0alTp3Tq1Cm99957WrlypXbs2BGtsftx+3fh9/vV2NjYd1+k06dP6/XXX4/GyE/ldo/JkyeroaFB0qO7Zn777beaMWNGxOcdikGf32F92z+En376yRQWFppFixaZwsJC09bWZowxZv369aa5udkY8+g7TKWlpSY7O9tkZ2ebzz77LJIjuuJmjxUrVph58+aZZcuW9f06f/58NMcewM0eT9qzZ4913/Vzs4PjOGbXrl0mLy/PLFmyxOzatcs4jhPNsQdws8fPP/9s1q5da/x+v1m8eLEpLy83wWAwmmP3s2PHDpOZmWl8Pp958803zZIlS4wx4Tm/uXsCAOvxZjoA6xEqANYjVACsR6gAWI9QAbAeoQJgPUIFwHr/B08yiZ86xTFsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 595.276x841.89 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "layout = fifi.svg_to_axes.FigureLayout('../../../Figure/clustering.svg',\n",
    "                                           autogenlayers=True, make_mplfigures=True, hide_layers=[])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbd38e19",
   "metadata": {},
   "source": [
    "### Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "aa9839bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Matplotlib figure\n",
    "ax=layout.axes[('fig','ax')]\n",
    "# f, ax = plt.subplots(figsize=(9, 8))\n",
    "ax.grid(False)\n",
    "\n",
    "cax = ax.imshow(test.iloc[:,::-1], cmap='bone_r', aspect='auto', rasterized=True) ## flipping for paper\n",
    "ax.set_rasterization_zorder(-20)\n",
    "\n",
    "ax.set_xticks(np.arange(len(order)))\n",
    "ax.set_yticks(np.arange(len(order)))\n",
    "\n",
    "\n",
    "marker = np.arange(0,25,1)\n",
    "mpl_functions.adjust_spines(ax,['left','bottom'],\n",
    "                            spine_locations={'left':4,'bottom':4},\n",
    "                            smart_bounds=True,\n",
    "                            yticks=marker.tolist(),\n",
    "                            xticks=marker.tolist(),\n",
    "                            linewidth=0.5)\n",
    "\n",
    "\n",
    "alph=0.3\n",
    "\n",
    "xlabels=ax.get_xticklabels()\n",
    "ylabels=ax.get_yticklabels()\n",
    "\n",
    "indices = [8, 9, 11, 23]\n",
    "\n",
    "for i in indices:\n",
    "    new_names_[i] = r'$\\rightarrow$' + new_names_[i]\n",
    "\n",
    "ax.set_xticklabels(new_names_[::-1], rotation=90) ## flipping for paper and narrative reasons ->left to right flow\n",
    "ax.set_yticklabels(new_names_[::-1])\n",
    "\n",
    "\n",
    "values=newdf.max(axis=0).values\n",
    "\n",
    "full_cmap = plt.cm.get_cmap('seismic')\n",
    "\n",
    "a1=0.4\n",
    "b1=0\n",
    "# Extract the blue part of the colormap\n",
    "blue_part_cmap = mcolors.LinearSegmentedColormap.from_list(\n",
    "    'trunc({n},{a:.2f},{b:.2f})'.format(n=full_cmap.name, a=a1, b=b1),\n",
    "    full_cmap(np.linspace(a1, b1, 256))\n",
    ")\n",
    "\n",
    "\n",
    "# Normalize the values to the desired range\n",
    "normalized_values = (values - values.min()) / (values.max() - values.min())\n",
    "\n",
    "# Get the colors for each value\n",
    "colors = blue_part_cmap(normalized_values)\n",
    "\n",
    "# Set x and y tick label colors\n",
    "for i, color in enumerate(colors):\n",
    "    xlabels[i].set_color(color)\n",
    "    ylabels[i].set_color(color)\n",
    "\n",
    "\n",
    "figurefirst.mpl_functions.set_fontsize(ax, FS)\n",
    "layout.append_figure_to_layer(layout.figures['fig'], 'fig', cleartarget=True)\n",
    "layout.write_svg('../../../Figure/clustering.svg')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7601b89",
   "metadata": {},
   "source": [
    "### Colorbar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4fb4f376",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = layout.axes[('fig', 'cbar')]\n",
    "xtic=[normalized_values.min(),normalized_values.max()]\n",
    "\n",
    "\n",
    "norm = mcolors.Normalize(vmin=0, vmax=0.6)\n",
    "ax.grid(False)\n",
    "plt.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=blue_part_cmap), cax=ax,orientation='horizontal');\n",
    "# fpl.colorbar(ax=ax, colormap=blue_part_cmap, orientation='horizontal',ticks=xtic)\n",
    "ax.set_rasterization_zorder(-20)\n",
    "mpl_functions.adjust_spines(ax, ['bottom'], \n",
    "                                    smart_bounds=True,\n",
    "                                    spine_locations={'bottom': 5}, \n",
    "                                    xticks=[0,0.6],\n",
    "                                    tick_length=1.5,\n",
    "                                    linewidth=0.5)\n",
    "\n",
    "ax.set_xlabel(\"$R^2$\",rotation=0, labelpad=-5)\n",
    "\n",
    "ax.set_xticklabels(['0', '0.6'])\n",
    "figurefirst.mpl_functions.set_fontsize(ax, FS)\n",
    "\n",
    "layout.append_figure_to_layer(layout.figures['fig'], 'fig', cleartarget=True)\n",
    "layout.write_svg('../../../Figure/clustering.svg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73fd1139",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}