{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d7082351-486c-4176-89ce-099d81338dbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we defined a union mask created based on taking the max correlation from ses-01 and ses-02 reliability thresholds with ses-03, then taking the union between the two masks to apply to ses-03\n",
    "# the goal was to hopefully capture most of the reliable voxels from ses-03 just based on ses-01 and ses-02\n",
    "# here we would like to check how many of the reliable voxels calculated based on ses-03 are captured by the union mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1d5912cd-b16d-4a65-9bbe-bba47e53fb90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "importing modules\n",
      "SLURM seed not found, using default: 0\n"
     ]
    }
   ],
   "source": [
    "print(\"importing modules\")\n",
    "import os\n",
    "import sys\n",
    "import json\n",
    "import argparse\n",
    "import numpy as np\n",
    "import time\n",
    "import random\n",
    "import string\n",
    "import h5py\n",
    "from tqdm import tqdm\n",
    "import webdataset as wds\n",
    "from PIL import Image\n",
    "import pandas as pd\n",
    "import nibabel as nib\n",
    "import nilearn\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torchvision import transforms\n",
    "\n",
    "# tf32 data type is faster than standard float32\n",
    "torch.backends.cuda.matmul.allow_tf32 = True\n",
    "\n",
    "import utils\n",
    "from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas\n",
    "\n",
    "# imports utils from mindeye_preproc as \"preproc\"\n",
    "import importlib.util\n",
    "parent_utils_path = \"/home/ri4541/mindeye_preproc/analysis/utils.py\"\n",
    "spec = importlib.util.spec_from_file_location(\"utils\", parent_utils_path)\n",
    "preproc = importlib.util.module_from_spec(spec)\n",
    "parent_dir = os.path.dirname(parent_utils_path)\n",
    "if parent_dir not in sys.path:\n",
    "    sys.path.append(parent_dir)\n",
    "spec.loader.exec_module(preproc)\n",
    "\n",
    "if utils.is_interactive():\n",
    "    from IPython.display import clear_output # function to clear print outputs in cell\n",
    "    %load_ext autoreload \n",
    "    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n",
    "    %autoreload 2 \n",
    "    \n",
    "seed = utils.get_slurm_seed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0e1be91e-2922-4f2c-97e1-1a2cae9b153c",
   "metadata": {},
   "outputs": [],
   "source": [
    "if utils.is_interactive():\n",
    "    sub = \"sub-005\"\n",
    "    session = \"ses-03\"\n",
    "    task = 'C'  # 'study' or 'A'; used to search for functional run in bids format\n",
    "    func_task_name = 'C'  # 'study' or 'A'; used to search for functional run in bids format\n",
    "else:\n",
    "    sub = os.environ[\"sub\"]\n",
    "    session = os.environ[\"session\"]\n",
    "    task = os.environ[\"task\"]\n",
    "\n",
    "if session == \"all\":\n",
    "    ses_list = [\"ses-01\", \"ses-02\", \"ses-03\"]  # list of actual session IDs\n",
    "    design_ses_list = [\"ses-01\", \"ses-02\", \"ses-03\"]  # list of session IDs to search for design matrix\n",
    "else:\n",
    "    ses_list = [session]\n",
    "    design_ses_list = [session]\n",
    "    \n",
    "task_name = f\"_task-{task}\" if task != 'study' else ''\n",
    "resample_voxel_size = False\n",
    "resample_post_glmsingle = False  # do you want to do voxel resampling here? if resample_voxel_size = True and resample_post_glmsingle = False, assume the resampling has been done prior to GLMsingle, so just use resampled directory but otherwise proceed as normal\n",
    "load_from_resampled_file = False  # do you want to load resampled data from file? if True, assume resampling was done in this notebook before, and that we're not using the GLMsingle resampled data\n",
    "    \n",
    "train_test_split = 'MST' # 'MST', 'orig', 'unique'\n",
    "remove_close_to_MST = False\n",
    "remove_random_n = False\n",
    "\n",
    "if remove_close_to_MST or remove_random_n:\n",
    "    assert remove_close_to_MST != remove_random_n  # don't remove both sets of images\n",
    "\n",
    "n_to_remove = 0\n",
    "if remove_random_n:\n",
    "    assert train_test_split == 'MST'  # MST images are excluded from the n images removed, so only makes sense if they're not in the training set\n",
    "    n_to_remove = 150\n",
    "    \n",
    "if resample_voxel_size:\n",
    "    # voxel size was unchanged in glmsingle, want to perform resampling here\n",
    "    resampled_vox_size = 2.5\n",
    "    resample_method = \"sinc\"  # {trilinear,nearestneighbour,sinc,spline}, credit: https://johnmuschelli.com/fslr/reference/flirt.help.html\n",
    "    \n",
    "    # file name helper variables\n",
    "    vox_dim_str = str(resampled_vox_size).replace('.', '_')  # in case the voxel size has a decimal, replace with an underscore\n",
    "    resampled_suffix = f\"resampled_{vox_dim_str}mm_{resample_method}\"\n",
    "    mask_resampled_suffix = resampled_suffix\n",
    "    if resample_post_glmsingle:\n",
    "        resampled_suffix += '_postglmsingle'\n",
    "    else:\n",
    "        resampled_suffix += '_preglmsingle'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8a5af1bd-1a2b-4d1b-babd-aad5fad33b4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "session label: ses-03\n"
     ]
    }
   ],
   "source": [
    "session_label = preproc.get_session_label(ses_list)\n",
    "print('session label:', session_label)\n",
    "n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7f331b09-3bbe-425a-a276-08442aeb75d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-03_task-C\n",
      "glmsingle path exists!\n"
     ]
    }
   ],
   "source": [
    "if utils.is_interactive():\n",
    "    glmsingle_path = f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{session_label}_task-{task}\"\n",
    "else:\n",
    "    glmsingle_path = os.environ[\"glmsingle_path\"]\n",
    "    \n",
    "designdir = \"/home/ri4541/real_time_mindEye2\"\n",
    "print(glmsingle_path)\n",
    "\n",
    "if resample_voxel_size:\n",
    "    # option 1: we are using original (non-resampled) GLMsingle outputs and doing the resampling here\n",
    "    # option 2: doing resampling pre-GLMsingle and using those outputs; no resampling involved here\n",
    "    if resample_post_glmsingle:\n",
    "        # option 1\n",
    "        orig_glmsingle_path = glmsingle_path\n",
    "        glmsingle_path += f\"_{resampled_suffix}\"\n",
    "        print(\"resampled glmsingle path:\", glmsingle_path)\n",
    "        if load_from_resampled_file:\n",
    "            # resampling is already done; load from file\n",
    "             assert os.path.exists(glmsingle_path)  # the new directory must have been created if we reached here\n",
    "        else:\n",
    "            # don't load from file; do resampling here\n",
    "            os.makedirs(glmsingle_path,exist_ok=True)\n",
    "    else:\n",
    "        # option 2\n",
    "        glmsingle_path += f\"_{resampled_suffix}\"\n",
    "        print(\"glmsingle path:\", glmsingle_path)\n",
    "\n",
    "assert os.path.exists(glmsingle_path)\n",
    "print(\"glmsingle path exists!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e8d313d5-2d8e-44f8-a6c7-0562d8cbd81e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading brain mask\n",
      "Mask dimensions: (2.0, 2.0, 2.0)\n",
      "\n",
      "Affine:\n",
      "[[  2.           0.           0.         -76.29234314]\n",
      " [  0.           2.           0.         -84.79180908]\n",
      " [  0.           0.           2.         -62.80359268]\n",
      " [  0.           0.           0.           1.        ]]\n",
      "\n",
      "There are 180585 voxels in the included brain mask\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 660x350 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from nilearn.plotting import plot_roi\n",
    "assert sub == 'sub-005' and session == \"ses-03\"\n",
    "print('loading brain mask')\n",
    "# func_masks, avg_mask, nsd_masks, roi = utils.get_mask(['ses-01', 'ses-02', 'ses-03'], sub, func_task_name)\n",
    "final_brain = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')\n",
    "final_nsdgeneral = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_mask.nii.gz')\n",
    "\n",
    "# mask info\n",
    "dimsize=final_brain.header.get_zooms()\n",
    "affine_mat = final_brain.affine\n",
    "brain=final_brain.get_fdata()\n",
    "xyz=brain.shape #xyz dimensionality of brain mask and epi data\n",
    "\n",
    "print('Mask dimensions:', dimsize)\n",
    "print('')\n",
    "print('Affine:')\n",
    "print(affine_mat)\n",
    "print('')\n",
    "print(f'There are {int(np.sum(brain))} voxels in the included brain mask\\n')\n",
    "\n",
    "plot_roi(final_nsdgeneral, bg_img=final_brain)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9c666952-9463-45e5-bfae-b14240848b9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "union_mask = np.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_ses-01-02.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "82ded738-d92d-4cb1-988b-81777e4e88ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the union mask's shape is the same as the 1's in the final mask (which is the intersection of the nsdgeneral roi with all functional runs from ses-01, 02, 03\n",
    "assert final_nsdgeneral.get_fdata().sum() == union_mask.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f83ababd-9fc0-4dad-8b76-df18af3fefbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 660x350 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# since the union mask is a subset of the final mask, generate a nifti mask based on intersecting the union and final masks\n",
    "u = nilearn.masking.unmask(union_mask, final_nsdgeneral)\n",
    "plot_roi(u, bg_img=final_brain)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b0271aff-e1c7-45b3-9353-6fd694f682fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate ses-03 reliability mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1fdeedd9-fa90-404e-b873-e784626da375",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data shape: (780, 126)\n",
      "Using design file: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-03.csv\n",
      "Total number of images: 770\n",
      "Number of unique images: 532\n"
     ]
    }
   ],
   "source": [
    "data, starts, images, is_new_run, image_names, unique_images, len_unique_images = preproc.load_design_files(\n",
    "    sub=sub,\n",
    "    session=session,\n",
    "    func_task_name=task,\n",
    "    designdir=designdir,\n",
    "    design_ses_list=design_ses_list\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7eae315d-96e2-4b3a-add2-2e2c61331a23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data shape: (780, 126)\n",
      "Using design file: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-03.csv\n",
      "Total number of images: 770\n",
      "Number of unique images: 532\n",
      "n_runs 11\n",
      "['all_stimuli/unchosen_nsd_1000_images/unchosen_7211_cocoid_59250.png'\n",
      " 'all_stimuli/special515/special_67295.jpg'\n",
      " 'all_stimuli/unchosen_nsd_1000_images/unchosen_5729_cocoid_53029.png'\n",
      " 'all_stimuli/special515/special_70232.jpg']\n",
      "[174.7109683 178.7049172 182.7072832 186.7297016]\n",
      "[0. 0. 0. 0.]\n",
      "(693,)\n"
     ]
    }
   ],
   "source": [
    "data, starts, images, is_new_run, image_names, unique_images, len_unique_images = preproc.load_design_files(\n",
    "    sub=sub,\n",
    "    session=session,\n",
    "    func_task_name=task,\n",
    "    designdir=designdir,\n",
    "    design_ses_list=design_ses_list\n",
    ")\n",
    "\n",
    "if sub == 'sub-001':\n",
    "    if session == 'ses-01':\n",
    "        assert image_names[0] == 'images/image_686_seed_1.png'\n",
    "    elif session in ('ses-02', 'all'):\n",
    "        assert image_names[0] == 'all_stimuli/special515/special_40840.jpg'\n",
    "    elif session == 'ses-03':\n",
    "        assert image_names[0] == 'all_stimuli/special515/special_69839.jpg'\n",
    "    elif session == 'ses-04':\n",
    "        assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'\n",
    "elif sub == 'sub-003':\n",
    "    assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'\n",
    "\n",
    "unique_images = np.unique(image_names.astype(str))\n",
    "unique_images = unique_images[(unique_images!=\"nan\")]\n",
    "len_unique_images = len(unique_images)\n",
    "print(\"n_runs\",n_runs)\n",
    "\n",
    "if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):\n",
    "    assert len(unique_images) == 851\n",
    "\n",
    "print(image_names[:4])\n",
    "print(starts[:4])\n",
    "print(is_new_run[:4])\n",
    "\n",
    "if remove_random_n:\n",
    "    # want to remove 150 imgs\n",
    "    # 100 special515 imgs are repeated 3x (300 total)\n",
    "    # all other train imgs are only shown once (558 total)\n",
    "    # of the 150, want to sample proportionally since we're cutting all repeats for special515\n",
    "    # so take out 51 (17 unique) from special515 and 99 from rest = removing 150 total\n",
    "    np.random.seed(seed)\n",
    "    options_to_remove = [x for x in set(image_names) if str(x) != 'nan' and x != 'blank.jpg' and 'MST_pairs' not in x and 'special515' not in x and list(image_names).count(x)==1]  # all the imgs that only appear once (this is O(N^2) b/c of count() within list comprehension but image_names is a relatively small list)\n",
    "    options_to_remove_special515 = [x for x in set(image_names) if str(x) != 'nan' and x != 'blank.jpg' and 'MST_pairs' not in x and 'special515' in x and list(image_names).count(x)>1]  # all the special515 images that are repeated (count()>1 necessary because there are special515 that are not repeated)\n",
    "    imgs_to_remove = np.random.choice(options_to_remove, size=99, replace=False)\n",
    "    imgs_to_remove = np.append(imgs_to_remove, np.random.choice(options_to_remove_special515, size=17, replace=False))\n",
    "\n",
    "image_idx = np.array([])  # contains the unique index of each presented image\n",
    "vox_image_names = np.array([])  # contains the names of the images corresponding to image_idx\n",
    "all_MST_images = dict()\n",
    "for i, im in enumerate(image_names):\n",
    "    # skip if blank, nan\n",
    "    if im == \"blank.jpg\":\n",
    "        i+=1\n",
    "        continue\n",
    "    if str(im) == \"nan\":\n",
    "        i+=1\n",
    "        continue\n",
    "    vox_image_names = np.append(vox_image_names, im)\n",
    "    if remove_close_to_MST:  # optionally skip close_to_MST images \n",
    "        if \"closest_pairs\" in im:\n",
    "            i+=1\n",
    "            continue\n",
    "    elif remove_random_n:\n",
    "        if im in imgs_to_remove:\n",
    "            i+=1\n",
    "            continue\n",
    "            \n",
    "    image_idx_ = np.where(im==unique_images)[0].item()\n",
    "    image_idx = np.append(image_idx, image_idx_)\n",
    "    \n",
    "    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):  # MST images are ones that matched these image titles\n",
    "        import re\n",
    "        if ('w_' in im or 'paired_image_' in im or re.match(r'all_stimuli/rtmindeye_stimuli/\\d{1,2}_\\d{1,3}\\.png$', im) or re.match(r'images/\\d{1,2}_\\d{1,3}\\.png$', im)):  \n",
    "        # the regexp here looks for **_***.png, allows 1-2 chars before underscore and 1-3 chars after it\n",
    "            # print(im)\n",
    "            all_MST_images[i] = im\n",
    "            i+=1            \n",
    "    elif 'MST' in im:\n",
    "        all_MST_images[i] = im\n",
    "        i+=1\n",
    "    \n",
    "image_idx = torch.Tensor(image_idx).long()\n",
    "# for im in new_image_names[MST_images]:\n",
    "#     assert 'MST_pairs' in im\n",
    "# assert len(all_MST_images) == 300\n",
    "\n",
    "unique_MST_images = np.unique(list(all_MST_images.values())) \n",
    "\n",
    "MST_ID = np.array([], dtype=int)\n",
    "if remove_close_to_MST:\n",
    "    close_to_MST_idx = np.array([], dtype=int)\n",
    "if remove_random_n:\n",
    "    random_n_idx = np.array([], dtype=int)\n",
    "\n",
    "vox_idx = np.array([], dtype=int)\n",
    "j=0  # this is a counter keeping track of the remove_random_n used later to index vox based on the removed images; unused otherwise\n",
    "for i, im in enumerate(image_names):  # need unique_MST_images to be defined, so repeating the same loop structure\n",
    "    # skip if blank, nan\n",
    "    if im == \"blank.jpg\":\n",
    "        i+=1\n",
    "        continue\n",
    "    if str(im) == \"nan\":\n",
    "        i+=1\n",
    "        continue\n",
    "    if remove_close_to_MST:  # optionally skip close_to_MST images \n",
    "        if \"closest_pairs\" in im:\n",
    "            close_to_MST_idx = np.append(close_to_MST_idx, i)\n",
    "            i+=1\n",
    "            continue\n",
    "    if remove_random_n:\n",
    "        if im in imgs_to_remove:\n",
    "            vox_idx = np.append(vox_idx, j)\n",
    "            i+=1\n",
    "            j+=1\n",
    "            continue\n",
    "    j+=1\n",
    "    curr = np.where(im == unique_MST_images)\n",
    "    # print(curr)\n",
    "    if curr[0].size == 0:\n",
    "        MST_ID = np.append(MST_ID, np.array(len(unique_MST_images)))  # add a value that should be out of range based on the for loop, will index it out later\n",
    "    else:\n",
    "        MST_ID = np.append(MST_ID, curr)\n",
    "        \n",
    "assert len(MST_ID) == len(image_idx)\n",
    "# assert len(np.argwhere(pd.isna(data['current_image']))) + len(np.argwhere(data['current_image'] == 'blank.jpg')) + len(image_idx) == len(data)\n",
    "# MST_ID = torch.tensor(MST_ID[MST_ID != len(unique_MST_images)], dtype=torch.uint8)  # torch.tensor (lowercase) allows dtype kwarg, Tensor (uppercase) is an alias for torch.FloatTensor\n",
    "print(MST_ID.shape)\n",
    "if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):\n",
    "    assert len(all_MST_images) == 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "66228348-6f62-45a5-b0dc-83ac2fd36f86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vox (693, 1, 1, 183408)\n",
      "vox (693, 183408)\n"
     ]
    }
   ],
   "source": [
    "vox = None\n",
    "needs_postprocessing = False\n",
    "params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)\n",
    "\n",
    "if resample_post_glmsingle == True:\n",
    "    glm_save_path_resampled = f\"{glmsingle_path}/vox_resampled.nii.gz\"\n",
    "    if load_from_resampled_file == True:\n",
    "        # resampling was done in this notebook so we can load from file\n",
    "        vox = nib.load(glm_save_path_resampled)\n",
    "    else:\n",
    "        # do resampling here\n",
    "        assert os.path.exists(ref_name) and os.path.exists(omat_name), \"need to generate the boldref and omat separately since we don't have access to the functional data here; either do so using flirt on the command line or copy over the glmsingle resampled outputs\"\n",
    "        vox = load_preprocess_betas(orig_glmsingle_path, *params)\n",
    "        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)\n",
    "    needs_postprocessing = True\n",
    "\n",
    "if vox is None:\n",
    "    # either resampling was done in glmsingle or we aren't resampling \n",
    "    vox = load_preprocess_betas(glmsingle_path, *params)\n",
    "\n",
    "if needs_postprocessing == True:\n",
    "    vox = apply_mask(vox, final_brain)\n",
    "    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)\n",
    "    print(vox.shape)\n",
    "\n",
    "assert len(vox) == len(image_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ce741c64-721a-4136-b288-f2f5703469e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total voxels (whole brain) = 180585\n",
      "final_mask voxels = 19174\n"
     ]
    }
   ],
   "source": [
    "a = final_brain.get_fdata().flatten()\n",
    "print(f\"total voxels (whole brain) = {int(a.sum())}\")\n",
    "roi = final_nsdgeneral\n",
    "roi = roi.get_fdata()\n",
    "roi = roi.flatten()\n",
    "roi = roi[a.astype(bool)]\n",
    "roi[np.isnan(roi)] = 0\n",
    "roi = roi.astype(bool)\n",
    "print(f\"final_mask voxels = {roi.sum()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cc11c66c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ses_mask = nib.load(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_{session_label}_task-C/sub-005_{session_label}_task-C_brain.nii.gz')\n",
    "assert np.all(ses_mask.affine == final_brain.affine)\n",
    "assert np.all(ses_mask.shape == final_brain.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0fcdfebf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(693, 180585)\n",
      "applied final nsdgeneral roi mask\n",
      "(693, 19174)\n"
     ]
    }
   ],
   "source": [
    "v = nilearn.masking.unmask(vox, ses_mask)  # move back to 3D based on own session mask\n",
    "vox = nilearn.masking.apply_mask(v, final_brain)  # re-flatten based on final mask so everything is in the same shape now\n",
    "print(vox.shape)\n",
    "vox = vox[:, roi]\n",
    "print(\"applied final nsdgeneral roi mask\")\n",
    "print(vox.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d4c5f3e1-0c84-4e41-b5b6-906ece01b008",
   "metadata": {},
   "outputs": [],
   "source": [
    "image_idx = np.array([])  # contains the unique index of each presented image\n",
    "for i, im in enumerate(image_names):\n",
    "    # skip if blank, nan\n",
    "    if im == \"blank.jpg\":\n",
    "        i+=1\n",
    "        continue\n",
    "    if str(im) == \"nan\":\n",
    "        i+=1\n",
    "        continue\n",
    "    vox_image_names = np.append(vox_image_names, im)\n",
    "    if remove_close_to_MST:  # optionally skip close_to_MST images \n",
    "        if \"closest_pairs\" in im:\n",
    "            i+=1\n",
    "            continue\n",
    "    elif remove_random_n:\n",
    "        if im in imgs_to_remove:\n",
    "            i+=1\n",
    "            continue\n",
    "            \n",
    "    image_idx_ = np.where(im==unique_images)[0].item()\n",
    "    image_idx = np.append(image_idx, image_idx_)\n",
    "image_idx = torch.Tensor(image_idx).long()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1f51d934-dc0b-49ec-b72c-25e3c941b2df",
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs = utils.find_paired_indices(image_idx)\n",
    "pairs = sorted(pairs, key=lambda x: x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "eed5447f-472c-4dbc-b4b8-8dc8e40b2ebe",
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs_homog = np.array([[p[0], p[1]] for p in pairs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fbc93c96-b71d-45a8-b0fa-5e46e97c7adc",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 19174/19174 [00:01<00:00, 17557.86it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rels (19174,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "vox_pairs = utils.zscore(vox[pairs_homog])\n",
    "rels = np.full(vox.shape[-1],np.nan)\n",
    "for v in tqdm(range(vox.shape[-1])):\n",
    "    rels[v] = np.corrcoef(vox_pairs[:,0,v], vox_pairs[:,1,v])[1,0]\n",
    "print(\"rels\", rels.shape)\n",
    "assert np.sum(np.all(np.isnan(rels))) == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "dbe8a932-1f3d-4aca-b573-dafb70ccb727",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(112, 19174, 2)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 112/112 [00:00<00:00, 3502.37it/s]\n"
     ]
    }
   ],
   "source": [
    "# creating img x vox x repetitions matrix | shape=(150, 18419, 2)\n",
    "vox0 = np.zeros((len(pairs_homog), vox.shape[-1], 2))\n",
    "print(vox0.shape)\n",
    "for ipair, pair in enumerate(tqdm(pairs_homog)):\n",
    "    pair = pair[:2] # to keep things consistent, just using the first two repeats\n",
    "    i,j = pair\n",
    "    vox0[ipair, :, :] = vox[pair].T\n",
    "vox_avg = vox0.mean(-1) # average across the repetitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "225de1fa-7e87-42d2-a239-e239501e9461",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reliability threshold = 0.2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 112/112 [00:02<00:00, 48.02it/s]\n"
     ]
    }
   ],
   "source": [
    "# Masking RDM for each reliability threshold\n",
    "r_thresholds = np.array([.2])\n",
    "rdm = np.zeros((len(r_thresholds), len(pairs), len(pairs))) \n",
    "for ir_thresh, r_thresh in enumerate(r_thresholds):\n",
    "    print(f\"reliability threshold = {r_thresh}\")\n",
    "    for i in tqdm(range(len(pairs))):\n",
    "        for j in range(len(pairs)):\n",
    "            rdm[ir_thresh,i,j] = np.corrcoef(vox_avg[i,rels>r_thresh], \n",
    "                                             vox_avg[j,rels>r_thresh])[0,1]\n",
    "# rdm is shape (4, 150, 150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b5058b74-bd73-478a-b270-a21f3bb64d91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "thresh = .2\n",
    "plt.figure(figsize=(4,4))\n",
    "plt.imshow(rdm[np.where(r_thresholds==thresh)[0].item()], clim=(-1,1))\n",
    "plt.colorbar(shrink=0.8)\n",
    "plt.title(f\"{sub}_{session}\\nreliability threshold={thresh}\\n\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5ec5e8ea-32a6-4b05-bf1c-e53130aed631",
   "metadata": {},
   "outputs": [],
   "source": [
    "for thresh in range(rdm.shape[0]):\n",
    "    for img in range(rdm.shape[1]):\n",
    "        assert np.isclose(rdm[thresh, img, img], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8ca3a078-a7c5-403b-8b2d-b8ed77189337",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Reliability thresholding?\n",
    "# print(f\"\\nvox before reliability thresholding: {vox.shape}\")\n",
    "# vox = vox[:,rels>.2]\n",
    "# print(f\"\\nvox after reliability thresholding: {vox.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2a3cbaf6-ae22-4150-8224-03f53d506738",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(19174,)\n"
     ]
    }
   ],
   "source": [
    "# now rel_mask is a reliability mask with the same shape as final_nsdgeneral\n",
    "# union mask also has the same shape so they can be compared directly\n",
    "rel_mask = rels>.2\n",
    "assert rel_mask.shape == union_mask.shape\n",
    "print(rel_mask.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "69d2c231",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ses-03 reliability mask (threshold > 0.2): 10.99% of nsdgeneral roi (2107/19174 voxels)\n",
      "ses-01 and 02 derived union mask: 44.99% of nsdgeneral roi (8627/19174 voxels)\n"
     ]
    }
   ],
   "source": [
    "# what's the overlap between the two masks and the final_nsdgeneral roi?\n",
    "print(f\"ses-03 reliability mask (threshold > 0.2): {(rel_mask.sum() / rel_mask.shape[0]):.2%} of nsdgeneral roi ({rel_mask.sum()}/{rel_mask.shape[0]} voxels)\")\n",
    "print(f\"ses-01 and 02 derived union mask: {(union_mask.sum() / rel_mask.shape[0]):.2%} of nsdgeneral roi ({union_mask.sum()}/{rel_mask.shape[0]} voxels)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c4460833",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81.30% overlap between reliability and union mask (1713/2107 voxels)\n"
     ]
    }
   ],
   "source": [
    "# what's the overlap between the two masks as a percent?\n",
    "overlap = np.sum(union_mask & rel_mask)\n",
    "overlap_pct = overlap / rel_mask.sum()\n",
    "print(f\"{overlap_pct:.2%} overlap between reliability and union mask ({overlap}/{rel_mask.sum()} voxels)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0850948f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80.14% (6914/8627) voxels in the union mask have reliability < 0.2 in ses-03 (are not present in the reliability mask)\n"
     ]
    }
   ],
   "source": [
    "# how many of the union mask voxels are not in the reliability mask? \n",
    "\n",
    "print(f\"{((union_mask.sum() - overlap) / union_mask.sum()):.2%} ({union_mask.sum() - overlap}/{union_mask.sum()}) voxels in the union mask have reliability < 0.2 in ses-03 (are not present in the reliability mask)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69d3d359",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11412ee3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rt_mindEye2 [~/.conda/envs/rt_mindEye2/]",
   "language": "python",
   "name": "conda_rt_mindeye2"
  },
  "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}