{ "cells": [ { "cell_type": "code", "execution_count": 1, "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\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": 2, "metadata": {}, "outputs": [], "source": [ "cfg_filename = os.path.join('profiles', 'andrey_hippoSIT_006865.json')" ] }, { "cell_type": "code", "execution_count": 3, "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": 4, "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": 5, "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, cfg['video']['file_path'])\n", "cfg['position']['file_path'] = os.path.join(save_to, cfg['position']['file_path'])\n", "cfg['position']['contour_path'] = os.path.join(save_to, cfg['position']['contour_path'])\n", "cfg['experiment']['file_path'] = os.path.join(save_to, cfg['experiment']['file_path'])\n", "cfg['sound']['file_path'] = os.path.join(save_to, cfg['sound']['file_path'])\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": 6, "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": 7, "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": 8, "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": 9, "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": 10, "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": 11, "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 and feeder via Arduino\n", "if cfg['experiment']['MCSArduinoPort'] == 'fake':\n", " board = FakeArduino()\n", "else:\n", " board = MCSArduino(cfg['experiment']['MCSArduinoPort'])\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.subtract(pt.background, frame)\n", " #frame = cv2.absdiff(frame, pt.background)\n", " #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n", " frame = cv2.bitwise_and(src1=frame, src2=pt.mask)\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", " board.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", " \n", " if k == ord('l'):\n", " switch_light(pt, board)\n", " \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 = 0, 0, 0\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 = 0, 0, 0\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", " 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": 12, "metadata": {}, "outputs": [], "source": [ "session_path = save_to\n", "#session_path = os.path.join('sessions', '2021-07-30_09-24-14') # some particular session\n", "#session_path = 'Y:\\\\Michael\\\\FreeBehaving\\\\SIT_sessions\\\\50_aSIT_2021-10-25_10-32-19'" ] }, { "cell_type": "code", "execution_count": 13, "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": 14, "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": 15, "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": 16, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'Speed')" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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.T, 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 (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": 2 }