Spiro_eye_tracking_old.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analysis of eye tracking files from Spiro study.\n",
    "Gaze dispersion metric based on Christoforou et al, 2015: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4428128/pdf/fpsyg-06-00579.pdf\n",
    "The objective is as follows:\n",
    "(1) compute within-subject dispersion metric, based on short sections of the film (250 ms with 50 ms shift, ie 80% overlap)\n",
    "(2) get sections with extreme dispersion score\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import pairwise_distances\n",
    "from PIL import Image\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import norm\n",
    "# get participant numbers\n",
    "\n",
    "def get_pnums(infiles):\n",
    "    \"\"\"\n",
    "    Get participant numbers from filenames.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    infiles: array of input file names\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    list of participant numbers \n",
    "    \"\"\"\n",
    "    id = []\n",
    "    for i,filenames in enumerate(infiles):\n",
    "        pnum = [int(s) for s in filenames.split('_') if s.isdigit()]\n",
    "        id.append([pnum])\n",
    "\n",
    "def flatten(list_name):\n",
    "    \"\"\" \n",
    "    Function that flattens list of lists.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    list_name: str\n",
    "        Name of the list to flatten\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Flattened list\n",
    "    \"\"\"\n",
    "    flattened = [item for sublist in list_name for item in sublist]\n",
    "    return flattened\n",
    "\n",
    "def get_random_samps(df, frame_num_max, id):\n",
    "    \"\"\" \n",
    "    Fit a participant's gaze data to normal distribution.\n",
    "    Randomly sample normal distribution with participant-specific mean and std.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    df: pandas dataframe\n",
    "        dataframe holding eye tracking data from all participants\n",
    "\n",
    "    frame_num_max: int\n",
    "        maximum number of frames for participant,\n",
    "        will be used to determine how many samples to draw\n",
    "\n",
    "    id: int\n",
    "        participant id \n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Simulated gaze data in x and y.\n",
    "\n",
    "    \"\"\"\n",
    "    # first, let's simulate some gaze data.\n",
    "    # some basic parameters\n",
    "    #gaze_length = df.frame_num.max() # number of samples we need to generate\n",
    "    mux,stdx = norm.fit(df.loc[df.id == id,'gaze_in_x'])\n",
    "    muy,stdy = norm.fit(df.loc[df.id == id, 'gaze_in_y'])\n",
    "    # get samples\n",
    "    sim_in_x = norm.rvs(loc = mux, scale = stdx, size = frame_num_max)\n",
    "    sim_in_y = norm.rvs(loc = muy, scale = stdy, size = frame_num_max)\n",
    "    return sim_in_x, sim_in_y\n",
    "\n",
    "def calculate_dispersion_scores(frame_num, gaze_x, gaze_y,window_size, window_step):\n",
    "    \"\"\"\n",
    "    Calculate dispersion scores for each window.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    frame_num: array\n",
    "        frame number\n",
    "    gaze_x, gaze_y: pandas DataFrame\n",
    "        gaze positions in x and y\n",
    "    window_size: int\n",
    "        size of window (how many frames)\n",
    "    window_step: int\n",
    "        number of frames to move each time the window slides\n",
    "        (ie overlap between windows)\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    list containing mean score per window\n",
    "    \"\"\"\n",
    "    dists = []\n",
    "    for i in frame_num:\n",
    "        frame_df = pd.concat([gaze_x.loc[i,:],gaze_y.loc[i,:]],axis = 1)\n",
    "        frame_dist_val =  np.unique(pairwise_distances(frame_df.dropna(),\n",
    "                            frame_df.dropna(),force_all_finite = True)).mean()\n",
    "        dists.append(frame_dist_val)\n",
    "\n",
    "     # now we calculate the mean euclidean distance for each window.\n",
    "    steps = np.arange(0,len(dists)-15,window_step)\n",
    "\n",
    "    # now calculate the mean for each 15-frame window (corresponds to ~250 ms)\n",
    "    # with a step size of 3 (80% overlap between successive windows)\n",
    "    wind_dists = []\n",
    "    for i in steps:\n",
    "        wind_dist = np.array(dists)[i:i+window_size].mean()\n",
    "        wind_dists.append(wind_dist)\n",
    "    wind_dists = pd.Series(wind_dists)\n",
    "    return wind_dists\n",
    "\n",
    "def get_consec_sections2(divergent_winds_numwinds):\n",
    "    \"\"\"\n",
    "    Find consecutive sections of divergent windows.\n",
    "    This should be faster than the other version.\n",
    "    Timeit says it's not.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    divergent_winds_numwinds: iterable\n",
    "        Iterable representing the window numbers\n",
    "        of windows identified as divergent\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    list of window numbers at which a break in \n",
    "    consecutive values was detected.\n",
    "    \"\"\"\n",
    "    index_break = [f for i,f in enumerate(divergent_winds_numwinds)\n",
    "                    if (i>0) & (f > divergent_winds_numwinds[i-1]+1)]\n",
    "\n",
    "    return index_break\n",
    "\n",
    "def get_consec_sections(divergent_winds_numwinds):\n",
    "    \"\"\"\n",
    "    Find consecutive sections of divergent windows.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    divergent_winds_numwinds: iterable\n",
    "        Iterable representing the window numbers\n",
    "        of windows identified as divergent\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    list of window numbers at which a break in \n",
    "    consecutive values was detected.\n",
    "\n",
    "    \"\"\"\n",
    "    index_break = []\n",
    "    for i,window in enumerate(divergent_winds_numwinds):\n",
    "        if i==0:\n",
    "            wind = window\n",
    "        elif (i>0) & (window-wind > 1):\n",
    "            index_break.append(window)\n",
    "            wind = window\n",
    "        else:\n",
    "            wind = window \n",
    "    return index_break\n",
    "\n",
    "def get_frame_nums(index_break,step,wind):\n",
    "    \"\"\"\n",
    "    Get first and last frame for divergent windows.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    index_break:   iterable\n",
    "        iterable containing start indices of each\n",
    "        non-consecutive batch of divergent windows\n",
    "        (I know, sorry)\n",
    "    step:   int\n",
    "        step size used for window calculation\n",
    "    wind:   int\n",
    "        number of frames in each window\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    list of tuples\n",
    "    start/stop frame for each divergent section\n",
    "    \"\"\"\n",
    "    start_and_stop = list(zip(index_break[:-1], [i-1 for i in index_break[1:]]))\n",
    "    frame_nums = [(start*step+wind,stop*step+wind)\n",
    "                for start,stop in start_and_stop]\n",
    "\n",
    "    return frame_nums\n",
    "\n",
    "\n",
    "def calculate_iGDI(dispersion_scores, mean_sim_score):\n",
    "    \"\"\"\n",
    "    Calculate the eye gaze divergence index (iGDI)\n",
    "    Proportion of divergent windows across film viewings\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    dispersion_scores:  pd.Series\n",
    "        dispersion scores for each window\n",
    "    mean_sim_score: float\n",
    "        mean dispersion score across all\n",
    "        simulated windows\n",
    "\n",
    "    Returns\n",
    "    ------- \n",
    "    divergent_windows:\n",
    "        Binary array indicating whether a given window was\n",
    "        classed as divergent or not\n",
    "    \n",
    "    iGDI_score:\n",
    "        Proportion of windows classed as divergent\n",
    "        (ie eye gaze divergence index)\n",
    "\n",
    "    \"\"\"\n",
    "    divergent_windows = np.zeros(len(dispersion_scores))\n",
    "\n",
    "    for i,disp_score in enumerate(dispersion_scores):\n",
    "        if disp_score>mean_sim_score:\n",
    "            divergent_windows[i]=1\n",
    "        else:\n",
    "            continue\n",
    "    \n",
    "    iGDI_score = sum(divergent_windows)/len(dispersion_scores)\n",
    "    return iGDI_score, divergent_windows\n",
    "    \n",
    "def substring_in_df_col(df,substrings):\n",
    "    \"\"\"\n",
    "    filter pandas dataframe using\n",
    "    multiple substrings\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    df: pandas DataFrame\n",
    "        input dataframe to filter\n",
    "    substrings: iterable\n",
    "        (typically) list of\n",
    "        substrings of interest\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Filtered dataframe\n",
    "    \"\"\"\n",
    "    colnames = df.columns\n",
    "    out_cols = [col for col in colnames\n",
    "                for substr in substrings\n",
    "                if substr in col]\n",
    "    \n",
    "    out_df = df.loc[:,out_cols]\n",
    "    return out_df\n",
    "\n",
    "def remove_start_secs(frame_numbers:list, threshold:tuple):\n",
    "    \"\"\"\n",
    "    remove \"Scene 1\" and \"Scene 2\" display\n",
    "    sections.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    len_frames: list\n",
    "        number of frames in each stretch of consecutive\n",
    "        divergent windows\n",
    "    threshold:  tuple(int, int)\n",
    "        start and end of window of frame numbers to ignore\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    len_frames with windows falling into threshold replaced with 0\n",
    "    \n",
    "    \"\"\"\n",
    "    masked_len_frames = [(0,0) if (num1>threshold[0])&(num2<threshold[1])\n",
    "                        else (num1,num2) for (num1,num2) in frame_numbers]\n",
    "    return masked_len_frames\n",
    "\n",
    "def remove_short_secs(frame_numbers, len_thresh):\n",
    "    \"\"\"\n",
    "    Remove sections too short to be considered of interest.\n",
    "    Given that the frame rate of the film is ~30 fps,\n",
    "    30 frames is probably a reasonable threshold to use.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    frame_numbers:  list of tuples\n",
    "        start and stop frame of each section\n",
    "        of consecutive windows\n",
    "    len_thresh: int\n",
    "        minimum number of frames in section\n",
    "        to be considered of interest\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    list of frame numbers with sections not of interest\n",
    "    masked with (0,0)\n",
    "    \"\"\"\n",
    "    masked_frames = [(num1,num2)for num1,num2\n",
    "                    in frame_numbers \n",
    "                    if (num2-num1>=len_thresh)]\n",
    "    return masked_frames\n",
    "\n",
    "def get_gaze_dat_sec(gaze_data_df, sec):\n",
    "    \"\"\"\n",
    "    Get gaze point data for frame numbers\n",
    "    within sec\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    gaze_data_df:   pd DataFrame\n",
    "        gaze point data\n",
    "    sec:    tuple(int,int)\n",
    "        numer of first and last frames\n",
    "        w/in section of interest\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    dataframe corresponding to gaze data w/in\n",
    "    section of interest\n",
    "    \"\"\"\n",
    "    gaze_sec_df = gaze_data_df.loc[(gaze_data_df.frame_num>=sec[0])&\n",
    "                                    (gaze_data_df.frame_num<=sec[1]),\n",
    "                                    [\"id\",\"gaze_in_x\",\"gaze_in_y\",\"frame_num\"]]\n",
    "    return gaze_sec_df\n",
    "\n",
    "def calc_wind_avg_recur(gaze_dat_df,win_size, step_size, gaze_num = []):\n",
    "    \"\"\"\n",
    "    Calulate mean gaze position w/in window\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    Returns\n",
    "    -------\n",
    "    \"\"\"\n",
    "    if gaze_dat_df.shape[0]<=win_size:\n",
    "        gaze_num.append(gaze_dat_df.mean())\n",
    "    else:\n",
    "        gaze_num.append(gaze_dat_df.iloc[:15,:].mean())\n",
    "        calc_wind_avg_recur(gaze_dat_df.iloc[step_size:,:],win_size,step_size,gaze_num = gaze_num)\n",
    "    return gaze_num\n",
    "\n",
    "def get_diff_rows_recur(iter_in,diffs = []):\n",
    "    \"\"\"\n",
    "    Get difference between successive rows.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    iter_in: iterable\n",
    "        array containing sorted k nearest neighbors\n",
    "        distances. Must be of 1xn dimensional for this\n",
    "        to work.\n",
    "    diffs:  list\n",
    "        list to append differences between rows to.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Array of between-row differences (in reverse order).\n",
    "        \n",
    "    \"\"\"\n",
    "    if len(iter_in)<2:\n",
    "        diffs.append(np.nan)\n",
    "        return diffs\n",
    "    else:\n",
    "        diffs.append(iter_in[-1]-iter_in[-2])\n",
    "        get_diff_rows_recur(iter_in[:-1],diffs = diffs)\n",
    "    return diffs\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(i) get time stamps from message file\n",
    "- discard everything but the messages containing frame nr.\n",
    "(ii) load data file and add column for frame nr\n",
    "(iii) label rows between message (framenr) time stamps with the appropriate frame nr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "home = 0\n",
    "if home:\n",
    "    rawfilepath = r\"C:\\Users\\Luzia T\\Eye-gaze-divergence\"\n",
    "    Tobii_files = [f for f in os.listdir(rawfilepath) if 'merged' in f]\n",
    "    calibration_files = [f for f in os.listdir(rawfilepath) if 'calib' in f]\n",
    "else:\n",
    "    # first we need to establish where to find the files and read them in.\n",
    "    rawfilepath = r\"P:\\Spironolactone\\eye_tracking\\Tobii\"\n",
    "    intrusions_dir = r\"P:\\Eye-gaze-divergence\"\n",
    "    # get merged Tobii files - these have both event info and eye gaze data.\n",
    "    Tobii_files = [f for f in os.listdir(rawfilepath) if 'merged' in f]\n",
    "    # get_calibration files\n",
    "    calibration_files = [f for f in os.listdir(rawfilepath) if 'calib' in f and f.endswith('.tsv')]\n",
    "    msg_files = [f for f in os.listdir(rawfilepath) if 'msg' in f and f.endswith('.tsv')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get pnum, left/right gaze point on display area, event messages \n",
    "# keep only columns between framenum 0 and the last frame\n",
    "# set invalid samples to NaN (validity == 0)\n",
    "frames = []\n",
    "gaze_in_x = []\n",
    "gaze_in_y = []\n",
    "pnums = []\n",
    "\n",
    "for i,filename in enumerate(Tobii_files):\n",
    "    # read file\n",
    "    tobii_file = pd.read_table(os.path.join(rawfilepath, filename))\n",
    "    # get participant number and add as column\n",
    "    tobii_file['pnum'] = np.repeat([int(s) for s in filename.split('_') if s.isdigit()], tobii_file.shape[0])\n",
    "    # get row index of frame each frame presentation\n",
    "    event_index = tobii_file.loc[tobii_file.msg.str.contains('FRAME',na = False),'msg'].index\n",
    "    # drop everything before first frame index (ie frame 0) and after last frame\n",
    "    tobii_file = tobii_file.loc[event_index[0]:event_index[-1],:]\n",
    "    # extract frame number from event time stamps\n",
    "    tobii_file.loc[event_index, 'msg'] = [f[0] for f in tobii_file.loc[event_index,'msg'].str.split(';', n = 1)]\n",
    "    tobii_file['frame_num'] = tobii_file.loc[event_index,'msg'].apply(lambda x: re.findall(r'\\d',x)).apply(''.join).astype('int')\n",
    "    # fill the rows between event markers with the appropriate frame number\n",
    "    tobii_file.loc[:,'frame_num'] = tobii_file.loc[:,'frame_num'].fillna(method = 'ffill')\n",
    "    # drop event markers\n",
    "    tobii_file = tobii_file.drop(labels = event_index,axis = 0)\n",
    "    # discard invalid samples\n",
    "    tobii_file = tobii_file.loc[(tobii_file.right_gaze_point_validity == 1)&(tobii_file.left_gaze_point_validity == 1),:]\n",
    "    tobii_file = tobii_file.groupby('frame_num').mean()\n",
    "    tobii_file = tobii_file.reset_index()\n",
    "    # collect data into lists\n",
    "    pnums.append(tobii_file.pnum.values)\n",
    "    gaze_in_x.append(tobii_file.left_gaze_point_on_display_area_x.values)\n",
    "    gaze_in_y.append(tobii_file.left_gaze_point_on_display_area_y.values)\n",
    "    frames.append(tobii_file.frame_num.values)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create dataframe\n",
    "et_df = pd.DataFrame({'id':flatten(pnums),'gaze_in_x':flatten(gaze_in_x),'gaze_in_y':flatten(gaze_in_y),'frame_num':flatten(frames)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have valid data for left/right gaze positions (on display area) for all participants in a single data frame. We now want to get a measure of divergence. We need to bear in mind a couple of things.\n",
    "First of all, calibration accuracy/precision will be different between participants. The first thing to check is to make sure that the precision is roughly the same. If not, this could really affect the divergence measure in a fairly unpredictable way, so we would need to exclude those subjects. Next, we want to have a look at accuracy. This is less of an issue because it is basically just an offset. We could try to correct gaze point data for each participant, but this will not be needed as divergent frames are identified based on comparing to a 'random' sequence of gaze data (which we will simulate below). Unless the offset is extreme, this should therefore not affect the results.\n",
    "Because different participants are missing different frames and because we don't expect huge variation between individual frames, given a frame rate of ~30 fps, we will look at 250 ms windows, and we will use a sliding window approach, shifting the window 50 ms each time (resulting in 80% overlap between windows).\n",
    "For each window and participant, we will calculate the Euclidean distance between the participant in question and every other participant/the participant in question and the random sequence. For any given window, we will then check whether this distance is greater in the former case than in the latter. If so, the window is identified as 'divergent' for that participant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's simulate x/y data by sampling from a normal distribution, based on each participant's gaze data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create columns to hold simulated values\n",
    "et_df['gaze_in_x_sim'] = np.nan\n",
    "et_df['gaze_in_y_sim'] = np.nan\n",
    "\n",
    "# fill with simulated gaze data in x and y for each participant\n",
    "for i,pnum in enumerate(et_df.id.unique()):\n",
    "    pnum_df = et_df.loc[et_df.id == pnum,['id','gaze_in_x','gaze_in_y']]\n",
    "    max_frame = pnum_df.shape[0]\n",
    "    simx,simy = get_random_samps(pnum_df,max_frame,pnum)\n",
    "    et_df.loc[et_df.id == pnum, 'gaze_in_x_sim'] = simx\n",
    "    et_df.loc[et_df.id == pnum, 'gaze_in_y_sim'] = simy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first, let's construct a dataframe for the x and y gaze positions that holds data from all participants.\n",
    "gaze_x = et_df.pivot(index = 'frame_num',columns = 'id', values = 'gaze_in_x')\n",
    "gaze_y = et_df.pivot(index = 'frame_num',columns = 'id', values = 'gaze_in_y')\n",
    "gaze_x_sim = et_df.pivot(index = 'frame_num',columns = 'id', values = 'gaze_in_x_sim')\n",
    "gaze_y_sim = et_df.pivot(index = 'frame_num',columns = 'id', values = 'gaze_in_y_sim')\n",
    "\n",
    "# calculate dispersion scores for simulated and 'actual' gaze data.\n",
    "wind_dists_act = calculate_dispersion_scores(gaze_y.index, gaze_x,gaze_y, 15, 3)\n",
    "wind_dists_sim = calculate_dispersion_scores(gaze_y.index,gaze_x_sim,gaze_y_sim,15,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mean divergence for simulated windows is 0.1736770071743414.\n",
      "The mean divergence for actual windows is 0.13059413046270418.\n",
      "The percentage of divergent windows is 12.832019405700423.\n"
     ]
    }
   ],
   "source": [
    "mean_dist_sim = wind_dists_sim.mean()\n",
    "iGDIs, divergent_winds = calculate_iGDI(wind_dists_act,mean_dist_sim)\n",
    "print('The mean divergence for simulated windows is {}.'.format(mean_dist_sim))\n",
    "print('The mean divergence for actual windows is {}.'.format(wind_dists_act.mean()))\n",
    "print('The percentage of divergent windows is {}.'.format(iGDIs*100))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get indices of consecutive sections of divergent windows and equivalent frame numbers\n",
    "index_break = get_consec_sections2(\n",
    "                wind_dists_act[wind_dists_act*divergent_winds>0].index\n",
    "                )\n",
    "frame_nums = get_frame_nums(index_break, 3, 15)\n",
    "# remove sections for Scene 1, Scene 2 display\n",
    "# (had a lot of divergence within those windows)\n",
    "secs_to_remove = [(0,470),(21207,21657)]\n",
    "for sec in secs_to_remove:\n",
    "    frame_nums = remove_start_secs(frame_nums,sec)\n",
    "# remove sections too short to be of interest\n",
    "frame_nums = remove_short_secs(frame_nums,30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create new df with each frame_num for each participant\n",
    "mult_ind = pd.MultiIndex.from_product([list(et_df.id.unique()),\n",
    "                                        list(et_df.frame_num.unique())],\n",
    "                                        names = [\"id\",\"frame_num\"])\n",
    "# fill with nan\n",
    "sparse_et_df = pd.DataFrame({\"gaze_in_x\":np.nan,\"gaze_in_y\":np.nan}, index = mult_ind)\n",
    "# hold on to pnums for later\n",
    "pnums = et_df.id.unique()\n",
    "# make et_df multiindex\n",
    "et_df = et_df.set_index([\"id\",\"frame_num\"])\n",
    "# now add the gaze point data in et_df to the sparse version.\n",
    "sparse_et_df.loc[et_df.index,:] = et_df\n",
    "# sort the index\n",
    "sparse_et_df = sparse_et_df.sort_index(axis = 0, level = [0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now calculate mean gaze point values for each id and window\n",
    "# within each divergent section\n",
    "idx = pd.IndexSlice\n",
    "id_dat = []\n",
    "for id in pnums:\n",
    "    gaze_df = sparse_et_df.loc[idx[id,:],:]\n",
    "    #print(gaze_df.droplevel(level = 0))\n",
    "    gaze_df = gaze_df.droplevel(level = 0)#.sort_index()\n",
    "    for start,stop in frame_nums:\n",
    "        res = calc_wind_avg_recur(gaze_df.loc[start:stop,:],15,3,gaze_num = [])\n",
    "        id_dat.append([id,(start,stop),res])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# put everything into a dataframe\n",
    "mean_gaze_dat_df = pd.DataFrame(\n",
    "                                {\"participant_id\":[val[0] for val in id_dat],\n",
    "                                \"stop_start_frame\":[val[1] for val in id_dat],\n",
    "                                \"mean_gaze_dat\":[val[2] for val in id_dat]}\n",
    "                                )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for start, stop in mean_gaze_dat_df.stop_start_frame.unique():\n",
    "    df = mean_gaze_dat_df.loc[mean_gaze_dat_df.stop_start_frame == (start,stop),:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df = mean_gaze_dat_df.loc[mean_gaze_dat_df.stop_start_frame == (465,1161),:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_gaze = [f[1] for sublist  in test_df.mean_gaze_dat for f in sublist]\n",
    "y_gaze = [f[0] for sublist  in test_df.mean_gaze_dat for f in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "gaze_dat = [wind[1] for wind in test_df.mean_gaze_dat]\n",
    "x_gaze = [f[0] for f in gaze_dat]\n",
    "y_gaze = [f[1] for f in gaze_dat]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pd.DataFrame({\"x_gaze\":x_gaze,\"y_gaze\":y_gaze,\"id\":test_df.participant_id})\n",
    "nan_labels = X[(X.x_gaze.isna()) & (X.y_gaze.isna())].index\n",
    "X = X.drop(labels = nan_labels, axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cluster import DBSCAN\n",
    "from sklearn.neighbors import NearestNeighbors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x230303a41c0>]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "neigh = NearestNeighbors(n_neighbors = 2).fit(X.loc[:,[\"x_gaze\",\"y_gaze\"]])\n",
    "dist,inds = neigh.kneighbors(X.loc[:,[\"x_gaze\",\"y_gaze\"]])\n",
    "distances = np.sort(dist,axis = 0)[:,1]\n",
    "plt.plot(distances)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='x_gaze', ylabel='y_gaze'>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dbscan = DBSCAN(eps = 0.1,min_samples = 10).fit(X.loc[:,[\"x_gaze\",\"y_gaze\"]])\n",
    "X[\"labels\"] = dbscan.labels_\n",
    "sns.scatterplot(X.x_gaze,X.y_gaze, hue = X[\"labels\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Film/gaze data visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stop/start stills to figure out vid content within each section\n",
    "film_stills_dir = r\"C:\\Users\\luzia.troebinger\\CortEx\\film_stills\"\n",
    "stills = os.listdir(film_stills_dir)\n",
    "save = 0\n",
    "if save:\n",
    "    output_dir = os.path.join(os.getcwd(),\"stills_start_end\" )\n",
    "    for i, frame in enumerate(frame_nums):                                                                         \n",
    "        img = Image.open(os.path.join(film_stills_dir, stills[frame[0]]))   \n",
    "        img.save(os.path.join(output_dir, ''.join(['sec_'+str(i)+'_start_frame.png'])))\n",
    "        img = Image.open(os.path.join(film_stills_dir, stills[frame[1]]))\n",
    "        img.save(os.path.join(output_dir, ''.join(['sec_'+str(i)+'_end_frame.png'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_dir = os.path.join(rawfilepath, \"film_stills_woverlay\")\n",
    "try:\n",
    "    os.mkdir(overlay_dir)\n",
    "except OSError:\n",
    "    pass\n",
    "    \n",
    "for i, still in enumerate(stills[:-1]):\n",
    "    fig,ax = plt.subplots()\n",
    "    img = plt.imread(os.path.join(film_stills_dir,still))\n",
    "    sns.kdeplot(ax = ax, x = gaze_x.loc[i,:]*img.shape[1], y = gaze_y.loc[i,:]*img.shape[0], fill = True)\n",
    "    ax.axis(\"off\")\n",
    "    ax.imshow(img)\n",
    "    fig.savefig(os.path.join(overlay_dir, \"_\".join([still, \"overlay.jpg\"])))\n",
    "    plt.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://hamelot.io/visualization/using-ffmpeg-to-convert-a-set-of-images-into-a-video/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# intrusions data\n",
    "intrusions_df = pd.read_csv(os.path.join(intrusions_dir, 'qualtrics_study_day.csv'))\n",
    "# drop incomplete\n",
    "intrusions_df = intrusions_df[intrusions_df.Finished == 'TRUE']\n",
    "substring_filter = ['DQ-1','Q196','Q195']\n",
    "intrusions_df = substring_in_df_col(intrusions_df, substring_filter)\n",
    "intrusions_df = intrusions_df[intrusions_df['DQ-1'].astype('float')<100]\n",
    "intrusions_df = intrusions_df.replace('0',np.nan)\n",
    "intrusions_df = intrusions_df.dropna(how = 'all', axis = 0)\n",
    "intrusions_df = intrusions_df.dropna(how = 'all',axis = 1)\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "48186e61764c8c514947f0ef500accf59797b98e64cdc910e21ec2975c1f1025"
  },
  "kernelspec": {
   "display_name": "Python 3.9.4 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}