2.1_animation_rutherford.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b7bdfc96",
   "metadata": {},
   "source": [
    "# Explaining cortical thickness development: Modeled data animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b1849f76-b17d-4286-bf57-50ff56e81bf8",
   "metadata": {
    "id": "b1849f76-b17d-4286-bf57-50ff56e81bf8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Working directory: /Users/llotter/projects/CTdev\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import os\n",
    "from os.path import join\n",
    "from glob import glob\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib import cm\n",
    "from matplotlib.cm import get_cmap\n",
    "from matplotlib.colors import Normalize\n",
    "import seaborn as sns\n",
    "import nilearn as nl\n",
    "from surfplot import Plot\n",
    "import imageio.v2 as iio\n",
    "\n",
    "# custom functions\n",
    "from scripts.templates import get_destrieux\n",
    "\n",
    "# working path\n",
    "wd = os.path.dirname(os.path.realpath(\"__file__\"))\n",
    "print(\"Working directory:\", wd)\n",
    "\n",
    "# JuSpyce\n",
    "sys.path.append(os.path.dirname(join(wd, \"scripts\", \"juspyce\")))\n",
    "from juspyce.api import JuSpyce\n",
    "\n",
    "# plot directories\n",
    "plot_dir_gif = join(wd, \"plots\", \"prediction_dominance\", \"animation\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parcellation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parcellation\n",
    "parc_destrieux, destrieux_idps = get_destrieux()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Timepoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age-differences to look at: [(5, 10), (6, 11), (7, 12), (8, 13), (9, 14), (10, 15), (11, 16), (12, 17), (13, 18), (14, 19), (15, 20), (16, 21), (17, 22), (18, 23), (19, 24), (20, 25), (21, 26), (22, 27), (23, 28), (24, 29), (25, 30), (26, 31), (27, 32), (28, 33), (29, 34), (30, 35), (31, 36), (32, 37), (33, 38), (34, 39), (35, 40), (36, 41), (37, 42), (38, 43), (39, 44), (40, 45), (41, 46), (42, 47), (43, 48), (44, 49), (45, 50), (46, 51), (47, 52), (48, 53), (49, 54), (50, 55), (51, 56), (52, 57), (53, 58), (54, 59), (55, 60), (56, 61), (57, 62), (58, 63), (59, 64), (60, 65), (61, 66), (62, 67), (63, 68), (64, 69), (65, 70), (66, 71), (67, 72), (68, 73), (69, 74), (70, 75), (71, 76), (72, 77), (73, 78), (74, 79), (75, 80), (76, 81), (77, 82), (78, 83), (79, 84), (80, 85), (81, 86), (82, 87), (83, 88), (84, 89), (85, 90)]\n"
     ]
    }
   ],
   "source": [
    "# time points we look at:\n",
    "tps_whole = (5,30)\n",
    "tps_steps = [(i,i+5) for i in np.arange(5,86,1)]\n",
    "tps_index = [f\"Δ({tps_whole[0]},{tps_whole[1]})\"]+[f\"Δ({s[0]},{s[1]})\" for s in tps_steps]\n",
    "print(\"Age-differences to look at:\", tps_steps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dominance analyses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:juspyce.api:Loaded complete object from /Users/llotter/projects/CTdev/data_rutherford/juspyce_ct_slr_fm_500_5.pkl.gz.\n",
      "INFO:juspyce.api:Loaded complete object from /Users/llotter/projects/CTdev/data_rutherford/juspyce_ct_dominance_fm_500_5.pkl.gz.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p_fdr < 0.05: n = 9\n",
      " ['ni3-FDOPA-DAT-D1-NMDA', 'ni4-GI-5HT1b-MU-A4B2', 'ni5-VAChT-NET', 'ni6-CBF-CMRglu', 'ni9-D2', 'ce3-Micro-OPC', 'ce4-In3-In2-Astro', 'ce5-In6-Ex2', 'ce9-In8']\n",
      "p_fdr < 0.05: n = 6\n",
      " ['ni3-FDOPA-DAT-D1-NMDA', 'ni5-VAChT-NET', 'ni9-D2', 'ce3-Micro-OPC', 'ce4-In3-In2-Astro', 'ce9-In8']\n"
     ]
    }
   ],
   "source": [
    "juspyce_ct_slr = JuSpyce.from_pickle(\\\n",
    "    join(wd, \"data_rutherford\", f\"juspyce_ct_slr_fm_500_5.pkl.gz\"))\n",
    "juspyce_ct_dominance = JuSpyce.from_pickle(\\\n",
    "    join(wd, \"data_rutherford\", f\"juspyce_ct_dominance_fm_500_5.pkl.gz\"))\n",
    "\n",
    "# identify significant predictors\n",
    "slr_sig = (juspyce_ct_slr.p_predictions[\"slr--fdr_bh\"] < 0.05).any()\n",
    "predictors_sig = slr_sig[slr_sig==True].index.to_list()\n",
    "print(f\"p_fdr < 0.05: n = {len(predictors_sig)}\\n\", predictors_sig)\n",
    "dom_sig = (juspyce_ct_dominance.p_predictions[\"dominance_total--fdr_bh\"] < 0.05).any()\n",
    "predictors_sig_dom = dom_sig[dom_sig==True].index.to_list()\n",
    "print(f\"p_fdr < 0.05: n = {len(predictors_sig_dom)}\\n\", predictors_sig_dom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regional influence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prediction error function\n",
    "def pe(x, y):    \n",
    "    X = np.c_[x, np.ones(x.shape[0])] \n",
    "    beta = np.linalg.pinv((X.T).dot(X)).dot(X.T.dot(y))\n",
    "    y_hat = np.dot(X, beta)\n",
    "    pe = y_hat - y\n",
    "    return pe\n",
    "\n",
    "# dict to store results\n",
    "regional_influence = dict()\n",
    "\n",
    "# exclude missing rows\n",
    "no_nan = np.array(~juspyce_ct_dominance._nan_bool)\n",
    "\n",
    "# all predictors\n",
    "x = juspyce_ct_dominance.X.values[:,no_nan].T\n",
    "\n",
    "# iterate time points\n",
    "for i_tp, tp in enumerate(tps_index):\n",
    "    \n",
    "    # empty array\n",
    "    pe_diff = np.full((juspyce_ct_dominance.X.shape[1],juspyce_ct_dominance.X.shape[0]), np.nan)\n",
    "    \n",
    "    # iterate predictors/rows\n",
    "    for i_pred, pred in enumerate(list(juspyce_ct_dominance.X.index)):\n",
    "        # get all predictors w/o current predictor\n",
    "        x_red = np.delete(x, i_pred, axis=1)\n",
    "        # CT differences of current tp\n",
    "        y = juspyce_ct_dominance.Y.loc[f\"{tp}\"].values[no_nan]\n",
    "        # calculate pe\n",
    "        pe_all = pe(x=x, y=y)\n",
    "        pe_red = pe(x=x_red, y=y)\n",
    "        # save\n",
    "        pe_diff[no_nan,i_pred] = np.abs(pe_red) - np.abs(pe_all)\n",
    "    # to dataframe\n",
    "    regional_influence[tp] = pd.DataFrame(\n",
    "        pe_diff, \n",
    "        columns=juspyce_ct_dominance.X.index,\n",
    "        index=juspyce_ct_dominance.X.columns\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dominance plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## p-to-asterisk function\n",
    "def p_to_ast(p_data, pc_data):\n",
    "    p_1d = np.array(p_data).flatten()\n",
    "    pc_1d = np.array(pc_data).flatten()\n",
    "    ast = list()\n",
    "    for (p, pc) in zip(p_1d, pc_1d):\n",
    "        if (pc < 0.05): ast.append(\"★\")\n",
    "        elif (p < 0.05) & (pc >= 0.05): ast.append(\"☆\")\n",
    "        else: ast.append(\"\")\n",
    "    return pd.DataFrame(np.array(ast).reshape(p_data.shape), \n",
    "                        index=p_data.index, columns=p_data.columns)\n",
    "    \n",
    "\n",
    "## Function to add developmental stages (aligned to CT change period mean, e.g. delta(5,10) = 7.5)\n",
    "def add_stages(\n",
    "    ax, height=0.09,\n",
    "    alignment=-2.5,\n",
    "    stages=[(6,12), (12,20), (20,40), (40,60), (60,100)],\n",
    "    stage_names=[\"Late childhood\", \"Adolescence\", \"Young adulthood\", \"Middle adulthood\", \"Late adulthood\"]\n",
    "    ):\n",
    "    \n",
    "    ax_stages = ax.inset_axes((0, 1, 1, height))\n",
    "    ax_stages.set_xlim(ax.get_xlim())\n",
    "    ax_stages.set_ylim(0,1)\n",
    "    ax_stages.set_axis_off()\n",
    "    \n",
    "    for i, x_range in enumerate(stages):\n",
    "        x0 = x_range[0] - 5 + alignment\n",
    "        x1 = x_range[1] - 5 + alignment\n",
    "        if x_range[0] > 10:\n",
    "            ax_stages.axvline(\n",
    "                x0, \n",
    "                c=\"0.3\",\n",
    "                lw=1,\n",
    "                zorder=0\n",
    "            )\n",
    "        if x0 < 2:\n",
    "            x0 = -5\n",
    "        if x1 > 90:\n",
    "            x1 = 80\n",
    "        ax_stages.text(\n",
    "            x=(x0 + x1) / 2,\n",
    "            y=0.5,\n",
    "            s=f\"{stage_names[i]}\\n${x_range[0]} - {x_range[1]}\\ y.$\",\n",
    "            ha=\"center\",\n",
    "            va=\"center\"\n",
    "        )\n",
    "        \n",
    "\n",
    "## single plot function\n",
    "def plot_diffs(data, data_p, data_null, ax, title=\"\", colors=None,\n",
    "               size_text=11,\n",
    "               title_size=12, title_color=\"k\", \n",
    "               legend_color=\"linecolor\", legend_size=12, legend=True):\n",
    "    pred = list(data.columns)\n",
    "    if colors is None: colors = get_cmap(\"tab10\")(range(len(pred)))\n",
    "    alpha_med = 0.7\n",
    "    alpha_text = 0.4\n",
    "    pos_text = [-0.02,0.015]\n",
    "\n",
    "    ## plot null\n",
    "    for pz, pz_color in zip([(1,99), (5,95), (25,75)], [\"0.97\", \"0.93\", \"0.89\"]):\n",
    "        # left\n",
    "        ax.fill_between(\n",
    "            x=[-1,0,1],\n",
    "            y1=np.percentile(data_null, pz[0], axis=0)[0],\n",
    "            y2=np.percentile(data_null, pz[1], axis=0)[0],\n",
    "            lw=0,\n",
    "            color=pz_color\n",
    "        )\n",
    "        # right\n",
    "        ax.fill_between(\n",
    "            x=tps_index[1:],\n",
    "            y1=np.percentile(data_null, pz[0], axis=0)[1:],\n",
    "            y2=np.percentile(data_null, pz[1], axis=0)[1:],\n",
    "            lw=0,\n",
    "            color=pz_color\n",
    "        )\n",
    "\n",
    "    ## plot predictor-wise\n",
    "    for i, p in enumerate(pred):\n",
    "        \n",
    "        if data_p is not None:\n",
    "            if \"★\" in data_p[p].to_list():\n",
    "                label = p + \" ★\"\n",
    "            elif \"☆\" in data_p[p].to_list():\n",
    "                label = p + \" ☆\"\n",
    "            else:\n",
    "                label = p  \n",
    "        else:\n",
    "            label = p\n",
    "                \n",
    "        ax.plot(data.index[1:], data[p][1:], color=colors[i], alpha=alpha_med, label=label)\n",
    "        \n",
    "        if data_p is not None:\n",
    "            for x, (y, p) in enumerate(zip(data[p][1:], data_p[p][1:])):\n",
    "                ax.text(x+pos_text[0], y+pos_text[1], p, ha=\"center\", va=\"top\", \n",
    "                        color=colors[i], alpha=alpha_text+0.3, size=size_text)\n",
    "                \n",
    "    if legend:\n",
    "        legend = ax.legend(loc=\"upper right\", ncol=1, prop=dict(size=legend_size), \n",
    "                           labelcolor=legend_color)\n",
    "        legend.set_title(title)\n",
    "        plt.setp(legend.get_title(), color=title_color, size=title_size, weight=\"semibold\")\n",
    "    \n",
    "    # general\n",
    "    ax.set_xlim(-0.6,0.6)\n",
    "    ax.set_xticks(list(np.arange(0,86,5)))\n",
    "    ax.set_xticks(list(range(90)), minor=True)\n",
    "    ax.set_xlim(-0.8,data.shape[0]-1.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Brain & scatter plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to make parcellated gifti from input vector\n",
    "def get_parc_gifti(data, parc_gifti=parc_destrieux):\n",
    "    lh = np.zeros(parc_gifti[0].darrays[0].data.shape)\n",
    "    rh = np.zeros(parc_gifti[1].darrays[0].data.shape)\n",
    "    for parcel_idx, parcel_val  in enumerate(data, start=1):\n",
    "        lh[parc_gifti[0].darrays[0].data==parcel_idx] = parcel_val\n",
    "        rh[parc_gifti[1].darrays[0].data==parcel_idx] = parcel_val\n",
    "    lh[parc_gifti[0].darrays[0].data==0] = np.nan\n",
    "    rh[parc_gifti[1].darrays[0].data==0] = np.nan\n",
    "    return lh, rh\n",
    "\n",
    "# surfplot function    \n",
    "def plot_surf_ax(lh, fig, ax, template=\"pial\", views=[\"lateral\", \"medial\"], size=(1000,400),\n",
    "                 layout=\"row\", c=\"viridis_r\", c_lims=None, \n",
    "                 cbar_symm=False, cbar=True, rotate_labels=False, \n",
    "                 zoom=1.6):\n",
    "    fsaverage = nl.datasets.fetch_surf_fsaverage()\n",
    "    if c_lims is None:\n",
    "        if cbar_symm==False:\n",
    "            c_lims = (np.nanmin(lh), np.nanmax(lh))\n",
    "        elif cbar_symm==True:\n",
    "            c_lims = (-np.nanmax(np.abs(lh)), np.nanmax(np.abs(lh)))\n",
    "    p = Plot(fsaverage[f\"{template}_left\"], layout=layout, size=size, zoom=zoom, views=views)\n",
    "    p.add_layer(dict(left=lh), cmap=c, color_range=c_lims)\n",
    "    p.build(fig=fig, ax=ax, colorbar=False)\n",
    "    # legend\n",
    "    if cbar==True:\n",
    "        cbar_width = 0.45\n",
    "        cbar = fig.colorbar(\n",
    "            cm.ScalarMappable(\n",
    "                norm=Normalize(c_lims[0],c_lims[1]), \n",
    "                cmap=c), \n",
    "            cax=ax.inset_axes([(1-cbar_width)/2, 0.05, cbar_width, 0.06]),\n",
    "            orientation=\"horizontal\")\n",
    "        if rotate_labels:\n",
    "            plt.setp(cbar.ax.get_xticklabels(), rotation=-40, ha=\"left\", rotation_mode=\"anchor\")\n",
    "            cbar.ax.tick_params(axis=\"x\", which=\"major\", pad=2)\n",
    "\n",
    "def scatter(x, y, hue, fig, ax, hue_lims=None, r=None, c=None):\n",
    "    # limits\n",
    "    if hue_lims is None:\n",
    "        hue_max = np.nanmax(np.abs(np.array(hue)))\n",
    "        hue_lims = (-hue_max, hue_max)\n",
    "    # scatter\n",
    "    sns.scatterplot(\n",
    "        x=x, \n",
    "        y=y, \n",
    "        ax=ax, \n",
    "        hue=hue, palette=\"RdBu_r\", alpha=0.7, hue_norm=hue_lims, edgecolor='k', legend=None)\n",
    "    sns.regplot(\n",
    "        x=x, \n",
    "        y=y, \n",
    "        ax=ax, \n",
    "        color=c, scatter=False)\n",
    "    if r:\n",
    "        ax.annotate(\n",
    "            text=f\"${r:.2f}$\",\n",
    "            xy=(0.05,0.81) if r>0 else (0.96,0.81),\n",
    "            xycoords=\"axes fraction\",\n",
    "            ha=\"left\" if r>0 else \"right\",\n",
    "            c=c,\n",
    "            bbox=dict(boxstyle=\"round,pad=0.1\", fc=\"white\", alpha=0.5)\n",
    "        )\n",
    "    ax.set_xlabel(\"\")\n",
    "    ax.set_ylabel(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(61,66)\n",
      "Δ(62,67)\n",
      "Δ(63,68)\n",
      "Δ(64,69)\n",
      "Δ(65,70)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(66,71)\n",
      "Δ(67,72)\n",
      "Δ(68,73)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(69,74)\n",
      "Δ(70,75)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(71,76)\n",
      "Δ(72,77)\n",
      "Δ(73,78)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(74,79)\n",
      "Δ(75,80)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(76,81)\n",
      "Δ(77,82)\n",
      "Δ(78,83)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(79,84)\n",
      "Δ(80,85)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(81,86)\n",
      "Δ(82,87)\n",
      "Δ(83,88)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ(84,89)\n",
      "Δ(85,90)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Context leak detected, msgtracer returned -1\n"
     ]
    }
   ],
   "source": [
    "tps = tps_index[1:]\n",
    "\n",
    "# ct limits\n",
    "ct_lims = (juspyce_ct_dominance.Y.iloc[1:,:].min().min() * 100, \n",
    "           juspyce_ct_dominance.Y.iloc[1:,:].max().max() * 100)\n",
    "ct_lims_abs = (-np.abs(ct_lims).max(), np.abs(ct_lims).max())\n",
    "\n",
    "# pe limits\n",
    "pe_lim = list()\n",
    "for tp in tps:\n",
    "    pe_lim.append(np.abs(regional_influence[tp]).max().max())\n",
    "pe_lims = (-max(pe_lim), max(pe_lim))\n",
    "\n",
    "for tp in tps[56:]:\n",
    "    print(tp)\n",
    "    delta = juspyce_ct_dominance.Y.loc[tp,:] * 100\n",
    "    \n",
    "    pe_lim = (np.abs(regional_influence[tp]).max().max())   # ACTIVATE IF TP-WISE INDIVIDUAL LIMITS\n",
    "    pe_lims = (-pe_lim, pe_lim)                             # ACTIVATE IF TP-WISE INDIVIDUAL LIMITS\n",
    "    \n",
    "    ## figure\n",
    "    fig = plt.figure(figsize=(17,17))\n",
    "    colors = get_cmap(\"tab10\")(range(10))\n",
    "    gs = fig.add_gridspec(\n",
    "        6, 8+3, \n",
    "        height_ratios=(0.25,0.25,0.25, 0.05, 1.3, 0.5), \n",
    "        width_ratios=(0.5,1,0.025, 0.5,1,0.025, 0.5,1,0.025, 0.5,1),\n",
    "        wspace=0.1,\n",
    "        hspace=0.4)\n",
    "    fig.patch.set_facecolor('w')\n",
    "\n",
    "    ## brains\n",
    "    # CT\n",
    "    ax_ct = fig.add_subplot(gs[0,:2])\n",
    "    plot_surf_ax(get_parc_gifti(delta)[0], fig, ax_ct, c=\"RdBu_r\", \n",
    "                 cbar_symm=True, rotate_labels=True,\n",
    "                 #c_lims=ct_lims_abs                        # DEACTIVATE IF TP-WISE INDIVIDUAL LIMITS\n",
    "                 )\n",
    "    ax_ct.set_title(\"CT \"+tp, size=13, weight=\"semibold\", c=\"k\")\n",
    "    ax_ct.annotate(\"Cortical thickness development [%-change]\", \n",
    "                   xy=(-0.43,-1.4), xycoords=\"axes fraction\", \n",
    "                   ha=\"center\", va=\"center\", rotation=90, size=13)\n",
    "    \n",
    "    # whitespace\n",
    "    fig.add_subplot(gs[:3,2]).set_axis_off()\n",
    "    fig.add_subplot(gs[:3,5]).set_axis_off()\n",
    "    \n",
    "    # predictors    \n",
    "    for i, pred, gs_i in zip(    \n",
    "        range(len(predictors_sig)),\n",
    "        predictors_sig,\n",
    "        [(0,3), (0,6), (0,9), (1,0), (1,3), (1,6), (1,9), (2,0), (2,3)]\n",
    "    ):\n",
    "        \n",
    "        # data\n",
    "        z = juspyce_ct_dominance.X.loc[pred,:]\n",
    "        perror = regional_influence[tp][pred]\n",
    "        # scatter\n",
    "        ax_pred1 = fig.add_subplot(gs[gs_i])\n",
    "        scatter(z, delta, perror, fig, ax_pred1, c=colors[i], hue_lims=pe_lims,\n",
    "                r=juspyce_ct_dominance.predictions[\"spearman\"].loc[tp,pred])\n",
    "        #ax_pred1.set_ylim(ct_lims[0], ct_lims[1])          # DEACTIVATE IF CONSTANT INDIVIDUAL LIMITS\n",
    "        # brain\n",
    "        ax_pred2 = fig.add_subplot(gs[gs_i[0], gs_i[1]+1])\n",
    "        plot_surf_ax(get_parc_gifti(perror)[0], fig, ax_pred2, c=\"RdBu_r\", c_lims=pe_lims, \n",
    "                     rotate_labels=True, cbar=False)\n",
    "        # title\n",
    "        ax_pred1.set_title(pred, loc=\"left\", ha=\"left\", size=13, weight=\"semibold\", c=colors[i])\n",
    "        # labels\n",
    "        #if gs_i[1]==0:\n",
    "            #ax_pred1.set_ylabel(\"CT (%-change)\", size=12)\n",
    "        if gs_i in [(2,0), (2,3), (1,6), (1,9)]:\n",
    "            ax_pred1.set_xlabel(\"Predictors [Z]\", size=12)\n",
    "            \n",
    "    # colorbar\n",
    "    ax_cbar = fig.add_subplot(gs[2,7])\n",
    "    ax_cbar.axis(\"off\")\n",
    "    cbar = fig.colorbar(\n",
    "        cm.ScalarMappable(\n",
    "            norm=Normalize(pe_lims[0], pe_lims[1]), \n",
    "            cmap=\"RdBu_r\"\n",
    "        ), \n",
    "        ax=ax_cbar,\n",
    "        orientation=\"horizontal\",\n",
    "        fraction=0.25,\n",
    "        pad=-1)\n",
    "    plt.setp(cbar.ax.get_xticklabels(), rotation=-40, ha=\"left\", rotation_mode=\"anchor\")\n",
    "    cbar.ax.tick_params(axis=\"x\", which=\"major\", pad=2)\n",
    "    cbar.ax.set_title(\"Residual difference\")\n",
    "    \n",
    "    ## dominance analysis\n",
    "    fig.add_subplot(gs[3,:]).set_axis_off()\n",
    "    ax_dom = fig.add_subplot(gs[4,:])\n",
    "    plot_diffs(\n",
    "        data=juspyce_ct_dominance.predictions[\"dominance_total\"],\n",
    "        data_p=p_to_ast(\n",
    "            juspyce_ct_dominance.p_predictions[\"dominance_total\"], \n",
    "            juspyce_ct_dominance.p_predictions[\"dominance_total--fdr_bh\"]),\n",
    "        data_null=pd.DataFrame(\n",
    "            data=np.column_stack(\n",
    "                [juspyce_ct_dominance.nulls[\"predictions-dominance\"][i][\"dominance_total\"] \\\n",
    "                    for i in range(10000)]).T,\n",
    "            index=range(10000*len(predictors_sig)),\n",
    "            columns=tps_index\n",
    "        ),\n",
    "        ax=ax_dom,\n",
    "        legend=True,\n",
    "        legend_size=12,\n",
    "    )\n",
    "    ax_dom.axvline(tp, c=\"k\")\n",
    "    \n",
    "    # total explained R2\n",
    "    ax_dom.annotate(\n",
    "        text=\"$\\\\bfTotal\\ adjusted\\ R^2=\"\n",
    "             f\"{juspyce_ct_dominance.predictions['dominance_full_r2'].loc[tp].values[0]:.02f}$\",\n",
    "        xy=(1,0.28),\n",
    "        size=15,\n",
    "        c=\"0.4\"\n",
    "    )\n",
    "    \n",
    "    ## developmental stage\n",
    "    add_stages(ax_dom, height=0.09)\n",
    "\n",
    "    ## spearman correlations\n",
    "    ax_cor = fig.add_subplot(gs[5,:])\n",
    "    max_pred = juspyce_ct_dominance.predictions[\"dominance_total\"].iloc[1:,:].idxmax()\n",
    "    sig_correlations = juspyce_ct_dominance.predictions[\"spearman\"]\n",
    "    colors = get_cmap(\"tab10\")(range(len(predictors_sig)))\n",
    "    for i, p in enumerate(predictors_sig):\n",
    "        ax_cor.plot(\n",
    "            list(sig_correlations.index[1:]), \n",
    "            sig_correlations[p][1:], \n",
    "            color=colors[i], alpha=0.7, label=p\n",
    "        )\n",
    "\n",
    "    ax_cor.axhline(0, c=\"k\", linewidth=1)\n",
    "    ax_cor.set_xticks(ax_dom.get_xticks())\n",
    "    ax_cor.set_xticks(ax_dom.get_xticks(minor=True), minor=True)\n",
    "    ax_cor.set_xticklabels(juspyce_ct_dominance.y_lab.to_list()[1::5] + [\"\"], \n",
    "                           rotation=-30, ha=\"left\", rotation_mode=\"anchor\")\n",
    "    ax_cor.set_xlim(ax_dom.get_xlim())\n",
    "    ax_cor.axvline(tp, c=\"k\")\n",
    "    ax_cor.tick_params(axis=\"both\", which=\"major\", labelsize=11)\n",
    "\n",
    "    # finish\n",
    "    ax_dom.set_ylim(-0.01, 0.32)\n",
    "    ax_cor.set_ylim(-0.85,0.85)\n",
    "    ax_dom.set_ylabel(\"CT change explained [$adjusted\\ R^2$]\", size=13)\n",
    "    ax_cor.set_ylabel(\"Z $[Spearman's\\ rho]$\", size=13)\n",
    "    ax_cor.set_xlabel(\"Age windows [5-year steps]\", size=13, labelpad=10)\n",
    "    ax_dom.set_xticklabels(ax_cor.get_xticklabels(),\n",
    "                           rotation=-30, ha=\"left\", rotation_mode=\"anchor\")\n",
    "    ax_dom.tick_params(axis=\"both\", which=\"major\", labelsize=11)\n",
    "    \n",
    "    save_path = join(plot_dir_gif, f\"dev_ct_animation_fm_500_5_{tps_index.index(tp):02d}.jpg\")\n",
    "    fig.savefig(save_path,  bbox_inches=\"tight\", dpi=150, transparent=False)\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "imgs = glob(join(plot_dir_gif, \"*.jpg\"))\n",
    "imgs.sort()\n",
    "frames = []\n",
    "[frames.append(iio.imread(i)) for i in imgs],\n",
    "iio.mimwrite(join(plot_dir_gif, \"dev_ct_animation_fm_500_5.gif\"), frames, fps=1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "55a5a13bab2c2636ad1654b177bb15c7b38b3aeaddbba167703e2619b356d1fa"
  },
  "kernelspec": {
   "display_name": "Python 3.9.11 ('ntdev')",
   "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.9.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}