updrsTapping_exploring_features.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ReTap - UPDRS-Tapping Assessment - Feature Exploration\n",
    "\n",
    "This notebooks helps to visualise and statistically tst created tapping-features.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0. Loading packages and functions, defining paths\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Python and external packages\n",
    "import os\n",
    "import sys\n",
    "import importlib\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import sklearn as sk\n",
    "import scipy\n",
    "import matplotlib.pyplot as plt\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python sys 3.9.13 (main, Oct 13 2022, 21:23:06) [MSC v.1916 64 bit (AMD64)]\n",
      "pandas 1.4.4\n",
      "numpy 1.23.3\n",
      "sci-py 1.9.1\n",
      "sci-kit learn 1.1.2\n"
     ]
    }
   ],
   "source": [
    "# check some package versions for documentation and reproducability\n",
    "print('Python sys', sys.version)\n",
    "print('pandas', pd.__version__)\n",
    "print('numpy', np.__version__)\n",
    "# print('mne_bids', mne_bids.__version__)\n",
    "# print('mne', mne.__version__)\n",
    "print('sci-py', scipy.__version__)\n",
    "print('sci-kit learn', sk.__version__)\n",
    "\n",
    "\n",
    "\n",
    "## developed with:\n",
    "# Python sys 3.9.7 (default, Sep 16 2021, 08:50:36) \n",
    "# [Clang 10.0.0 ]\n",
    "# pandas 1.3.4\n",
    "# numpy 1.20.3\n",
    "# mne_bids 0.9\n",
    "# mne 0.24.1\n",
    "# sci-py 1.7.1\n",
    "# sci-kit learn 1.0.1\n",
    "\n",
    "## Currently (own env) since 31.08.22\n",
    "# Python sys 3.9.12 (main, Jun  1 2022, 06:36:29) \n",
    "# [Clang 12.0.0 ]\n",
    "# pandas 1.4.3\n",
    "# numpy 1.21.5\n",
    "# sci-py 1.7.3\n",
    "# sci-kit learn 1.1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ft extraction\n",
    "import tap_extract_fts.tapping_postFeatExtr_calc as ft_calc \n",
    "\n",
    "# own helper functions\n",
    "import retap_utils.utils_dataManagement as utils_dataMn\n",
    "\n",
    "import tap_plotting.main_plot_single_tap_timings as plot_timings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load or creating tapping-traces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "### IMPORT CREATED CLASSES FROM FILES\n",
    "from tap_extract_fts.main_featExtractionClass import FeatureSet, singleTrace\n",
    "\n",
    "deriv_path = os.path.join(utils_dataMn.get_local_proj_dir(), 'data', 'derivatives')\n",
    "\n",
    "# berClass = utils_dataManagement.load_class_pickle(os.path.join(deriv_path, 'ftClass_bertest.P'))\n",
    "# dusClass = utils_dataManagement.load_class_pickle(os.path.join(deriv_path, 'ftClass_DUS.P'))\n",
    "\n",
    "fts = utils_dataMn.load_class_pickle(os.path.join(deriv_path, 'ftClass_ALL_20230301.P'))\n",
    "# ftClass = utils_dataMn.load_class_pickle(os.path.join(deriv_path, 'ftClass_ALL_20221214.P'))\n",
    "# ftClass10 = utils_dataMn.load_class_pickle(os.path.join(deriv_path, 'ftClass_ALL_max10_20221214.P'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1 Visualise detected Features over time (FIG3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "importlib.reload(ft_calc)\n",
    "\n",
    "fig_fname = 'FIG3_featCourse_2Cases_2704'\n",
    "\n",
    "PLOT_SINGLE_TRACES = True\n",
    "PLOT_MEANS = True\n",
    "TO_SAVE = True\n",
    "TO_SHOW = False\n",
    "\n",
    "subs = [\n",
    "    'BER023',\n",
    "    'BER024',\n",
    "    # 'DUS022',\n",
    "    # 'DUS007'\n",
    "]\n",
    "ft_sel = ['impactRMS', 'raise_velocity', 'intraTapInt', 'tap_entropy']\n",
    "ft_names = ['impact-RMS', 'raising-velocity','inter-tap-interval',  'tap-entropy']\n",
    "ft_units = ['g', r'm / s${^2}$', 's',  'a.u.']\n",
    "\n",
    "score_colors = {0: 'olivedrab', 1: 'forestgreen',  #lawngreen\n",
    "                2: 'blue', 3: 'purple'}\n",
    "fsize = 16 \n",
    "fig, axes = plt.subplots(len(ft_sel), len(subs), \n",
    "                         sharex='col',\n",
    "                        #  sharey='row',\n",
    "                         figsize=(12, 12))\n",
    "\n",
    "for i_s, sub in enumerate(subs):\n",
    "    if i_s == 0: title = 'Case A'\n",
    "    elif i_s == 1: title = 'Case B'\n",
    "    axes[0, i_s].set_title(title, fontsize=fsize+4, weight='bold',)\n",
    "\n",
    "    for i_f, f in enumerate(ft_sel):\n",
    "\n",
    "        axes[i_f, 0].set_ylabel(r\"$\\bf{\" + str(ft_names[i_f])\n",
    "                                + \"}$\" + f'\\n({ft_units[i_f]})',\n",
    "                                fontsize=fsize,)\n",
    "\n",
    "        # gather score values per sub, per feat\n",
    "        if PLOT_MEANS:\n",
    "            score_lists = {}\n",
    "            for score in score_colors.keys(): score_lists[score] = []\n",
    "\n",
    "        for t in fts.incl_traces:\n",
    "\n",
    "            if not t.startswith(sub): continue\n",
    "            score = getattr(fts, t).tap_score\n",
    "            if score == 4: continue\n",
    "            col = score_colors[score]\n",
    "\n",
    "            feats = getattr(fts, t).fts\n",
    "            values = getattr(feats, f)\n",
    "\n",
    "            if PLOT_SINGLE_TRACES:\n",
    "                axes[i_f, i_s].plot(values, color=col, alpha=.2,)\n",
    "            \n",
    "            if PLOT_MEANS:\n",
    "                 score_lists[score].append(list(values))\n",
    "\n",
    "        if PLOT_MEANS:\n",
    "            mean_dict, err_dict = ft_calc.get_means_std_errs(score_lists)\n",
    "            for score in mean_dict.keys():\n",
    "                axes[i_f, i_s].plot(mean_dict[score],\n",
    "                                    color=score_colors[score],\n",
    "                                    alpha=.8, lw=3,)\n",
    "                axes[i_f, i_s].fill_between(x=np.arange(len(mean_dict[score])),\n",
    "                                            y1=mean_dict[score] - err_dict[score],\n",
    "                                            y2=mean_dict[score] + err_dict[score],\n",
    "                                            color=score_colors[score], alpha=.3,)\n",
    "                \n",
    "\n",
    "\n",
    "        axes[i_f, i_s].tick_params(axis='both', labelsize=fsize,\n",
    "                                    size=fsize)\n",
    "        axes[i_f, i_s].spines[['right', 'top']].set_visible(False)\n",
    "\n",
    "    axes[-1, i_s].set_xlabel('Detected taps (observations)', fontsize=fsize,)\n",
    "    # create legend labels with dummy plots\n",
    "    if i_s == 0:\n",
    "        for score in score_colors.keys():\n",
    "            axes[-1, 1].plot([], c=score_colors[score], label=f\"{score}\",\n",
    "                             lw=5, )\n",
    "\n",
    "        lgd = fig.legend(ncol=4, fontsize=fsize+4, frameon=False,\n",
    "                   bbox_to_anchor=(.5, -.08), loc='lower center',\n",
    "                   title='Tap scores (expert-rated)',\n",
    "                #    title_fontsize=fsize+4,\n",
    "                   title_fontproperties={'weight': 'bold',\n",
    "                                         'size': fsize+2})\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "if TO_SAVE:\n",
    "    plt.savefig(os.path.join(utils_dataMn.find_onedrive_path('figures'),\n",
    "                             'feature_course (fig3)', fig_fname),\n",
    "                bbox_extra_artists=(lgd,), bbox_inches='tight',\n",
    "                dpi=450, facecolor='w',)\n",
    "if TO_SHOW: plt.show()\n",
    "else: plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tap_plotting.retap_check_taps as plot_taps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ### PLOT DETECTED TAPS for all Traces and save figures\n",
    "# importlib.reload(plot_taps)\n",
    "# plot_taps.plot_detected_taps(ftClass)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2 Individual feature differences between therapeutic conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "SUBS_EXCL = ['BER028', ]  # too many missing acc-data\n",
    "TRACES_EXCL = [\n",
    "    'DUS006_M0S0_L_1',  # no score/video\n",
    "    'DUS017_M1S0_L_1', 'DUS017_M1S1_L_1',  # corrupt acc-axis\n",
    "    # 'BER023_M1S0_R_2',  # tap score 4\n",
    "]\n",
    "for sub in SUBS_EXCL:\n",
    "    for t in fts.incl_traces:\n",
    "        if t.startswith(sub):\n",
    "            print(t)\n",
    "            TRACES_EXCL.append(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRACES = []  # traces to include\n",
    "\n",
    "for t in fts.incl_traces:\n",
    "    if t not in TRACES_EXCL:\n",
    "        TRACES.append(t)\n",
    "\n",
    "SUBS = [t[:6] for t in TRACES]\n",
    "SUBS = list(set(SUBS))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_best_worst_traces(\n",
    "    traces_consider: list, method='per_hand',\n",
    "    only_responders=False,  \n",
    "):\n",
    "    subs_consider = [t[:6] for t in traces_consider]\n",
    "    subs_consider = list(set(subs_consider))\n",
    "\n",
    "    TRACE_SEL = {}\n",
    "\n",
    "    if method == 'per_state':\n",
    "        TRACE_SEL['best'] = []\n",
    "        TRACE_SEL['worst'] = []\n",
    "\n",
    "    for SUB in subs_consider:\n",
    "        # handle sides separately\n",
    "        for SIDE in ['L', 'R']:\n",
    "            # DUS never right, only left recorded\n",
    "            if SUB.startswith('DUS') and SIDE == 'R': continue\n",
    "\n",
    "            if method == 'per_hand':\n",
    "                TRACE_SEL[f'{SUB}_{SIDE}'] = {'best': [], 'worst': []}\n",
    "\n",
    "            # select traces\n",
    "            for t in traces_consider:\n",
    "                sub, cnd, side, run = t.split('_')\n",
    "\n",
    "                if sub != SUB or side != SIDE: continue\n",
    "\n",
    "                # select condition\n",
    "                if cnd == 'M0S0':\n",
    "                    if method == 'per_hand':\n",
    "                        TRACE_SEL[f'{SUB}_{SIDE}']['worst'].append(t)\n",
    "                    elif method == 'per_state':\n",
    "                        TRACE_SEL['worst'].append(t)\n",
    "                if cnd == 'M1S1':\n",
    "                    if method == 'per_hand':\n",
    "                        TRACE_SEL[f'{SUB}_{SIDE}']['best'].append(t)\n",
    "                    elif method == 'per_state':\n",
    "                        TRACE_SEL['best'].append(t)\n",
    "\n",
    "            # select out sub-sides without best and worst present\n",
    "            if method == 'per_hand':\n",
    "                if (TRACE_SEL[f'{SUB}_{SIDE}']['best'] == [] or\n",
    "                    TRACE_SEL[f'{SUB}_{SIDE}']['worst'] == []):\n",
    "\n",
    "                    del TRACE_SEL[f'{SUB}_{SIDE}']\n",
    "            \n",
    "            # elif method == 'per_state':\n",
    "            #     if only_responders:\n",
    "                    \n",
    "\n",
    "    return TRACE_SEL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_subsides_responders(\n",
    "    traces_consider: list, min_diff=1,\n",
    "    \n",
    "):\n",
    "    n_excl = 0\n",
    "    subsides_consider = []\n",
    "\n",
    "    for t in traces_consider:\n",
    "        \n",
    "        sub, cnd, side, run = t.split('_')\n",
    "        if [sub, side] not in subsides_consider:\n",
    "            subsides_consider.append([sub, side])\n",
    "\n",
    "    responders = {}\n",
    "\n",
    "    for SUB, SIDE in subsides_consider:\n",
    "\n",
    "        state_scores = {'M1S1': [], 'M1S0': [], 'M0S1': [], 'M0S0': []}\n",
    "\n",
    "        for t in traces_consider:\n",
    "            sub, cnd, side, run = t.split('_')\n",
    "            if not (sub == SUB and SIDE == side): continue\n",
    "            state_scores[cnd].append(getattr(fts, t).tap_score)\n",
    "        \n",
    "        # get means per state\n",
    "        off_mean = np.nanmean(state_scores['M0S0'])\n",
    "        if np.isnan(off_mean):\n",
    "            print(f'NO OFF: skip {SUB, SIDE}')\n",
    "            n_excl += 1\n",
    "            continue\n",
    "        on_means = []\n",
    "        for state in ['M1S1', 'M1S0', 'M0S1']:\n",
    "            on_means.append(np.nanmean(state_scores[state]))\n",
    "        if np.isnan(on_means).all():\n",
    "            n_excl += 1\n",
    "            print(f'NO ONs: skip {SUB, SIDE}')\n",
    "            continue\n",
    "            \n",
    "\n",
    "        if (off_mean - np.nanmin(on_means)) >= min_diff:\n",
    "            best_state = ['M1S1', 'M1S0', 'M0S1'][np.nanargmin(on_means)]\n",
    "            responders[f'{SUB}_{SIDE}'] = best_state\n",
    "        # else:\n",
    "        #     print(off_mean, on_means)\n",
    "    \n",
    "    print(f'n responders: {len(responders)}, out of '\n",
    "          f'{len(subsides_consider) - n_excl} ({n_excl} excl)')\n",
    "\n",
    "    return responders\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO OFF: skip ('BER021', 'L')\n",
      "NO OFF: skip ('BER021', 'R')\n",
      "NO ONs: skip ('BER056', 'R')\n",
      "NO OFF: skip ('DUS006', 'L')\n",
      "NO OFF: skip ('DUS009', 'L')\n",
      "NO OFF: skip ('DUS023', 'L')\n",
      "n responders: 25, out of 47 (6 excl)\n",
      "{'BER025_R': 'M0S1', 'BER026_L': 'M1S0', 'BER029_L': 'M1S1', 'BER029_R': 'M1S1', 'BER033_L': 'M0S1', 'BER033_R': 'M0S1', 'BER052_L': 'M1S0', 'BER055_L': 'M1S0', 'BER055_R': 'M1S0', 'BER049_R': 'M1S0', 'BER023_L': 'M1S1', 'BER023_R': 'M0S1', 'DUS024_L': 'M1S1', 'DUS007_L': 'M1S1', 'DUS011_L': 'M1S1', 'DUS014_L': 'M1S1', 'DUS010_L': 'M1S1', 'DUS026_L': 'M1S1', 'DUS020_L': 'M1S1', 'DUS008_L': 'M1S1', 'DUS016_L': 'M1S1', 'DUS025_L': 'M1S1', 'DUS015_L': 'M1S1', 'DUS004_L': 'M1S1', 'DUS022_L': 'M1S1'}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\habetsj\\AppData\\Local\\Temp\\ipykernel_5128\\1791937933.py:33: RuntimeWarning: Mean of empty slice\n",
      "  on_means.append(np.nanmean(state_scores[state]))\n",
      "C:\\Users\\habetsj\\AppData\\Local\\Temp\\ipykernel_5128\\1791937933.py:26: RuntimeWarning: Mean of empty slice\n",
      "  off_mean = np.nanmean(state_scores['M0S0'])\n"
     ]
    }
   ],
   "source": [
    "resp = get_subsides_responders(TRACES, min_diff=0.5)\n",
    "print(resp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [],
   "source": [
    "five_fts = ['trace_RMSn',\n",
    "            'jerkiness_trace',\n",
    "            'coefVar_intraTapInt',\n",
    "            'coefVar_impactRMS',\n",
    "            'mean_raise_velocity']\n",
    "ft_labels = ['normed RMS (trace)',\n",
    "             'jerkiness (trace)',\n",
    "             'CV ITI',\n",
    "             'CV impact-RMS',\n",
    "             'mean\\nfinger-open velocity']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "# trace_sel = select_best_worst_traces(TRACES, method='per_hand')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import mannwhitneyu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig, axes = plt.subplots(len(five_fts), 1, figsize=(6, 12))\n",
    "fig, ax = plt.subplots(1, 1, figsize=(16, 4))\n",
    "\n",
    "cmaps = plot_timings.get_colors()\n",
    "\n",
    "col_off = list(cmaps.values())[2]\n",
    "col_all_on = list(cmaps.values())[5]\n",
    "col_sel_on = list(cmaps.values())[1]\n",
    "fs=18\n",
    "signs_sel, signs_all = [], []\n",
    "\n",
    "box_offs, box_on_sel, box_on_all = [], [], []\n",
    "\n",
    "for i_ft, ft in enumerate(five_fts):\n",
    "    # create benchmark variation on all\n",
    "    sel_on_values, off_values, all_on_values = [], [], []\n",
    "\n",
    "    \n",
    "    for sub_side in resp.keys():\n",
    "        best_cond = resp[sub_side]\n",
    "        SUB, SIDE = sub_side.split('_')\n",
    "    \n",
    "        for t in TRACES:\n",
    "            sub, cnd, side, run = t.split('_')\n",
    "            if not (sub==SUB and side==SIDE): continue\n",
    "            \n",
    "            # fill off off\n",
    "            if cnd == 'M0S0':\n",
    "                trace_feats = getattr(fts, t).fts\n",
    "                trace_value = getattr(trace_feats, ft)\n",
    "                off_values.append(trace_value)\n",
    "            # fill ALL other ONs\n",
    "            else:\n",
    "                all_on_values.append(trace_value)\n",
    "            # fill selected responders\n",
    "            if cnd == best_cond:\n",
    "                trace_feats = getattr(fts, t).fts\n",
    "                trace_value = getattr(trace_feats, ft)\n",
    "                sel_on_values.append(trace_value)\n",
    "                        \n",
    "    \n",
    "    # plot on one lines (normalised)\n",
    "    box_offs.append(np.array(off_values) / max(off_values))\n",
    "    box_on_all.append(np.array(all_on_values) / max(all_on_values))\n",
    "    box_on_sel.append(np.array(sel_on_values) / max(sel_on_values))\n",
    "\n",
    "    p_sel = mannwhitneyu(off_values, sel_on_values)[1]\n",
    "    p_all = mannwhitneyu(off_values, all_on_values)[1]\n",
    "    if p_sel < (0.001 / len(five_fts)):\n",
    "        signs_sel.append(True)\n",
    "    else:\n",
    "        signs_sel.append(False)\n",
    "    if p_all < (0.001 / len(five_fts)):\n",
    "        signs_all.append(True)\n",
    "    else:\n",
    "        signs_all.append(False)\n",
    "    \n",
    "\n",
    "    \n",
    "bp1 = ax.boxplot(box_offs, positions=np.arange(0, 5, 1),\n",
    "                 widths=0.15, patch_artist=True)\n",
    "bp2 = ax.boxplot(box_on_all, positions=np.arange(0.2, 5.2, 1),\n",
    "                 widths=0.15, patch_artist=True)\n",
    "bp3 = ax.boxplot(box_on_sel, positions=np.arange(0.4, 5.4, 1),\n",
    "                 widths=0.15, patch_artist=True,)\n",
    "for b in bp1['boxes']: b.set(facecolor=col_off)\n",
    "for b in bp2['boxes']: b.set(facecolor=col_all_on)\n",
    "for b in bp3['boxes']: b.set(facecolor=col_sel_on)\n",
    "plt.setp(bp1['medians'], color='k')\n",
    "plt.setp(bp2['medians'], color='k')\n",
    "plt.setp(bp3['medians'], color='k')\n",
    "\n",
    "# add significance\n",
    "for i_sig, sig in enumerate(signs_sel):\n",
    "    if sig: plt.text(x=.4 + i_sig, y=1.1, s='*',\n",
    "                     size=fs*2, ha='center', va='center',\n",
    "                     color='red',)\n",
    "\n",
    "ax.set_xticks(np.arange(.2, 5.2, 1))\n",
    "ax.set_xticklabels(ft_labels)\n",
    "\n",
    "ax.set_ylabel('Normalised feature\\nvalue (a.u.)', size=fs)\n",
    "ax.set_ylim(0, 1.7)\n",
    "ax.set_yticks([0, 1])\n",
    "ax.spines[['right', 'top',]].set_visible(False)  # \n",
    "\n",
    "ax.legend([bp1[\"boxes\"][0], bp2[\"boxes\"][0], bp3[\"boxes\"][0]],\n",
    "          [f\"all Off-Off (n={len(box_offs[0])})\",\n",
    "           f\"all On (n={len(box_on_all[0])})\",\n",
    "           f\"best On (n={len(box_on_sel[0])})\"],\n",
    "           ncol=3, fontsize=fs + 4,\n",
    "          loc='upper center', frameon=False,)\n",
    "\n",
    "plt.tick_params(axis='both', size=fs, labelsize=fs,\n",
    "                color='k')\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(os.path.join(utils_dataMn.find_onedrive_path('figures'),\n",
    "                         'SuppFig_OnOff_differences'),\n",
    "            dpi=450, facecolor='w',)\n",
    "\n",
    "plt.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nightblue': '#332288',\n",
       " 'darkgreen': '#117733',\n",
       " 'turquoise': '#44AA99',\n",
       " 'lightblue': '#88CCEE',\n",
       " 'sand': '#DDCC77',\n",
       " 'softred': '#CC6677',\n",
       " 'lila': '#AA4499',\n",
       " 'purplered': '#882255'}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cmaps"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('retap')",
   "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "f23a308fb4398211655e9950c8371f856de701ec09eac61c96054832e4a49057"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}