{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "# include controllers to the path\n",
    "import sys, os\n",
    "sys.path.append(os.getcwd())\n",
    "sys.path.append(os.path.join(os.getcwd(), 'controllers'))\n",
    "\n",
    "import cv2\n",
    "import threading\n",
    "import math\n",
    "import time\n",
    "import random\n",
    "import json\n",
    "import datetime\n",
    "import os, shutil\n",
    "import numpy as np\n",
    "import multiprocess as mp\n",
    "\n",
    "# controllers\n",
    "import nbimporter\n",
    "from controllers.situtils import FPSTimes\n",
    "from controllers.camera import WebcamStream\n",
    "from controllers.video import VideoWriter\n",
    "from controllers.position import PositionTracker\n",
    "from controllers.sound import SoundController\n",
    "from controllers.serial import MCSArduino, FakeArduino, Feeder\n",
    "from postprocessing import pack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load experiment settings\n",
    "\n",
    "For every experimental cofiguration you can copy the original 'settings.json' file, build your own specific experimental preset, save it in this folder as e.g. 'settings_elena.json' and load it here instead of 'settings.json'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "cfg_filename = os.path.join('profiles', 'andrey_hippoSIT_test.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "with open(cfg_filename) as json_file:\n",
    "    cfg = json.load(json_file)\n",
    "cfg['experiment']['experiment_date'] = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n",
    "\n",
    "# print loaded settings\n",
    "#print(json.dumps(cfg, indent=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check if the sound interface is there\n",
    "import sounddevice as sd\n",
    "asio = [x for x in sd.query_devices() if x['name'].find('ASIO') > 0]\n",
    "#if len(asio) == 0:\n",
    "#    raise SystemExit('The sound interface is not found. Please restart the computer')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize session folder\n",
    "\n",
    "Run the upcoming cell, to create a session folder and to save the chosen experimetal parameters to a JSON-file (\"experiment_id_parameters.json\"). The session folder will be created here where this notebook is located."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This session's protocols will be saved to this folder\n",
    "cfg_exp = cfg['experiment']\n",
    "experiment_id = \"%s_%s_%s\" % (cfg_exp['subject'], cfg_exp['experiment_type'], cfg_exp['experiment_date'])\n",
    "save_to = os.path.join('sessions', experiment_id)\n",
    "             \n",
    "if not os.path.exists(save_to):\n",
    "    os.makedirs(save_to)\n",
    "\n",
    "# update paths (assuming this paths are relative to this notebook)\n",
    "cfg['video']['file_path'] = os.path.join(save_to, 'video.avi')\n",
    "cfg['position']['file_path'] = os.path.join(save_to, 'positions.csv')\n",
    "cfg['experiment']['file_path'] = os.path.join(save_to, 'events.csv')\n",
    "cfg['sound']['file_path'] = os.path.join(save_to, 'sounds.csv')\n",
    "cfg['position']['background_light'] = os.path.join('assets', cfg['position']['background_light'])\n",
    "cfg['position']['background_dark'] = os.path.join('assets', cfg['position']['background_dark'])\n",
    "    \n",
    "# Saves all parameters to a JSON file with the user-defined \"Experiment ID\" as filename\n",
    "with open(os.path.join(save_to, experiment_id + '.json'), 'w') as f:\n",
    "    json.dump(cfg, f, indent=4)\n",
    "    \n",
    "with open(cfg['experiment']['file_path'], 'w') as f:\n",
    "    # state: 0 - trial start, 1 - trial success, 2 - trial fail\n",
    "    f.write('time, target_x, target_y, target_r, trial, state\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Island:    \n",
    "    def __init__(self, x, y, radius, sound_id, is_distractor=False):\n",
    "        self.x = x  # in meters\n",
    "        self.y = y  # in meters\n",
    "        self.r = radius  # in meters\n",
    "        self.sound_id = sound_id\n",
    "        self.is_distractor = is_distractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_island_position(time_from_start, phi_initial, phi_max, timepoints=[600, 1200, 1800, 2400]):\n",
    "    # returns the angle of the island (in polar coordinates)\n",
    "    # all angles are in radians\n",
    "    \n",
    "    # no change during light periods\n",
    "    if time_from_start <= timepoints[0] or time_from_start >= timepoints[-1]:\n",
    "        return phi_initial\n",
    "    \n",
    "    # max anglular conflict in the middle of the dark\n",
    "    if time_from_start >= timepoints[1] and time_from_start <= timepoints[2]:\n",
    "        return phi_initial + phi_max\n",
    "    \n",
    "    # raising phase\n",
    "    if time_from_start < timepoints[1]:\n",
    "        p_dur = timepoints[1] - timepoints[0]\n",
    "        t_in_p = time_from_start - timepoints[0]\n",
    "        return phi_initial + phi_max * (t_in_p/p_dur)\n",
    "        \n",
    "    # falling phase\n",
    "    p_dur = timepoints[3] - timepoints[2]\n",
    "    t_in_p = time_from_start - timepoints[2]\n",
    "    return phi_initial + phi_max * (1 - (t_in_p/p_dur))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timeout(t_start):\n",
    "    return time.time() - t_start > cfg_exp['session_duration'] if t_start is not None else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_event(*args):  # log start / end of a trial\n",
    "    with open(cfg_exp['file_path'], 'a') as f:\n",
    "        f.write(\",\".join([str(x) for x in args]) + \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "def switch_light(pt, board):\n",
    "    pt.switch_background()\n",
    "    board.switch_light()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start the experiment\n",
    "\n",
    "This cell contains code for animal tracking. We hope that the comments provided in the code suffice to understand the individual steps and to adjust them to your own setup and needs, if necessary.\n",
    "\n",
    "- press 's' to start recording\n",
    "- press 's' again to stop recording\n",
    "- press 'q' to quit\n",
    "\n",
    "The experiment will stop automatically if the pre-defined session duration is reached."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Webcam stream 1024.0:768.0 at 20.00 FPS started\n",
      "Position tracker stopped\n",
      "Video writer stopped\n",
      "Camera released\n"
     ]
    }
   ],
   "source": [
    "# actual sound selector: 0 - silence, 1 - foraging, 2 - target, 3 - distractor\n",
    "sound = mp.Value('i', 1)\n",
    "\n",
    "# experiment status: 1 - idle, 2 - running (recording, logging), 0 - stopped\n",
    "status = mp.Value('i', 1)\n",
    "\n",
    "# init the sync with the acquisition system via Arduino\n",
    "if cfg['experiment']['MCSArduinoPort'] == 'fake':\n",
    "    board = FakeArduino()\n",
    "else:\n",
    "    board = MCSArduino(cfg['experiment']['MCSArduinoPort'])\n",
    "\n",
    "# init the feeder\n",
    "feeder = Feeder(cfg['experiment']['feeder_port'])\n",
    "    \n",
    "# start the camera stream\n",
    "vs = WebcamStream(cfg['camera'])\n",
    "vs.start()\n",
    "\n",
    "# init video recorder\n",
    "vw = VideoWriter(status, vs, cfg['video'])\n",
    "vw.start()\n",
    "\n",
    "# start position tracking\n",
    "pt = PositionTracker(status, vs, cfg['position'])\n",
    "pt.start()\n",
    "\n",
    "# playing sound in a separate process for performance\n",
    "sc = mp.Process(target=SoundController.run, args=(sound, status, cfg['sound']))\n",
    "sc.start()\n",
    "\n",
    "timers = []\n",
    "fps = FPSTimes()\n",
    "names = ['camera', 'video', 'position', 'main']\n",
    "trial = 0\n",
    "rewards = 0\n",
    "t_start = None\n",
    "target_since = None\n",
    "punishment_since = None\n",
    "trial_start = time.time()\n",
    "phase = 0  # 0 - idle, 1 - foraging, 2 - inter-trial interval\n",
    "cfg_exp = cfg['experiment']\n",
    "cfg_pos = cfg['position']\n",
    "\n",
    "COLORS = {\n",
    "    'red': (0,0,255), 'green': (127,255,0), 'blue': (255,127,0), 'yellow': (0,127,255), \\\n",
    "    'black': (0,0,0), 'white': (255,255,255)\n",
    "}\n",
    "islands = []\n",
    "\n",
    "# initial position of the island\n",
    "phi_initial = np.random.rand() * 2 * np.pi if cfg_exp['target_angle'] == 'random' else np.deg2rad(int(cfg_exp['target_angle']))\n",
    "rho = pt.cfg['floor_radius'] * pt.pixel_size - cfg_exp['target_radius']  # constant, in meters\n",
    "iti_distance = 0.0\n",
    "last_x, last_y = None, None\n",
    "\n",
    "# inaudible island trial profiles\n",
    "max_trials = 200\n",
    "p0 = np.array([0 for x in range(max_trials)])                          # never\n",
    "p1 = np.array([0 if (x+1) % 4 > 0 else 1 for x in range(max_trials)])  # every 4-th trial\n",
    "p2 = np.array([0 if (x+1) % 2 > 0 else 1 for x in range(max_trials)])  # every 2-nd trial\n",
    "p3 = np.array([1 if x % 4 > 0 else 0 for x in range(max_trials)])      # always except every 4-th trial\n",
    "unaudible_trials = np.vstack([p0, p1, p2, p3])\n",
    "\n",
    "try:\n",
    "    while trial <= cfg_exp['trial_number'] and not timeout(t_start):\n",
    "        frame = vs.read()\n",
    "        if frame is None:\n",
    "            time.sleep(0.1)\n",
    "            continue # wait for the stream\n",
    "            \n",
    "        c_time = time.time()\n",
    "        fps.count()\n",
    "        status_color = COLORS['green'] if status.value == 1 else COLORS['red']\n",
    "\n",
    "        # -------- prepare the video frame ---------------\n",
    "        \n",
    "        # mask space outside arena\n",
    "        frame = cv2.bitwise_and(src1=frame, src2=pt.mask)\n",
    "        #frame = cv2.subtract(frame, pt.background)\n",
    "        #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "        # draw position center and contours\n",
    "        if pt.x_in_px is not None:\n",
    "            cv2.circle(frame, (pt.x_in_px, pt.y_in_px), 10, status_color, -1)\n",
    "            cv2.drawContours(frame, [pt.contour], 0, status_color, 1, cv2.LINE_AA)            \n",
    "\n",
    "        # add FPS indicators\n",
    "        for i, ctrl in enumerate([vs, vw, pt, fps]):\n",
    "            cv2.putText(frame, '%s: %.2f FPS' % (names[i], ctrl.get_avg_fps()), \n",
    "                     (10, 30 + 20*(i+1)), cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])\n",
    "\n",
    "        # size of the arena and status indicator\n",
    "        cv2.circle(frame, (cfg_pos['arena_x'], cfg_pos['arena_y']), cfg_pos['arena_radius'], COLORS['red'], 2)\n",
    "        cv2.circle(frame, (cfg_pos['arena_x'], cfg_pos['arena_y']), cfg_pos['floor_radius'], COLORS['red'], 2)\n",
    "        cv2.circle(frame, (20,20), 10, status_color, -6)\n",
    "\n",
    "        # draw islands\n",
    "        if len(islands) > 0:\n",
    "            for island in islands:\n",
    "                clr = COLORS['red'] if island.is_distractor else COLORS['green']\n",
    "                x, y = pt.meters_to_px(island.x, island.y)\n",
    "                cv2.circle(frame, (x, y), int(island.r/pt.pixel_size), clr, 2)\n",
    "\n",
    "        # positions of animal and target\n",
    "        if pt.x_in_px is not None:\n",
    "            cv2.putText(frame, 'Animal: %.3f %.3f' % (pt.x_in_m, pt.y_in_m), (10, 550), \\\n",
    "                        cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])\n",
    "            cv2.putText(frame, '%.2f %.2f' % (pt.x_in_m, pt.y_in_m), (pt.x_in_px + 10, pt.y_in_px + 10), \\\n",
    "                        cv2.FONT_HERSHEY_DUPLEX, .3, COLORS['white'])\n",
    "            \n",
    "        if len(islands) > 0:\n",
    "            target = [i for i in islands if not i.is_distractor][0]\n",
    "            cv2.putText(frame, 'Target: %.3f %.3f' % (target.x, target.y), (10, 570), \\\n",
    "                        cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])\n",
    "            \n",
    "        # stopwatch\n",
    "        stopwatch = 'Time: %.2f' % float(c_time - t_start) if t_start is not None else 'Time: Idle'\n",
    "        cv2.putText(frame, stopwatch, (10, 590), cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])\n",
    "\n",
    "        # trial countdown (TODO add island countdown)\n",
    "        if phase == 1:\n",
    "            text = 'Trial: %.2f' % float(cfg_exp['trial_duration'] - (c_time - trial_start))\n",
    "            cv2.putText(frame, text, (10, 610), cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])\n",
    "        cv2.putText(frame, 'Trial: %s' % trial, (10, 630), cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])\n",
    "\n",
    "        # rewards\n",
    "        cv2.putText(frame, 'Rewards: %s' % rewards, (10, 650), cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])\n",
    "        \n",
    "        # time since in target\n",
    "        if target_since is not None:\n",
    "            cv2.putText(frame, 'In target: %.2f' % float(c_time - target_since), (10, 670), cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])\n",
    "\n",
    "        # light or dark period\n",
    "        cv2.putText(frame, 'Light' if pt.is_light else 'Dark', (10, 690), cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])            \n",
    "\n",
    "        if iti_distance > 0:  # TODO change red / white color\n",
    "            cv2.putText(frame, 'ITI distance: %.2f' % iti_distance, (10, 710), cv2.FONT_HERSHEY_DUPLEX, .5, COLORS['white'])            \n",
    "            \n",
    "        # indicators of the initial / conflicting anges\n",
    "        p_rho, p_phi = pt.cfg['floor_radius']*pt.pixel_size, pt.correct_angle(phi_initial)\n",
    "        x_init, y_init = pt.meters_to_px(p_rho * np.sin(p_phi), p_rho * np.cos(p_phi))\n",
    "        cv2.circle(frame, (x_init, y_init), 10, COLORS['blue'], -1)\n",
    "        \n",
    "        p_phi = pt.correct_angle(phi_initial + np.deg2rad(cfg_exp['phi_max']))\n",
    "        x_init, y_init = pt.meters_to_px(p_rho * np.sin(p_phi), p_rho * np.cos(p_phi))\n",
    "        cv2.circle(frame, (x_init, y_init), 10, COLORS['yellow'], -1)\n",
    "            \n",
    "        # assign the frame back to the video stream for other controllers\n",
    "        vs.frame_with_infos = frame\n",
    "        \n",
    "        cv2.imshow('Press (s)-to start/stop, (q)-to end', frame)\n",
    "\n",
    "        # -------- experiment logic ---------------\n",
    "        \n",
    "        # animals is either foraging (phase == 1) or in the inter-trial-interval (phase == 2)\n",
    "        if phase == 1: # foraging\n",
    "            if pt.x_in_m is not None and len(islands) > 0:\n",
    "                # check if animal in the island and for how long\n",
    "                tgt = [i for i in islands if not i.is_distractor][0]\n",
    "                distractors = [i for i in islands if i.is_distractor]\n",
    "                \n",
    "                if (pt.x_in_m - tgt.x)**2 + (pt.y_in_m - tgt.y)**2 <= cfg_exp['target_radius']**2:\n",
    "                    if target_since is None:  # just entered target\n",
    "                        target_since = c_time\n",
    "                        if unaudible_trials[cfg_exp['unaudible_profile']][trial - 1] == 0:\n",
    "                            sound.value = 2\n",
    "\n",
    "                    elif c_time - target_since > cfg_exp['target_duration']: # successful trial\n",
    "                        log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 1) # log trial success\n",
    "                        feeder.feed()\n",
    "                        \n",
    "                        # init inter-trial interval and new trial\n",
    "                        trial_start = c_time + 20 + 5 * np.random.rand()  # random b/w 10-15 sec\n",
    "                        sound.value = 0  # silence\n",
    "                        islands = []\n",
    "                        phase = 2\n",
    "                        rewards += 1\n",
    "                        target_since = None\n",
    "                        \n",
    "                elif c_time - trial_start > cfg_exp['trial_duration']:  # trial failed and animal is not in the target\n",
    "                    log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 2) # log trial failed\n",
    "\n",
    "                    trial_start = c_time + 20 + 5 * np.random.rand()  # random b/w 10-15 sec\n",
    "                    sound.value = -1  # punishment\n",
    "                    punishment_since = c_time\n",
    "                    islands = []\n",
    "                    phase = 2\n",
    "                \n",
    "                else:\n",
    "                    target_since = None\n",
    "                    in_distractor = False\n",
    "                    \n",
    "                    for isl in distractors:  # maybe animal is in one of the distractors\n",
    "                        if (pt.x_in_m - isl.x)**2 + (pt.y_in_m - isl.y)**2 <= cfg_exp['target_radius']**2:\n",
    "                            sound.value = isl.sound_id\n",
    "                            in_distractor = True\n",
    "                    \n",
    "                    if not in_distractor:  # outside of the islands\n",
    "                        sound.value = 1\n",
    "            \n",
    "        elif phase == 2:  # inter-trial-interval\n",
    "            # count distance between trials\n",
    "            if last_x is None:\n",
    "                last_x, last_y = pt.x_in_m, pt.y_in_m\n",
    "            else:\n",
    "                x, y = pt.x_in_m, pt.y_in_m\n",
    "                iti_distance += np.sqrt((x - last_x)**2 + (y - last_y)**2)\n",
    "                last_x, last_y = x, y\n",
    "            \n",
    "            if punishment_since is not None and c_time - punishment_since > 10:  # max 10 sec of punishment\n",
    "                sound.value = 0\n",
    "                punishment_since = None\n",
    "\n",
    "            phi = get_island_position(c_time - t_start, phi_initial, np.deg2rad(cfg_exp['phi_max']), cfg_exp['timepoints'])\n",
    "            phi = pt.correct_angle(phi)  # correct for the camera orientation\n",
    "            x_tgt, y_tgt = rho * np.sin(phi), rho * np.cos(phi)\n",
    "\n",
    "            if c_time > trial_start and iti_distance > cfg_exp['iti_distance'] and \\\n",
    "                  (pt.x_in_m - x_tgt)**2 + (pt.y_in_m - y_tgt)**2 >= cfg_exp['target_radius']**2:\n",
    "                # init_new_trial\n",
    "                islands = [Island(x_tgt, y_tgt, cfg_exp['target_radius'], 2)]\n",
    "                sound.value = 1\n",
    "                phase = 1\n",
    "                trial += 1\n",
    "                \n",
    "                # reset ITI distance and trial_start\n",
    "                iti_distance = 0\n",
    "                trial_start = c_time\n",
    "                \n",
    "                # log trial start\n",
    "                tgt = [i for i in islands if not i.is_distractor][0]\n",
    "                log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 0)\n",
    "        \n",
    "        # -------- key press events ---------------\n",
    "        \n",
    "        k = cv2.waitKey(33)\n",
    "        if k == ord('q'):\n",
    "            break\n",
    "\n",
    "        if k == ord('s'):\n",
    "            board.start_or_stop()  # start/stop data acquisition\n",
    "            c_time = time.time()   # more accurate time\n",
    "\n",
    "            if status.value == 1: # start the session\n",
    "                if t_start is None:\n",
    "                    t_start = c_time\n",
    "                trial_start = c_time\n",
    "                status.value = 2\n",
    "                \n",
    "                # init_new_trial\n",
    "                phi = get_island_position(c_time - t_start, phi_initial, np.deg2rad(cfg_exp['phi_max']), cfg_exp['timepoints'])\n",
    "                phi = pt.correct_angle(phi)  # correct for the camera orientation\n",
    "                x_tgt, y_tgt = rho * np.sin(phi), rho * np.cos(phi)\n",
    "                islands = [Island(x_tgt, y_tgt, cfg_exp['target_radius'], 2)]\n",
    "                sound.value = 1\n",
    "                phase = 1\n",
    "                trial += 1\n",
    "\n",
    "                # log trial start\n",
    "                tgt = [i for i in islands if not i.is_distractor][0]\n",
    "                log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 0)\n",
    "                \n",
    "                # init light events\n",
    "                timers = []\n",
    "                for event_t in cfg_exp['light_events']:\n",
    "                    timers.append(threading.Timer(event_t, switch_light, args=(pt, board)))                \n",
    "                for t in timers:\n",
    "                    t.start()\n",
    "                \n",
    "            elif status.value == 2:  # pause the session\n",
    "                if len(islands) > 0:\n",
    "                    tgt = [i for i in islands if not i.is_distractor][0]\n",
    "                    x, y, r = round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4)\n",
    "                else:\n",
    "                    x, y, r = None, None, None\n",
    "                log_event(c_time, x, y, r, trial, -1)  # log experiment break\n",
    "                \n",
    "                status.value = 1\n",
    "                phase = 0\n",
    "                islands = []\n",
    "                for t in timers:\n",
    "                    t.cancel()\n",
    "                    \n",
    "        if k == ord('a'):\n",
    "            sound.value = 0 if sound.value == 1 else 1\n",
    "\n",
    "finally:\n",
    "    if status.value == 2:  # stop data acquisition, in case exited via timeout\n",
    "        board.start_or_stop()\n",
    "        if len(islands) > 0:\n",
    "            tgt = [i for i in islands if not i.is_distractor][0]\n",
    "            x, y, r = round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4)\n",
    "        else:\n",
    "            x, y, r = None, None, None\n",
    "        log_event(c_time, x, y, r, trial, -1)  # log experiment end\n",
    "        \n",
    "    status.value = 0\n",
    "    time.sleep(0.01)\n",
    "    for t in timers:\n",
    "        t.cancel()\n",
    "    \n",
    "    feeder.exit()\n",
    "    if board.is_light_off:\n",
    "        board.switch_light()  # turn light back on\n",
    "        time.sleep(0.1)\n",
    "    board.exit()\n",
    "    cv2.destroyAllWindows()\n",
    "    sc.join()\n",
    "    for ctrl in [pt, vw, vs]:\n",
    "        ctrl.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merge data in HDF5 file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "session_path = save_to\n",
    "#session_path = os.path.join('sessions', '2021-07-30_09-24-14')  # some particular session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not trial > 0:\n",
    "    raise SystemExit('Nothing recorded. No sense to continue.')\n",
    "\n",
    "# do pack data to HDF5\n",
    "h5name = pack(session_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot sessions stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import numpy as np\n",
    "from scipy import signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "arena_r = 0.4  # in meters\n",
    "\n",
    "with h5py.File(h5name, 'r') as f:\n",
    "    tl = np.array(f['processed']['timeline'])\n",
    "    trial_idxs = np.array(f['processed']['trial_idxs'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Speed')"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(12, 12))\n",
    "\n",
    "# trajectory and islands\n",
    "ax = fig.add_subplot(221)\n",
    "ax.scatter(tl[:, 1], tl[:, 2], s=1, alpha=0.1)  # positions\n",
    "scat = ax.scatter(trial_idxs[:, 2], trial_idxs[:, 3], s=1000, facecolors='none', edgecolors='r')  # islands, radius approx.\n",
    "ax.add_patch(plt.Circle((0, 0), arena_r, color='r', fill=False))\n",
    "ax.set_aspect('equal')\n",
    "ax.set_xlabel('X, m', fontsize=14)\n",
    "ax.set_ylabel('Y, m', fontsize=14)\n",
    "ax.set_title('Running', fontsize=14)\n",
    "ax.grid()\n",
    "\n",
    "# occupancy\n",
    "sigma = 0.1\n",
    "lin_profile = np.linspace(-15, 15, 20)\n",
    "bump = np.exp(-sigma * lin_profile**2)\n",
    "bump /= np.trapz(bump)  # normalize to 1\n",
    "kernel = bump[:, np.newaxis] * bump[np.newaxis, :]\n",
    "occupancy_map, _, _ = np.histogram2d(tl[:, 1], tl[:, 2], bins=[40, 40], range=np.array([[-0.5, 0.5], [-0.5, 0.5]]))\n",
    "occupancy_map = signal.convolve2d(occupancy_map, kernel, mode='same')\n",
    "\n",
    "ax = fig.add_subplot(222)\n",
    "ax.imshow(occupancy_map, origin='lower', extent=(-0.5, 0.5, -0.5, 0.5), cmap='Blues')\n",
    "ax.add_patch(plt.Circle((0, 0), arena_r, color='r', fill=False))\n",
    "ax.set_xlabel('X, m', fontsize=14)\n",
    "ax.set_title('Occupancy', fontsize=14)\n",
    "ax.grid()\n",
    "\n",
    "# trials\n",
    "durations = tl[trial_idxs[:, 1].astype(int)][:, 0] - tl[trial_idxs[:, 0].astype(int)][:, 0]\n",
    "colors = ['red' if x == 1 else 'grey' for x in trial_idxs[:, 5]]\n",
    "\n",
    "ax = fig.add_subplot(223)\n",
    "ax.barh(np.arange(len(trial_idxs)), durations, color=colors, align='center')\n",
    "ax.set_xlabel('Time, s', fontsize=14)\n",
    "ax.set_ylabel('Trial, #', fontsize=14)\n",
    "ax.set_title('Trials', fontsize=14)\n",
    "\n",
    "# speed\n",
    "ax = fig.add_subplot(224)\n",
    "ax.hist(tl[:, 3], bins=50, ec='black')\n",
    "ax.set_xlabel('Speed, m/s', fontsize=14)\n",
    "ax.set_title('Speed', fontsize=14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}