From 05ccecf09960e349262aa59a4cb2a7f178ee18cb Mon Sep 17 00:00:00 2001
From: anujanegi <anujanegi1@gmail.com>
Date: Thu, 21 Nov 2024 16:48:39 +0100
Subject: [PATCH] fig4

---
 visualisation_fixed underover.ipynb | 1620 +++++++++++++++++++++++++++
 1 file changed, 1620 insertions(+)
 create mode 100644 visualisation_fixed underover.ipynb

diff --git a/visualisation_fixed underover.ipynb b/visualisation_fixed underover.ipynb
new file mode 100644
index 0000000..ba8e3cf
--- /dev/null
+++ b/visualisation_fixed underover.ipynb	
@@ -0,0 +1,1620 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f40c1228",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4965d207",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# MODIFY to generate figures for that number of active sources\n",
+    "nnz = 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "34a53287",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using pyvista 3d backend.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages/mne/viz/backends/_pyvista.py:40: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
+      "  VTK9 = LooseVersion(getattr(vtk, 'VTK_VERSION', '9.0')) >= LooseVersion('9.0')\n",
+      "/home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages/mne/viz/backends/_pyvista.py:40: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
+      "  VTK9 = LooseVersion(getattr(vtk, 'VTK_VERSION', '9.0')) >= LooseVersion('9.0')\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os \n",
+    "\n",
+    "# please update your paths\n",
+    "import mne\n",
+    "\n",
+    "os.environ['SUBJECTS_DIR'] = '/home/anujanegi/tj/bdsg/freesurfer/subjects'\n",
+    "PATH_TO_ESTIMATES = \"bsi_zoo/tests/data/estimates/fixed/nnz_%d\"%nnz\n",
+    "PATH_TO_SAVE_FIGURES = \"figures/nnz_%d\"%nnz\n",
+    "SOLVER_NAMES = ['iterative_L1', 'iterative_L2', 'iterative_sqrt', 'iterative_L1_typeII', 'iterative_L2_typeII', 'gamma_map']\n",
+    "SUBJECTS = [\"CC120166\", \"CC120264\", \"CC120309\", \"CC120313\"]\n",
+    "\n",
+    "mne.viz.set_3d_backend('pyvista')\n",
+    "HEMISPHERES = [\"lh\", \"rh\"]\n",
+    "# ['iterative_L1' , 'iterative_L2', 'iterative_sqrt', 'iterative_L1_typeII', 'iterative_L2_typeII', 'gamma_map']\n",
+    "\n",
+    "if not os.path.exists(PATH_TO_SAVE_FIGURES):\n",
+    "    os.makedirs(PATH_TO_SAVE_FIGURES)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "ad4bbd48",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def metrics(fwd, stc, stc_hat):\n",
+    "    vertices = []\n",
+    "    vertices.append(fwd[\"src\"][0][\"vertno\"])\n",
+    "    vertices.append(fwd[\"src\"][1][\"vertno\"])\n",
+    "\n",
+    "    # Reverse the effect of make_sparse_stc\n",
+    "    # stc now contains a sparse matrix with a lot of zero rows and few non-zero\n",
+    "    # rows containing the activations\n",
+    "\n",
+    "    stc.expand(vertices)\n",
+    "    stc_hat.expand(vertices)\n",
+    "\n",
+    "    est_activations = np.abs(stc_hat.data).sum(axis=-1)\n",
+    "    true_activations = np.abs(stc.data).sum(axis=-1)\n",
+    "\n",
+    "    estimated_as = est_activations != 0\n",
+    "    true_as = true_activations != 0\n",
+    "\n",
+    "    recall = recall_score(true_as, estimated_as, zero_division=0)\n",
+    "    emd = wasserstein_distance(est_activations, true_activations) #TODO: info about geometry\n",
+    "    hammingloss = hamming_loss(true_as, estimated_as)\n",
+    "    jaccard = jaccard_score(true_as, estimated_as, zero_division=0) #TODO: verify\n",
+    "\n",
+    "    return recall, emd, hammingloss, jaccard"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ce01fdfd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_margin(nonwhite_col, margin=5):\n",
+    "    margin_nonwhite_col = nonwhite_col.copy()\n",
+    "    for i in range(len(nonwhite_col)):\n",
+    "        if nonwhite_col[i] == True and nonwhite_col[i - 1] == False:\n",
+    "            margin_nonwhite_col[i - (1 + margin) : i - 1] = True\n",
+    "        elif nonwhite_col[i] == False and nonwhite_col[i - 1] == True:\n",
+    "            margin_nonwhite_col[i : i + margin] = True\n",
+    "    return margin_nonwhite_col"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "db843a18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_foci_to_brain_surface(brain, stc, ax, color, label):\n",
+    "    for i_hemi, hemi in enumerate(HEMISPHERES):\n",
+    "        surface_coords = brain.geo[hemi].coords\n",
+    "        hemi_data = stc.lh_data if hemi == \"lh\" else stc.rh_data\n",
+    "        \n",
+    "        for k in range(len(stc.vertices[i_hemi])):\n",
+    "            activation_idx = stc.vertices[i_hemi][k]\n",
+    "            foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "            # In milliseconds\n",
+    "            (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "            brain.add_foci(foci_coords, hemi=hemi, color=line.get_color(), alpha=0.5, name=label)\n",
+    "\n",
+    "    ax.set_xlabel(\"Time (ms)\")\n",
+    "    ax.set_ylabel(\"Amplitude (nAm)\")\n",
+    "    ax.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "4ad8d7a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from bsi_zoo.config import get_leadfield_path\n",
+    "subject = SUBJECTS[0]\n",
+    "from bsi_zoo.data_generator import get_data\n",
+    "from bsi_zoo.estimators import eloreta, iterative_L1, gamma_map\n",
+    "from mne.inverse_sparse.mxne_inverse import _make_sparse_stc\n",
+    "from mne import read_forward_solution\n",
+    "import numpy as np\n",
+    "\n",
+    "y, L, x, cov, _ = get_data(seed=22, nnz=nnz, n_times=10\n",
+    "                           , cov_type=\"diag\", orientation_type=\"fixed\", alpha=0.7, path_to_leadfield=get_leadfield_path(subject, type=\"fixed\"))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3f1ebd80",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0.0001, 0.01, 0.01, 0.1, 1, 10, 100, 1000, 10000, 100000]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[0.0001, 0.01, 0.01, 0.1, 1, 10, 100, 1000, 10000, 100000]\n",
+    "estimator_alphas_II = [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000, 100000]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d35b813",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for eloreta\n",
+    "\n",
+    "### TNL .3\n",
+    "\n",
+    "# true - 0.2, \n",
+    "alpha=.00001\n",
+    "EMD: 0.053394436144769346\n",
+    "reconstructed_noise: 0.10355713761023558\n",
+    "\n",
+    "# true - 0.1, \n",
+    "alpha=.0003\n",
+    "EMD: 0.052962287018743684\n",
+    "reconstructed_noise: 0.20707996546431942\n",
+    "\n",
+    "# true,\n",
+    "alpha=.02 \n",
+    "EMD: 0.048753658947964816\n",
+    "reconstructed_noise: 0.3054756651212348\n",
+    "\n",
+    "\n",
+    "# true + 0.1, \n",
+    "alpha=.7\n",
+    "EMD: 0.04311814061520803\n",
+    "reconstructed_noise: 0.4034334023778557\n",
+    "\n",
+    "# true + 0.2\n",
+    "alpha=3\n",
+    "EMD: 0.04286022738653591\n",
+    "reconstructed_noise: 0.5165606095676858\n",
+    "\n",
+    "\n",
+    "# # for eloreta old before nov\n",
+    "\n",
+    "# ### TNL .3\n",
+    "\n",
+    "# # true - 0.2, \n",
+    "# alpha=.00001\n",
+    "# EMD: 0.053394436144769346\n",
+    "# reconstructed_noise: 0.10355713761023558\n",
+    "\n",
+    "# # true - 0.1, \n",
+    "# alpha=.0003\n",
+    "# EMD: 0.052962287018743684\n",
+    "# reconstructed_noise: 0.20707996546431942\n",
+    "\n",
+    "# # true,\n",
+    "# alpha=.02 \n",
+    "# EMD: 0.048753658947964816\n",
+    "# reconstructed_noise: 0.3054756651212348\n",
+    "\n",
+    "\n",
+    "# # true + 0.1, \n",
+    "# alpha=.7\n",
+    "# EMD: 0.04311814061520803\n",
+    "# reconstructed_noise: 0.4034334023778557\n",
+    "\n",
+    "# # true + 0.2\n",
+    "# alpha=3\n",
+    "# EMD: 0.04286022738653591\n",
+    "# reconstructed_noise: 0.5165606095676858"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "id": "7a4cd14f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading forward solution from bsi_zoo/tests/data/CC120166-fwd.fif...\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    2 source spaces read\n",
+      "    Desired named matrix (kind = 3523) not available\n",
+      "    Read MEG forward solution (5123 sources, 306 channels, free orientations)\n",
+      "    Source spaces transformed to the forward solution coordinate frame\n",
+      "    No patch info available. The standard source space normals will be employed in the rotation to the local surface coordinates....\n",
+      "    Changing to fixed-orientation forward solution with surface-based source orientations...\n",
+      "    [done]\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    2 source spaces read\n",
+      "reconstructed_noise: 0.18465463206084398\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_hat = eloreta(L,  y, alpha=0.0001, n_orient=1)\n",
+    "\n",
+    "fwd_fname = \"bsi_zoo/tests/data/%s-fwd.fif\"%subject\n",
+    "fwd = read_forward_solution(fwd_fname)\n",
+    "fwd = mne.convert_forward_solution(fwd, force_fixed=True)\n",
+    "active_set = np.linalg.norm(x, axis=1) != 0\n",
+    "\n",
+    " # check if no vertices are estimated\n",
+    "temp = np.linalg.norm(x_hat, axis=1)\n",
+    "if len(np.unique(temp))==1:\n",
+    "    print(\"No vertices estimated!\")\n",
+    "\n",
+    "temp_ = np.partition(-temp, nnz)\n",
+    "# max_temp = temp\n",
+    "max_temp = -temp_[:300] #plot top 10 for dense method\n",
+    "\n",
+    "# remove 0 from list incase less vertices than nnz were estimated\n",
+    "max_temp = np.delete(max_temp, np.where(max_temp==0.))\n",
+    "active_set_hat = np.array(list(map(max_temp.__contains__, temp)))\n",
+    "\n",
+    "\n",
+    "stc = _make_sparse_stc(\n",
+    "    x[active_set], active_set, fwd, tmin=1, tstep=1\n",
+    ")  # ground truth\n",
+    "stc_hat = _make_sparse_stc(\n",
+    "    x_hat[active_set_hat], active_set_hat, fwd, tmin=1, tstep=1\n",
+    ")  # estimate\n",
+    "\n",
+    "source_space = mne.read_source_spaces(fwd_fname)\n",
+    "\n",
+    "stc_fs = mne.compute_source_morph(\n",
+    "    stc_hat, subject, \"fsaverage\", '/home/anujanegi/tj/bdsg/freesurfer/subjects'\n",
+    ").apply(stc_hat)\n",
+    "\n",
+    "#              # Plot the STC, get the brain image, crop it:\n",
+    "# brain = stc_fs.plot(\n",
+    "#     # views=[\"lat\", \"medial\"],\n",
+    "#     # hemi=\"split\" if len(HEMISPHERES) > 1 else HEMISPHERES[0],\n",
+    "#     hemi=\"both\",\n",
+    "#     size=(500, 800),\n",
+    "#     background=\"w\",\n",
+    "#     # clim=\"auto\",\n",
+    "#     colorbar=False,\n",
+    "#     colormap=\"inferno\",\n",
+    "#     time_viewer=True,\n",
+    "#     show_traces=True,\n",
+    "#     surface=\"flat\",\n",
+    "#     cortex=\"classic\",\n",
+    "#     # volume_options=dict(resolution=1),\n",
+    "#     view_layout=\"horizontal\",\n",
+    "# )\n",
+    "\n",
+    "# for i_hemi, hemi in enumerate(['lh', 'rh']):\n",
+    "#     surface_coords = brain.geo[hemi].coords\n",
+    "#     hemi_data = stc.lh_data if hemi == \"lh\" else stc.rh_data\n",
+    "#     for k in range(len(stc.vertices[i_hemi])):\n",
+    "#         activation_idx = stc.vertices[i_hemi][k]\n",
+    "#         foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "#         # In milliseconds\n",
+    "#         # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "#         brain.add_foci(foci_coords, hemi=hemi, color='red', alpha=1)\n",
+    "\n",
+    "# for i_hemi, hemi in enumerate(['lh', 'rh']):\n",
+    "#     surface_coords = brain.geo[hemi].coords\n",
+    "#     hemi_data = stc_hat.lh_data if hemi == \"lh\" else stc_hat.rh_data\n",
+    "#     for k in range(len(stc_hat.vertices[i_hemi])):\n",
+    "#         activation_idx = stc_hat.vertices[i_hemi][k]\n",
+    "#         foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "#         # In milliseconds\n",
+    "#         # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "#         brain.add_foci(foci_coords, hemi=hemi, color='blue', alpha=.9)\n",
+    "\n",
+    "# screenshot = brain.screenshot()\n",
+    "\n",
+    "# import numpy as np\n",
+    "# import matplotlib.pyplot as plt\n",
+    "# from mpl_toolkits.axes_grid1 import make_axes_locatable, ImageGrid, inset_locator\n",
+    "\n",
+    "# import mne\n",
+    "# nonwhite_pix = (screenshot != 255).any(-1)\n",
+    "# nonwhite_row = nonwhite_pix.any(1)\n",
+    "# nonwhite_col = nonwhite_pix.any(0)\n",
+    "# cropped_screenshot = screenshot[nonwhite_row][:, nonwhite_col]\n",
+    "\n",
+    "# # plot screenshot\n",
+    "# fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "# # ax.imshow(screenshot)\n",
+    "# # no ticks and graph borders\n",
+    "# ax.set_xticks([])\n",
+    "# ax.set_yticks([])\n",
+    "# ax.spines[\"top\"].set_visible(False)\n",
+    "# ax.spines[\"right\"].set_visible(False)\n",
+    "# ax.spines[\"bottom\"].set_visible(False)\n",
+    "# ax.spines[\"left\"].set_visible(False)\n",
+    "\n",
+    "# ax.imshow(cropped_screenshot)\n",
+    "# # save in high quality with transparent background\n",
+    "# # fig.savefig(\"./bsi_zoo/data/figs/brain.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "# # fig.savefig(\"./bsi_zoo/data/figs/recon source.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "\n",
+    "\n",
+    "# from bsi_zoo.metrics import emd, reconstructed_noise\n",
+    "# e = emd(x, x_hat, 'fixed', subject)\n",
+    "# print('EMD:', e)\n",
+    "\n",
+    "r = reconstructed_noise(x, x_hat, 'fixed', y=y, L=L)\n",
+    "print('reconstructed_noise:', r)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "id": "4b7ae104",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading forward solution from bsi_zoo/tests/data/CC120166-fwd.fif...\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    2 source spaces read\n",
+      "    Desired named matrix (kind = 3523) not available\n",
+      "    Read MEG forward solution (5123 sources, 306 channels, free orientations)\n",
+      "    Source spaces transformed to the forward solution coordinate frame\n",
+      "    No patch info available. The standard source space normals will be employed in the rotation to the local surface coordinates....\n",
+      "    Changing to fixed-orientation forward solution with surface-based source orientations...\n",
+      "    [done]\n",
+      "EMD: 0.053391181294270874\n",
+      "reconstructed_noise: 0.18465463206084398\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "# Average over time\n",
+    "stc_avg = stc_fs.mean()\n",
+    "\n",
+    "peak_time = stc_fs.get_peak(vert_as_index=True, time_as_index=True)\n",
+    "stc_peak = stc_fs.copy().crop(peak_time[1], peak_time[1])\n",
+    "\n",
+    "data_range = stc_avg.data  # or stc.data for the whole source estimate\n",
+    "\n",
+    "# Define thresholds based on percentiles or standard deviations\n",
+    "lower_thresh = np.percentile(data_range, 49)  # 10th percentile as lower bound\n",
+    "mid_thresh = np.percentile(data_range, 74)  # Mean as midpoint\n",
+    "upper_thresh = np.percentile(data_range, 99)  # 99th percentile as upper bound\n",
+    "\n",
+    "\n",
+    "# Plot source estimate as a heatmap on the cortex\n",
+    "brain = stc_avg.plot(hemi='split', subject='fsaverage',\n",
+    "                     subjects_dir='/home/anujanegi/tj/bdsg/freesurfer/subjects', time_label='Average activation',\n",
+    "                     colormap='Blues', clim=dict(kind='value', lims=[lower_thresh, mid_thresh, upper_thresh]), smoothing_steps=5, surface='flat', size=(500, 800), background=\"w\", colorbar=False, time_viewer=False,\n",
+    "    show_traces=False,)\n",
+    "\n",
+    "for i_hemi, hemi in enumerate(['lh', 'rh']):\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc.lh_data if hemi == \"lh\" else stc.rh_data\n",
+    "    for k in range(len(stc.vertices[i_hemi])):\n",
+    "        activation_idx = stc.vertices[i_hemi][k]\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "        # In milliseconds\n",
+    "        # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "        brain.add_foci(foci_coords, hemi=hemi, color='red', alpha=1)\n",
+    "\n",
+    "# for i_hemi, hemi in enumerate(['lh', 'rh']):\n",
+    "#     surface_coords = brain.geo[hemi].coords\n",
+    "#     hemi_data = stc_hat.lh_data if hemi == \"lh\" else stc_hat.rh_data\n",
+    "#     for k in range(len(stc_hat.vertices[i_hemi])):\n",
+    "        \n",
+    "#         activation_idx = stc_hat.vertices[i_hemi][k]\n",
+    "#         foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "#         # In milliseconds\n",
+    "#         # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "#         brain.add_foci(foci_coords, hemi=hemi, color='blue', alpha=.9)\n",
+    "\n",
+    "screenshot = brain.screenshot()\n",
+    "\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mpl_toolkits.axes_grid1 import make_axes_locatable, ImageGrid, inset_locator\n",
+    "\n",
+    "import mne\n",
+    "nonwhite_pix = (screenshot != 255).any(-1)\n",
+    "nonwhite_row = nonwhite_pix.any(1)\n",
+    "nonwhite_col = nonwhite_pix.any(0)\n",
+    "cropped_screenshot = screenshot[nonwhite_row][:, nonwhite_col]\n",
+    "\n",
+    "# plot screenshot\n",
+    "fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "# ax.imshow(screenshot)\n",
+    "# no ticks and graph borders\n",
+    "ax.set_xticks([])\n",
+    "ax.set_yticks([])\n",
+    "ax.spines[\"top\"].set_visible(False)\n",
+    "ax.spines[\"right\"].set_visible(False)\n",
+    "ax.spines[\"bottom\"].set_visible(False)\n",
+    "ax.spines[\"left\"].set_visible(False)\n",
+    "\n",
+    "ax.imshow(cropped_screenshot)\n",
+    "# save in high quality with transparent background\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/brain.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/recon source.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "\n",
+    "from bsi_zoo.metrics import emd, reconstructed_noise\n",
+    "e = emd(x, x_hat, 'fixed', subject)\n",
+    "print('EMD:', e)\n",
+    "\n",
+    "r = reconstructed_noise(x, x_hat, 'fixed', y=y, L=L)\n",
+    "print('reconstructed_noise:', r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "489de0e7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "id": "e2e6890f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.0012042809978234101, 0.021923798817663577, 0.12719774096581207)"
+      ]
+     },
+     "execution_count": 109,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# Get the data range from the source estimate (peak or full data)\n",
+    "data_range = stc_avg.data  # or stc.data for the whole source estimate\n",
+    "\n",
+    "# Define thresholds based on percentiles or standard deviations\n",
+    "lower_thresh = np.percentile(data_range, 49)  # 10th percentile as lower bound\n",
+    "mid_thresh = np.percentile(data_range, 74)  # Mean as midpoint\n",
+    "upper_thresh = np.percentile(data_range, 99)  # 99th percentile as upper bound\n",
+    "\n",
+    "# # Plot with auto-calculated thresholds\n",
+    "# brain = stc_peak.plot(\n",
+    "#     hemi='both',\n",
+    "#     views='lat',\n",
+    "#     subject=subject,\n",
+    "#     subjects_dir=subjects_dir,\n",
+    "#     time_label=f'Peak activation at {stc_peak.times[0]:.3f} s',\n",
+    "#     colormap='hot',\n",
+    "#     clim=dict(kind='value', lims=[lower_thresh, mid_thresh, upper_thresh]),\n",
+    "#     smoothing_steps=5\n",
+    "# )\n",
+    "lower_thresh, mid_thresh, upper_thresh\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4160ed4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for gamma map\n",
+    "\n",
+    "### TNL .3\n",
+    "\n",
+    "# true - 0.2, \n",
+    "alpha=.0003\n",
+    "\n",
+    "\n",
+    "# true - 0.1, iter 20\n",
+    "alpha=0.00002\n",
+    "EMD: 0.05135846874567991\n",
+    "reconstructed_noise: 0.24984908863339395\n",
+    "\n",
+    "# true,\n",
+    "alpha=0.000028 iter 100\n",
+    "EMD: 0.03743358287784861\n",
+    "reconstructed_noise: 0.3021198447240613\n",
+    "\n",
+    "# true + 0.1, \n",
+    "alpha=0.00024 iter 100\n",
+    "EMD: 0.010839995615006115\n",
+    "reconstructed_noise: 0.40171399473426483\n",
+    "\n",
+    "# true + 0.2\n",
+    "alpha=0.00054 iter 100\n",
+    "EMD: 0.0159943331133686\n",
+    "reconstructed_noise: 0.5009840733320554\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14ff30c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "0.000007\n",
+    "RNL 0.27"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "8f66d955",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 0\t active set size: 4686\t convergence: 4.799e-01\n",
+      "Iteration: 14\t active set size: 4685\t convergence: 1.041e-01\n",
+      "Iteration: 15\t active set size: 4681\t convergence: 9.530e-02\n",
+      "Iteration: 16\t active set size: 4670\t convergence: 8.899e-02\n",
+      "Iteration: 17\t active set size: 4651\t convergence: 8.287e-02\n",
+      "Iteration: 18\t active set size: 4608\t convergence: 7.651e-02\n",
+      "Iteration: 19\t active set size: 4527\t convergence: 7.153e-02\n",
+      "Iteration: 20\t active set size: 4421\t convergence: 6.844e-02\n",
+      "Iteration: 21\t active set size: 4277\t convergence: 6.569e-02\n",
+      "Iteration: 22\t active set size: 4118\t convergence: 6.334e-02\n",
+      "Iteration: 23\t active set size: 3905\t convergence: 6.070e-02\n",
+      "Iteration: 24\t active set size: 3700\t convergence: 5.793e-02\n",
+      "Iteration: 25\t active set size: 3514\t convergence: 5.525e-02\n",
+      "Iteration: 26\t active set size: 3327\t convergence: 5.247e-02\n",
+      "Iteration: 27\t active set size: 3139\t convergence: 4.964e-02\n",
+      "Iteration: 28\t active set size: 2979\t convergence: 4.680e-02\n",
+      "Iteration: 29\t active set size: 2819\t convergence: 4.398e-02\n",
+      "Iteration: 30\t active set size: 2671\t convergence: 4.139e-02\n",
+      "Iteration: 31\t active set size: 2540\t convergence: 3.894e-02\n",
+      "Iteration: 32\t active set size: 2403\t convergence: 3.657e-02\n",
+      "Iteration: 33\t active set size: 2286\t convergence: 3.429e-02\n",
+      "Iteration: 34\t active set size: 2159\t convergence: 3.210e-02\n",
+      "Iteration: 35\t active set size: 2020\t convergence: 3.001e-02\n",
+      "Iteration: 36\t active set size: 1897\t convergence: 2.803e-02\n",
+      "Iteration: 37\t active set size: 1793\t convergence: 2.616e-02\n",
+      "Iteration: 38\t active set size: 1690\t convergence: 2.445e-02\n",
+      "Iteration: 39\t active set size: 1615\t convergence: 2.302e-02\n",
+      "Iteration: 40\t active set size: 1529\t convergence: 2.167e-02\n",
+      "Iteration: 41\t active set size: 1460\t convergence: 2.041e-02\n",
+      "Iteration: 42\t active set size: 1389\t convergence: 1.924e-02\n",
+      "Iteration: 43\t active set size: 1332\t convergence: 1.814e-02\n",
+      "Iteration: 44\t active set size: 1283\t convergence: 1.711e-02\n",
+      "Iteration: 45\t active set size: 1236\t convergence: 1.616e-02\n",
+      "Iteration: 46\t active set size: 1185\t convergence: 1.527e-02\n",
+      "Iteration: 47\t active set size: 1138\t convergence: 1.444e-02\n",
+      "Iteration: 48\t active set size: 1092\t convergence: 1.367e-02\n",
+      "Iteration: 49\t active set size: 1043\t convergence: 1.295e-02\n",
+      "Iteration: 50\t active set size: 1012\t convergence: 1.228e-02\n",
+      "Iteration: 51\t active set size: 981\t convergence: 1.166e-02\n",
+      "Iteration: 52\t active set size: 945\t convergence: 1.108e-02\n",
+      "Iteration: 53\t active set size: 928\t convergence: 1.054e-02\n",
+      "Iteration: 54\t active set size: 900\t convergence: 1.004e-02\n",
+      "Iteration: 55\t active set size: 868\t convergence: 9.570e-03\n",
+      "Iteration: 56\t active set size: 839\t convergence: 9.130e-03\n",
+      "Iteration: 57\t active set size: 818\t convergence: 8.719e-03\n",
+      "Iteration: 58\t active set size: 794\t convergence: 8.334e-03\n",
+      "Iteration: 59\t active set size: 764\t convergence: 7.973e-03\n",
+      "Iteration: 60\t active set size: 731\t convergence: 7.634e-03\n",
+      "Iteration: 61\t active set size: 700\t convergence: 7.316e-03\n",
+      "Iteration: 62\t active set size: 681\t convergence: 7.016e-03\n",
+      "Iteration: 63\t active set size: 659\t convergence: 6.734e-03\n",
+      "Iteration: 64\t active set size: 632\t convergence: 6.468e-03\n",
+      "Iteration: 65\t active set size: 608\t convergence: 6.216e-03\n",
+      "Iteration: 66\t active set size: 586\t convergence: 5.978e-03\n",
+      "Iteration: 67\t active set size: 561\t convergence: 5.752e-03\n",
+      "Iteration: 68\t active set size: 546\t convergence: 5.539e-03\n",
+      "Iteration: 69\t active set size: 519\t convergence: 5.335e-03\n",
+      "Iteration: 70\t active set size: 501\t convergence: 5.143e-03\n",
+      "Iteration: 71\t active set size: 486\t convergence: 4.959e-03\n",
+      "Iteration: 72\t active set size: 475\t convergence: 4.784e-03\n",
+      "Iteration: 73\t active set size: 456\t convergence: 4.617e-03\n",
+      "Iteration: 74\t active set size: 443\t convergence: 4.458e-03\n",
+      "Iteration: 75\t active set size: 428\t convergence: 4.305e-03\n",
+      "Iteration: 76\t active set size: 417\t convergence: 4.160e-03\n",
+      "Iteration: 77\t active set size: 408\t convergence: 4.020e-03\n",
+      "Iteration: 78\t active set size: 396\t convergence: 3.886e-03\n",
+      "Iteration: 79\t active set size: 379\t convergence: 3.758e-03\n",
+      "Iteration: 80\t active set size: 371\t convergence: 3.635e-03\n",
+      "Iteration: 81\t active set size: 365\t convergence: 3.517e-03\n",
+      "Iteration: 82\t active set size: 360\t convergence: 3.403e-03\n",
+      "Iteration: 83\t active set size: 353\t convergence: 3.294e-03\n",
+      "Iteration: 84\t active set size: 338\t convergence: 3.188e-03\n",
+      "Iteration: 85\t active set size: 325\t convergence: 3.087e-03\n",
+      "Iteration: 86\t active set size: 316\t convergence: 2.989e-03\n",
+      "Iteration: 87\t active set size: 301\t convergence: 2.895e-03\n",
+      "Iteration: 88\t active set size: 295\t convergence: 2.804e-03\n",
+      "Iteration: 89\t active set size: 284\t convergence: 2.716e-03\n",
+      "Iteration: 90\t active set size: 275\t convergence: 2.632e-03\n",
+      "Iteration: 91\t active set size: 269\t convergence: 2.550e-03\n",
+      "Iteration: 92\t active set size: 260\t convergence: 2.471e-03\n",
+      "Iteration: 93\t active set size: 255\t convergence: 2.394e-03\n",
+      "Iteration: 94\t active set size: 249\t convergence: 2.321e-03\n",
+      "Iteration: 95\t active set size: 242\t convergence: 2.249e-03\n",
+      "Iteration: 96\t active set size: 237\t convergence: 2.180e-03\n",
+      "Iteration: 97\t active set size: 235\t convergence: 2.113e-03\n",
+      "Iteration: 98\t active set size: 233\t convergence: 2.049e-03\n",
+      "Iteration: 99\t active set size: 225\t convergence: 1.986e-03\n",
+      "Reading forward solution from bsi_zoo/tests/data/CC120166-fwd.fif...\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    2 source spaces read\n",
+      "    Desired named matrix (kind = 3523) not available\n",
+      "    Read MEG forward solution (5123 sources, 306 channels, free orientations)\n",
+      "    Source spaces transformed to the forward solution coordinate frame\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/anujanegi/tj/bdsg/BSI-Zoo/bsi_zoo/estimators.py:398: RuntimeWarning: \n",
+      "Convergence NOT reached !\n",
+      "\n",
+      "  warn(\"\\nConvergence NOT reached !\\n\")\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "    No patch info available. The standard source space normals will be employed in the rotation to the local surface coordinates....\n",
+      "    Changing to fixed-orientation forward solution with surface-based source orientations...\n",
+      "    [done]\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    Reading a source space...\n",
+      "    [done]\n",
+      "    2 source spaces read\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_22645/2103247322.py:31: RuntimeWarning: 4855/157720 vertices not included in smoothing, consider increasing the number of steps\n",
+      "  stc_fs = mne.compute_source_morph(\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_hat = gamma_map(L,  y, alpha=0.00054, n_orient=1, max_iter=100)\n",
+    "\n",
+    "fwd_fname = \"bsi_zoo/tests/data/%s-fwd.fif\"%subject\n",
+    "fwd = read_forward_solution(fwd_fname)\n",
+    "fwd = mne.convert_forward_solution(fwd, force_fixed=True)\n",
+    "active_set = np.linalg.norm(x, axis=1) != 0\n",
+    "\n",
+    " # check if no vertices are estimated\n",
+    "temp = np.linalg.norm(x_hat, axis=1)\n",
+    "if len(np.unique(temp))==1:\n",
+    "    print(\"No vertices estimated!\")\n",
+    "\n",
+    "temp_ = np.partition(-temp, nnz)\n",
+    "max_temp = -temp_[:20]\n",
+    "\n",
+    "# remove 0 from list incase less vertices than nnz were estimated\n",
+    "max_temp = np.delete(max_temp, np.where(max_temp==0.))\n",
+    "active_set_hat = np.array(list(map(max_temp.__contains__, temp)))\n",
+    "\n",
+    "\n",
+    "stc = _make_sparse_stc(\n",
+    "    x[active_set], active_set, fwd, tmin=1, tstep=1\n",
+    ")  # ground truth\n",
+    "stc_hat = _make_sparse_stc(\n",
+    "    x_hat[active_set_hat], active_set_hat, fwd, tmin=1, tstep=1\n",
+    ")  # estimate\n",
+    "\n",
+    "source_space = mne.read_source_spaces(fwd_fname)\n",
+    "\n",
+    "\n",
+    "stc_fs = mne.compute_source_morph(\n",
+    "    stc_hat, subject, \"fsaverage\", '/home/anujanegi/tj/bdsg/freesurfer/subjects'\n",
+    ").apply(stc_hat)            \n",
+    "\n",
+    "# stc_fs = mne.compute_source_morph(\n",
+    "#     stc, subject, \"fsaverage\", '/home/anujanegi/tj/bdsg/freesurfer/subjects'\n",
+    "# ).apply(stc)\n",
+    "            \n",
+    "#              # Plot the STC, get the brain image, crop it:\n",
+    "# brain = stc_fs.plot(\n",
+    "#     # views=[\"lat\", \"medial\"],\n",
+    "#     # hemi=\"split\" if len(HEMISPHERES) > 1 else HEMISPHERES[0],\n",
+    "#     hemi=\"both\",\n",
+    "#     size=(500, 800),\n",
+    "#     background=\"w\",\n",
+    "#     # clim=\"auto\",\n",
+    "#     colorbar=False,\n",
+    "#     # colormap=\"inferno\",\n",
+    "#     time_viewer=False,\n",
+    "#     show_traces=False,\n",
+    "#     surface=\"flat\",\n",
+    "#     cortex=\"classic\",\n",
+    "#     # volume_options=dict(resolution=1),\n",
+    "#     view_layout=\"horizontal\",\n",
+    "# )\n",
+    "\n",
+    "# for i_hemi, hemi in enumerate(['lh', 'rh']):\n",
+    "#     surface_coords = brain.geo[hemi].coords\n",
+    "#     hemi_data = stc.lh_data if hemi == \"lh\" else stc.rh_data\n",
+    "#     for k in range(len(stc.vertices[i_hemi])):\n",
+    "#         activation_idx = stc.vertices[i_hemi][k]\n",
+    "#         foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "#         # In milliseconds\n",
+    "#         # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "#         brain.add_foci(foci_coords, hemi=hemi, color='red', alpha=1)\n",
+    "\n",
+    "# for i_hemi, hemi in enumerate(['lh', 'rh']):\n",
+    "#     surface_coords = brain.geo[hemi].coords\n",
+    "#     hemi_data = stc_hat.lh_data if hemi == \"lh\" else stc_hat.rh_data\n",
+    "#     for k in range(len(stc_hat.vertices[i_hemi])):\n",
+    "#         activation_idx = stc_hat.vertices[i_hemi][k]\n",
+    "#         foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "#         # In milliseconds\n",
+    "#         # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "#         brain.add_foci(foci_coords, hemi=hemi, color='blue', alpha=.9)\n",
+    "\n",
+    "# screenshot = brain.screenshot()\n",
+    "\n",
+    "# import numpy as np\n",
+    "# import matplotlib.pyplot as plt\n",
+    "# from mpl_toolkits.axes_grid1 import make_axes_locatable, ImageGrid, inset_locator\n",
+    "\n",
+    "# import mne\n",
+    "# nonwhite_pix = (screenshot != 255).any(-1)\n",
+    "# nonwhite_row = nonwhite_pix.any(1)\n",
+    "# nonwhite_col = nonwhite_pix.any(0)\n",
+    "# cropped_screenshot = screenshot[nonwhite_row][:, nonwhite_col]\n",
+    "\n",
+    "# # plot screenshot\n",
+    "# fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "# # ax.imshow(screenshot)\n",
+    "# # no ticks and graph borders\n",
+    "# ax.set_xticks([])\n",
+    "# ax.set_yticks([])\n",
+    "# ax.spines[\"top\"].set_visible(False)\n",
+    "# ax.spines[\"right\"].set_visible(False)\n",
+    "# ax.spines[\"bottom\"].set_visible(False)\n",
+    "# ax.spines[\"left\"].set_visible(False)\n",
+    "\n",
+    "# ax.imshow(cropped_screenshot)\n",
+    "# # save in high quality with transparent background\n",
+    "# # fig.savefig(\"./bsi_zoo/data/figs/brain.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "# # fig.savefig(\"./bsi_zoo/data/figs/recon source.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "\n",
+    "\n",
+    "# from bsi_zoo.metrics import emd, reconstructed_noise\n",
+    "# e = emd(x, x_hat, 'fixed', subject)\n",
+    "# print('EMD:', e)\n",
+    "\n",
+    "# r = reconstructed_noise(x, x_hat, 'fixed', y=y, L=L)\n",
+    "# print('reconstructed_noise:', r)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "edd0422f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using control points [0.03855327 0.09192635 1.16489971]\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'screenshot' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[31], line 93\u001b[0m\n\u001b[1;32m     90\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mmpl_toolkits\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39maxes_grid1\u001b[39;00m \u001b[39mimport\u001b[39;00m make_axes_locatable, ImageGrid, inset_locator\n\u001b[1;32m     92\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmne\u001b[39;00m\n\u001b[0;32m---> 93\u001b[0m nonwhite_pix \u001b[39m=\u001b[39m (screenshot \u001b[39m!=\u001b[39m \u001b[39m255\u001b[39m)\u001b[39m.\u001b[39many(\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[1;32m     94\u001b[0m nonwhite_row \u001b[39m=\u001b[39m nonwhite_pix\u001b[39m.\u001b[39many(\u001b[39m1\u001b[39m)\n\u001b[1;32m     95\u001b[0m nonwhite_col \u001b[39m=\u001b[39m nonwhite_pix\u001b[39m.\u001b[39many(\u001b[39m0\u001b[39m)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'screenshot' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# Average over time\n",
+    "stc_avg = stc_fs.mean()\n",
+    "\n",
+    "peak_time = stc_fs.get_peak(vert_as_index=True, time_as_index=True)\n",
+    "stc_peak = stc_fs.copy().crop(peak_time[1], peak_time[1])\n",
+    "\n",
+    "data_range = stc_avg.data  # or stc.data for the whole source estimate\n",
+    "\n",
+    "# Define thresholds based on percentiles or standard deviations\n",
+    "lower_thresh = np.percentile(data_range, 49)  # 10th percentile as lower bound\n",
+    "mid_thresh = np.percentile(data_range, 74)  # Mean as midpoint\n",
+    "upper_thresh = np.percentile(data_range, 99)  # 99th percentile as upper bound\n",
+    "\n",
+    "\n",
+    "# Plot source estimate as a heatmap on the cortex\n",
+    "brain = stc_fs.plot(hemi='split', subject='fsaverage',\n",
+    "                     subjects_dir='/home/anujanegi/tj/bdsg/freesurfer/subjects', time_label='Average activation',\n",
+    "                     colormap='Blues', smoothing_steps=1, surface='flat', size=(500, 800), background=\"w\", colorbar=False, time_viewer=False,\n",
+    "    show_traces=False,)\n",
+    "\n",
+    "# brain = stc_fs.plot(\n",
+    "#     # views=[\"lat\", \"medial\"],\n",
+    "#     # hemi=\"split\" if len(HEMISPHERES) > 1 else HEMISPHERES[0],\n",
+    "#     hemi=\"both\",\n",
+    "#     size=(500, 800),\n",
+    "#     background=\"w\",\n",
+    "#     # clim=\"auto\",\n",
+    "#     colorbar=False,\n",
+    "#     # colormap=\"inferno\",\n",
+    "#     time_viewer=False,\n",
+    "#     show_traces=False,\n",
+    "#     surface=\"flat\",\n",
+    "#     cortex=\"classic\",\n",
+    "#     # volume_options=dict(resolution=1),\n",
+    "#     view_layout=\"horizontal\",\n",
+    "# )\n",
+    "\n",
+    "\n",
+    "for i_hemi, hemi in enumerate(['lh', 'rh']):\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc.lh_data if hemi == \"lh\" else stc.rh_data\n",
+    "    for k in range(len(stc.vertices[i_hemi])):\n",
+    "        activation_idx = stc.vertices[i_hemi][k]\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "        # In milliseconds\n",
+    "        # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "        brain.add_foci(foci_coords, hemi=hemi, color='red', alpha=1)\n",
+    "\n",
+    "# for i_hemi, hemi in enumerate(['lh', 'rh']):\n",
+    "#     surface_coords = brain.geo[hemi].coords\n",
+    "#     hemi_data = stc_hat.lh_data if hemi == \"lh\" else stc_hat.rh_data\n",
+    "#     for k in range(len(stc_hat.vertices[i_hemi])):\n",
+    "        \n",
+    "#         activation_idx = stc_hat.vertices[i_hemi][k]\n",
+    "#         foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "#         # In milliseconds\n",
+    "#         # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "#         brain.add_foci(foci_coords, hemi=hemi, color='Blue', alpha=.9)\n",
+    "\n",
+    "# screenshot = brain.screenshot()\n",
+    "from matplotlib.colors import Normalize\n",
+    "from matplotlib.cm import get_cmap, get\n",
+    "colormap = get_cmap(\"Blues\")  # Use \"Blues\" for reconstructed data\n",
+    "norm = Normalize(vmin=np.min(np.abs(stc_hat.data)), vmax=np.max(np.abs(stc_hat.data)))\n",
+    "\n",
+    "for i_hemi, hemi in enumerate([\"lh\", \"rh\"]):\n",
+    "    # Get hemisphere-specific data\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc_hat.lh_data if hemi == \"lh\" else stc_hat.rh_data\n",
+    "\n",
+    "    for k in range(len(stc_hat.vertices[i_hemi])):\n",
+    "        # Get vertex index and activation strength\n",
+    "        activation_idx = stc_hat.vertices[i_hemi][k]\n",
+    "        strength = np.abs(hemi_data[k])  # Get the amplitude (strength)\n",
+    "\n",
+    "        # Get focus coordinates and color based on strength\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "        color = colormap(norm(max(strength)))  # Map strength to color using colormap\n",
+    "        color = tuple(map(float, color[:3]))\n",
+    "\n",
+    "        # Add foci with computed color\n",
+    "        brain.add_foci(foci_coords, hemi=hemi, color=color, alpha=0.9)\n",
+    "\n",
+    "\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mpl_toolkits.axes_grid1 import make_axes_locatable, ImageGrid, inset_locator\n",
+    "\n",
+    "import mne\n",
+    "nonwhite_pix = (screenshot != 255).any(-1)\n",
+    "nonwhite_row = nonwhite_pix.any(1)\n",
+    "nonwhite_col = nonwhite_pix.any(0)\n",
+    "cropped_screenshot = screenshot[nonwhite_row][:, nonwhite_col]\n",
+    "\n",
+    "# plot screenshot\n",
+    "fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "# ax.imshow(screenshot)\n",
+    "# no ticks and graph borders\n",
+    "ax.set_xticks([])\n",
+    "ax.set_yticks([])\n",
+    "ax.spines[\"top\"].set_visible(False)\n",
+    "ax.spines[\"right\"].set_visible(False)\n",
+    "ax.spines[\"bottom\"].set_visible(False)\n",
+    "ax.spines[\"left\"].set_visible(False)\n",
+    "\n",
+    "ax.imshow(cropped_screenshot)\n",
+    "# save in high quality with transparent background\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/brain.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/recon source.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "\n",
+    "from bsi_zoo.metrics import emd, reconstructed_noise\n",
+    "e = emd(x, x_hat, 'fixed', subject)\n",
+    "print('EMD:', e)\n",
+    "\n",
+    "r = reconstructed_noise(x, x_hat, 'fixed', y=y, L=L)\n",
+    "print('reconstructed_noise:', r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "6783fd16",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAABACAYAAABsv8+/AAAAFHRFWHRUaXRsZQBCbHVlcyBjb2xvcm1hcIbbCAEAAAAadEVYdERlc2NyaXB0aW9uAEJsdWVzIGNvbG9ybWFweISh5wAAADB0RVh0QXV0aG9yAE1hdHBsb3RsaWIgdjMuNC4yLCBodHRwczovL21hdHBsb3RsaWIub3JnrNZj3QAAADJ0RVh0U29mdHdhcmUATWF0cGxvdGxpYiB2My40LjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmeCcPz6AAAB00lEQVR4nO3WwU7rMAAAQcP//y8HpIQDJQi3Vopa3uHtzCVynDhxCdK+vL3v+xhj7J+HcTmMy+E4P47x7fnjqgfnp8ct57/Xe2z+3v397/Pz77ON+XvYfze/OP81vn/+9ntuV+89z6/2d1l/Hh/X397fdhwX+5zWOV3/5Pz8HqfXLe9fvN/8+yzuv/p7zPNX+zj5Ts6et1pvsY9717v6bk72cz4+2df2rOf87rmPr/vzH281f+91z1rnr5439u3rhp/jbRqvrnv6+F8953P8OgCAHAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIOgDfCcYQIPsTRMAAAAASUVORK5CYII=",
+      "text/html": [
+       "<div style=\"vertical-align: middle;\"><strong>Blues</strong> </div><div class=\"cmap\"><img alt=\"Blues colormap\" title=\"Blues\" style=\"border: 1px solid #555;\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAgAAAABACAYAAABsv8+/AAAAFHRFWHRUaXRsZQBCbHVlcyBjb2xvcm1hcIbbCAEAAAAadEVYdERlc2NyaXB0aW9uAEJsdWVzIGNvbG9ybWFweISh5wAAADB0RVh0QXV0aG9yAE1hdHBsb3RsaWIgdjMuNC4yLCBodHRwczovL21hdHBsb3RsaWIub3JnrNZj3QAAADJ0RVh0U29mdHdhcmUATWF0cGxvdGxpYiB2My40LjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmeCcPz6AAAB00lEQVR4nO3WwU7rMAAAQcP//y8HpIQDJQi3Vopa3uHtzCVynDhxCdK+vL3v+xhj7J+HcTmMy+E4P47x7fnjqgfnp8ct57/Xe2z+3v397/Pz77ON+XvYfze/OP81vn/+9ntuV+89z6/2d1l/Hh/X397fdhwX+5zWOV3/5Pz8HqfXLe9fvN/8+yzuv/p7zPNX+zj5Ts6et1pvsY9717v6bk72cz4+2df2rOf87rmPr/vzH281f+91z1rnr5439u3rhp/jbRqvrnv6+F8953P8OgCAHAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIEgAAECQAACAIAEAAEECAACCBAAABAkAAAgSAAAQJAAAIOgDfCcYQIPsTRMAAAAASUVORK5CYII=\"></div><div style=\"vertical-align: middle; max-width: 514px; display: flex; justify-content: space-between;\"><div style=\"float: left;\"><div title=\"#f7fbffff\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #f7fbffff;\"></div> under</div><div style=\"margin: 0 auto; display: inline-block;\">bad <div title=\"#00000000\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #00000000;\"></div></div><div style=\"float: right;\">over <div title=\"#08306bff\" style=\"display: inline-block; width: 1em; height: 1em; margin: 0; vertical-align: middle; border: 1px solid #555; background-color: #08306bff;\"></div></div>"
+      ],
+      "text/plain": [
+       "<matplotlib.colors.LinearSegmentedColormap at 0x7fad8a26d970>"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "colormap"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "18434801",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.sub_cmap.<locals>.<lambda>(v)>"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def sub_cmap(cmap, vmin, vmax):\n",
+    "    return lambda v: cmap(vmin + (vmax - vmin) * v)\n",
+    "\n",
+    "cmap = get_cmap('Blues') # Get your favorite cmap\n",
+    "new_cmap = sub_cmap(cmap, 0.2, 0.9)\n",
+    "new_cmap\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "de466228",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting cmasher\n",
+      "  Downloading cmasher-1.8.0-py3-none-any.whl (533 kB)\n",
+      "\u001b[K     |████████████████████████████████| 533 kB 539 kB/s eta 0:00:01\n",
+      "\u001b[?25hCollecting matplotlib>=3.5\n",
+      "  Downloading matplotlib-3.9.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (8.3 MB)\n",
+      "\u001b[K     |████████████████████████████████| 8.3 MB 2.4 MB/s eta 0:00:01\n",
+      "\u001b[?25hRequirement already satisfied: numpy>=1.19.3 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from cmasher) (1.20.3)\n",
+      "Collecting colorspacious>=1.1.0\n",
+      "  Downloading colorspacious-1.1.2-py2.py3-none-any.whl (37 kB)\n",
+      "Requirement already satisfied: kiwisolver>=1.3.1 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from matplotlib>=3.5->cmasher) (1.4.4)\n",
+      "Requirement already satisfied: pyparsing>=2.3.1 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from matplotlib>=3.5->cmasher) (3.0.9)\n",
+      "Requirement already satisfied: fonttools>=4.22.0 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from matplotlib>=3.5->cmasher) (4.25.0)\n",
+      "Requirement already satisfied: cycler>=0.10 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from matplotlib>=3.5->cmasher) (0.11.0)\n",
+      "Requirement already satisfied: python-dateutil>=2.7 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from matplotlib>=3.5->cmasher) (2.8.2)\n",
+      "Collecting numpy>=1.19.3\n",
+      "  Downloading numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (19.5 MB)\n",
+      "\u001b[K     |████████████████████████████████| 19.5 MB 797 kB/s eta 0:00:01\n",
+      "\u001b[?25hRequirement already satisfied: packaging>=20.0 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from matplotlib>=3.5->cmasher) (23.0)\n",
+      "Collecting importlib-resources>=3.2.0\n",
+      "  Downloading importlib_resources-6.4.5-py3-none-any.whl (36 kB)\n",
+      "Collecting contourpy>=1.0.1\n",
+      "  Downloading contourpy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (321 kB)\n",
+      "\u001b[K     |████████████████████████████████| 321 kB 2.6 MB/s eta 0:00:01\n",
+      "\u001b[?25hRequirement already satisfied: pillow>=8 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from matplotlib>=3.5->cmasher) (8.2.0)\n",
+      "Requirement already satisfied: zipp>=3.1.0 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib>=3.5->cmasher) (3.11.0)\n",
+      "Requirement already satisfied: six>=1.5 in /home/anujanegi/anaconda3/envs/mne/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib>=3.5->cmasher) (1.16.0)\n",
+      "Installing collected packages: numpy, importlib-resources, contourpy, matplotlib, colorspacious, cmasher\n",
+      "  Attempting uninstall: numpy\n",
+      "    Found existing installation: numpy 1.20.3\n",
+      "    Uninstalling numpy-1.20.3:\n",
+      "      Successfully uninstalled numpy-1.20.3\n",
+      "  Attempting uninstall: matplotlib\n",
+      "    Found existing installation: matplotlib 3.4.2\n",
+      "    Uninstalling matplotlib-3.4.2:\n",
+      "      Successfully uninstalled matplotlib-3.4.2\n",
+      "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "scipy 1.6.3 requires numpy<1.23.0,>=1.16.5, but you have numpy 2.0.2 which is incompatible.\u001b[0m\n",
+      "Successfully installed cmasher-1.8.0 colorspacious-1.1.2 contourpy-1.3.0 importlib-resources-6.4.5 matplotlib-3.9.2 numpy-2.0.2\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install cmasher"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13d3f167",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_hat = iterative_L1(L,  y, alpha=0.0001, n_orient=1)\n",
+    "\n",
+    "fwd_fname = \"bsi_zoo/tests/data/%s-fwd.fif\"%subject\n",
+    "fwd = read_forward_solution(fwd_fname)\n",
+    "fwd = mne.convert_forward_solution(fwd, force_fixed=True)\n",
+    "active_set = np.linalg.norm(x, axis=1) != 0\n",
+    "\n",
+    " # check if no vertices are estimated\n",
+    "temp = np.linalg.norm(x_hat, axis=1)\n",
+    "if len(np.unique(temp))==1:\n",
+    "    print(\"No vertices estimated!\")\n",
+    "\n",
+    "temp_ = np.partition(-temp, nnz)\n",
+    "max_temp = -temp_[:nnz] #get n(=nnz) max amplitudes \n",
+    "\n",
+    "# remove 0 from list incase less vertices than nnz were estimated\n",
+    "max_temp = np.delete(max_temp, np.where(max_temp==0.))\n",
+    "active_set_hat = np.array(list(map(max_temp.__contains__, temp)))\n",
+    "\n",
+    "stc = _make_sparse_stc(\n",
+    "    x[active_set], active_set, fwd, tmin=1, tstep=1\n",
+    ")  # ground truth\n",
+    "stc_hat = _make_sparse_stc(\n",
+    "    x_hat[active_set_hat], active_set_hat, fwd, tmin=1, tstep=1\n",
+    ")  # estimate\n",
+    "\n",
+    "source_space = mne.read_source_spaces(fwd_fname)\n",
+    "            \n",
+    "             # Plot the STC, get the brain image, crop it:\n",
+    "brain = stc.plot(\n",
+    "    views=[\"lat\", \"medial\"],\n",
+    "    # hemi=\"split\" if len(HEMISPHERES) > 1 else HEMISPHERES[0],\n",
+    "    hemi=\"lh\",\n",
+    "    size=(500, 800),\n",
+    "    background=\"w\",\n",
+    "    # clim=\"auto\",\n",
+    "    colorbar=False,\n",
+    "    colormap=\"inferno\",\n",
+    "    time_viewer=False,\n",
+    "    show_traces=False,\n",
+    "    surface=\"inflated\",\n",
+    "    cortex=\"classic\",\n",
+    "    # volume_options=dict(resolution=1),\n",
+    "    view_layout=\"horizontal\",\n",
+    ")\n",
+    "\n",
+    "for i_hemi, hemi in enumerate(['lh']):\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc.lh_data if hemi == \"lh\" else stc.rh_data\n",
+    "    for k in range(len(stc.vertices[i_hemi])):\n",
+    "        activation_idx = stc.vertices[i_hemi][k]\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "        # In milliseconds\n",
+    "        # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "        brain.add_foci(foci_coords, hemi=hemi, color='red', alpha=1)\n",
+    "\n",
+    "for i_hemi, hemi in enumerate(['lh']):\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc_hat.lh_data if hemi == \"lh\" else stc_hat.rh_data\n",
+    "    for k in range(len(stc_hat.vertices[i_hemi])):\n",
+    "        activation_idx = stc_hat.vertices[i_hemi][k]\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "        # In milliseconds\n",
+    "        # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "        brain.add_foci(foci_coords, hemi=hemi, color='blue', alpha=.9)\n",
+    "\n",
+    "screenshot = brain.screenshot()\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mpl_toolkits.axes_grid1 import make_axes_locatable, ImageGrid, inset_locator\n",
+    "\n",
+    "import mne\n",
+    "nonwhite_pix = (screenshot != 255).any(-1)\n",
+    "nonwhite_row = nonwhite_pix.any(1)\n",
+    "nonwhite_col = nonwhite_pix.any(0)\n",
+    "cropped_screenshot = screenshot[nonwhite_row][:, nonwhite_col]\n",
+    "\n",
+    "# plot screenshot\n",
+    "fig, ax = plt.subplots(figsize=(10, 20))\n",
+    "# ax.imshow(screenshot)\n",
+    "# no ticks and graph borders\n",
+    "ax.set_xticks([])\n",
+    "ax.set_yticks([])\n",
+    "ax.spines[\"top\"].set_visible(False)\n",
+    "ax.spines[\"right\"].set_visible(False)\n",
+    "ax.spines[\"bottom\"].set_visible(False)\n",
+    "ax.spines[\"left\"].set_visible(False)\n",
+    "\n",
+    "ax.imshow(screenshot)\n",
+    "# save in high quality with transparent background\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/brain.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/recon source.png\", dpi=300, bbox_inches=\"tight\", transparent=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1fb6c94d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_hat = eloreta(L,  y, alpha=0.01, n_orient=1)\n",
+    "\n",
+    "fwd_fname = \"bsi_zoo/tests/data/%s-fwd.fif\"%subject\n",
+    "fwd = read_forward_solution(fwd_fname)\n",
+    "fwd = mne.convert_forward_solution(fwd, force_fixed=True)\n",
+    "active_set = np.linalg.norm(x, axis=1) != 0\n",
+    "\n",
+    " # check if no vertices are estimated\n",
+    "temp = np.linalg.norm(x_hat, axis=1)\n",
+    "if len(np.unique(temp))==1:\n",
+    "    print(\"No vertices estimated!\")\n",
+    "\n",
+    "temp_ = np.partition(-temp, nnz)\n",
+    "max_temp = -temp_[:10] #plot top 10 for dense method\n",
+    "\n",
+    "# remove 0 from list incase less vertices than nnz were estimated\n",
+    "max_temp = np.delete(max_temp, np.where(max_temp==0.))\n",
+    "active_set_hat = np.array(list(map(max_temp.__contains__, temp)))\n",
+    "\n",
+    "\n",
+    "stc = _make_sparse_stc(\n",
+    "    x[active_set], active_set, fwd, tmin=1, tstep=1\n",
+    ")  # ground truth\n",
+    "stc_hat = _make_sparse_stc(\n",
+    "    x_hat[active_set_hat], active_set_hat, fwd, tmin=1, tstep=1\n",
+    ")  # estimate\n",
+    "\n",
+    "source_space = mne.read_source_spaces(fwd_fname)\n",
+    "            \n",
+    "             # Plot the STC, get the brain image, crop it:\n",
+    "brain = stc.plot(\n",
+    "    views=[\"lat\", \"medial\"],\n",
+    "    # hemi=\"split\" if len(HEMISPHERES) > 1 else HEMISPHERES[0],\n",
+    "    hemi=\"lh\",\n",
+    "    size=(500, 800),\n",
+    "    background=\"w\",\n",
+    "    # clim=\"auto\",\n",
+    "    colorbar=False,\n",
+    "    colormap=\"inferno\",\n",
+    "    time_viewer=False,\n",
+    "    show_traces=False,\n",
+    "    surface=\"inflated\",\n",
+    "    cortex=\"classic\",\n",
+    "    # volume_options=dict(resolution=1),\n",
+    "    view_layout=\"horizontal\",\n",
+    ")\n",
+    "\n",
+    "for i_hemi, hemi in enumerate(['lh']):\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc.lh_data if hemi == \"lh\" else stc.rh_data\n",
+    "    for k in range(len(stc.vertices[i_hemi])):\n",
+    "        activation_idx = stc.vertices[i_hemi][k]\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "        # In milliseconds\n",
+    "        # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "        brain.add_foci(foci_coords, hemi=hemi, color='red', alpha=1)\n",
+    "\n",
+    "for i_hemi, hemi in enumerate(['lh']):\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc_hat.lh_data if hemi == \"lh\" else stc_hat.rh_data\n",
+    "    for k in range(len(stc_hat.vertices[i_hemi])):\n",
+    "        activation_idx = stc_hat.vertices[i_hemi][k]\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "        # In milliseconds\n",
+    "        # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "        brain.add_foci(foci_coords, hemi=hemi, color='blue', alpha=.9)\n",
+    "\n",
+    "screenshot = brain.screenshot()\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mpl_toolkits.axes_grid1 import make_axes_locatable, ImageGrid, inset_locator\n",
+    "\n",
+    "import mne\n",
+    "nonwhite_pix = (screenshot != 255).any(-1)\n",
+    "nonwhite_row = nonwhite_pix.any(1)\n",
+    "nonwhite_col = nonwhite_pix.any(0)\n",
+    "cropped_screenshot = screenshot[nonwhite_row][:, nonwhite_col]\n",
+    "\n",
+    "# plot screenshot\n",
+    "fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "# ax.imshow(screenshot)\n",
+    "# no ticks and graph borders\n",
+    "ax.set_xticks([])\n",
+    "ax.set_yticks([])\n",
+    "ax.spines[\"top\"].set_visible(False)\n",
+    "ax.spines[\"right\"].set_visible(False)\n",
+    "ax.spines[\"bottom\"].set_visible(False)\n",
+    "ax.spines[\"left\"].set_visible(False)\n",
+    "\n",
+    "ax.imshow(cropped_screenshot)\n",
+    "# save in high quality with transparent background\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/brain.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/recon source.png\", dpi=300, bbox_inches=\"tight\", transparent=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2274ff7f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_hat = gamma_map(L,  y, alpha=0.01, n_orient=1, max_iter=16)\n",
+    "\n",
+    "fwd_fname = \"bsi_zoo/tests/data/%s-fwd.fif\"%subject\n",
+    "fwd = read_forward_solution(fwd_fname)\n",
+    "fwd = mne.convert_forward_solution(fwd, force_fixed=True)\n",
+    "active_set = np.linalg.norm(x, axis=1) != 0\n",
+    "\n",
+    " # check if no vertices are estimated\n",
+    "temp = np.linalg.norm(x_hat, axis=1)\n",
+    "if len(np.unique(temp))==1:\n",
+    "    print(\"No vertices estimated!\")\n",
+    "\n",
+    "temp_ = np.partition(-temp, nnz)\n",
+    "max_temp = -temp_[:nnz]\n",
+    "\n",
+    "# remove 0 from list incase less vertices than nnz were estimated\n",
+    "max_temp = np.delete(max_temp, np.where(max_temp==0.))\n",
+    "active_set_hat = np.array(list(map(max_temp.__contains__, temp)))\n",
+    "\n",
+    "\n",
+    "stc = _make_sparse_stc(\n",
+    "    x[active_set], active_set, fwd, tmin=1, tstep=1\n",
+    ")  # ground truth\n",
+    "stc_hat = _make_sparse_stc(\n",
+    "    x_hat[active_set_hat], active_set_hat, fwd, tmin=1, tstep=1\n",
+    ")  # estimate\n",
+    "\n",
+    "source_space = mne.read_source_spaces(fwd_fname)\n",
+    "            \n",
+    "             # Plot the STC, get the brain image, crop it:\n",
+    "brain = stc.plot(\n",
+    "    views=[\"lat\", \"medial\"],\n",
+    "    # hemi=\"split\" if len(HEMISPHERES) > 1 else HEMISPHERES[0],\n",
+    "    hemi=\"lh\",\n",
+    "    size=(500, 800),\n",
+    "    background=\"w\",\n",
+    "    # clim=\"auto\",\n",
+    "    colorbar=False,\n",
+    "    colormap=\"inferno\",\n",
+    "    time_viewer=False,\n",
+    "    show_traces=False,\n",
+    "    surface=\"inflated\",\n",
+    "    cortex=\"classic\",\n",
+    "    # volume_options=dict(resolution=1),\n",
+    "    view_layout=\"horizontal\",\n",
+    ")\n",
+    "\n",
+    "for i_hemi, hemi in enumerate(['lh']):\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc.lh_data if hemi == \"lh\" else stc.rh_data\n",
+    "    for k in range(len(stc.vertices[i_hemi])):\n",
+    "        activation_idx = stc.vertices[i_hemi][k]\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "        # In milliseconds\n",
+    "        # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "        \n",
+    "        brain.add_foci(foci_coords, hemi=hemi, color='blue', alpha=1)\n",
+    "\n",
+    "for i_hemi, hemi in enumerate(['lh']):\n",
+    "    surface_coords = brain.geo[hemi].coords\n",
+    "    hemi_data = stc_hat.lh_data if hemi == \"lh\" else stc_hat.rh_data\n",
+    "    for k in range(len(stc_hat.vertices[i_hemi])):\n",
+    "        activation_idx = stc_hat.vertices[i_hemi][k]\n",
+    "        foci_coords = surface_coords[activation_idx]\n",
+    "\n",
+    "        # In milliseconds\n",
+    "        # (line,) = ax.plot(stc.times * 1e3, 1e9 * hemi_data[k], '--', color=color, label=label)\n",
+    "        # brain.add_foci(foci_coords, hemi=hemi, color='blue', alpha=.9)\n",
+    "\n",
+    "screenshot = brain.screenshot()\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mpl_toolkits.axes_grid1 import make_axes_locatable, ImageGrid, inset_locator\n",
+    "\n",
+    "import mne\n",
+    "nonwhite_pix = (screenshot != 255).any(-1)\n",
+    "nonwhite_row = nonwhite_pix.any(1)\n",
+    "nonwhite_col = nonwhite_pix.any(0)\n",
+    "cropped_screenshot = screenshot[nonwhite_row][:, nonwhite_col]\n",
+    "\n",
+    "# plot screenshot\n",
+    "fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "# ax.imshow(screenshot)\n",
+    "# no ticks and graph borders\n",
+    "ax.set_xticks([])\n",
+    "ax.set_yticks([])\n",
+    "ax.spines[\"top\"].set_visible(False)\n",
+    "ax.spines[\"right\"].set_visible(False)\n",
+    "ax.spines[\"bottom\"].set_visible(False)\n",
+    "ax.spines[\"left\"].set_visible(False)\n",
+    "\n",
+    "ax.imshow(cropped_screenshot)\n",
+    "# save in high quality with transparent background\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/brain.png\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
+    "# fig.savefig(\"./bsi_zoo/data/figs/recon source.png\", dpi=300, bbox_inches=\"tight\", transparent=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f42fffc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for free orientation the active set needs to diminised to the same shape of fixed\n",
+    "for subject in SUBJECTS:\n",
+    "    for solver in SOLVER_NAMES:\n",
+    "            print('-'*30)\n",
+    "            print('Making figures for %s method for subject %s...'%(solver.replace('_', ' '), subject))\n",
+    "            print('-'*30)\n",
+    "            \n",
+    "            x = np.load(os.path.join(PATH_TO_ESTIMATES, subject, solver+'_x_10.npy'))\n",
+    "            x_hat = np.load(os.path.join(PATH_TO_ESTIMATES, subject, solver+'_x_hat_10.npy'))\n",
+    "\n",
+    "            fwd_fname = \"bsi_zoo/tests/data/%s-fwd.fif\"%subject\n",
+    "            fwd = read_forward_solution(fwd_fname)\n",
+    "            fwd = mne.convert_forward_solution(fwd, force_fixed=True)\n",
+    "            active_set = np.linalg.norm(x, axis=1) != 0\n",
+    "            \n",
+    "            # check if no vertices are estimated\n",
+    "            temp = np.linalg.norm(x_hat, axis=1)\n",
+    "            if len(np.unique(temp))==1:\n",
+    "                print(\"No vertices estimated!\")\n",
+    "                continue\n",
+    "            \n",
+    "            temp_ = np.partition(-temp, nnz)\n",
+    "            max_temp = -temp_[:nnz] #get n(=nnz) max amplitudes \n",
+    "\n",
+    "            # remove 0 from list incase less vertices than nnz were estimated\n",
+    "            max_temp = np.delete(max_temp, np.where(max_temp==0.))\n",
+    "            active_set_hat = np.array(list(map(max_temp.__contains__, temp)))\n",
+    "\n",
+    "            stc = _make_sparse_stc(\n",
+    "                x[active_set], active_set, fwd, tmin=1, tstep=1\n",
+    "            )  # ground truth\n",
+    "            stc_hat = _make_sparse_stc(\n",
+    "                x_hat[active_set_hat], active_set_hat, fwd, tmin=1, tstep=1\n",
+    "            )  # estimate\n",
+    "            \n",
+    "            source_space = mne.read_source_spaces(fwd_fname)\n",
+    "            \n",
+    "             # Plot the STC, get the brain image, crop it:\n",
+    "            brain = stc.plot(\n",
+    "                views=[\"lat\", \"med\"],\n",
+    "                hemi=\"split\" if len(HEMISPHERES) > 1 else HEMISPHERES[0],\n",
+    "                size=(500, 250),\n",
+    "                background=\"w\",\n",
+    "                clim=\"auto\",\n",
+    "                colorbar=False,\n",
+    "                colormap=\"inferno\",\n",
+    "                time_viewer=False,\n",
+    "                show_traces=False,\n",
+    "                cortex=\"classic\",\n",
+    "                volume_options=dict(resolution=1),\n",
+    "            )\n",
+    "\n",
+    "            t = 10\n",
+    "            brain.set_time(t)\n",
+    "\n",
+    "            fig = plt.figure(figsize=(5.5, 5.5))\n",
+    "            axes = [\n",
+    "                plt.subplot2grid((9, 1), (0, 0), rowspan=4),\n",
+    "                plt.subplot2grid((9, 1), (4, 0), rowspan=3),\n",
+    "                plt.subplot2grid((9, 1), (7, 0), rowspan=1), #hacky spacing\n",
+    "                plt.subplot2grid((9, 1), (8, 0), rowspan=1), #metrics\n",
+    "            ]\n",
+    "\n",
+    "            add_foci_to_brain_surface(brain, stc, axes[1], color=(1, 0, 0), label='Ground Truth') #red\n",
+    "            add_foci_to_brain_surface(brain, stc_hat, axes[1], color=(0, 0, 1), label='Estimate') #blue\n",
+    "\n",
+    "            screenshot = brain.screenshot()\n",
+    "\n",
+    "            nonwhite_pix = (screenshot != 255).any(-1)\n",
+    "            nonwhite_row = nonwhite_pix.any(1)\n",
+    "            nonwhite_col = nonwhite_pix.any(0)\n",
+    "\n",
+    "            # Add blank columns for margin\n",
+    "            nonwhite_col = add_margin(nonwhite_col)\n",
+    "\n",
+    "            cropped_screenshot = screenshot[nonwhite_row][:, nonwhite_col]\n",
+    "\n",
+    "            brain_idx = 0\n",
+    "            spacing_idx = 2 \n",
+    "            metrics_idx = 3\n",
+    "\n",
+    "            axes[brain_idx].imshow(cropped_screenshot)\n",
+    "            axes[brain_idx].axis(\"off\")\n",
+    "            \n",
+    "            axes[spacing_idx].axis(\"off\")\n",
+    "            \n",
+    "            axes[metrics_idx].axis(\"off\")\n",
+    "            # get metrics\n",
+    "            recall, emd, hammingloss, jaccard = metrics(fwd, stc, stc_hat)\n",
+    "            axes[metrics_idx].text(0.01, 0.5, 'Recall: %.2f  EMD: %.2e \\nHamming Loss: %.2e  Jaccard Score: %.2e'%(recall, emd, hammingloss, jaccard),\n",
+    "                                   bbox=dict(facecolor='grey', alpha=0.1))\n",
+    "            \n",
+    "            fig.subplots_adjust(left=0.3, right=0.9, bottom=0.15, top=0.9, wspace=0.1,\n",
+    "                    hspace=0.2)\n",
+    "\n",
+    "            fig.tight_layout()\n",
+    "            \n",
+    "            fig.savefig(os.path.join(PATH_TO_SAVE_FIGURES,'%s_%s.svg'%(solver, subject)))\n",
+    "            brain.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "472fe1e6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ca112d6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#             plot_sparse_source_estimates(\n",
+    "#                 source_space, [stc, stc_hat], bgcolor=(1, 1, 1),\n",
+    "#                 fig_name=solver, opacity=0.1, colors=['r','b']\n",
+    "#             )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1770bf6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#             brain = mne.viz.Brain(\n",
+    "#                 subject_id=subject,\n",
+    "#                 views=[\"lat\", \"med\"],\n",
+    "# #                 views=[\"lat\"],\n",
+    "#                 hemi=\"split\" if len(HEMISPHERES) > 1 else HEMISPHERES[0],\n",
+    "#                 size=(500, 250),\n",
+    "#                 # size=(500, 500),\n",
+    "#                 background=\"w\",\n",
+    "#                 surf='inflated',\n",
+    "#                 cortex=\"classic\",\n",
+    "#                 show_toolbar=True\n",
+    "#             )\n",
+    "\n",
+    "#             brain.add_text(34, 50,'dsd',name='dsdsadsadasdaa', row=0, col=0)\n",
+    "#             fig, ax = plt.subplots(1, 1)\n",
+    "#             add_foci_to_brain_surface(brain, stc, ax, color=(1, 0, 0), label='Ground Truth') #red\n",
+    "#             add_foci_to_brain_surface(brain, stc_hat, ax, color=(0, 0, 1), label='Estimate') #blue\n",
+    "#             fig.suptitle('Solver: %s'%solver)\n",
+    "#             plt.savefig(os.path.join(PATH_TO_SAVE_FIGURES, '%s_%s.jpg'%(solver, subject)))\n",
+    "#             brain.save_image(os.path.join(PATH_TO_SAVE_FIGURES, '%s_%s.png'%(solver, subject)))\n",
+    "#             brain.close()"
+   ]
+  }
+ ],
+ "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.9.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}