{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Import modules\n", "\n", "Make sure that Python 3 and the following modules (recommended version ID) are installed on your computer:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "jupyter==1.0.0\n", "pyFirmata==1.1.0\n", "numpy==1.18.4\n", "opencv-python==4.2.0.34\n", "sounddevice\n", "multiprocess\n", "\n" ] } ], "source": [ "# to install with pip run:\n", "# pip install -r requirements.txt\n", "\n", "with open('requirements.txt', 'r') as f:\n", " print(''.join(f.readlines()))" ] }, { "cell_type": "code", "execution_count": 30, "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": 31, "metadata": {}, "outputs": [], "source": [ "cfg_filename = 'settings_dark.json'" ] }, { "cell_type": "code", "execution_count": 32, "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": 33, "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": 34, "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_file'] = os.path.join('assets', cfg['position']['background_file'])\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, animal_x, animal_y, target_x, target_y, target_r, trial, state\\n')" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "class Island: \n", " def __init__(self, x, y, radius, sound_id, is_distractor=False):\n", " self.x = x\n", " self.y = y\n", " self.r = radius\n", " self.sound_id = sound_id\n", " self.is_distractor = is_distractor" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "def generate_islands(arena_x, arena_y, arena_radius, island_radius, distractors=0):\n", " while True:\n", " x = (arena_x - arena_radius + island_radius) + np.random.rand() * 2 * (arena_radius - island_radius)\n", " y = (arena_y - arena_radius + island_radius) + np.random.rand() * 2 * (arena_radius - island_radius)\n", " \n", " if (x - arena_x)**2 + (y - arena_y)**2 <= (arena_radius - island_radius)**2:\n", " break\n", " \n", " # TODO write multi islands\n", " return [Island(int(x), int(y), island_radius, 2)] # always a list of Islands" ] }, { "cell_type": "code", "execution_count": 37, "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": 38, "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": "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": 39, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Webcam stream 1024.0:768.0 at 20.00 FPS started\n", "Fake Arduino - sending a TTL pulse\n", "Fake Arduino - sending a TTL pulse\n", "Fake Arduino - exiting...\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('COM8')\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", "fps = FPSTimes()\n", "names = ['camera', 'video', 'position', 'main']\n", "trial = 0\n", "rewards = 0\n", "t_start = None\n", "target_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", "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", "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 is not None:\n", " cv2.circle(frame, (pt.x, pt.y), 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, (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", " cv2.circle(frame, (island.x, island.y), island.r, clr, 2)\n", "\n", " # positions of animal and target\n", " if pt.x is not None:\n", " cv2.putText(frame, 'Animal: %s %s' % (pt.x, pt.y), (10, 550), cv2.FONT_HERSHEY_DUPLEX, .5, 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: %s %s' % (target.x, target.y), (10, 570), 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 status.value > 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", " # 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 c_time - trial_start > cfg_exp['trial_duration']: # trial failed\n", " if len(islands) > 0: # this should always be true\n", " tgt = [i for i in islands if not i.is_distractor][0]\n", " log_event(c_time, tgt.x, tgt.y, tgt.r, trial, 2) # log trial failed\n", " \n", " trial_start = c_time + 5 + 10 * np.random.rand() # random b/w 5-15 sec\n", " sound.value = 4 # punishment\n", " islands = []\n", " phase = 2\n", " \n", " elif pt.x 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 - tgt.x)**2 + (pt.y - tgt.y)**2 <= cfg_exp['target_radius']**2:\n", " if target_since is None: # just entered target\n", " target_since = c_time\n", " sound.value = 2\n", "\n", " elif c_time - target_since > cfg_exp['target_duration']: # successful trial\n", " log_event(c_time, tgt.x, tgt.y, tgt.r, trial, 1) # log trial success\n", " feeder.feed()\n", " \n", " # init inter-trial interval and new trial\n", " trial_start = c_time + 5 + 10 * np.random.rand() # random b/w 5-15 sec\n", " sound.value = 0 # silence\n", " islands = []\n", " phase = 2\n", " rewards += 1\n", " target_since = None\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 - isl.x)**2 + (pt.y - isl.y)**2 <= cfg_exp['target_radius']:\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", " if c_time > trial_start:\n", " # init_new_trial\n", " islands = generate_islands(cfg_pos['arena_x'], cfg_pos['arena_y'], cfg_pos['arena_radius'], \\\n", " cfg_exp['target_radius'])\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, tgt.x, tgt.y, tgt.r, trial, 0)\n", "\n", " \n", " # -------- key press events ---------------\n", " \n", " k = cv2.waitKey(33)\n", " if k == ord('q'):\n", " if status.value == 2: # stop data acquisition\n", " board.start_or_stop()\n", " break\n", "\n", " if k == ord('s'):\n", " board.start_or_stop() # start/stop data acquisition\n", "\n", " if status.value == 1: # start the session\n", " t_start = time.time()\n", " trial_start = t_start\n", " status.value = 2\n", " \n", " # init_new_trial\n", " islands = generate_islands(cfg_pos['arena_x'], cfg_pos['arena_y'], cfg_pos['arena_radius'], \\\n", " cfg_exp['target_radius'])\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(trial_start, tgt.x, tgt.y, tgt.r, trial, 0)\n", " \n", " elif status.value == 2: # pause the session\n", " status.value = 1\n", " phase = 0\n", " islands = []\n", " \n", " if k == ord('a'):\n", " sound.value = 0 if sound.value == 1 else 1\n", "\n", "finally:\n", " status.value = 0\n", " time.sleep(0.01)\n", " \n", " feeder.exit()\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": 40, "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": 41, "metadata": {}, "outputs": [], "source": [ "# do pack data to HDF5\n", "h5name = pack(session_path)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot sessions stats" ] }, { "cell_type": "code", "execution_count": 42, "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": 43, "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": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'Speed')" ] }, "execution_count": 44, "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, 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": [] }, { "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 }