blp-analysis-structural-mri-fukutomi-replication.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d000a44f",
   "metadata": {},
   "source": [
    "# Brainlife analyses using Jupyter Notebooks and Python3\n",
    "\n",
    "This example notebook will guide the user through grabbing data for their project from the secondary warehouse, compiling data across the entire project, and analyzing and visualizing the compiled results on brainlife.io via the 'Analysis' tab. This example is written for python3, and uses one of the Python3 notebook types.\n",
    "\n",
    "Within this notebook, I will guide the user through analyses comprising derivatives generated from one of the three main datatypes available on brainlife.io, specifically neuro/dwi. Specifically, I will guide the user through:\n",
    "        \n",
    "    1. Analyze cortical parcel microstructural statistics derived from diffusion MRI, including DTI measures such as FA and MD and NODDI measures such as NDI and ODI\n",
    "        \n",
    "The functions provided in this notebook were designed for performing the many experiments provided in Hayashi & Caron et al (in prep), but should be a good starting point for you to get started on analyzing your project on brainlife.io!\n",
    "\n",
    "### Important Note regarding assumptions of data structures, both inputs and outputs\n",
    "\n",
    "Before we get started, it is important to note at the begging that the code in this notebook was designed mostly with a stereotypical data structure format in mind. For many of the datatypes, specifically the csv datatypes, follow the tidy format [https://www.jstatsoft.org/article/view/v059i10], where \"each column is a variable, every row is an observation, and every cell is a singular value\"[https://cran.r-project.org/web/packages/tidyr/vignettes/tidy-data.html]. There will be a few common columns, specifically 'subjectID' denoting the brainlife subject ID, 'sessionID' denoting the session ID on brainlife (will be 1 if there is no session ID data available), 'structureID' denoting the tissue structure of interest (ex. white matter tract, cortical parcel, eeg node), and 'nodeID' denoting the sample number of the structure. 'nodeID' is included across many .csv-based datatypes to conform with profilometry data, which has multiple samples or nodes per structure. For single measures of a given structure, the nodeID for all structures will be 1. \n",
    "\n",
    "However, this is not the case for network adjacency matrices. Specifically with the network.json.gz files that come within the generic/network datatype, the resulting compiled data structure will be compiled as a json structure with a numpy array of the matrix for each subject and session. \n",
    "\n",
    "I will provide examples of these resulting structures later on in the notebook.\n",
    "\n",
    "I bring this up now to note that if you are not a fan of the style of the resulting data structures, or your data doesn't confirm to this style, you are free to alter this code to your deepest desires! I've attempted to do my best to comment and explain everything as much as possible for each section, function, and analysis. If there are any points where something is not working or you are not sure what the code is doing, feel free to email me at [bacaron245@gmail.com!]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "623ec1ae",
   "metadata": {},
   "source": [
    "# With that, let's get started!\n",
    "\n",
    "## Install packages\n",
    "The first things we need to do are to install some software packages using python's pip package manager, and then to load all of the necessary modules into our notebook.\n",
    "\n",
    "Specifically, we will install the python-import of the brain connectivity toolbox (BCT; ) known as bctpy [], jgf to load json packages (for our network matrices), and nilearn to make some pretty network plots!\n",
    "\n",
    "We will also be loading some other packages, including matplotlib, seaborn, and nilearn for plotting, numpy for numerical calculations and array manipulations, itertools and scipy for statistical testing, pandas, json, and jgf for loading various datat strucutres, and scikit-learn's mean_squared_error function to compute root-mean-square-error for some of the final analyses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f2d27821",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: bctpy in /home/brad/.local/lib/python3.8/site-packages (0.5.2)\n",
      "Requirement already satisfied: jgf in /home/brad/.local/lib/python3.8/site-packages (0.2.2)\n",
      "Requirement already satisfied: nilearn in /home/brad/.local/lib/python3.8/site-packages (0.6.2)\n",
      "Requirement already satisfied: scipy in /home/brad/.local/lib/python3.8/site-packages (from bctpy) (1.4.1)\n",
      "Requirement already satisfied: numpy in /home/brad/.local/lib/python3.8/site-packages (from bctpy) (1.21.5)\n",
      "Requirement already satisfied: nibabel>=2.0.2 in /home/brad/.local/lib/python3.8/site-packages (from nilearn) (3.0.2)\n",
      "Requirement already satisfied: sklearn in /home/brad/.local/lib/python3.8/site-packages (from nilearn) (0.0)\n",
      "Requirement already satisfied: scikit-learn>=0.19 in /home/brad/.local/lib/python3.8/site-packages (from nilearn) (0.22.2.post1)\n",
      "Requirement already satisfied: joblib>=0.11 in /home/brad/.local/lib/python3.8/site-packages (from nilearn) (1.1.0)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install bctpy jgf nilearn"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cbb1577",
   "metadata": {},
   "source": [
    "## Importing packages\n",
    "The first things we need to do is to load python packages in order to perform actions on the processed data, including matplotlib and seaborn for plotting, numpy for numerical calculations and array manipulations, itertools and scipy for statistical testing, pandas, and scikit-learn's mean_squared_error function to compute root-mean-square-error for some of the final analyses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9951cac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os,sys,glob\n",
    "import requests\n",
    "from matplotlib import colors as mcolors\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import json\n",
    "import seaborn as sns\n",
    "from itertools import combinations\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from scipy import stats\n",
    "import bct\n",
    "import jgf\n",
    "from nilearn import plotting\n",
    "from scipy.signal import resample"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edb690f4",
   "metadata": {},
   "source": [
    "## Let's define and load some useful functions!\n",
    "\n",
    "This next section loads many functions for loading, compiling, analyzing, and visualizing some common datatypes on brainlife.io. To make it easier to load, I've provided all the functions used throughout the rest of the notebook in a single cell. However, for each function, I've provided comments that attempt to explain what the function does and what the inputs and outputs are. I've sectioned off the code into multiple sections: 1) data loading, compilation, and storage, 2) data analysis, manipulation and statistical computations, and 3) visualizations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2407a774",
   "metadata": {},
   "source": [
    "### Data loading, compilation, and storage\n",
    "The first section of functions deals with collecting data from secondary warehouse and compiling the data into a useful structures for further analysis. The main function the user will call from this section is the wrapper 'collect_data', which will identify the appropriate data from the secondary warehouse based on user input and compile that data into a structure the user can use for analysis. This function makes a couple of important assumptions. Specifically:\n",
    "\n",
    "    1. If there are duplicate datatypes that meet all of the specifications and filters, this function will only collect the data that was most recent to finish\n",
    "    \n",
    "    2. If the data can be formatted to a csv-file, it will be formatted to a csv-file. The only exception is network adjacency matrices.\n",
    "    \n",
    "    3. Users can control what data is grabbed and compiled by being specific with datatype_tags and tags.\n",
    "    \n",
    "The remaining functions perform other useful tasks, such as adding subjectID and sessionID data if missing, checking for duplicate entries of the same datatype (assumption 1), and append and compile data into the output data structure.\n",
    "\n",
    "As previously mentioned, the resulting csv-file structures will be in the tidy format, and network adjacency matricies will be stored as a json-structure with the matricies stored as numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bc58a7e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "## this will add a subjectID and sessionID column to the output data\n",
    "def add_subjects_sessions(subject,session,path,data):\n",
    "    \n",
    "    if 'subjectID' not in data.keys():\n",
    "        data['subjectID'] = [ str(subject) for f in range(len(data)) ]\n",
    "    \n",
    "    if 'sessionID' not in data.keys():\n",
    "        data['sessionID'] = [ str(session) for f in range(len(data)) ]\n",
    "        \n",
    "    return data\n",
    "\n",
    "## this function calles check_for_duplicates and attempts to find duplicates. then uses that output, sets a dumby sessionID if not present,\n",
    "## and appends the object data\n",
    "def append_data(subjects,sessions,paths,finish_dates,obj,filename):\n",
    "        \n",
    "    # check for duplicates. if so, remove\n",
    "    finish_dates, subjects, sessions, paths = check_for_duplicates(obj,finish_dates,subjects,sessions,paths)\n",
    "\n",
    "    # append data to appropriate lists\n",
    "    subjects = np.append(subjects,str(obj['output']['meta']['subject']))\n",
    "    if 'session' in obj['output']['meta'].keys():\n",
    "        sessions = np.append(sessions,obj['output']['meta']['session'])\n",
    "    else:\n",
    "        sessions = np.append(sessions,'1')\n",
    "    paths = np.append(paths,\"input/\"+obj[\"path\"]+\"/\"+filename)\n",
    "    finish_dates = np.append(finish_dates,obj['finish_date'])\n",
    "    \n",
    "    return finish_dates, subjects, sessions, paths\n",
    "\n",
    "## this function will call add_subjects_sessions to add the appropriate columns and will append the object data to a study-wide dataframe\n",
    "def compile_data(paths,subjects,sessions,data):\n",
    "    # loops through all paths\n",
    "    for i in range(len(paths)):\n",
    "        # if network, load json. if not, load csv\n",
    "        if '.json.gz' in paths[i]:\n",
    "            tmpdata = pd.read_json(paths[i],orient='index').reset_index(drop=True)\n",
    "            tmpdata = add_subjects_sessions(subjects[i],sessions[i],paths[i],tmpdata)\n",
    "        else:\n",
    "            if '.tsv' in paths[i]:\n",
    "                sep = '\\t'\n",
    "            else:\n",
    "                sep = ','\n",
    "            tmpdata = pd.read_csv(paths[i],sep=sep)\n",
    "            tmpdata = add_subjects_sessions(subjects[i],sessions[i],paths[i],tmpdata)\n",
    "\n",
    "        data = data.append(tmpdata,ignore_index=True)\n",
    "\n",
    "    # replace empty spaces with nans\n",
    "    data = data.replace(r'^\\s+$', np.nan, regex=True)\n",
    "    \n",
    "    return data\n",
    "\n",
    "# this function will comile network adjacency matrices into a dictionary structure\n",
    "def compile_network_adjacency_matrices(paths,subjects,sessions,data):\n",
    "    \n",
    "    # loop through paths and append adjacency matrix to dictionary\n",
    "    for i in range(len(paths)):\n",
    "        data[subjects[i]+'_sess'+sessions[i]] = jgf.conmat.load(paths[i],compressed=True)[0]\n",
    "\n",
    "    return data\n",
    "\n",
    "### load data\n",
    "## this function is useful for identifying duplicate datatypes. if it finds one, it will update the data with the latest finishing dataset.\n",
    "def check_for_duplicates(obj,finish_dates,subjects,sessions,paths):\n",
    "    \n",
    "    # first checks if there is a session id available in the keys of the object. if finds one, then checks if the subject and session ID \n",
    "    # were already looped over. if so, will delete position in list and update with appropriate path. if it doesn't find a session ID, it\n",
    "    # just attempts to find if the subject has already been looped over\n",
    "    if 'session' in obj['output']['meta'].keys():\n",
    "        if (obj['output']['meta']['subject'] in subjects) and (obj['output']['meta']['session'] in sessions):\n",
    "            index = np.where(np.logical_and(subjects == obj['output']['meta']['subject'],sessions == obj['output']['meta']['session']))\n",
    "            if finish_dates[index] <= obj[\"finish_date\"]:\n",
    "                subjects = np.delete(subjects,index)\n",
    "                paths = np.delete(paths,index)\n",
    "                sessions = np.delete(sessions,index)\n",
    "                finish_dates = np.delete(finish_dates,index)\n",
    "    else:\n",
    "        if (obj['output']['meta']['subject'] in subjects):\n",
    "            index = np.where(subjects == obj['output']['meta']['subject'])\n",
    "            if finish_dates[index] <= obj[\"finish_date\"]:\n",
    "                subjects = np.delete(subjects,index)\n",
    "                paths = np.delete(paths,index)\n",
    "                sessions = np.delete(sessions,index)\n",
    "                finish_dates = np.delete(finish_dates,index)\n",
    "\n",
    "    return finish_dates, subjects, sessions, paths\n",
    "\n",
    "# this will check to see if the datatype tags or tags of the datatype object exists within the filtered ('!') tags\n",
    "def check_for_filter_tags(input_tags,obj,tagOrDatatypeTag):\n",
    "    \n",
    "    filter_checks = 0\n",
    "    for i in input_tags:\n",
    "        if i.replace('!','') not in obj['output'][tagOrDatatypeTag]:\n",
    "            filter_checks = filter_checks+1\n",
    "\n",
    "    return filter_checks\n",
    "\n",
    "## this function is the wrapper function that calls all the prevouis functions to generate a dataframe for the entire project of the appropriate datatype\n",
    "def collect_data(datatype,datatype_tags,tags,filename,outPath,net_adj):\n",
    "\n",
    "    # grab path and data objects\n",
    "    objects = requests.get('https://brainlife.io/api/warehouse/secondary/list/%s'%os.environ['PROJECT_ID']).json()\n",
    "\n",
    "    # subjects and paths\n",
    "    subjects = []\n",
    "    sessions = []\n",
    "    paths = []\n",
    "    finish_dates = []\n",
    "    obj_datatype_tags = []\n",
    "    obj_tags = []\n",
    "\n",
    "    # set up output\n",
    "    data = pd.DataFrame()\n",
    "\n",
    "    # loop through objects and find appropriate objects based on datatype, datatype_tags, and tags. can include drop tags ('!'). this logic could probably be simplified\n",
    "    for obj in objects:\n",
    "        if obj['datatype']['name'] == datatype:\n",
    "            # if datatype_tags is set, identify data using this info. if not, just use tag data. if no tags either, just append if meets datatype criteria. will check for filter with a not tag (!)\n",
    "            if datatype_tags:\n",
    "                # if the input datatype_tags are included in the object's datatype_tags, look for appropriate tags. if no tags, just append\n",
    "                if 'datatype_tags' in list(obj['output'].keys()) and len(obj['output']['datatype_tags']) != 0:\n",
    "                    if '!' in str(datatype_tags):\n",
    "                        datatype_tags_to_drop = [ f for f in datatype_tags if '!' in str(f) ]\n",
    "                        datatype_tag_keep = [ f for f in datatype_tags if f not in datatype_tags_to_drop ]\n",
    "\n",
    "                        if set(datatype_tag_keep).issubset(obj['output']['datatype_tags']):\n",
    "                            datatype_tag_checks = check_for_filter_tags(datatype_tags_to_drop,obj,'datatype_tags')\n",
    "                            if datatype_tag_checks == len(datatype_tags_to_drop):\n",
    "                                datatype_tag_filter = True\n",
    "                            else:\n",
    "                                datatype_tag_filter = False\n",
    "                        else:\n",
    "                            datatype_tag_filter = False\n",
    "                    else:\n",
    "                        if set(datatype_tags).issubset(obj['output']['datatype_tags']):\n",
    "                            datatype_tag_filter = True\n",
    "                        else:\n",
    "                            datatype_tag_filter = False\n",
    "                else:\n",
    "                    datatype_tag_filter = False\n",
    "            else:\n",
    "                datatype_tag_filter = True\n",
    "\n",
    "            if tags:\n",
    "                if 'tags' in list(obj['output'].keys()) and len(obj['output']['tags']) != 0:\n",
    "                    if '!' in str(tags):\n",
    "                        tags_drop = [ f for f in tags if '!' in str(f) ]\n",
    "                        tags_keep = [ f for f in tags if f not in tags_drop ]\n",
    "\n",
    "                        if set(tags_keep).issubset(obj['output']['tags']):\n",
    "                            tag_checks = checkcheck_for_filter_tagsForFilterTags(tags_drop,obj,'tags')\n",
    "                            if tag_checks == len(tags_drop):\n",
    "                                tag_filter = True\n",
    "                            else:\n",
    "                                tag_filter = False\n",
    "                        else:\n",
    "                            tag_filter = False\n",
    "                    else:\n",
    "                        if set(tags).issubset(obj['output']['tags']):\n",
    "                            tag_filter = True\n",
    "                        else:\n",
    "                            tag_filter = False\n",
    "                else:\n",
    "                    tag_filter = False\n",
    "            else:\n",
    "                tag_filter = True\n",
    "\n",
    "            if datatype_tag_filter == True & tag_filter == True:\n",
    "                obj_datatype_tags = np.append(obj_datatype_tags,obj['output']['datatype_tags'])\n",
    "                obj_tags = np.append(obj_tags,obj['output']['tags'])\n",
    "                finish_dates, subjects, sessions, paths = append_data(subjects,sessions,paths,finish_dates,obj,filename)\n",
    "\n",
    "    # shuffle data so subjects are in order\n",
    "    paths = [z for _,_,z in sorted(zip(subjects,sessions,paths))]\n",
    "    subjects = [x for x,_,_ in sorted(zip(subjects,sessions,paths))]\n",
    "    sessions = [y for _,y,_ in sorted(zip(subjects,sessions,paths))]\n",
    "\n",
    "    # check if tab separated or comma separated by looking at input filename\n",
    "    if '.tsv' in filename:\n",
    "        sep = '\\t'\n",
    "    else:\n",
    "        sep = ','\n",
    "\n",
    "    # compile data\n",
    "    if net_adj:\n",
    "        data = {}\n",
    "        data = compile_network_adjacency_matrices(paths,subjects,sessions,data)\n",
    "        if outPath:\n",
    "            np.save(outPath,data)\n",
    "    else:\n",
    "        data = compile_data(paths,subjects,sessions,data)\n",
    "\n",
    "    # output data structure for records and any further analyses\n",
    "    if outPath:\n",
    "        data.to_csv(outPath,sep=sep,index=False)\n",
    "\n",
    "    return data\n",
    "\n",
    "### subjects dataframe generation\n",
    "## this function will make a dataframe from a list of subjects and groups. will also add a color column for easy plotting\n",
    "def collect_subject_data(topPath,dataPath,groups,subjects,colors):\n",
    "\n",
    "    # set up variables\n",
    "    data_columns = ['subjectID','classID','colors']\n",
    "    data =  pd.DataFrame([],columns=data_columns)\n",
    "\n",
    "    # populate structure\n",
    "    data['subjectID'] = [ f for g in groups for f in subjects[g] ]\n",
    "    data['classID'] = [ g for g in groups for f in range(len(subjects[g]))]\n",
    "    data['colors'] = [ colors[c] for c in colors for f in subjects[c]]\n",
    "\n",
    "    # output data structure for records and any further analyses\n",
    "    if not os.path.exists(dataPath):\n",
    "        os.mkdir(dataPath)\n",
    "\n",
    "    data.to_csv(dataPath+'subjects.csv',index=False)\n",
    "\n",
    "    return data\n",
    "\n",
    "## this will create a subject-specific color for each subject in the subjects dataframe\n",
    "def create_color_dictionary(data,measure,colorPalette):\n",
    "\n",
    "    # Create subject keys and color values\n",
    "    keys = data[measure].unique()\n",
    "    values = sns.color_palette(colorPalette,len(keys))\n",
    "    values = values.as_hex()\n",
    "\n",
    "    # zip dictionary together\n",
    "    colors_dict = dict(zip(keys,values))\n",
    "\n",
    "    return colors_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b27af75e",
   "metadata": {},
   "source": [
    "### Data analysis, manipulation and statistical computations\n",
    "This next section contains functions for manipulating, analysing, and computing statistics from the data collected using the functions previously described. This includes many different manipulations and computations, including trimming nodes off profilometry data, computing mean dataframes, computing outliers and generating reference datasets, and some simple network adjacency matrix manipulations including binarizing, thresholding, and computing the mean witihin-network functional connectivity. \n",
    "\n",
    "The bulk of these functions are devoted to identifying outliers and generating reference datasets. My approach for this included identifying outliers for each structure and measure across a given project  by computing the mean distribution and identifying those with distances from that point greater than a percentile threshold. I then removed those data points, and recomputed the reference dataset. The references generated have been built-into many of the verification steps following Apps. The resulting dataframes are formatted in both csv and json structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1767b9ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "### dataframe manipulations\n",
    "## cut nodes for profilometry / timeseries data\n",
    "def cut_nodes(data,num_nodes,dataPath,foldername,savename):\n",
    "\n",
    "    # identify inner n nodes based on num_nodes input\n",
    "    total_nodes = len(data['nodeID'].unique())\n",
    "    cut_nodes = int((total_nodes - num_nodes) / 2)\n",
    "\n",
    "    # remove cut_nodes from dataframe\n",
    "    data = data[data['nodeID'].between((cut_nodes)+1,(num_nodes+cut_nodes))]\n",
    "\n",
    "    # replace empty spaces with nans\n",
    "    data = data.replace(r'^\\s+$', np.nan, regex=True)\n",
    "\n",
    "    # output data structure for records and any further analyses\n",
    "    if not os.path.exists(dataPath):\n",
    "        os.mkdir(dataPath)\n",
    "\n",
    "    data.to_csv(dataPath+'/'+foldername+'-'+savename+'.csv',index=False)\n",
    "\n",
    "    return data\n",
    "\n",
    "## will compute mean dataframe \n",
    "def compute_mean_data(dataPath,data,outname):\n",
    "\n",
    "    # make mean data frame\n",
    "    data_mean =  data.groupby(['subjectID','classID','structureID']).mean().reset_index()\n",
    "    data_mean['nodeID'] = [ 1 for f in range(len(data_mean['nodeID'])) ]\n",
    "\n",
    "    # output data structure for records and any further analyses\n",
    "    if not os.path.exists(dataPath):\n",
    "        os.mkdir(dataPath)\n",
    "\n",
    "    data_mean.to_csv(dataPath+outname+'.csv',index=False)\n",
    "\n",
    "    return data_mean\n",
    "\n",
    "### scripts related to outlier detection and reference dataframe generation\n",
    "## this function will compute distance measures from input data and reference data\n",
    "def compute_distance(data,references_data,measures,metric):\n",
    "\n",
    "    # imports important distance functions\n",
    "    from sklearn.metrics.pairwise import euclidean_distances\n",
    "    from scipy.stats import wasserstein_distance\n",
    "\n",
    "    # if distance metric desired is euclidean distance (i.e. for profiles), computes distance of profile from reference profile. else, just computes difference using emd\n",
    "    if metric == 'euclidean':\n",
    "        dist = data.groupby('subjectID',sort=False).apply(lambda x: euclidean_distances([x[measures].values.tolist(),references_data[measures].values.tolist()])[0][1]).values\n",
    "    else:\n",
    "        dist = data.groupby('subjectID',sort=False).apply(lambda x: wasserstein_distance(x[measures],[references_data[measures].values[0]]))\n",
    "\n",
    "    return dist\n",
    "\n",
    "## this function will compute simple average references for a given input data\n",
    "def compute_references(x,groupby_measures,index_measure,diff_measures):\n",
    "    \n",
    "    # computes mean and sd of the measures in a dataframe\n",
    "    references_mean = x.groupby(groupby_measures).mean().reset_index(index_measure)\n",
    "    references_sd = x.groupby(groupby_measures).std().reset_index(index_measure)\n",
    "    references_sd[diff_measures] = references_sd[diff_measures] * 2\n",
    "    \n",
    "    return references_mean, references_sd\n",
    "\n",
    "## this function calls compute_references and compute_distance to create a dataframe of distance measures\n",
    "def create_distance_dataframe(data,structures,groupby_measure,measures,dist_metric):\n",
    "    \n",
    "    # set up output lists that we will append to\n",
    "    dist = []\n",
    "    subj = []\n",
    "    meas = []\n",
    "    struc = []\n",
    "\n",
    "    # loop through appropriate structures\n",
    "    for i in structures:\n",
    "        print(i)\n",
    "        # set data for a given structure\n",
    "        subj_data = data.loc[data['structureID'] == i]\n",
    "        # compute reference for given structure\n",
    "        references_data = compute_references(subj_data,groupby_measure,groupby_measure,measures)\n",
    "        # loop through measures and compute distance from reference\n",
    "        for m in measures:\n",
    "            if dist_metric == 'euclidean':\n",
    "                dist = np.append(dist,compute_distance(subj_data,references_data[0],m,'euclidean'))\n",
    "            else:\n",
    "                dist = np.append(dist,compute_distance(subj_data,references_data[0],m,'emd'))\n",
    "            \n",
    "            # append data to appropriate lists\n",
    "            subj = np.append(subj,subj_data.subjectID.unique().tolist())\n",
    "            meas = np.append(meas,[ m for f in range(len(subj_data.subjectID.unique().tolist())) ])\n",
    "            struc = np.append(struc,[ i for f in range(len(subj_data.subjectID.unique().tolist())) ])\n",
    "\n",
    "    # create distance dataframe\n",
    "    dist_dataframe = pd.DataFrame()\n",
    "    dist_dataframe['subjectID'] = subj\n",
    "    dist_dataframe['structureID'] = struc\n",
    "    dist_dataframe['measures'] = meas\n",
    "    dist_dataframe['distance'] = dist\n",
    "    \n",
    "    return dist_dataframe\n",
    "\n",
    "## this function is useful for saving reference.jsons for a given structure\n",
    "def output_reference_json(ref_data,measures,profile,resample_points,sourceID,data_dir,filename):\n",
    "    \n",
    "    # loop through structures in dataframe\n",
    "    for st in ref_data.structureID.unique():\n",
    "        # set up important measures\n",
    "        reference_json = []\n",
    "        tmp = {}\n",
    "        tmp['structurename'] = st\n",
    "        tmp['source'] = sourceID\n",
    "        # loop through measures\n",
    "        for meas in measures:\n",
    "            # grab data\n",
    "            tmp[meas] = {}\n",
    "            if profile:\n",
    "                gb_frame = ref_data.loc[ref_data['structureID'] == st][['nodeID',meas]].dropna().groupby('nodeID')[meas]\n",
    "            else:\n",
    "                gb_frame = ref_data.loc[ref_data['structureID'] == st][[meas]].dropna()[meas]\n",
    "            \n",
    "            # if resample_points is a value, resamples references and computes multiple summary measures.\n",
    "            # else, will just output the entire data. this second option is really only useful for non-profile/series data\n",
    "            data_tmp = []\n",
    "            if resample_points:                \n",
    "                mean_tmp = resample(gb_frame.mean().values.tolist(),resample_points).tolist()\n",
    "                min_tmp = resample(gb_frame.min().values.tolist(),resample_points).tolist()\n",
    "                max_tmp = resample(gb_frame.max().values.tolist(),resample_points).tolist()\n",
    "                sd_tmp = resample(gb_frame.std().values.tolist(),resample_points).tolist()\n",
    "                five_tmp = resample(gb_frame.quantile(q=.05).values.tolist(),resample_points).tolist()\n",
    "                twofive_tmp = resample(gb_frame.quantile(q=.25).values.tolist(),resample_points).tolist()\n",
    "                sevenfive_tmp = resample(gb_frame.quantile(q=.75).values.tolist(),resample_points).tolist()\n",
    "                ninefive_tmp = resample(gb_frame.quantile(q=.95).values.tolist(),resample_points).tolist()\n",
    "                tmp[meas]['mean'] = mean_tmp\n",
    "                tmp[meas]['min'] = min_tmp\n",
    "                tmp[meas]['max'] = max_tmp\n",
    "                tmp[meas]['sd'] = sd_tmp\n",
    "                tmp[meas]['5_percentile'] = five_tmp\n",
    "                tmp[meas]['25_percentile'] = twofive_tmp\n",
    "                tmp[meas]['75_percentile'] = sevenfive_tmp\n",
    "                tmp[meas]['95_percentile'] = ninefive_tmp\n",
    "            else:\n",
    "                data_tmp = gb_frame.values.tolist()\n",
    "                tmp[meas]['data'] = data_tmp\n",
    "        reference_json.append(tmp)\n",
    "\n",
    "        with open(data_dir+'/'+filename+'_'+st+'.json','w') as ref_out_f:\n",
    "            json.dump(reference_json,ref_out_f)\n",
    "    \n",
    "    return reference_json\n",
    "\n",
    "## this function is used to build the reference dataset removing any subjects identified as outliers. the dataframe may or may not be useful\n",
    "def build_reference_data(data,outliers,profile,data_dir,filename):\n",
    "    \n",
    "    # set up dataframe\n",
    "    reference_data = pd.DataFrame()\n",
    "\n",
    "    # loop through structures and measures and set data\n",
    "    for s in outliers.structureID.unique():\n",
    "        for m in outliers.measures.unique():\n",
    "            if profile:\n",
    "                meas = ['structureID','subjectID','nodeID',m]\n",
    "            else:\n",
    "                meas = ['structureID','subjectID',m]\n",
    "            tmpdata = data[(data[\"structureID\"] == s) & (~data['subjectID'].isin(outliers.loc[outliers['structureID'] == s].loc[outliers['measures'] == m].subjectID.unique()))][meas].reset_index(drop=True)\n",
    "            reference_data = pd.concat([reference_data,tmpdata])\n",
    "    # if not profile, will compute average\n",
    "    if not profile:\n",
    "        reference_data = reference_data.groupby(['structureID','subjectID']).mean().reset_index()\n",
    "\n",
    "    reference_data.to_csv(data_dir+'/'+filename+'.csv',index=False)\n",
    "\n",
    "    return reference_data\n",
    "\n",
    "## this function will identify if a given subjects' data is an outlier based on distance from reference and a threshold percentage\n",
    "def compute_outliers(distances,threshold):\n",
    "    \n",
    "    # set up dataframe\n",
    "    outliers = pd.DataFrame()\n",
    "    \n",
    "    # loop through structureas and measures and identify outliers based on thereshold distance\n",
    "    for i in distances.structureID.unique():\n",
    "        for m in distances.measures.unique():\n",
    "            tmpdata = distances.loc[distances['structureID'] == i].loc[distances['measures'] == m]\n",
    "            outliers = pd.concat([outliers,tmpdata[tmpdata['distance'] > np.percentile(tmpdata['distance'],threshold)]])\n",
    "            \n",
    "    return outliers\n",
    "\n",
    "## this function calls compute_outliers, create_distance_dataframe, and build_reference_data and output_reference_json to actually generate the outliers\n",
    "## and final reference datasets\n",
    "def outlier_detection(data,structures,groupby_measure,measures,threshold,dist_metric,build_outliers,profile,resample_points,sourceID,data_dir,filename):\n",
    "    \n",
    "    # set up important lists\n",
    "    outliers_subjects = []\n",
    "    outliers_structures = []\n",
    "    outliers_measures = []\n",
    "    outliers_metrics = []\n",
    "\n",
    "    # compute distances and identify outliers\n",
    "    distances = create_distance_dataframe(data,structures,groupby_measure,measures,dist_metric)\n",
    "    outliers_dataframe = compute_outliers(distances,threshold)\n",
    "    \n",
    "    # if building references, build the reference data. otherwise, output a blank array\n",
    "    if build_outliers:\n",
    "        reference_dataframe = build_reference_data(data,outliers_dataframe,profile,data_dir,filename)\n",
    "        reference_json = output_reference_json(reference_dataframe,measures,profile,resample_points,sourceID,data_dir,filename)\n",
    "    else:\n",
    "        reference_dataframe = []\n",
    "        reference_json = []\n",
    "        \n",
    "    return distances, outliers_dataframe, reference_dataframe, reference_json\n",
    "\n",
    "## this function is useful in identifying subjects who may have had a flipped profile as compared to a reference profile.\n",
    "## calls compute_references, compute_distance.\n",
    "## logic: if the distance of a subject's tract profile from a reference profile is positive and greater than a threshold percentage, then it's likely\n",
    "## the data has been flipped. needs more work for all use cases. works well for easy examples like uncinate\n",
    "def profile_flip_check(data,subjects,structures,test_measure,flip_measures,dist_metric,threshold,outPath):\n",
    "    \n",
    "    # set up important lists\n",
    "    flipped_subjects = []\n",
    "    flipped_structures = []\n",
    "    distance = []\n",
    "    flipped_distance = []\n",
    "\n",
    "    # loop through structures\n",
    "    for i in structures:\n",
    "        print(i)\n",
    "        # set data frame for structure, including a copy that has the test_measure flipped\n",
    "        struc_data = data.loc[data['structureID'] == i]\n",
    "        flipped_struc_data = struc_data.copy()\n",
    "        flipped_struc_data[test_measure] = flipped_struc_data.groupby('subjectID',sort=False).apply(lambda x: np.flip(x['fa'])).tolist()\n",
    "\n",
    "        # build reference data\n",
    "        references_data = compute_references(struc_data,'nodeID','nodeID',flip_measures)\n",
    "\n",
    "        # compute distances for normal data and for flipped. then compute difference\n",
    "        dist = compute_distance(struc_data,references_data[0],test_measure,dist_metric)\n",
    "        dist_flipped = compute_distance(flipped_struc_data,references_data[0],test_measure,dist_metric)\n",
    "        differences = dist - dist_flipped\n",
    "\n",
    "        # identify threshold of distances based on percentile. identify those that have positive differences and are greater than the threshold.\n",
    "        # if so, append information\n",
    "        percentile_threshold = np.percentile(differences,threshold)\n",
    "        for m in range(len(differences)):\n",
    "            if differences[m] > 0 and differences[m] > percentile_threshold:\n",
    "                flipped_subjects = np.append(flipped_subjects,subjects[m])\n",
    "                flipped_structures = np.append(flipped_structures,i)\n",
    "                distance = np.append(distance,dist[m])\n",
    "                flipped_distance = np.append(flipped_distance,dist_flipped[m])\n",
    "\n",
    "    # generate ouput dataframe containing flipped subject data\n",
    "    output_summary = pd.DataFrame()\n",
    "    output_summary['flipped_subjects'] = flipped_subjects\n",
    "    output_summary['flipped_structures'] = flipped_structures\n",
    "    output_summary['distance'] = distance\n",
    "    output_summary['flipped_distance'] = flipped_distance\n",
    "\n",
    "    if outPath:\n",
    "        output_summary.to_csv(outPath+'_flipped_profiles.csv',index=False)\n",
    "        \n",
    "# this function will merge the structural and diffusion data for the reference datasets\n",
    "def merge_structural_diffusion_json(data,structuralPath,diffusionPath,outPath):\n",
    "    for i in data.structureID.unique():\n",
    "        print(i)\n",
    "        with open(structuralPath+'_'+i+'.json','r') as structural_f:\n",
    "            structural = json.load(structural_f)\n",
    "\n",
    "        with open(diffusionPath+'_'+i+'.json','r') as diffusion_f:\n",
    "            diffusion = json.load(diffusion_f)\n",
    "\n",
    "        merged = [{**structural[0],**diffusion[0]}]\n",
    "\n",
    "        with open(outPath+'_'+i+'.json','w') as out_f:\n",
    "            json.dump(merged,out_f)\n",
    "\n",
    "### adjacency-matrix related fuctions for computing network values locally\n",
    "# this function will binarize an adjacency matrix\n",
    "def binarize_matrices(data):\n",
    "    \n",
    "    # use brain connectivity toolbox to binarize data\n",
    "    bin_data = [ bct.utils.binarize(data[f]) for f in data.keys() ]\n",
    "    \n",
    "    return bin_data\n",
    "\n",
    "# this function will threshold an adjacency matrix based on a percentage threshold of subjects with a binary 1 in that node pair\n",
    "def threshold_matrices(data,bin_data,thresholdPercentageSubjects):\n",
    "    \n",
    "    # compute sum of matrices\n",
    "    sum_mat = np.zeros(np.shape(bin_data)[1:])\n",
    "    \n",
    "    for i in bin_data:\n",
    "        sum_mat = sum_mat + i\n",
    "        \n",
    "    # compute threshold value\n",
    "    thrs = thresholdPercentageSubjects*len(bin_data)\n",
    "    \n",
    "    # loop through data and make those nodes that dont meet threshold 0\n",
    "    for i in data.keys():\n",
    "        data[i][sum_mat < thrs] = 0\n",
    "        \n",
    "    return data\n",
    "\n",
    "# this function will compute the mean within-node functional connectivity\n",
    "def compute_mean_network_connectivity(data,networks,indices,out_path):\n",
    "\n",
    "    mean_data = []\n",
    "    subs = []\n",
    "    nets = []\n",
    "\n",
    "    for l in data.keys():\n",
    "        for n in networks:\n",
    "            tmpdata = []\n",
    "            subs = np.append(subs,l)\n",
    "            nets = np.append(nets,n)\n",
    "            for i in indices[n]:\n",
    "                for j in indices[n]:\n",
    "                    if i != j:\n",
    "                        tmpdata = np.append(tmpdata,data[l][int(i)][int(j)])\n",
    "            mean_data = np.append(mean_data,np.mean(tmpdata))\n",
    "\n",
    "    out_df = pd.DataFrame()\n",
    "    out_df['subjectID'] = [ f.split('_sess1')[0] for f in subs ]\n",
    "    out_df['FC'] = mean_data\n",
    "    out_df = pd.merge(out_df,subjects_data,on='subjectID')\n",
    "    out_df['structureID'] = nets\n",
    "\n",
    "    if out_path:\n",
    "        out_df.to_csv(out_path,index=False)\n",
    "        \n",
    "    return out_df\n",
    "\n",
    "# this function will compute the mean network matrix\n",
    "def compute_mean_network(data):\n",
    "    \n",
    "    mean_network = np.array(np.zeros(np.shape(data[list(data.keys())[0]])))\n",
    "    \n",
    "    for i in data.keys():\n",
    "        mean_network = mean_network + data[i]\n",
    "        \n",
    "    mean_network = mean_network / len(data.keys())\n",
    "    \n",
    "    return mean_network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5299fc5",
   "metadata": {},
   "source": [
    "### Visualizations\n",
    "The final set of functions deals with generating many useful visualizations and plots of the data, including scatterplots, violin plots, and tract profile plots. Within this are many useful wrapper functions that organize the data into useful structures for plotting. These scripts are very 'baked in', in that they are in a style that I like. However, many of these visualizations can be changed with simple alterations to the code. Many of the plots use packages like seaborn or matplotlib to make the visualizations, which both have extensive documentation to guide and help!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3104a191",
   "metadata": {},
   "outputs": [],
   "source": [
    "### visualization related scripts\n",
    "# groups data by input measure and computes mean for each value in that column. x_stat is a pd dataframe, with each row being a single value, and each column being a different ID value or measure\n",
    "def average_within_column(x_stat,y_stat,x_measure,y_measure,measure):\n",
    "\n",
    "    X = x_stat.groupby(measure).mean()[x_measure].tolist()\n",
    "    Y = y_stat.groupby(measure).mean()[y_measure].tolist()\n",
    "\n",
    "    return X,Y\n",
    "\n",
    "# groups data by input measure and creates an array by appending data into x and y arrays. x_stat and y_stat are pd dataframes, with each row being a single value, and each column being a different ID value or measure\n",
    "# designed for test retest. x_stat and y_stat should have the same number of rows. but more importantly, should correspond to the same source (i.e. subject)\n",
    "# can be same pd.dataframe, but indexing of specific subject groups\n",
    "def append_within_column(x_stat,y_stat,x_measure,y_measure,measure):\n",
    "\n",
    "    X,Y = [np.array([]),np.array([])]\n",
    "    for i in range(len(x_stat[measure].unique())):\n",
    "        x = x_stat[x_stat[measure] == x_stat[measure].unique()[i]][x_measure]\n",
    "        y = y_stat[y_stat[measure] == y_stat[measure].unique()[i]][y_measure]\n",
    "\n",
    "        if np.isnan(x).any() or np.isnan(y).any():\n",
    "            print(\"skipping %s due to nan\" %x_stat[measure].unique()[i])\n",
    "        else:\n",
    "            # checks to make sure the same data\n",
    "            if len(x) == len(y):\n",
    "                X = np.append(X,x)\n",
    "                Y = np.append(Y,y)\n",
    "\n",
    "    return X,Y\n",
    "\n",
    "# unravels networks. x_stat and y_stat should be S x M, where S is the number of subjects and M is the adjacency matrix for that subject\n",
    "def ravel_network(x_stat,y_stat):\n",
    "\n",
    "    import numpy as np\n",
    "\n",
    "    X = np.ravel(x_stat).tolist()\n",
    "    Y = np.ravel(y_stat).tolist()\n",
    "\n",
    "    return X,Y\n",
    "\n",
    "# unravels nonnetwork data. x_stat and y_stat should be pd dataframes. x_measure and y_measure are the measure to unrvavel. \n",
    "# designed for test retest. x_stat and y_stat should have the same number of rows. but more importantly, should correspond to the same source (i.e. subject)\n",
    "# can be same pd.dataframe, but indexing of specific subject groups\n",
    "def ravel_non_network(x_stat,y_stat,x_measure,y_measure):\n",
    "\n",
    "    X = x_stat[x_measure].to_list()\n",
    "    Y = y_stat[y_measure].to_list()\n",
    "\n",
    "    return X,Y\n",
    "\n",
    "# wrapper function to call either of the above scripts based on user input\n",
    "def setup_data(x_data,y_data,x_measure,y_measure,ravelAverageAppend,isnetwork,measure):\n",
    "\n",
    "    x_stat = x_data\n",
    "    y_stat = y_data\n",
    "\n",
    "    if ravelAverageAppend == 'average':\n",
    "        X,Y = average_within_column(x_stat,y_stat,x_measure,y_measure,measure)\n",
    "    elif ravelAverageAppend == 'append':\n",
    "        X,Y = append_within_column(x_stat,y_stat,x_measure,y_measure,measure)\n",
    "    elif ravelAverageAppend == 'ravel':\n",
    "        if isnetwork == True:\n",
    "            X,Y = ravel_network(x_stat,y_stat)\n",
    "        else:\n",
    "            X,Y = ravel_non_network(x_stat,y_stat,x_measure,y_measure)\n",
    "\n",
    "    return x_stat,y_stat,X,Y\n",
    "\n",
    "# function to shuffle data and colors\n",
    "def shuffle_data_alg(X,Y,hues):\n",
    "\n",
    "    from sklearn.utils import shuffle\n",
    "\n",
    "    X,Y,hues = shuffle(X,Y,hues)\n",
    "\n",
    "    return X,Y,hues\n",
    "\n",
    "# simple display or figure save function\n",
    "def save_or_show_img(dir_out,x_measure,y_measure,img_name):\n",
    "    import os,sys \n",
    "    import matplotlib.pyplot as plt\n",
    "    import warnings\n",
    "    \n",
    "    with warnings.catch_warnings():\n",
    "        # this will suppress all warnings in this block\n",
    "        warnings.simplefilter(\"ignore\")\n",
    " \n",
    "        # save or show plot\n",
    "        if dir_out:\n",
    "            if not os.path.exists(dir_out):\n",
    "                os.mkdir(dir_out)\n",
    "\n",
    "            if x_measure == y_measure:\n",
    "                img_name_eps = img_name+'_'+x_measure+'.eps'\n",
    "                img_name_png = img_name+'_'+x_measure+'.png'\n",
    "                img_name_svg = img_name+'_'+x_measure+'.svg'\n",
    "            else:\n",
    "                img_name_eps = img_name+'_'+x_measure+'_vs_'+y_measure+'.eps'\n",
    "                img_name_png = img_name+'_'+x_measure+'_vs_'+y_measure+'.png'\n",
    "                img_name_svg = img_name+'_'+x_measure+'_vs_'+y_measure+'.svg'\n",
    "\n",
    "            plt.savefig(os.path.join(dir_out, img_name_eps),transparent=True)\n",
    "            plt.savefig(os.path.join(dir_out, img_name_png))     \n",
    "        else:\n",
    "            plt.show()\n",
    "\n",
    "        # plt.close()\n",
    "    \n",
    "# uses seaborn's relplot function to plot data for each unique value in a column of a pandas dataframe (ex. subjects, structureID). useful for supplementary figures or sanity checking or preliminary results\n",
    "# column measure is the measure within which each unique value will have its own plot. hue_measure is the column to use for coloring the data. column_wrap is how many panels you want per row\n",
    "# trendline, depending on user input, can either be the linear regression between x_data[x_measure] and y_data[y_measure] or the line of equality\n",
    "# dir_out and img_name are the directory where the figures should be saved and the name for the image. will save .eps and .png\n",
    "# if want to view plot instead of save, set dir_out=\"\"\n",
    "def relplot_scatter(x_data,y_data,x_measure,y_measure,column_measure,hue_measure,column_wrap,trendline,dir_out,img_name):\n",
    "\n",
    "    import os,sys\n",
    "    import numpy as np\n",
    "    import matplotlib.pyplot as plt\n",
    "    import seaborn as sns\n",
    "    from sklearn.metrics import mean_squared_error\n",
    "\n",
    "    # grab data: CANNOT BE AVERAGE\n",
    "    [x_stat,y_stat,X,Y] = setup_data(x_data,y_data,x_measure,y_measure,'ravel',False,hue_measure)\n",
    "\n",
    "    p = sns.relplot(x=X,y=Y,col=x_stat[column_measure],hue=x_stat[hue_measure],kind=\"scatter\",s=100,col_wrap=column_wrap)\n",
    "\n",
    "    # setting counter. looping through axes to add important info and regression lines\n",
    "    i = 0\n",
    "    for ax in p.axes.flat:\n",
    "        x_lim,y_lim = [ax.get_xlim(),ax.get_ylim()]\n",
    "\n",
    "        if trendline == 'equality':\n",
    "            ax.plot(x_lim,y_lim,ls=\"--\",c='k')\n",
    "        elif trendline == 'linreg':\n",
    "            m,b = np.polyfit(p.data[p.data[column_measure] == x_stat[column_measure].unique()[i]]['x'],p.data[p.data[column_measure] == y_stat[column_measure].unique()[i]]['y'],1)\n",
    "            ax.plot(ax.get_xticks(),m*ax.get_xticks() + b)\n",
    "            plt.text(0.1,0.7,'y = %s x + %s' %(str(np.round(m,4)),str(np.round(b,4))),fontsize=12,verticalalignment=\"top\",horizontalalignment=\"left\",transform=ax.transAxes)\n",
    "\n",
    "        ax.set_xlim(x_lim)\n",
    "        ax.set_ylim(y_lim)\n",
    "        ax.set_xlabel(x_measure)\n",
    "        ax.set_ylabel(y_measure)\n",
    "\n",
    "        # compute correlation for each subject and add to plots\n",
    "        corr = np.corrcoef(p.data[p.data[column_measure] == x_stat[column_measure].unique()[i]]['x'],p.data[p.data[column_measure] == y_stat[column_measure].unique()[i]]['y'])[1][0]\n",
    "        plt.text(0.1,0.9,'r = %s' %str(np.round(corr,4)),fontsize=12,verticalalignment=\"top\",horizontalalignment=\"left\",transform=ax.transAxes)\n",
    "\n",
    "        # compute rmse for each subject and add to plots\n",
    "        rmse = np.sqrt(mean_squared_error(p.data[p.data[column_measure] == x_stat[column_measure].unique()[i]]['x'],p.data[p.data[column_measure] == y_stat[column_measure].unique()[i]]['y']))\n",
    "        plt.text(0.1,0.8,'rmse = %s' %str(np.round(rmse,4)),fontsize=12,verticalalignment=\"top\",horizontalalignment=\"left\",transform=ax.transAxes)\n",
    "\n",
    "        # update counter\n",
    "        i = i+1\n",
    "\n",
    "    # save image or show image\n",
    "    save_or_show_img(dir_out,x_measure,y_measure,img_name)\n",
    "\n",
    "# uses seaborn's scatter function to plot data from x_data[x_measure] and y_data[y_measure]. useful for publication worthy figure\n",
    "# column measure is the measure within which data will be summarized. hue_measure is the column to use for coloring the data. \n",
    "# ravelAverageAppend is a string value of either 'append' to use the append function, 'ravel' to use the ravel function, or 'average' to use the average function\n",
    "# trendline, depending on user input, can either be the linear regression between x_data[x_measure] and y_data[y_measure] or the line of equality\n",
    "# dir_out and img_name are the directory where the figures should be saved and the name for the image. will save .eps and .png\n",
    "# if want to view plot instead of save, set dir_out=\"\"\n",
    "def singleplot_scatter(colors_dict,x_data,y_data,x_measure,y_measure,logX,column_measure,hue_measure,ravelAverageAppend,trendline,shuffleData,colorDistance,perfectOrSlope,subsample_percentage,dir_out,img_name):\n",
    "\n",
    "    import os,sys\n",
    "    import numpy as np\n",
    "    import matplotlib.pyplot as plt\n",
    "    import seaborn as sns\n",
    "    from sklearn.metrics import mean_squared_error\n",
    "\n",
    "    # grab data\n",
    "    [x_stat,y_stat,X,Y] = setup_data(x_data,y_data,x_measure,y_measure,ravelAverageAppend,False,column_measure)\n",
    "    \n",
    "    # compute corr and rmse first in case data gets subsampled later\n",
    "    corr = np.corrcoef(X,Y)[1][0]\n",
    "    rmse = np.sqrt(mean_squared_error(X,Y))\n",
    "    \n",
    "    # map trendlines before subsampling\n",
    "    if trendline == 'linreg':\n",
    "        m,b = np.polyfit(X,Y,1)\n",
    "    elif trendline == 'groupreg':\n",
    "        for g in range(len(groups)):\n",
    "            if stat_name == 'volume':\n",
    "                slope, intercept, r_value, p_value, std_err = stats.linregress(np.log10(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name]),stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm])\n",
    "            else:\n",
    "                slope, intercept, r_value, p_value, std_err = stats.linregress(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name],stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm])\n",
    "\n",
    "    if subsample_percentage:\n",
    "        X,Y = subsample_data(X,Y,subsample_percentage)\n",
    "    \n",
    "    if colorDistance:\n",
    "        category = color_distance_scatter(X,Y,perfectOrSlope)\n",
    "    else:\n",
    "        colors = sns.color_palette('colorblind',len(x_stat[hue_measure]))\n",
    "\n",
    "    if ravelAverageAppend == 'average':\n",
    "        if isinstance(x_stat[hue_measure].unique()[0],str):\n",
    "            hues = x_stat[hue_measure].unique().tolist()\n",
    "        else:\n",
    "            hues = x_stat.groupby(column_measure).mean()[hue_measure].tolist()\n",
    "    else:\n",
    "        hues = list(x_stat[hue_measure])\n",
    "\n",
    "    if shuffleData == True:\n",
    "        X,Y,hues = shuffle_data_alg(X,Y,hues)\n",
    "\n",
    "    if logX == True:\n",
    "        X = np.log10(X)\n",
    "\n",
    "    if colors_dict:\n",
    "        p = sns.scatterplot(x=X,y=Y,hue=hues,s=100,palette=colors_dict,legend=False)\n",
    "    elif colorDistance:\n",
    "        p = sns.scatterplot(x=X,y=Y,hue=category,hue_order=['two-sd','one-sd','lt-one-sd'],palette=['red','green','blue'],s=100)\n",
    "    else:\n",
    "        p = sns.scatterplot(x=X,y=Y,hue=hues,s=100)\n",
    "\n",
    "    # set x and ylimits, plot line of equality, and legend\n",
    "    if x_measure == y_measure:\n",
    "        p.axes.axis('square')\n",
    "        y_ticks = p.axes.get_yticks()\n",
    "        p.axes.set_xticks(y_ticks)\n",
    "        p.axes.set_yticks(p.axes.get_xticks())\n",
    "        p.axes.set_ylim(p.axes.get_xlim())\n",
    "        p.axes.set_xlim(p.axes.get_xlim())\n",
    "\n",
    "    x_lim,y_lim = [p.axes.get_xlim(),p.axes.get_ylim()]\n",
    "\n",
    "    # trendline: either equality or linear regression\n",
    "    if trendline == 'equality':\n",
    "        p.plot(x_lim,y_lim,ls=\"--\",c='k')\n",
    "        ax = plt.gca()\n",
    "        ax.get_legend().remove()\n",
    "    elif trendline == 'linreg':\n",
    "        m,b = np.polyfit(X,Y,1)\n",
    "        p.plot(p.get_xticks(),m*p.get_xticks() + b,c='k')\n",
    "        plt.text(0.1,0.7,'y = %s x + %s' %(str(np.round(m,4)),str(np.round(b,4))),fontsize=16,verticalalignment=\"top\",horizontalalignment=\"left\",transform=p.axes.transAxes)\n",
    "        ax = plt.gca()\n",
    "        ax.get_legend().remove()\n",
    "\n",
    "    elif trendline == 'groupreg':\n",
    "        for g in range(len(groups)):\n",
    "            if stat_name == 'volume':\n",
    "                slope, intercept, r_value, p_value, std_err = stats.linregress(np.log10(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name]),stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm])\n",
    "                ax = sns.regplot(x=np.log10(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name]),y=stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm],color=colors[groups[g]],scatter=True,line_kws={'label':\"y={0:.5f}x+{1:.4f}\".format(slope,intercept)})\n",
    "\n",
    "            else:\n",
    "                slope, intercept, r_value, p_value, std_err = stats.linregress(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name],stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm])\n",
    "                ax = sns.regplot(x=stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name],y=stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm],color=colors[groups[g]],scatter=True,line_kws={'label':\"y={0:.5f}x+{1:.4f}\".format(slope,intercept)})\n",
    "\n",
    "            ax.legend()\n",
    "\n",
    "    # compute correlation for each subject and add to plots\n",
    "    plt.text(0.1,0.9,'r = %s' %str(np.round(corr,4)),fontsize=16,verticalalignment=\"top\",horizontalalignment=\"left\",transform=p.axes.transAxes)\n",
    "\n",
    "    # compute rmse for each subject and add to plots\n",
    "    plt.text(0.1,0.8,'rmse = %s' %str(np.round(rmse,4)),fontsize=16,verticalalignment=\"top\",horizontalalignment=\"left\",transform=p.axes.transAxes)\n",
    "\n",
    "    # set title and x and y labels\n",
    "    plt.title('%s vs %s' %(x_measure,y_measure),fontsize=20)\n",
    "    plt.xlabel(x_measure,fontsize=18)\n",
    "    plt.ylabel(y_measure,fontsize=18)\n",
    "    plt.xticks(fontsize=16)\n",
    "    plt.yticks(fontsize=16)\n",
    "\n",
    "    # remove top and right spines from plot\n",
    "    p.axes.spines[\"top\"].set_visible(False)\n",
    "    p.axes.spines[\"right\"].set_visible(False)\n",
    "\n",
    "    # save image or show image\n",
    "    save_or_show_img(dir_out,x_measure,y_measure,img_name)\n",
    "    \n",
    "# this function will plot group summarized tract profile data, but can also be used with any timeseries-like data\n",
    "def plot_profiles(structures,stat,diffusion_measures,summary_method,error_method,dir_out,img_name):\n",
    "\n",
    "    # loop through all structures\n",
    "    for t in structures:\n",
    "        print(t)\n",
    "        # loop through all measures\n",
    "        for dm in diffusion_measures:\n",
    "            print(dm)\n",
    "\n",
    "            imgname=img_name+\"_\"+t+\"_\"+dm\n",
    "\n",
    "            # generate figures\n",
    "            fig = plt.figure(figsize=(15,15))\n",
    "\n",
    "            # fig.patch.set_visible(False)\n",
    "            p = plt.subplot()\n",
    "            \n",
    "            # set title and catch array for legend handle\n",
    "            plt.title(\"%s Profiles %s: %s\" %(summary_method,t,dm),fontsize=20)\n",
    "\n",
    "            # loop through groups and plot profile data\n",
    "            for g in range(len(stat.classID.unique())):\n",
    "                # x is nodes\n",
    "                x = stat['nodeID'].unique()\n",
    "\n",
    "                # y is summary (mean, median, max, main) profile data\n",
    "                if summary_method == 'mean':\n",
    "                    y = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).mean()[dm][t]\n",
    "                elif summary_method == 'median':\n",
    "                    y = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).median()[dm][t]\n",
    "                elif summary_method == 'max':\n",
    "                    y = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).max()[dm][t]\n",
    "                elif summary_method == 'min':\n",
    "                    y = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).min()[dm][t]\n",
    "\n",
    "                # error bar is either: standard error of mean (sem), standard deviation (std)\n",
    "                if error_method == 'sem':\n",
    "                    err = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).std()[dm][t] / np.sqrt(len(stat[stat['classID'] == stat.classID.unique()[g]]['subjectID'].unique()))\n",
    "                else:\n",
    "                    err = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).std()[dm][t]\n",
    "\n",
    "                # plot summary\n",
    "                plt.plot(x,y,color=stat[stat['classID'] == stat.classID.unique()[g]]['colors'].unique()[0],linewidth=5,label=stat.classID.unique()[g])\n",
    "\n",
    "                # plot shaded error\n",
    "                plt.fill_between(x,y-err,y+err,alpha=0.2,color=stat[stat['classID'] == stat.classID.unique()[g]]['colors'].unique()[0],label='1 %s %s' %(error_method,stat.classID.unique()[g]))\n",
    "\n",
    "            # set up labels and ticks\n",
    "            plt.xlabel('Location',fontsize=18)\n",
    "            plt.ylabel(dm,fontsize=18)\n",
    "            plt.xticks([x[0],x[-1]],['Begin','End'],fontsize=16)\n",
    "            plt.legend(fontsize=16)\n",
    "            y_lim = plt.ylim()\n",
    "            plt.yticks([np.round(y_lim[0],2),np.mean(y_lim),np.round(y_lim[1],2)],fontsize=16)\n",
    "\n",
    "            # remove top and right spines from plot\n",
    "            p.axes.spines[\"top\"].set_visible(False)\n",
    "            p.axes.spines[\"right\"].set_visible(False)\n",
    "\n",
    "            # save image or show image\n",
    "            save_or_show_img(dir_out,dm,dm,imgname)\n",
    "            \n",
    "# this function will identify data within 1 sd, between 1 and 2sd, and 2 sd or greater within a scatter distrbution. intended to be used when comparing a/b\n",
    "# like analyses (i.e. test retest, validity, etc)\n",
    "def color_distance_scatter(x,y,perfectOrSlope):\n",
    "    from scipy import stats\n",
    "    import numpy as np\n",
    "    import math\n",
    "\n",
    "    ### this process creates a list of sd categories by rotating the x,y distribution\n",
    "    ### by 45 degrees (to make the slope essentially zero) and computing the standard\n",
    "    ### deviation along the y-axis. then, it identifies whether the y-data falls either\n",
    "    ### within 1 sd, within 1-2 sd, and greater than 2 sds\n",
    "    \n",
    "    # if users want to compute distribution around perfect 45 deg equality line or around\n",
    "    # the actual data slope\n",
    "    if perfectOrSlope == True:\n",
    "        m = 1\n",
    "    else:\n",
    "        m,b = np.polyfit(x,y,1)\n",
    "    \n",
    "    # compute theta as the clockwise atan rotation along m\n",
    "    theta = -math.atan(m)\n",
    "    \n",
    "    # generate rotation matrix\n",
    "    r = np.array([[np.cos(theta),-np.sin(theta)],[np.sin(theta),np.cos(theta)]])\n",
    "    \n",
    "    # compute rotation\n",
    "    [x_dif,y_dif] = r.dot(np.array([x,y]))\n",
    "\n",
    "    # set output variable (category)\n",
    "    category = []\n",
    "    \n",
    "    # compute standard deviation thresholds for difference values\n",
    "    one_sd = np.std(np.abs(y_dif))\n",
    "    two_sd = one_sd * 2\n",
    "\n",
    "    # loop through each data point and determine category (one sd: within 1 and 2 sds, two-sd: greater or equal to 2 sds, lt-one-sd: within one sd)\n",
    "    category = [ 'one-sd' if one_sd <= f < two_sd else 'two-sd' if f >= two_sd else 'lt-one-sd' for f in np.abs(y_dif) ]\n",
    "    \n",
    "    return category\n",
    "\n",
    "# this function will randomly subsample the data to make lighter visualization images\n",
    "def subsample_data(x,y,percentage):\n",
    "    \n",
    "    data = np.array([x,y])\n",
    "    subsample = np.random.choice(data.shape[1],int(len(data[0])*(percentage/100)),replace=False)\n",
    "    \n",
    "    sub_x = data[0,subsample]\n",
    "    sub_y = data[1,subsample]\n",
    "    \n",
    "    return sub_x, sub_y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57bc8a02",
   "metadata": {},
   "source": [
    "## Generating subject demographic dataframe\n",
    "Now that we've loaded all the functions needed, but before we get started collecting and analyzing our data, we first need to generate a subjects demographic database. This can include information stored in the participants.json file stored in the Project's Detail tab, but can also be user-generated. This is so we can then append that relevant information to each of the data structures we collect, compile, and generate for analysis. This makes it easier to build models and to perform statistical analyses with co-variates.\n",
    "\n",
    "In the case of Hayashi & Caron et al (in prep), since I was using data from multiple Big Data repositories including the Human Connectome Project, the Cambridge Centre for Ageing and Neuroscience (Cam-CAN), and the Pediatric Imaging, Neurocognition, and Genetics (PING) Dataset  I uploaded the important subject identification and demographic data directly from each project's respective repository. I scrubbed the data of most of the relevant demographic information, as I was mostly only concerned with the participant's subject ID, age, and gender.\n",
    "\n",
    "In order to ensure participant anonymity, I've only included the subjectID in the example subjects_data.csv dataframe.\n",
    "\n",
    "Within this dataframe, I've also added a classID column corresponding to the project identification name (i.e. hcp, camcan, ping) and a colors column corresponding to the color I assigned to each project (hcp: green, camcan: orange, ping: purple).\n",
    "\n",
    "After this, I then created a color dictionary with a unique color for each participant in the project. This can make outlier detection a bit easier.\n",
    "\n",
    "In this example notebook, I will be using the HCP dataset!\n",
    "\n",
    "Finally, within this section we will also set up our data and image directories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bb3717c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setting up variables\n",
      "setting up variables complete\n",
      "grabbing demographic data\n",
      "grabbing demographic data complete\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_24176/1637281729.py:28: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  subjects_data['subjectID'] = [ str(int(np.float(f))) for f in subjects_data.subjectID ]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>subjectID</th>\n",
       "      <th>classID</th>\n",
       "      <th>colors</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100004</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>100206</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100307</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>100408</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>100610</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1201</th>\n",
       "      <td>992774</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1202</th>\n",
       "      <td>993675</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1203</th>\n",
       "      <td>994273</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1204</th>\n",
       "      <td>995174</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1205</th>\n",
       "      <td>996782</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1206 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     subjectID classID colors\n",
       "0       100004     hcp   blue\n",
       "1       100206     hcp   blue\n",
       "2       100307     hcp   blue\n",
       "3       100408     hcp   blue\n",
       "4       100610     hcp   blue\n",
       "...        ...     ...    ...\n",
       "1201    992774     hcp   blue\n",
       "1202    993675     hcp   blue\n",
       "1203    994273     hcp   blue\n",
       "1204    995174     hcp   blue\n",
       "1205    996782     hcp   blue\n",
       "\n",
       "[1206 rows x 3 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### setting up variables and adding paths\n",
    "print(\"setting up variables\")\n",
    "topPath = \"./\"\n",
    "os.chdir(topPath)\n",
    "data_dir = topPath+'/data/'\n",
    "if not os.path.exists(data_dir):\n",
    "    os.mkdir(data_dir)\n",
    "img_dir = topPath+'/img/'\n",
    "if not os.path.exists(img_dir):\n",
    "    os.mkdir(img_dir)\n",
    "\n",
    "# set up project identification (groups) and the project color (green)\n",
    "groups = ['hcp']\n",
    "colors_array = ['green']\n",
    "diff_micro_measures = ['ad','fa','md','rd','ndi','odi','isovf']\n",
    "print(\"setting up variables complete\")\n",
    "\n",
    "### grabbing subjects demographic data\n",
    "print(\"grabbing demographic data\")\n",
    "if os.path.isfile(data_dir+'/subjects_data.csv'):\n",
    "    subjects_data = pd.read_csv(data_dir+'/subjects_data.csv')\n",
    "else:\n",
    "    subjects_data = pd.read_json('input/participants.json')\n",
    "print(\"grabbing demographic data complete\")\n",
    "\n",
    "# hcp stored their subject IDs as integers instead of strings. changing that here\n",
    "if subjects_data['subjectID'].dtype == 'int':\n",
    "    subjects_data['subjectID'] = [ str(int(np.float(f))) for f in subjects_data.subjectID ]\n",
    "\n",
    "# create column for classID and colors\n",
    "subjects_data['classID'] = [ 'hcp' for f in subjects_data['subjectID'] ]\n",
    "subjects_data['colors'] = [ 'blue' for f in subjects_data['subjectID'] ]\n",
    "\n",
    "### generate colors dictionary with a unique color for each subject\n",
    "colors = {}\n",
    "subjects = {}\n",
    "\n",
    "# loop through groups and identify subjects and set color schema for each group\n",
    "for g in range(len(groups)):\n",
    "    # set subjects array\n",
    "    subjects[groups[g]] =  subjects_data['subjectID']\n",
    "    subjects[groups[g]].sort_values()\n",
    "    \n",
    "    # set colors array\n",
    "    colors_name = colors_array[g]\n",
    "    colors[groups[g]] = colors_array[g]\n",
    "\n",
    "# create subjects color dictionary\n",
    "colors_dict = create_color_dictionary(subjects_data,'subjectID','colorblind')\n",
    "\n",
    "## here's what the subjects_data dataframe looks like!\n",
    "subjects_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17ce22bd",
   "metadata": {},
   "source": [
    "## Collecting statistical data of cortical and subcortical parcels\n",
    "Now that we've generated our subjects dataframe, the next step is to collect, collate, and clean data pertaining to structural statistics of cortical and subcortical parcels. This data comes from the neuro/parc-stats datatypes.\n",
    "\n",
    "For this project, I specifically collected data from each participant of the HCP dataset pertaining to the macrostructural (thickness, surface area, volume) and microstructural (derived from diffusion MRI models) statistics of each cortical and subcortical parcel derived from Freesurfer and the Desikan-Killany atlas (aparc.a2009s) and the subcoritcal (aseg) segmentation, and the HCP-MMP cortical parcellation.\n",
    "\n",
    "The resulting data structures compile the cortical and subcortical parcel data from all participants into two respective dataframe. For the cortical dataframe, data from both atlases are compiled together into a single dataframe, with each atlas receiving it's own specific identifier ('parcellation').\n",
    "\n",
    "Following this, I cleaned and removed any data that fell outside known physical and measure limitations. Specifically, any rows with values outside of 0-1 FA, and/or 0-3 AD, MD, or RD were removed from the final dataframes.\n",
    "\n",
    "As this notebook exists outside of the project directory on brainlife.io, I've included the final cortical and subcortical dataframes to the github repository in the data directory (cortical_glasser.csv, cortical_glasser_parcel_volume.csv, cortical_aparc.csv, cortical_aparc_parcel_volume.csv, cortical.csv, subcortical.csv, cortical_cleaned.csv, and subcortical_cleaned.csv). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9998dcbd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "computing gray matter parcel analyses\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>subjectID</th>\n",
       "      <th>structureID</th>\n",
       "      <th>nodeID</th>\n",
       "      <th>ad</th>\n",
       "      <th>fa</th>\n",
       "      <th>md</th>\n",
       "      <th>rd</th>\n",
       "      <th>ndi</th>\n",
       "      <th>isovf</th>\n",
       "      <th>odi</th>\n",
       "      <th>...</th>\n",
       "      <th>number_of_vertices</th>\n",
       "      <th>surface_area_mm^2</th>\n",
       "      <th>gray_matter_volume_mm^3</th>\n",
       "      <th>average_thickness_mm</th>\n",
       "      <th>thickness_stddev_mm</th>\n",
       "      <th>integrated_rectified_mean_curvature_mm^-1</th>\n",
       "      <th>integrated_rectified_gaussian_curvature_mm^-2</th>\n",
       "      <th>folding_index</th>\n",
       "      <th>intrinsic_curvature_index</th>\n",
       "      <th>parcellation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_V1_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.135073</td>\n",
       "      <td>0.152558</td>\n",
       "      <td>0.994888</td>\n",
       "      <td>0.924796</td>\n",
       "      <td>0.323368</td>\n",
       "      <td>0.180941</td>\n",
       "      <td>0.432233</td>\n",
       "      <td>...</td>\n",
       "      <td>7732</td>\n",
       "      <td>4586</td>\n",
       "      <td>10660</td>\n",
       "      <td>2.178</td>\n",
       "      <td>0.436</td>\n",
       "      <td>0.128</td>\n",
       "      <td>0.034</td>\n",
       "      <td>117</td>\n",
       "      <td>10.8</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_MST_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.079538</td>\n",
       "      <td>0.241214</td>\n",
       "      <td>0.864003</td>\n",
       "      <td>0.756235</td>\n",
       "      <td>0.348970</td>\n",
       "      <td>0.124685</td>\n",
       "      <td>0.294187</td>\n",
       "      <td>...</td>\n",
       "      <td>326</td>\n",
       "      <td>222</td>\n",
       "      <td>407</td>\n",
       "      <td>2.212</td>\n",
       "      <td>0.304</td>\n",
       "      <td>0.126</td>\n",
       "      <td>0.024</td>\n",
       "      <td>3</td>\n",
       "      <td>0.4</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_V6_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.098271</td>\n",
       "      <td>0.163443</td>\n",
       "      <td>0.954007</td>\n",
       "      <td>0.881875</td>\n",
       "      <td>0.300102</td>\n",
       "      <td>0.152846</td>\n",
       "      <td>0.377738</td>\n",
       "      <td>...</td>\n",
       "      <td>865</td>\n",
       "      <td>563</td>\n",
       "      <td>1213</td>\n",
       "      <td>2.140</td>\n",
       "      <td>0.361</td>\n",
       "      <td>0.122</td>\n",
       "      <td>0.023</td>\n",
       "      <td>11</td>\n",
       "      <td>0.9</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_V2_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.099213</td>\n",
       "      <td>0.153434</td>\n",
       "      <td>0.962799</td>\n",
       "      <td>0.894592</td>\n",
       "      <td>0.316592</td>\n",
       "      <td>0.157004</td>\n",
       "      <td>0.425005</td>\n",
       "      <td>...</td>\n",
       "      <td>4965</td>\n",
       "      <td>3198</td>\n",
       "      <td>7580</td>\n",
       "      <td>2.209</td>\n",
       "      <td>0.442</td>\n",
       "      <td>0.157</td>\n",
       "      <td>0.038</td>\n",
       "      <td>89</td>\n",
       "      <td>8.5</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_V3_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.120492</td>\n",
       "      <td>0.151319</td>\n",
       "      <td>0.981672</td>\n",
       "      <td>0.912262</td>\n",
       "      <td>0.297853</td>\n",
       "      <td>0.155597</td>\n",
       "      <td>0.394120</td>\n",
       "      <td>...</td>\n",
       "      <td>2593</td>\n",
       "      <td>1770</td>\n",
       "      <td>4537</td>\n",
       "      <td>2.241</td>\n",
       "      <td>0.345</td>\n",
       "      <td>0.153</td>\n",
       "      <td>0.035</td>\n",
       "      <td>47</td>\n",
       "      <td>3.9</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_V4_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.033053</td>\n",
       "      <td>0.170728</td>\n",
       "      <td>0.885085</td>\n",
       "      <td>0.811101</td>\n",
       "      <td>0.297307</td>\n",
       "      <td>0.111915</td>\n",
       "      <td>0.376652</td>\n",
       "      <td>...</td>\n",
       "      <td>2572</td>\n",
       "      <td>1761</td>\n",
       "      <td>4389</td>\n",
       "      <td>2.293</td>\n",
       "      <td>0.389</td>\n",
       "      <td>0.130</td>\n",
       "      <td>0.025</td>\n",
       "      <td>31</td>\n",
       "      <td>2.8</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_V8_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>0.983062</td>\n",
       "      <td>0.174704</td>\n",
       "      <td>0.840748</td>\n",
       "      <td>0.769591</td>\n",
       "      <td>0.283042</td>\n",
       "      <td>0.075349</td>\n",
       "      <td>0.382062</td>\n",
       "      <td>...</td>\n",
       "      <td>331</td>\n",
       "      <td>220</td>\n",
       "      <td>810</td>\n",
       "      <td>3.199</td>\n",
       "      <td>0.398</td>\n",
       "      <td>0.151</td>\n",
       "      <td>0.040</td>\n",
       "      <td>6</td>\n",
       "      <td>0.6</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_4_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.132706</td>\n",
       "      <td>0.210307</td>\n",
       "      <td>0.955466</td>\n",
       "      <td>0.866846</td>\n",
       "      <td>0.367456</td>\n",
       "      <td>0.181493</td>\n",
       "      <td>0.377337</td>\n",
       "      <td>...</td>\n",
       "      <td>3824</td>\n",
       "      <td>2107</td>\n",
       "      <td>6426</td>\n",
       "      <td>2.725</td>\n",
       "      <td>0.467</td>\n",
       "      <td>0.096</td>\n",
       "      <td>0.023</td>\n",
       "      <td>30</td>\n",
       "      <td>3.7</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_3b_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.224648</td>\n",
       "      <td>0.167381</td>\n",
       "      <td>1.072879</td>\n",
       "      <td>0.996995</td>\n",
       "      <td>0.318258</td>\n",
       "      <td>0.220237</td>\n",
       "      <td>0.415740</td>\n",
       "      <td>...</td>\n",
       "      <td>2124</td>\n",
       "      <td>1383</td>\n",
       "      <td>2742</td>\n",
       "      <td>1.857</td>\n",
       "      <td>0.360</td>\n",
       "      <td>0.093</td>\n",
       "      <td>0.017</td>\n",
       "      <td>17</td>\n",
       "      <td>1.5</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>100206</td>\n",
       "      <td>L_FEF_ROI</td>\n",
       "      <td>1</td>\n",
       "      <td>1.114071</td>\n",
       "      <td>0.170683</td>\n",
       "      <td>0.958688</td>\n",
       "      <td>0.880997</td>\n",
       "      <td>0.287146</td>\n",
       "      <td>0.136502</td>\n",
       "      <td>0.367911</td>\n",
       "      <td>...</td>\n",
       "      <td>700</td>\n",
       "      <td>433</td>\n",
       "      <td>1239</td>\n",
       "      <td>2.664</td>\n",
       "      <td>0.402</td>\n",
       "      <td>0.106</td>\n",
       "      <td>0.021</td>\n",
       "      <td>6</td>\n",
       "      <td>0.6</td>\n",
       "      <td>glasser</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>10 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "  subjectID structureID  nodeID        ad        fa        md        rd  \\\n",
       "0    100206    L_V1_ROI       1  1.135073  0.152558  0.994888  0.924796   \n",
       "1    100206   L_MST_ROI       1  1.079538  0.241214  0.864003  0.756235   \n",
       "2    100206    L_V6_ROI       1  1.098271  0.163443  0.954007  0.881875   \n",
       "3    100206    L_V2_ROI       1  1.099213  0.153434  0.962799  0.894592   \n",
       "4    100206    L_V3_ROI       1  1.120492  0.151319  0.981672  0.912262   \n",
       "5    100206    L_V4_ROI       1  1.033053  0.170728  0.885085  0.811101   \n",
       "6    100206    L_V8_ROI       1  0.983062  0.174704  0.840748  0.769591   \n",
       "7    100206     L_4_ROI       1  1.132706  0.210307  0.955466  0.866846   \n",
       "8    100206    L_3b_ROI       1  1.224648  0.167381  1.072879  0.996995   \n",
       "9    100206   L_FEF_ROI       1  1.114071  0.170683  0.958688  0.880997   \n",
       "\n",
       "        ndi     isovf       odi  ...  number_of_vertices  surface_area_mm^2  \\\n",
       "0  0.323368  0.180941  0.432233  ...                7732               4586   \n",
       "1  0.348970  0.124685  0.294187  ...                 326                222   \n",
       "2  0.300102  0.152846  0.377738  ...                 865                563   \n",
       "3  0.316592  0.157004  0.425005  ...                4965               3198   \n",
       "4  0.297853  0.155597  0.394120  ...                2593               1770   \n",
       "5  0.297307  0.111915  0.376652  ...                2572               1761   \n",
       "6  0.283042  0.075349  0.382062  ...                 331                220   \n",
       "7  0.367456  0.181493  0.377337  ...                3824               2107   \n",
       "8  0.318258  0.220237  0.415740  ...                2124               1383   \n",
       "9  0.287146  0.136502  0.367911  ...                 700                433   \n",
       "\n",
       "  gray_matter_volume_mm^3 average_thickness_mm thickness_stddev_mm  \\\n",
       "0                   10660                2.178               0.436   \n",
       "1                     407                2.212               0.304   \n",
       "2                    1213                2.140               0.361   \n",
       "3                    7580                2.209               0.442   \n",
       "4                    4537                2.241               0.345   \n",
       "5                    4389                2.293               0.389   \n",
       "6                     810                3.199               0.398   \n",
       "7                    6426                2.725               0.467   \n",
       "8                    2742                1.857               0.360   \n",
       "9                    1239                2.664               0.402   \n",
       "\n",
       "  integrated_rectified_mean_curvature_mm^-1  \\\n",
       "0                                     0.128   \n",
       "1                                     0.126   \n",
       "2                                     0.122   \n",
       "3                                     0.157   \n",
       "4                                     0.153   \n",
       "5                                     0.130   \n",
       "6                                     0.151   \n",
       "7                                     0.096   \n",
       "8                                     0.093   \n",
       "9                                     0.106   \n",
       "\n",
       "   integrated_rectified_gaussian_curvature_mm^-2  folding_index  \\\n",
       "0                                          0.034            117   \n",
       "1                                          0.024              3   \n",
       "2                                          0.023             11   \n",
       "3                                          0.038             89   \n",
       "4                                          0.035             47   \n",
       "5                                          0.025             31   \n",
       "6                                          0.040              6   \n",
       "7                                          0.023             30   \n",
       "8                                          0.017             17   \n",
       "9                                          0.021              6   \n",
       "\n",
       "   intrinsic_curvature_index  parcellation  \n",
       "0                       10.8       glasser  \n",
       "1                        0.4       glasser  \n",
       "2                        0.9       glasser  \n",
       "3                        8.5       glasser  \n",
       "4                        3.9       glasser  \n",
       "5                        2.8       glasser  \n",
       "6                        0.6       glasser  \n",
       "7                        3.7       glasser  \n",
       "8                        1.5       glasser  \n",
       "9                        0.6       glasser  \n",
       "\n",
       "[10 rows x 27 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### structural and diffusion data in cortical and subcortical structures\n",
    "print(\"computing gray matter parcel analyses\")\n",
    "\n",
    "# create data structures\n",
    "# cortical measures - glasser\n",
    "# if os.path.isfile(data_dir+'/cortical_glasser.csv'):\n",
    "#     cortical_glasser = pd.read_csv(data_dir+'/cortical_glasser.csv')\n",
    "# else:\n",
    "#     cortical_glasser =  collect_data('neuro/parc-stats',['cortex_mapping_stats'],['glasser'],'parc_MEAN.csv',data_dir+'/cortical_glasser.csv',False)\n",
    "#     cortical_glasser = cortical_glasser.drop_duplicates()\n",
    "#     cortical_glasser['subjectID'] = cortical_glasser.subjectID.astype(str)\n",
    "#     cortical_glasser = pd.merge(cortical_glasser,subjects_data,on='subjectID')\n",
    "#     cortical_glasser.to_csv(data_dir+'/cortical_glasser.csv',index=False)\n",
    "\n",
    "# # replace vertex volume measure with overall parcel volume\n",
    "# if os.path.isfile(data_dir+'/cortical_glasser_parcel_volume.csv'):\n",
    "#     cortical_glasser_parcel_volume = pd.read_csv(data_dir+'/cortical_glasser_parcel_volume.csv')\n",
    "# else:\n",
    "#     cortical_glasser_parcel_volume = collect_data('neuro/parc-stats',['surface'],['glasser'],'cortex.csv',data_dir+'/cortical_glasser_parcel_volume.csv',False)\n",
    "#     cortical_glasser_parcel_volume = cortical_glasser_parcel_volume.drop_duplicates()\n",
    "#     cortical_glasser_parcel_volume['subjectID'] = cortical_glasser_parcel_volume.subjectID.astype(str)\n",
    "#     cortical_glasser_parcel_volume = cortical_glasser_parcel_volume[~cortical_glasser_parcel_volume['structureID'].isin([\"lh_unknown_0\",\"rh_unknown_0\",\"lh_???\",\"rh_???\"])]\n",
    "#     cortical_glasser_parcel_volume['structureID'] = [ f.split('h_')[1] for f in cortical_glasser_parcel_volume['structureID'] ]\n",
    "#     cortical_glasser_parcel_volume.to_csv(data_dir+'/cortical_glasser_parcel_volume.csv',index=False)\n",
    "\n",
    "# cortical_glasser.drop(columns=['volume','thickness'],inplace=True)\n",
    "# cortical_glasser = pd.merge(cortical_glasser,cortical_glasser_parcel_volume,on=['subjectID','structureID','nodeID','sessionID'])\n",
    "\n",
    "# # cortical measures -  aparc.a2009s\n",
    "# if os.path.isfile(data_dir+'/cortical_aparc.csv'):\n",
    "#     cortical_aparc = pd.read_csv(data_dir+'/cortical_aparc.csv')\n",
    "# else:\n",
    "#     cortical_aparc =  collect_data('neuro/parc-stats',['cortex_mapping_stats'],['glasser'],'aparc_MEAN.csv',data_dir+'/cortical_aparc.csv',False)\n",
    "#     cortical_aparc = cortical_aparc.drop_duplicates()\n",
    "#     cortical_aparc['subjectID'] = cortical_aparc.subjectID.astype(str)\n",
    "#     cortical_aparc = pd.merge(cortical_aparc,subjects_data,on='subjectID')\n",
    "#     cortical_aparc.to_csv(data_dir+'/cortical_aparc.csv',index=False)\n",
    "\n",
    "# # freesurfer measures: aparc\n",
    "# if os.path.isfile(data_dir+'/cortical_aparc_parcel_volume.csv'):\n",
    "#     cortical_aparc_parcel_volume = pd.read_csv(data_dir+'/cortical_aparc_parcel_volume.csv')\n",
    "# else:\n",
    "#     cortical_aparc_parcel_volume = collect_data('neuro/parc-stats',['freesurfer'],['aparc.a2009s'],'cortex.csv',data_dir+'/cortcal_aparc_parcel_volume.csv',False)\n",
    "#     cortical_aparc_parcel_volume = cortical_aparc_parcel_volume.drop_duplicates()\n",
    "#     cortical_aparc_parcel_volume['subjectID'] = cortical_aparc_parcel_volume.subjectID.astype(str)\n",
    "#     cortical_aparc_parcel_volume.to_csv(data_dir+'/cortical_aparc_parcel_volume.csv',index=False)\n",
    "\n",
    "# cortical_aparc.drop(columns=['volume','thickness'],inplace=True)\n",
    "# cortical_aparc = pd.merge(cortical_aparc,cortical_aparc_parcel_volume,on=['subjectID','structureID','nodeID','sessionID'])\n",
    "\n",
    "# # concatenate glasser and aparc\n",
    "# if os.path.isfile(data_dir+'/cortical.csv'):\n",
    "#     cortical = pd.read_csv(data_dir+'/cortical.csv')\n",
    "# else:\n",
    "#     cortical_glasser['parcellation'] = [ 'glasser' for f in cortical_glasser['subjectID']]\n",
    "#     cortical_aparc['parcellation'] = [ 'aparc.a2009s' for f in cortical_aparc['subjectID']]\n",
    "#     cortical = pd.concat([cortical_glasser,cortical_aparc])\n",
    "#     cortical.to_csv(data_dir+'/cortical.csv',index=False)\n",
    "\n",
    "# # # # subcortical measures\n",
    "# if os.path.isfile(data_dir+'/subcortical.csv'):\n",
    "#     subcortical = pd.read_csv(data_dir+'/subcortical.csv')\n",
    "# else:\n",
    "#     subcortical =  collect_data('neuro/parc-stats',['subcort_stats'],['tensor'],'aseg_nodes.csv',data_dir+'/subcortical.csv')\n",
    "#     subcortical = subcortical.drop_duplicates()\n",
    "#     subcortical['subjectID'] = subcortical.subjectID.astype(str)\n",
    "#     subcortical = pd.merge(subcortical,subjects_data,on='subjectID')\n",
    "#     subcortical.to_csv('subcortical.csv',index=False)\n",
    "\n",
    "# # clean and remove data that is outside physical bounds: cortical\n",
    "if os.path.isfile(data_dir+'/cortical_cleaned.csv'):\n",
    "    cortical = pd.read_csv(data_dir+'/cortical_cleaned.csv')\n",
    "    cortical['subjectID'] = [ str(f) for f in cortical['subjectID'] ]\n",
    "else:\n",
    "    bad_cortical = pd.DataFrame()\n",
    "    bad_cortical = pd.concat([bad_cortical,cortical.loc[cortical['ad'] > 3]])\n",
    "    bad_cortical = pd.concat([bad_cortical,cortical.loc[cortical['ad'] < 0]])\n",
    "    bad_cortical = pd.concat([bad_cortical,cortical.loc[cortical['fa'] > 1]])\n",
    "    bad_cortical = pd.concat([bad_cortical,cortical.loc[cortical['fa'] < 0]])\n",
    "    bad_cortical = pd.concat([bad_cortical,cortical.loc[cortical['md'] > 3]])\n",
    "    bad_cortical = pd.concat([bad_cortical,cortical.loc[cortical['md'] < 0]])\n",
    "    bad_cortical = pd.concat([bad_cortical,cortical.loc[cortical['rd'] > 3]])\n",
    "    bad_cortical = pd.concat([bad_cortical,cortical.loc[cortical['rd'] < 0]])\n",
    "    cortical = cortical.loc[~cortical.index.isin(bad_cortical.index)]\n",
    "    cortical.to_csv(data_dir+'/cortical_cleaned.csv',index=False)\n",
    "\n",
    "# # clean and remove data that is outside physical bounds: subcortical\n",
    "if os.path.isfile(data_dir+'/subcortical_cleaned.csv'):\n",
    "    subcortical = pd.read_csv(data_dir+'/subcortical_cleaned.csv')\n",
    "    subcortical['subjectID'] = [ str(f) for f in subcortical['subjectID'] ]\n",
    "else:\n",
    "    bad_subcortical = pd.DataFrame()\n",
    "    bad_subcortical = pd.concat([bad_subcortical,subcortical.loc[subcortical['ad'] > 3]])\n",
    "    bad_subcortical = pd.concat([bad_subcortical,subcortical.loc[subcortical['ad'] < 0]])\n",
    "    bad_subcortical = pd.concat([bad_subcortical,subcortical.loc[subcortical['fa'] > 1]])\n",
    "    bad_subcortical = pd.concat([bad_subcortical,subcortical.loc[subcortical['fa'] < 0]])\n",
    "    bad_subcortical = pd.concat([bad_subcortical,subcortical.loc[subcortical['md'] > 3]])\n",
    "    bad_subcortical = pd.concat([bad_subcortical,subcortical.loc[subcortical['md'] < 0]])\n",
    "    bad_subcortical = pd.concat([bad_subcortical,subcortical.loc[subcortical['rd'] > 3]])\n",
    "    bad_subcortical = pd.concat([bad_subcortical,subcortical.loc[subcortical['rd'] < 0]])\n",
    "    subcortical = subcortical.loc[~subcortical.index.isin(bad_subcortical.index)]\n",
    "    subcortical.to_csv(data_dir+'/subcortical_cleaned.csv',index=False)\n",
    "    \n",
    "# view dataframe generated\n",
    "cortical.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84185ac9",
   "metadata": {},
   "source": [
    "## Visualizing parcel ODI\n",
    "Now that the data is collected and cleaned, the next step for me is to visualize the distribution of the volume data of specific structures. To do this, I'll plot the distributions of orientation dispersion index (ODI), a measure of spread or fanning of neurites in brian tissue derived using the NODDI model, for the left and righ V1 from the glasser parcellation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bcded69f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    2082.000000\n",
      "mean        0.419273\n",
      "std         0.025874\n",
      "min         0.000000\n",
      "25%         0.405080\n",
      "50%         0.419994\n",
      "75%         0.435125\n",
      "max         0.491863\n",
      "Name: odi, dtype: float64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/brad/.local/lib/python3.8/site-packages/seaborn/categorical.py:1296: UserWarning: 77.0% of the points cannot be placed; you may want to decrease the size of the markers or use stripplot.\n",
      "  warnings.warn(msg, UserWarning)\n",
      "/home/brad/.local/lib/python3.8/site-packages/seaborn/categorical.py:1296: UserWarning: 75.5% of the points cannot be placed; you may want to decrease the size of the markers or use stripplot.\n",
      "  warnings.warn(msg, UserWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# select hippocampal volumes\n",
    "structures = ['L_V1_ROI','R_V1_ROI']\n",
    "data = cortical.loc[cortical['structureID'].isin(structures)]\n",
    "\n",
    "# describe the dataframe\n",
    "print(data['odi'].describe())\n",
    "\n",
    "# plot all of the data for each b0 measure\n",
    "plt.figure()\n",
    "sns.swarmplot(x='structureID', y='odi', data=data)\n",
    "\n",
    "# save figure\n",
    "plt.savefig(img_dir+'/hcp_v1_odi_distribution.png')\n",
    "plt.savefig(img_dir+'/hcp_v1_odi_distribution.eps')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a56a36b",
   "metadata": {},
   "source": [
    "## Removing outliers and creating reference datasets\n",
    "Once all of the appropriate data was collected, collated, and cleaned, I was now able to generate useful 'reference datasets' that can be used to identify potentially problematic participant data. I adopted a similar methodology as in the Pestilli et al (2014) LiFE paper which created \"reference datasets\", i.e. dataset of values of high-quality and high-diverse data, of properties derived from the LiFE model. The authors of this publication have released this data in the backend of the LiFE app here on brainlife.io, allowing users to directly compare their newly generated results with previously currated results.\n",
    "\n",
    "For this project, I took a similar approach across three large and diverse datasets: PING, HCP, and CAMCAN. For each data modality and structure, I computed the average value across many different models and measures including structural statistics derived from Freesurfer, diffusion microsturctural statistics derived from the DTI and NODDI models, quality assurance statistics (SNR), and network measures such as max node degree from structural connectivity measures and average functional connectivity derived from fMRI. I then identified those data points that were outside the top and bottom p% of the distribution, removed them, and recomputed the distribution. This newly cleaned distribution is the 'reference dataset' for that datatype, measure, and dataset.\n",
    "\n",
    "Following iterating through many datatypes, measures, structures, and projects, I released the final reference datasets on github and we have incorporated the data into the validators for the apps that generate those particular datatypes! This way users can directly compare their newly generated data with those I processed, analyzed, and curated!!\n",
    "\n",
    "This code can also be used to remove outliers from individual study designs, as the methods for identifying outliers and removing them from the data involves simple distribution sampling and percentile thresholding.\n",
    "\n",
    "For this notebook, I will demonstrate how to create reference dataframes for the all of the structures from the Glasser parcellation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "efcb193c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "creating references for subcortical parcel data\n",
      "cortical parcels\n",
      "L_V1_ROI\n",
      "L_V8_ROI\n",
      "L_4_ROI\n",
      "L_3b_ROI\n",
      "L_FEF_ROI\n",
      "L_PEF_ROI\n",
      "L_V3A_ROI\n",
      "L_RSC_ROI\n",
      "L_POS2_ROI\n",
      "L_V7_ROI\n",
      "L_IPS1_ROI\n",
      "L_FFC_ROI\n",
      "L_V3B_ROI\n",
      "L_LO1_ROI\n",
      "L_LO2_ROI\n",
      "L_PIT_ROI\n",
      "L_MT_ROI\n",
      "L_A1_ROI\n",
      "L_PSL_ROI\n",
      "L_SFL_ROI\n",
      "L_PCV_ROI\n",
      "L_STV_ROI\n",
      "L_7Pm_ROI\n",
      "L_7m_ROI\n",
      "L_POS1_ROI\n",
      "L_23d_ROI\n",
      "L_v23ab_ROI\n",
      "L_d23ab_ROI\n",
      "L_31pv_ROI\n",
      "L_5m_ROI\n",
      "L_5mv_ROI\n",
      "L_23c_ROI\n",
      "L_5L_ROI\n",
      "L_24dd_ROI\n",
      "L_24dv_ROI\n",
      "L_7AL_ROI\n",
      "L_SCEF_ROI\n",
      "L_6ma_ROI\n",
      "L_7Am_ROI\n",
      "L_7PL_ROI\n",
      "L_7PC_ROI\n",
      "L_LIPv_ROI\n",
      "L_VIP_ROI\n",
      "L_MIP_ROI\n",
      "L_1_ROI\n",
      "L_2_ROI\n",
      "L_3a_ROI\n",
      "L_6d_ROI\n",
      "L_6mp_ROI\n",
      "L_6v_ROI\n",
      "L_p24pr_ROI\n",
      "L_33pr_ROI\n",
      "L_a24pr_ROI\n",
      "L_p32pr_ROI\n",
      "L_d32_ROI\n",
      "L_8BM_ROI\n",
      "L_p32_ROI\n",
      "L_10r_ROI\n",
      "L_47m_ROI\n",
      "L_8Av_ROI\n",
      "L_8Ad_ROI\n",
      "L_9m_ROI\n",
      "L_8BL_ROI\n",
      "L_9p_ROI\n",
      "L_10d_ROI\n",
      "L_8C_ROI\n",
      "L_44_ROI\n",
      "L_45_ROI\n",
      "L_47l_ROI\n",
      "L_a47r_ROI\n",
      "L_6r_ROI\n",
      "L_IFJa_ROI\n",
      "L_IFJp_ROI\n",
      "L_IFSp_ROI\n",
      "L_IFSa_ROI\n",
      "L_p9-46v_ROI\n",
      "L_46_ROI\n",
      "L_a9-46v_ROI\n",
      "L_9-46d_ROI\n",
      "L_9a_ROI\n",
      "L_10v_ROI\n",
      "L_a10p_ROI\n",
      "L_11l_ROI\n",
      "L_13l_ROI\n",
      "L_OFC_ROI\n",
      "L_47s_ROI\n",
      "L_LIPd_ROI\n",
      "L_6a_ROI\n",
      "L_i6-8_ROI\n",
      "L_s6-8_ROI\n",
      "L_43_ROI\n",
      "L_OP4_ROI\n",
      "L_OP1_ROI\n",
      "L_OP2-3_ROI\n",
      "L_52_ROI\n",
      "L_RI_ROI\n",
      "L_PFcm_ROI\n",
      "L_PoI2_ROI\n",
      "L_TA2_ROI\n",
      "L_FOP4_ROI\n",
      "L_MI_ROI\n",
      "L_Pir_ROI\n",
      "L_AVI_ROI\n",
      "L_AAIC_ROI\n",
      "L_FOP1_ROI\n",
      "L_FOP3_ROI\n",
      "L_PFt_ROI\n",
      "L_AIP_ROI\n",
      "L_EC_ROI\n",
      "L_ProS_ROI\n",
      "L_PeEc_ROI\n",
      "L_STGa_ROI\n",
      "L_PBelt_ROI\n",
      "L_A5_ROI\n",
      "L_PHA1_ROI\n",
      "L_PHA3_ROI\n",
      "L_STSda_ROI\n",
      "L_STSdp_ROI\n",
      "L_STSvp_ROI\n",
      "L_TGd_ROI\n",
      "L_TE1a_ROI\n",
      "L_TE1p_ROI\n",
      "L_TE2a_ROI\n",
      "L_TF_ROI\n",
      "L_PHT_ROI\n",
      "L_TPOJ3_ROI\n",
      "L_DVT_ROI\n",
      "L_PGp_ROI\n",
      "L_IP2_ROI\n",
      "L_IP1_ROI\n",
      "L_IP0_ROI\n",
      "L_PFop_ROI\n",
      "L_PF_ROI\n",
      "L_PFm_ROI\n",
      "L_PGi_ROI\n",
      "L_PGs_ROI\n",
      "L_V6A_ROI\n",
      "L_VMV1_ROI\n",
      "L_VMV3_ROI\n",
      "L_PHA2_ROI\n",
      "L_V4t_ROI\n",
      "L_FST_ROI\n",
      "L_V3CD_ROI\n",
      "L_LO3_ROI\n",
      "L_VMV2_ROI\n",
      "L_31pd_ROI\n",
      "L_31a_ROI\n",
      "L_VVC_ROI\n",
      "L_25_ROI\n",
      "L_s32_ROI\n",
      "L_pOFC_ROI\n",
      "L_PoI1_ROI\n",
      "L_Ig_ROI\n",
      "L_FOP5_ROI\n",
      "L_p10p_ROI\n",
      "L_p47r_ROI\n",
      "L_TGv_ROI\n",
      "L_MBelt_ROI\n",
      "L_LBelt_ROI\n",
      "L_A4_ROI\n",
      "L_STSva_ROI\n",
      "L_a32pr_ROI\n",
      "L_p24_ROI\n",
      "R_V1_ROI\n",
      "R_V8_ROI\n",
      "R_4_ROI\n",
      "R_3b_ROI\n",
      "R_FEF_ROI\n",
      "R_PEF_ROI\n",
      "R_V3A_ROI\n",
      "R_RSC_ROI\n",
      "R_POS2_ROI\n",
      "R_V7_ROI\n",
      "R_IPS1_ROI\n",
      "R_FFC_ROI\n",
      "R_V3B_ROI\n",
      "R_LO1_ROI\n",
      "R_LO2_ROI\n",
      "R_PIT_ROI\n",
      "R_MT_ROI\n",
      "R_A1_ROI\n",
      "R_PSL_ROI\n",
      "R_PCV_ROI\n",
      "R_STV_ROI\n",
      "R_7Pm_ROI\n",
      "R_7m_ROI\n",
      "R_POS1_ROI\n",
      "R_23d_ROI\n",
      "R_v23ab_ROI\n",
      "R_d23ab_ROI\n",
      "R_31pv_ROI\n",
      "R_5m_ROI\n",
      "R_5mv_ROI\n",
      "R_23c_ROI\n",
      "R_5L_ROI\n",
      "R_24dd_ROI\n",
      "R_24dv_ROI\n",
      "R_7AL_ROI\n",
      "R_SCEF_ROI\n",
      "R_6ma_ROI\n",
      "R_7Am_ROI\n",
      "R_7PL_ROI\n",
      "R_7PC_ROI\n",
      "R_LIPv_ROI\n",
      "R_VIP_ROI\n",
      "R_MIP_ROI\n",
      "R_1_ROI\n",
      "R_2_ROI\n",
      "R_3a_ROI\n",
      "R_6d_ROI\n",
      "R_6mp_ROI\n",
      "R_6v_ROI\n",
      "R_p24pr_ROI\n",
      "R_33pr_ROI\n",
      "R_a24pr_ROI\n",
      "R_p32pr_ROI\n",
      "R_d32_ROI\n",
      "R_8BM_ROI\n",
      "R_p32_ROI\n",
      "R_10r_ROI\n",
      "R_47m_ROI\n",
      "R_8Av_ROI\n",
      "R_8Ad_ROI\n",
      "R_9m_ROI\n",
      "R_8BL_ROI\n",
      "R_9p_ROI\n",
      "R_10d_ROI\n",
      "R_8C_ROI\n",
      "R_44_ROI\n",
      "R_45_ROI\n",
      "R_47l_ROI\n",
      "R_a47r_ROI\n",
      "R_6r_ROI\n",
      "R_IFJa_ROI\n",
      "R_IFJp_ROI\n",
      "R_IFSp_ROI\n",
      "R_IFSa_ROI\n",
      "R_p9-46v_ROI\n",
      "R_46_ROI\n",
      "R_a9-46v_ROI\n",
      "R_9-46d_ROI\n",
      "R_9a_ROI\n",
      "R_10v_ROI\n",
      "R_a10p_ROI\n",
      "R_11l_ROI\n",
      "R_13l_ROI\n",
      "R_OFC_ROI\n",
      "R_47s_ROI\n",
      "R_LIPd_ROI\n",
      "R_6a_ROI\n",
      "R_i6-8_ROI\n",
      "R_s6-8_ROI\n",
      "R_43_ROI\n",
      "R_OP4_ROI\n",
      "R_OP1_ROI\n",
      "R_OP2-3_ROI\n",
      "R_52_ROI\n",
      "R_RI_ROI\n",
      "R_PFcm_ROI\n",
      "R_PoI2_ROI\n",
      "R_TA2_ROI\n",
      "R_FOP4_ROI\n",
      "R_MI_ROI\n",
      "R_Pir_ROI\n",
      "R_AVI_ROI\n",
      "R_AAIC_ROI\n",
      "R_FOP1_ROI\n",
      "R_FOP3_ROI\n",
      "R_PFt_ROI\n",
      "R_AIP_ROI\n",
      "R_EC_ROI\n",
      "R_ProS_ROI\n",
      "R_PeEc_ROI\n",
      "R_STGa_ROI\n",
      "R_PBelt_ROI\n",
      "R_A5_ROI\n",
      "R_PHA1_ROI\n",
      "R_PHA3_ROI\n",
      "R_STSda_ROI\n",
      "R_STSdp_ROI\n",
      "R_STSvp_ROI\n",
      "R_TGd_ROI\n",
      "R_TE1a_ROI\n",
      "R_TE2a_ROI\n",
      "R_TF_ROI\n",
      "R_PHT_ROI\n",
      "R_TPOJ3_ROI\n",
      "R_DVT_ROI\n",
      "R_PGp_ROI\n",
      "R_IP2_ROI\n",
      "R_IP1_ROI\n",
      "R_IP0_ROI\n",
      "R_PFop_ROI\n",
      "R_PF_ROI\n",
      "R_PFm_ROI\n",
      "R_PGi_ROI\n",
      "R_PGs_ROI\n",
      "R_V6A_ROI\n",
      "R_VMV1_ROI\n",
      "R_VMV3_ROI\n",
      "R_PHA2_ROI\n",
      "R_V4t_ROI\n",
      "R_FST_ROI\n",
      "R_V3CD_ROI\n",
      "R_LO3_ROI\n",
      "R_VMV2_ROI\n",
      "R_31a_ROI\n",
      "R_VVC_ROI\n",
      "R_25_ROI\n",
      "R_pOFC_ROI\n",
      "R_PoI1_ROI\n",
      "R_Ig_ROI\n",
      "R_FOP5_ROI\n",
      "R_p10p_ROI\n",
      "R_p47r_ROI\n",
      "R_TGv_ROI\n",
      "R_MBelt_ROI\n",
      "R_LBelt_ROI\n",
      "R_A4_ROI\n",
      "R_STSva_ROI\n",
      "R_a32pr_ROI\n",
      "R_p24_ROI\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>structureID</th>\n",
       "      <th>subjectID</th>\n",
       "      <th>odi</th>\n",
       "      <th>average_thickness_mm</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>L_10d_ROI</td>\n",
       "      <td>100206</td>\n",
       "      <td>0.257866</td>\n",
       "      <td>2.690</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>L_10d_ROI</td>\n",
       "      <td>100307</td>\n",
       "      <td>0.292687</td>\n",
       "      <td>2.799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>L_10d_ROI</td>\n",
       "      <td>100408</td>\n",
       "      <td>0.295914</td>\n",
       "      <td>2.574</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>L_10d_ROI</td>\n",
       "      <td>100610</td>\n",
       "      <td>0.288121</td>\n",
       "      <td>2.697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>L_10d_ROI</td>\n",
       "      <td>101006</td>\n",
       "      <td>0.318762</td>\n",
       "      <td>2.446</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>335929</th>\n",
       "      <td>R_v23ab_ROI</td>\n",
       "      <td>992774</td>\n",
       "      <td>0.373370</td>\n",
       "      <td>3.275</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>335930</th>\n",
       "      <td>R_v23ab_ROI</td>\n",
       "      <td>993675</td>\n",
       "      <td>0.301900</td>\n",
       "      <td>2.779</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>335931</th>\n",
       "      <td>R_v23ab_ROI</td>\n",
       "      <td>994273</td>\n",
       "      <td>0.357618</td>\n",
       "      <td>3.077</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>335932</th>\n",
       "      <td>R_v23ab_ROI</td>\n",
       "      <td>995174</td>\n",
       "      <td>0.403978</td>\n",
       "      <td>2.933</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>335933</th>\n",
       "      <td>R_v23ab_ROI</td>\n",
       "      <td>996782</td>\n",
       "      <td>0.356193</td>\n",
       "      <td>3.385</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>335934 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        structureID subjectID       odi  average_thickness_mm\n",
       "0         L_10d_ROI    100206  0.257866                 2.690\n",
       "1         L_10d_ROI    100307  0.292687                 2.799\n",
       "2         L_10d_ROI    100408  0.295914                 2.574\n",
       "3         L_10d_ROI    100610  0.288121                 2.697\n",
       "4         L_10d_ROI    101006  0.318762                 2.446\n",
       "...             ...       ...       ...                   ...\n",
       "335929  R_v23ab_ROI    992774  0.373370                 3.275\n",
       "335930  R_v23ab_ROI    993675  0.301900                 2.779\n",
       "335931  R_v23ab_ROI    994273  0.357618                 3.077\n",
       "335932  R_v23ab_ROI    995174  0.403978                 2.933\n",
       "335933  R_v23ab_ROI    996782  0.356193                 3.385\n",
       "\n",
       "[335934 rows x 4 columns]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### creating reference datasets\n",
    "print(\"creating references for subcortical parcel data\")\n",
    "\n",
    "# if empty, create references directory\n",
    "if not os.path.isdir(data_dir+'/references'):\n",
    "    os.mkdir(data_dir+'/references')\n",
    "\n",
    "# set threshold\n",
    "thrs = 99\n",
    "\n",
    "# set measure and structure. for structures, we want to identify glasser structures with average snr > 17 matching the Fukutomi et al paper\n",
    "structure = [ f for f in cortical.loc[cortical['parcellation'] == 'glasser']['structureID'].unique()[cortical.loc[cortical['parcellation'] == 'glasser'].groupby('structureID',as_index=False).mean()['snr'] > 17] if 'L_' in f or 'R_' in f]\n",
    "measures = ['odi','average_thickness_mm']\n",
    "\n",
    "# cortical parcels\n",
    "print('cortical parcels')\n",
    "if os.path.isfile(data_dir+'/references/cortical_reference_glasser_'+groups[0]+'_'+str(thrs)+'.csv'):\n",
    "    cortical_reference_dataframe = pd.read_csv(data_dir+'/references/cortical_reference_glasser_'+groups[0]+'_'+str(thrs)+'.csv')\n",
    "    cortical_reference_dataframe['subjectID'] = [ str(f) for f in cortical_reference_dataframe.subjectID ]\n",
    "else:\n",
    "    # compute reference dataset for subcortical structures. for quicker computations and less RAM requirements, split structural and diffusion measures and then merge at end\n",
    "    cortical_distances, cortical_outliers, cortical_reference_dataframe, cortical_reference_json = outlier_detection(cortical,structure,'structureID',measures,thrs,'emd',True,False,'',groups[0],data_dir+'/references','cortical_reference_glasser_'+groups[0]+'_'+str(thrs))\n",
    "\n",
    "cortical_reference_dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cc23ddc",
   "metadata": {},
   "source": [
    "### Generating visualizations and plots for Fukutomi et al 2018 replication\n",
    "These are visualizations replicating a figure from Fukutomi et al 2018, in which a negative relationship between cortical parcel ODI and thickness was observed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9481ad57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# replicate Fukutomi et al 2018 results\n",
    "# plot data\n",
    "singleplot_scatter(\"\",cortical_reference_dataframe.groupby(['structureID'],as_index=False).mean(),cortical_reference_dataframe.groupby(['structureID'],as_index=False).mean(),'average_thickness_mm','odi',False,'structureID','structureID','ravel','linreg',False,False,False,'','','')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}