{ "cells": [ { "cell_type": "markdown", "id": "recreational-beijing", "metadata": {}, "source": [ "# Offline pupillometry\n", "This notebook provides an example of how to use mEYE models in the Python environment to get pupillometry data from a prerecorded video file.\n", "\n", "## Installation\n", "Follow the requiremets described in the repo [homepage](https://github.com/fabiocarrara/meye). \n", "\n", "Download locally the NN model in a location in your computer. \n", "\n", "For **mEYE** you need Python 3 environment with the following packages installed:\n", "- tensorflow >= 2.4\n", "- imageio, imageio-ffmpeg\n", "- scipy\n", "- tqdm\n", "\n", "For running the rest of this **notebook** you will need:\n", "- cv2\n", "- numpy\n", "- pandas\n", "- matplotlib\n", "- scikit-image" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "!pip install -q opencv-python-headless scikit-image" ] }, { "cell_type": "code", "execution_count": 7, "id": "welcome-prescription", "metadata": {}, "outputs": [], "source": [ "# Import required packages for this notebook\n", "import os\n", "import numpy as np \n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import matplotlib.patches as ptch\n", "%matplotlib inline\n", "import cv2 as cv\n", "from skimage.measure import label, regionprops\n", "\n", "# Import the NN model\n", "from tensorflow.keras.models import load_model\n", "\n", "### WINDOWS ONLY (Comment if on other OS)\n", "# import winsound # makes a beep sound when whole video analysis is finished\n", "BEEP_FREQ = 2500 # Set Frequency To 2500 Hertz\n", "BEEP_DURATION_MS = 1000 # Set Duration To 1000 ms == 1 second\n", "###" ] }, { "cell_type": "markdown", "id": "impressive-youth", "metadata": {}, "source": [ "### Specify the full paths\n", " - **MODELPATH**: the NN model that you downloaded locally on your PC\n", " - **VIDEOPATH**: the video file you want to analyze" ] }, { "cell_type": "code", "execution_count": 2, "id": "eleven-avatar", "metadata": {}, "outputs": [], "source": [ "MODELPATH = r\"C:\\Users\\Leonardo\\Documents\\Python\\pupilNN\\meye-segmentation_i128_s4_c1_f16_g1_a-relu.hdf5\"\n", "VIDEOPATH = r\"D:\\PizzorussoLAB\\proj_Fasting\\exp_acuity-2P\\2P_data\\cage_gNex6\\20210107\\gNex6_postFast_2021-01-07-095936-0000.avi\"\n", "\n", "model = load_model(MODELPATH)" ] }, { "cell_type": "markdown", "id": "offensive-freeware", "metadata": {}, "source": [ "## Crop the movie\n", "\n", "The NN makes predition on images of a fixed size. The following section provide some code to interactively and iteratively perform a square region of interest (ROI) around the eye. \n", "You need to specify and eventually adjust 2 parameters:\n", "- **TOPLEFT**: tuple containing the XY (columns,rows) coordinates of the top-left corner of the ROI\n", "- **ROIWIDTH**: size of the side of the square ROI in pixels" ] }, { "cell_type": "code", "execution_count": 6, "id": "labeled-gibson", "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# EDIT PARAMETERS\n", "# Manually select a square ROI for the eye, by specifying the XY coordinates\n", "# and the width of the square in pixels\n", "# ---------------------------------------------------\n", "TOPLEFT = (260,50) # X,Y coordinates\n", "ROIWIDTH = 200 # width on the square ROI in pixels\n", "# ---------------------------------------------------\n", "\n", "cap = cv.VideoCapture(VIDEOPATH)\n", "try:\n", " numOfFrames = int(cap.get(cv.CAP_PROP_FRAME_COUNT))\n", " chosenFrame = np.random.randint(1, high=numOfFrames)# Choose randomly a frame\n", " \n", " cap.set(cv.CAP_PROP_POS_FRAMES,chosenFrame)\n", " _, frame = cap.read() # Read the frame\n", " frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)# Convert to grayscale\n", "except:\n", " print('An error occurred while getting a frame for the video.')\n", "finally:\n", " cap.release()\n", "\n", "fHeight, fWidth = frame.shape\n", "cropL = TOPLEFT[0]\n", "cropR = TOPLEFT[0]+ROIWIDTH\n", "cropT = TOPLEFT[1]\n", "cropB = TOPLEFT[1]+ROIWIDTH\n", "\n", "# Default crop is the selected crop is out of the image boundaries\n", "if (any(np.array([cropT,cropB])>fHeight)) or (any(np.array([cropL,cropR])>fWidth)):\n", " print('Crop limits exceed image size. Performing a default crop instead.')\n", " cropL = round((fWidth-ROIWIDTH) / 2)\n", " cropR = round((fWidth+ROIWIDTH) / 2)\n", " cropT = round((fHeight-ROIWIDTH) / 2)\n", " cropB = round((fHeight+ROIWIDTH) / 2) \n", " \n", "# Crop and resize \n", "requiredFrameSize = model.input.shape[1:3]\n", "crop = frame[cropT:cropB, cropL:cropR]\n", "crop = cv.resize(crop,tuple(requiredFrameSize))\n", "\n", "# Create a Rectangle patch\n", "rect = ptch.Rectangle((cropL,cropT),ROIWIDTH,ROIWIDTH,\n", " linewidth=4,edgecolor=[.2,1,.2],facecolor='none')\n", "\n", "# Visual plotting\n", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,4))\n", "ax1.imshow(frame, cmap='gray')\n", "ax1.add_patch(rect)\n", "ax1.set_title('Raw frame')\n", "ax2.imshow(crop, cmap='gray')\n", "ax2.set_title('Cropped, resized')\n", "ax1.grid(color=[1,.4,.4], linewidth=1, linestyle='-.')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "favorite-bearing", "metadata": {}, "source": [ "## Load and predict a single frame of the video\n", "This section allows to make a prediciton on a single frame of the video.\n", "By default the prediction returns: \n", "- an **output image** of the same size as the input image, containing a **probability map** (i.e. each pixel value represent the probability for that pizel to be part of a pupil).\n", "- the **eye-probability** (i.e., the probability for that frame to be an eye)\n", "- the **blink-probability** (i.e., the probability for that frame to be a blink)\n", "\n", "The output image can be binarized based on a probability threshold to get a binay mask of the pupil.\n", "\n", "----\n", "You need to specify and eventually adjust 2 parameters:\n", "- **FRAMENUMBER**: The frame to analyze. If FRAMENUMBER=[], then a random frame will be taken\n", "- **THRESHOLD**: The probability threshold to binarize the output image\n", "- **IMCLOSING**: Size in pixel for morphological closing (fill pupil areas not detected). Increase to fill more.\n", "- **INVERTIMAGE**: bool. Inverts the image (can be useful for tricky 2p images)" ] }, { "cell_type": "code", "execution_count": 114, "id": "permanent-fifth", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Analyzed image # 20400 / 23236\n", "Eye Probability: 99.82%\n", "Blink Probability: 2.64%\n" ] }, { "data": { "application/javascript": [ "/* Put everything inside the global mpl namespace */\n", "/* global mpl */\n", "window.mpl = {};\n", "\n", "mpl.get_websocket_type = function () {\n", " if (typeof WebSocket !== 'undefined') {\n", " return WebSocket;\n", " } else if (typeof MozWebSocket !== 'undefined') {\n", " return MozWebSocket;\n", " } else {\n", " alert(\n", " 'Your browser does not have WebSocket support. ' +\n", " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.'\n", " );\n", " }\n", "};\n", "\n", "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", " this.id = figure_id;\n", "\n", " this.ws = websocket;\n", "\n", " this.supports_binary = this.ws.binaryType !== undefined;\n", "\n", " if (!this.supports_binary) {\n", " var warnings = document.getElementById('mpl-warnings');\n", " if (warnings) {\n", " warnings.style.display = 'block';\n", " warnings.textContent =\n", " 'This browser does not support binary websocket messages. ' +\n", " 'Performance may be slow.';\n", " }\n", " }\n", "\n", " this.imageObj = new Image();\n", "\n", " this.context = undefined;\n", " this.message = undefined;\n", " this.canvas = undefined;\n", " this.rubberband_canvas = undefined;\n", " this.rubberband_context = undefined;\n", " this.format_dropdown = undefined;\n", "\n", " this.image_mode = 'full';\n", "\n", " this.root = document.createElement('div');\n", " this.root.setAttribute('style', 'display: inline-block');\n", " this._root_extra_style(this.root);\n", "\n", " parent_element.appendChild(this.root);\n", "\n", " this._init_header(this);\n", " this._init_canvas(this);\n", " this._init_toolbar(this);\n", "\n", " var fig = this;\n", "\n", " this.waiting = false;\n", "\n", " this.ws.onopen = function () {\n", " fig.send_message('supports_binary', { value: fig.supports_binary });\n", " fig.send_message('send_image_mode', {});\n", " if (fig.ratio !== 1) {\n", " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", " }\n", " fig.send_message('refresh', {});\n", " };\n", "\n", " this.imageObj.onload = function () {\n", " if (fig.image_mode === 'full') {\n", " // Full images could contain transparency (where diff images\n", " // almost always do), so we need to clear the canvas so that\n", " // there is no ghosting.\n", " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", " }\n", " fig.context.drawImage(fig.imageObj, 0, 0);\n", " };\n", "\n", " this.imageObj.onunload = function () {\n", " fig.ws.close();\n", " };\n", "\n", " this.ws.onmessage = this._make_on_message_function(this);\n", "\n", " this.ondownload = ondownload;\n", "};\n", "\n", "mpl.figure.prototype._init_header = function () {\n", " var titlebar = document.createElement('div');\n", " titlebar.classList =\n", " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", " var titletext = document.createElement('div');\n", " titletext.classList = 'ui-dialog-title';\n", " titletext.setAttribute(\n", " 'style',\n", " 'width: 100%; text-align: center; padding: 3px;'\n", " );\n", " titlebar.appendChild(titletext);\n", " this.root.appendChild(titlebar);\n", " this.header = titletext;\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._init_canvas = function () {\n", " var fig = this;\n", "\n", " var canvas_div = (this.canvas_div = document.createElement('div'));\n", " canvas_div.setAttribute(\n", " 'style',\n", " 'border: 1px solid #ddd;' +\n", " 'box-sizing: content-box;' +\n", " 'clear: both;' +\n", " 'min-height: 1px;' +\n", " 'min-width: 1px;' +\n", " 'outline: 0;' +\n", " 'overflow: hidden;' +\n", " 'position: relative;' +\n", " 'resize: both;'\n", " );\n", "\n", " function on_keyboard_event_closure(name) {\n", " return function (event) {\n", " return fig.key_event(event, name);\n", " };\n", " }\n", "\n", " canvas_div.addEventListener(\n", " 'keydown',\n", " on_keyboard_event_closure('key_press')\n", " );\n", " canvas_div.addEventListener(\n", " 'keyup',\n", " on_keyboard_event_closure('key_release')\n", " );\n", "\n", " this._canvas_extra_style(canvas_div);\n", " this.root.appendChild(canvas_div);\n", "\n", " var canvas = (this.canvas = document.createElement('canvas'));\n", " canvas.classList.add('mpl-canvas');\n", " canvas.setAttribute('style', 'box-sizing: content-box;');\n", "\n", " this.context = canvas.getContext('2d');\n", "\n", " var backingStore =\n", " this.context.backingStorePixelRatio ||\n", " this.context.webkitBackingStorePixelRatio ||\n", " this.context.mozBackingStorePixelRatio ||\n", " this.context.msBackingStorePixelRatio ||\n", " this.context.oBackingStorePixelRatio ||\n", " this.context.backingStorePixelRatio ||\n", " 1;\n", "\n", " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", "\n", " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", " 'canvas'\n", " ));\n", " rubberband_canvas.setAttribute(\n", " 'style',\n", " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", " );\n", "\n", " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", " if (this.ResizeObserver === undefined) {\n", " if (window.ResizeObserver !== undefined) {\n", " this.ResizeObserver = window.ResizeObserver;\n", " } else {\n", " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", " this.ResizeObserver = obs.ResizeObserver;\n", " }\n", " }\n", "\n", " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", " var nentries = entries.length;\n", " for (var i = 0; i < nentries; i++) {\n", " var entry = entries[i];\n", " var width, height;\n", " if (entry.contentBoxSize) {\n", " if (entry.contentBoxSize instanceof Array) {\n", " // Chrome 84 implements new version of spec.\n", " width = entry.contentBoxSize[0].inlineSize;\n", " height = entry.contentBoxSize[0].blockSize;\n", " } else {\n", " // Firefox implements old version of spec.\n", " width = entry.contentBoxSize.inlineSize;\n", " height = entry.contentBoxSize.blockSize;\n", " }\n", " } else {\n", " // Chrome <84 implements even older version of spec.\n", " width = entry.contentRect.width;\n", " height = entry.contentRect.height;\n", " }\n", "\n", " // Keep the size of the canvas and rubber band canvas in sync with\n", " // the canvas container.\n", " if (entry.devicePixelContentBoxSize) {\n", " // Chrome 84 implements new version of spec.\n", " canvas.setAttribute(\n", " 'width',\n", " entry.devicePixelContentBoxSize[0].inlineSize\n", " );\n", " canvas.setAttribute(\n", " 'height',\n", " entry.devicePixelContentBoxSize[0].blockSize\n", " );\n", " } else {\n", " canvas.setAttribute('width', width * fig.ratio);\n", " canvas.setAttribute('height', height * fig.ratio);\n", " }\n", " canvas.setAttribute(\n", " 'style',\n", " 'width: ' + width + 'px; height: ' + height + 'px;'\n", " );\n", "\n", " rubberband_canvas.setAttribute('width', width);\n", " rubberband_canvas.setAttribute('height', height);\n", "\n", " // And update the size in Python. We ignore the initial 0/0 size\n", " // that occurs as the element is placed into the DOM, which should\n", " // otherwise not happen due to the minimum size styling.\n", " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", " fig.request_resize(width, height);\n", " }\n", " }\n", " });\n", " this.resizeObserverInstance.observe(canvas_div);\n", "\n", " function on_mouse_event_closure(name) {\n", " return function (event) {\n", " return fig.mouse_event(event, name);\n", " };\n", " }\n", "\n", " rubberband_canvas.addEventListener(\n", " 'mousedown',\n", " on_mouse_event_closure('button_press')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'mouseup',\n", " on_mouse_event_closure('button_release')\n", " );\n", " // Throttle sequential mouse events to 1 every 20ms.\n", " rubberband_canvas.addEventListener(\n", " 'mousemove',\n", " on_mouse_event_closure('motion_notify')\n", " );\n", "\n", " rubberband_canvas.addEventListener(\n", " 'mouseenter',\n", " on_mouse_event_closure('figure_enter')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'mouseleave',\n", " on_mouse_event_closure('figure_leave')\n", " );\n", "\n", " canvas_div.addEventListener('wheel', function (event) {\n", " if (event.deltaY < 0) {\n", " event.step = 1;\n", " } else {\n", " event.step = -1;\n", " }\n", " on_mouse_event_closure('scroll')(event);\n", " });\n", "\n", " canvas_div.appendChild(canvas);\n", " canvas_div.appendChild(rubberband_canvas);\n", "\n", " this.rubberband_context = rubberband_canvas.getContext('2d');\n", " this.rubberband_context.strokeStyle = '#000000';\n", "\n", " this._resize_canvas = function (width, height, forward) {\n", " if (forward) {\n", " canvas_div.style.width = width + 'px';\n", " canvas_div.style.height = height + 'px';\n", " }\n", " };\n", "\n", " // Disable right mouse context menu.\n", " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", " event.preventDefault();\n", " return false;\n", " });\n", "\n", " function set_focus() {\n", " canvas.focus();\n", " canvas_div.focus();\n", " }\n", "\n", " window.setTimeout(set_focus, 100);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'mpl-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " continue;\n", " }\n", "\n", " var button = (fig.buttons[name] = document.createElement('button'));\n", " button.classList = 'mpl-widget';\n", " button.setAttribute('role', 'button');\n", " button.setAttribute('aria-disabled', 'false');\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", "\n", " var icon_img = document.createElement('img');\n", " icon_img.src = '_images/' + image + '.png';\n", " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", " icon_img.alt = tooltip;\n", " button.appendChild(icon_img);\n", "\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " var fmt_picker = document.createElement('select');\n", " fmt_picker.classList = 'mpl-widget';\n", " toolbar.appendChild(fmt_picker);\n", " this.format_dropdown = fmt_picker;\n", "\n", " for (var ind in mpl.extensions) {\n", " var fmt = mpl.extensions[ind];\n", " var option = document.createElement('option');\n", " option.selected = fmt === mpl.default_extension;\n", " option.innerHTML = fmt;\n", " fmt_picker.appendChild(option);\n", " }\n", "\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "};\n", "\n", "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", " // which will in turn request a refresh of the image.\n", " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", "};\n", "\n", "mpl.figure.prototype.send_message = function (type, properties) {\n", " properties['type'] = type;\n", " properties['figure_id'] = this.id;\n", " this.ws.send(JSON.stringify(properties));\n", "};\n", "\n", "mpl.figure.prototype.send_draw_message = function () {\n", " if (!this.waiting) {\n", " this.waiting = true;\n", " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " var format_dropdown = fig.format_dropdown;\n", " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", " fig.ondownload(fig, format);\n", "};\n", "\n", "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", " var size = msg['size'];\n", " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", " fig._resize_canvas(size[0], size[1], msg['forward']);\n", " fig.send_message('refresh', {});\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", " var x0 = msg['x0'] / fig.ratio;\n", " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", " var x1 = msg['x1'] / fig.ratio;\n", " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", " x0 = Math.floor(x0) + 0.5;\n", " y0 = Math.floor(y0) + 0.5;\n", " x1 = Math.floor(x1) + 0.5;\n", " y1 = Math.floor(y1) + 0.5;\n", " var min_x = Math.min(x0, x1);\n", " var min_y = Math.min(y0, y1);\n", " var width = Math.abs(x1 - x0);\n", " var height = Math.abs(y1 - y0);\n", "\n", " fig.rubberband_context.clearRect(\n", " 0,\n", " 0,\n", " fig.canvas.width / fig.ratio,\n", " fig.canvas.height / fig.ratio\n", " );\n", "\n", " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", "};\n", "\n", "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", " // Updates the figure title.\n", " fig.header.textContent = msg['label'];\n", "};\n", "\n", "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", " var cursor = msg['cursor'];\n", " switch (cursor) {\n", " case 0:\n", " cursor = 'pointer';\n", " break;\n", " case 1:\n", " cursor = 'default';\n", " break;\n", " case 2:\n", " cursor = 'crosshair';\n", " break;\n", " case 3:\n", " cursor = 'move';\n", " break;\n", " }\n", " fig.rubberband_canvas.style.cursor = cursor;\n", "};\n", "\n", "mpl.figure.prototype.handle_message = function (fig, msg) {\n", " fig.message.textContent = msg['message'];\n", "};\n", "\n", "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", " // Request the server to send over a new figure.\n", " fig.send_draw_message();\n", "};\n", "\n", "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", " fig.image_mode = msg['mode'];\n", "};\n", "\n", "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", " for (var key in msg) {\n", " if (!(key in fig.buttons)) {\n", " continue;\n", " }\n", " fig.buttons[key].disabled = !msg[key];\n", " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", " if (msg['mode'] === 'PAN') {\n", " fig.buttons['Pan'].classList.add('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " } else if (msg['mode'] === 'ZOOM') {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.add('active');\n", " } else {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " }\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Called whenever the canvas gets updated.\n", " this.send_message('ack', {});\n", "};\n", "\n", "// A function to construct a web socket function for onmessage handling.\n", "// Called in the figure constructor.\n", "mpl.figure.prototype._make_on_message_function = function (fig) {\n", " return function socket_on_message(evt) {\n", " if (evt.data instanceof Blob) {\n", " /* FIXME: We get \"Resource interpreted as Image but\n", " * transferred with MIME type text/plain:\" errors on\n", " * Chrome. But how to set the MIME type? It doesn't seem\n", " * to be part of the websocket stream */\n", " evt.data.type = 'image/png';\n", "\n", " /* Free the memory for the previous frames */\n", " if (fig.imageObj.src) {\n", " (window.URL || window.webkitURL).revokeObjectURL(\n", " fig.imageObj.src\n", " );\n", " }\n", "\n", " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", " evt.data\n", " );\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " } else if (\n", " typeof evt.data === 'string' &&\n", " evt.data.slice(0, 21) === 'data:image/png;base64'\n", " ) {\n", " fig.imageObj.src = evt.data;\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " }\n", "\n", " var msg = JSON.parse(evt.data);\n", " var msg_type = msg['type'];\n", "\n", " // Call the \"handle_{type}\" callback, which takes\n", " // the figure and JSON message as its only arguments.\n", " try {\n", " var callback = fig['handle_' + msg_type];\n", " } catch (e) {\n", " console.log(\n", " \"No handler for the '\" + msg_type + \"' message type: \",\n", " msg\n", " );\n", " return;\n", " }\n", "\n", " if (callback) {\n", " try {\n", " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", " callback(fig, msg);\n", " } catch (e) {\n", " console.log(\n", " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", " e,\n", " e.stack,\n", " msg\n", " );\n", " }\n", " }\n", " };\n", "};\n", "\n", "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", "mpl.findpos = function (e) {\n", " //this section is from http://www.quirksmode.org/js/events_properties.html\n", " var targ;\n", " if (!e) {\n", " e = window.event;\n", " }\n", " if (e.target) {\n", " targ = e.target;\n", " } else if (e.srcElement) {\n", " targ = e.srcElement;\n", " }\n", " if (targ.nodeType === 3) {\n", " // defeat Safari bug\n", " targ = targ.parentNode;\n", " }\n", "\n", " // pageX,Y are the mouse positions relative to the document\n", " var boundingRect = targ.getBoundingClientRect();\n", " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", "\n", " return { x: x, y: y };\n", "};\n", "\n", "/*\n", " * return a copy of an object with only non-object keys\n", " * we need this to avoid circular references\n", " * http://stackoverflow.com/a/24161582/3208463\n", " */\n", "function simpleKeys(original) {\n", " return Object.keys(original).reduce(function (obj, key) {\n", " if (typeof original[key] !== 'object') {\n", " obj[key] = original[key];\n", " }\n", " return obj;\n", " }, {});\n", "}\n", "\n", "mpl.figure.prototype.mouse_event = function (event, name) {\n", " var canvas_pos = mpl.findpos(event);\n", "\n", " if (name === 'button_press') {\n", " this.canvas.focus();\n", " this.canvas_div.focus();\n", " }\n", "\n", " var x = canvas_pos.x * this.ratio;\n", " var y = canvas_pos.y * this.ratio;\n", "\n", " this.send_message(name, {\n", " x: x,\n", " y: y,\n", " button: event.button,\n", " step: event.step,\n", " guiEvent: simpleKeys(event),\n", " });\n", "\n", " /* This prevents the web browser from automatically changing to\n", " * the text insertion cursor when the button is pressed. We want\n", " * to control all of the cursor setting manually through the\n", " * 'cursor' event from matplotlib */\n", " event.preventDefault();\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", " // Handle any extra behaviour associated with a key event\n", "};\n", "\n", "mpl.figure.prototype.key_event = function (event, name) {\n", " // Prevent repeat events\n", " if (name === 'key_press') {\n", " if (event.which === this._key) {\n", " return;\n", " } else {\n", " this._key = event.which;\n", " }\n", " }\n", " if (name === 'key_release') {\n", " this._key = null;\n", " }\n", "\n", " var value = '';\n", " if (event.ctrlKey && event.which !== 17) {\n", " value += 'ctrl+';\n", " }\n", " if (event.altKey && event.which !== 18) {\n", " value += 'alt+';\n", " }\n", " if (event.shiftKey && event.which !== 16) {\n", " value += 'shift+';\n", " }\n", "\n", " value += 'k';\n", " value += event.which.toString();\n", "\n", " this._key_event_extra(event, name);\n", "\n", " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", " if (name === 'download') {\n", " this.handle_save(this, null);\n", " } else {\n", " this.send_message('toolbar_button', { name: name });\n", " }\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", " this.message.textContent = tooltip;\n", "};\n", "\n", "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", "// prettier-ignore\n", "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", "\n", "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", "\n", "mpl.default_extension = \"png\";/* global mpl */\n", "\n", "var comm_websocket_adapter = function (comm) {\n", " // Create a \"websocket\"-like object which calls the given IPython comm\n", " // object with the appropriate methods. Currently this is a non binary\n", " // socket, so there is still some room for performance tuning.\n", " var ws = {};\n", "\n", " ws.close = function () {\n", " comm.close();\n", " };\n", " ws.send = function (m) {\n", " //console.log('sending', m);\n", " comm.send(m);\n", " };\n", " // Register the callback with on_msg.\n", " comm.on_msg(function (msg) {\n", " //console.log('receiving', msg['content']['data'], msg);\n", " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", " ws.onmessage(msg['content']['data']);\n", " });\n", " return ws;\n", "};\n", "\n", "mpl.mpl_figure_comm = function (comm, msg) {\n", " // This is the function which gets called when the mpl process\n", " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", "\n", " var id = msg.content.data.id;\n", " // Get hold of the div created by the display call when the Comm\n", " // socket was opened in Python.\n", " var element = document.getElementById(id);\n", " var ws_proxy = comm_websocket_adapter(comm);\n", "\n", " function ondownload(figure, _format) {\n", " window.open(figure.canvas.toDataURL());\n", " }\n", "\n", " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", "\n", " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", " // web socket which is closed, not our websocket->open comm proxy.\n", " ws_proxy.onopen();\n", "\n", " fig.parent_element = element;\n", " fig.cell_info = mpl.find_output_cell(\"
\");\n", " if (!fig.cell_info) {\n", " console.error('Failed to find cell for figure', id, fig);\n", " return;\n", " }\n", " fig.cell_info[0].output_area.element.on(\n", " 'cleared',\n", " { fig: fig },\n", " fig._remove_fig_handler\n", " );\n", "};\n", "\n", "mpl.figure.prototype.handle_close = function (fig, msg) {\n", " var width = fig.canvas.width / fig.ratio;\n", " fig.cell_info[0].output_area.element.off(\n", " 'cleared',\n", " fig._remove_fig_handler\n", " );\n", " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", "\n", " // Update the output cell to use the data from the current canvas.\n", " fig.push_to_output();\n", " var dataURL = fig.canvas.toDataURL();\n", " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", " // the notebook keyboard shortcuts fail.\n", " IPython.keyboard_manager.enable();\n", " fig.parent_element.innerHTML =\n", " '';\n", " fig.close_ws(fig, msg);\n", "};\n", "\n", "mpl.figure.prototype.close_ws = function (fig, msg) {\n", " fig.send_message('closing', msg);\n", " // fig.ws.close()\n", "};\n", "\n", "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", " // Turn the data on the canvas into data in the output cell.\n", " var width = this.canvas.width / this.ratio;\n", " var dataURL = this.canvas.toDataURL();\n", " this.cell_info[1]['text/html'] =\n", " '';\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Tell IPython that the notebook contents must change.\n", " IPython.notebook.set_dirty(true);\n", " this.send_message('ack', {});\n", " var fig = this;\n", " // Wait a second, then push the new image to the DOM so\n", " // that it is saved nicely (might be nice to debounce this).\n", " setTimeout(function () {\n", " fig.push_to_output();\n", " }, 1000);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'btn-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " var button;\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " continue;\n", " }\n", "\n", " button = fig.buttons[name] = document.createElement('button');\n", " button.classList = 'btn btn-default';\n", " button.href = '#';\n", " button.title = name;\n", " button.innerHTML = '';\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " // Add the status bar.\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message pull-right';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "\n", " // Add the close button to the window.\n", " var buttongrp = document.createElement('div');\n", " buttongrp.classList = 'btn-group inline pull-right';\n", " button = document.createElement('button');\n", " button.classList = 'btn btn-mini btn-primary';\n", " button.href = '#';\n", " button.title = 'Stop Interaction';\n", " button.innerHTML = '';\n", " button.addEventListener('click', function (_evt) {\n", " fig.handle_close(fig, {});\n", " });\n", " button.addEventListener(\n", " 'mouseover',\n", " on_mouseover_closure('Stop Interaction')\n", " );\n", " buttongrp.appendChild(button);\n", " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", "};\n", "\n", "mpl.figure.prototype._remove_fig_handler = function (event) {\n", " var fig = event.data.fig;\n", " if (event.target !== this) {\n", " // Ignore bubbled events from children.\n", " return;\n", " }\n", " fig.close_ws(fig, {});\n", "};\n", "\n", "mpl.figure.prototype._root_extra_style = function (el) {\n", " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (el) {\n", " // this is important to make the div 'focusable\n", " el.setAttribute('tabindex', 0);\n", " // reach out to IPython and tell the keyboard manager to turn it's self\n", " // off when our div gets focus\n", "\n", " // location in version 3\n", " if (IPython.notebook.keyboard_manager) {\n", " IPython.notebook.keyboard_manager.register_events(el);\n", " } else {\n", " // location in version 2\n", " IPython.keyboard_manager.register_events(el);\n", " }\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", " var manager = IPython.notebook.keyboard_manager;\n", " if (!manager) {\n", " manager = IPython.keyboard_manager;\n", " }\n", "\n", " // Check for shift+enter\n", " if (event.shiftKey && event.which === 13) {\n", " this.canvas_div.blur();\n", " // select the cell after this one\n", " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", " IPython.notebook.select(index + 1);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " fig.ondownload(fig, null);\n", "};\n", "\n", "mpl.find_output_cell = function (html_output) {\n", " // Return the cell and output element which can be found *uniquely* in the notebook.\n", " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", " // IPython event is triggered only after the cells have been serialised, which for\n", " // our purposes (turning an active figure into a static one), is too late.\n", " var cells = IPython.notebook.get_cells();\n", " var ncells = cells.length;\n", " for (var i = 0; i < ncells; i++) {\n", " var cell = cells[i];\n", " if (cell.cell_type === 'code') {\n", " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", " var data = cell.output_area.outputs[j];\n", " if (data.data) {\n", " // IPython >= 3 moved mimebundle to data attribute of output\n", " data = data.data;\n", " }\n", " if (data['text/html'] === html_output) {\n", " return [cell, data, j];\n", " }\n", " }\n", " }\n", " }\n", "};\n", "\n", "// Register the function which deals with the matplotlib target/channel.\n", "// The kernel may be null if the page has been refreshed.\n", "if (IPython.notebook.kernel !== null) {\n", " IPython.notebook.kernel.comm_manager.register_target(\n", " 'matplotlib',\n", " mpl.mpl_figure_comm\n", " );\n", "}\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# EDIT PARAMETERS\n", "# ---------------------------------------------------\n", "FRAMENUMBER = 20400 # frame number to analyze. If [] a random frame will be taken \n", "THRESHOLD = 0.1 # probability threshold for image binarization\n", "IMCLOSING = 13 # pixel radius of circular kernel for morphological closing\n", "INVERTIMAGE = True\n", "# ---------------------------------------------------\n", "\n", "cap = cv.VideoCapture(VIDEOPATH)\n", "try:\n", " numOfFrames = int(cap.get(cv.CAP_PROP_FRAME_COUNT))\n", " if not FRAMENUMBER:\n", " FRAMENUMBER = np.random.randint(1, high=numOfFrames)\n", " if FRAMENUMBER>numOfFrames:\n", " print('requested a frame (#{}) beyond video length ({}).'.format(FRAMENUMBER,numOfFrames),end='')\n", " print(' Analyzing last frame instead')\n", " FRAMENUMBER=numOfFrames\n", " cap.set(cv.CAP_PROP_POS_FRAMES,FRAMENUMBER-1) \n", " # -1 because CAP_PROP_FRAME_COUNT is 1-based while CAP_PROP_POS_FRAMES is 0-based\n", " \n", " # Read a frame from the \n", " _, frame = cap.read()\n", " # Convert to grayscale\n", " frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)\n", "except:\n", " print('An error occurred while getting a frame for the video.')\n", "finally:\n", " cap.release()\n", " \n", "def cropResize(sourceImg):\n", " cropped = sourceImg[cropT:cropB, cropL:cropR]\n", " cropped = cv.resize(cropped,tuple(requiredFrameSize))\n", " return cropped\n", "\n", "def morphProcessing(sourceImg):\n", " # Binarize \n", " binarized = sourceImg > THRESHOLD\n", " # Divide in regions and keep only the biggest\n", " label_img = label(binarized)\n", " regions = regionprops(label_img)\n", " if len(regions)==0:\n", " morph = np.zeros(sourceImg.shape, dtype='uint8')\n", " centroid = (np.nan, np.nan)\n", " return (morph, centroid)\n", " regions.sort(key=lambda x: x.area, reverse=True)\n", " centroid = regions[0].centroid # centroid coordinates of the biggest object\n", " if len(regions) > 1:\n", " for rg in regions[1:]:\n", " label_img[rg.coords[:,0], rg.coords[:,1]] = 0\n", " label_img[label_img!=0] = 1\n", " biggestRegion = (label_img*255).astype(np.uint8)\n", " # Morphological\n", " kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE,(IMCLOSING,IMCLOSING))\n", " morph = cv.morphologyEx(biggestRegion, cv.MORPH_CLOSE, kernel)\n", " return (morph, centroid)\n", "\n", "croppedFrame = cropResize(frame)\n", "\n", "if INVERTIMAGE:\n", " croppedFrame = cv.bitwise_not(croppedFrame)\n", "\n", "networkInput = croppedFrame.astype(np.float32) / 255.0 # convert from uint8 [0, 255] to float32 [0, 1]\n", "networkInput = networkInput[None, :, :, None] # add batch and channel dimensions\n", "mask, info = model(networkInput)\n", "\n", "# Extract infos\n", "prediction = mask[0,:,:,0]\n", "eyeProbability = info[0,0]\n", "blinkProbability = info[0,1]\n", "\n", "morphedMask, centroid = morphProcessing(prediction)\n", "\n", "# Generate falsecolor image\n", "falseColor = np.dstack((morphedMask, croppedFrame, croppedFrame))\n", "\n", "# OUTPUT\n", "print('Analyzed image # {} / {}'.format(FRAMENUMBER, numOfFrames))\n", "print('Eye Probability: {:4.2%}'.format(eyeProbability))\n", "print('Blink Probability: {:4.2%}'.format(blinkProbability))\n", "\n", "fig, ax = plt.subplots(nrows=1, ncols=5, figsize=(15,5))\n", "ax[0].imshow(croppedFrame, cmap='gray')\n", "ax[0].set_title('Cropped Frame')\n", "\n", "ax[1].imshow(prediction, vmin=0, vmax=1)\n", "ax[1].set_title('Probability map')\n", "\n", "ax[2].imshow(prediction > THRESHOLD)\n", "ax[2].set_title('Map Binarized')\n", "\n", "ax[3].imshow(morphedMask)\n", "ax[3].set_title('After Morphology')\n", "\n", "ax[4].imshow(falseColor)\n", "ax[4].plot(centroid[1], centroid[0], marker='+', markersize=12, mew=2, mec='g')\n", "ax[4].set_title('Binary pupil')\n", "\n", "for a in ax.reshape(-1):\n", " a.axis('off')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "european-bruce", "metadata": {}, "source": [ "## Predict pupil size for the whole video\n", "\n", "After adjusting all the parameters on single images in the previous section you can use this section to measure pupilsize on the whole video. \n", "**This process can be long** (minutes), but having a GPU that tensorflow can use, might shorthen processing time significantly. " ] }, { "cell_type": "code", "execution_count": 103, "id": "protective-locking", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing frames... (400/23236)\n", "Processing frames... (800/23236)\n", "Processing frames... (1200/23236)\n", "Processing frames... (1600/23236)\n", "Processing frames... (2000/23236)\n", "Processing frames... (2400/23236)\n", "Processing frames... (2800/23236)\n", "Processing frames... (3200/23236)\n", "Processing frames... (3600/23236)\n", "Processing frames... (4000/23236)\n", "Processing frames... (4400/23236)\n", "Processing frames... (4800/23236)\n", "Processing frames... (5200/23236)\n", "Processing frames... (5600/23236)\n", "Processing frames... (6000/23236)\n", "Processing frames... (6400/23236)\n", "Processing frames... (6800/23236)\n", "Processing frames... (7200/23236)\n", "Processing frames... (7600/23236)\n", "Processing frames... (8000/23236)\n", "Processing frames... (8400/23236)\n", "Processing frames... (8800/23236)\n", "Processing frames... (9200/23236)\n", "Processing frames... (9600/23236)\n", "Processing frames... (10000/23236)\n", "Processing frames... (10400/23236)\n", "Processing frames... (10800/23236)\n", "Processing frames... (11200/23236)\n", "Processing frames... (11600/23236)\n", "Processing frames... (12000/23236)\n", "Processing frames... (12400/23236)\n", "Processing frames... (12800/23236)\n", "Processing frames... (13200/23236)\n", "Processing frames... (13600/23236)\n", "Processing frames... (14000/23236)\n", "Processing frames... (14400/23236)\n", "Processing frames... (14800/23236)\n", "Processing frames... (15200/23236)\n", "Processing frames... (15600/23236)\n", "Processing frames... (16000/23236)\n", "Processing frames... (16400/23236)\n", "Processing frames... (16800/23236)\n", "Processing frames... (17200/23236)\n", "Processing frames... (17600/23236)\n", "Processing frames... (18000/23236)\n", "Processing frames... (18400/23236)\n", "Processing frames... (18800/23236)\n", "Processing frames... (19200/23236)\n", "Processing frames... (19600/23236)\n", "Processing frames... (20000/23236)\n", "Processing frames... (20400/23236)\n", "Processing frames... (20800/23236)\n", "Processing frames... (21200/23236)\n", "Processing frames... (21600/23236)\n", "Processing frames... (22000/23236)\n", "Processing frames... (22400/23236)\n", "Processing frames... (22800/23236)\n", "Processing frames... (23200/23236)\n" ] } ], "source": [ "cap = cv.VideoCapture(VIDEOPATH)\n", "numFrames = int(cap.get(cv.CAP_PROP_FRAME_COUNT))\n", "\n", "df = pd.DataFrame(columns=['frameN','pupilSize','pupCntr_x','pupCntr_y','eyeProb','blinkProb'])\n", "\n", "try:\n", " for i in range(numFrames):\n", " _, frame = cap.read()\n", " frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)\n", " \n", " croppedFrame = cropResize(frame)\n", " if INVERTIMAGE:\n", " croppedFrame = cv.bitwise_not(croppedFrame)\n", " \n", " networkInput = croppedFrame.astype(np.float32) / 255.0\n", " networkInput = networkInput[None, :, :, None]\n", " mask, info = model(networkInput)\n", " prediction = mask[0,:,:,0]\n", " morphedMask, centroid = morphProcessing(prediction)\n", " \n", " # Extract infos\n", " eyeProbability = info[0,0]\n", " blinkProbability = info[0,1]\n", " \n", " #Save values for the current frame\n", " df = df.append({'frameN':int(i+1),\n", " 'pupilSize':np.sum(morphedMask)/255,\n", " 'pupCntr_x':centroid[1],\n", " 'pupCntr_y':centroid[0],\n", " 'eyeProb':eyeProbability,\n", " 'blinkProb':blinkProbability},\n", " ignore_index=True)\n", " \n", " if (i!=0) & (i%400==0) :\n", " print('Processing frames... ({}/{})'.format(i,numFrames))\n", "finally:\n", " cap.release()\n", " winsound.Beep(BEEP_FREQ, BEEP_DURATION_MS)" ] }, { "cell_type": "markdown", "id": "quarterly-cocktail", "metadata": {}, "source": [ "## Preprocessing of pupil size\n", "In the following section the estimated pupil size for the whole video will undergo two preprocessing steps:\n", "1. **Blink removal**: Blink events can generate artifacts in the pupil size prediction. We can correct for this by looking at the blink probability for each frame. Frames with a blink probability higher that a threshold (*BLINK_THRESH*) will be rejected and pupil size will be linearly interpolated between the points.\n", "2. **Curve smoothing**: Ofthen the video FrameRate is much higher than the typical timecourse of pupil dilations. The resulting pupil size signal can thus be filtered to increase the saliency of biological fluctuations and remove noise. We implemented a simple *moving median filter*. Users can select an appropiate window size (in frames).\n", "----\n", "You need to specify and eventually adjust 2 parameters:\n", "- **BLINK_THRESH**: Probability threshold for each frame to be classified as a blink\n", "- **MEDIAN_WINDOW**: Window size (in frames) for median filtering. (Usually between 300-900ms works)" ] }, { "cell_type": "code", "execution_count": 105, "id": "activated-father", "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/javascript": [ "/* Put everything inside the global mpl namespace */\n", "/* global mpl */\n", "window.mpl = {};\n", "\n", "mpl.get_websocket_type = function () {\n", " if (typeof WebSocket !== 'undefined') {\n", " return WebSocket;\n", " } else if (typeof MozWebSocket !== 'undefined') {\n", " return MozWebSocket;\n", " } else {\n", " alert(\n", " 'Your browser does not have WebSocket support. ' +\n", " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.'\n", " );\n", " }\n", "};\n", "\n", "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", " this.id = figure_id;\n", "\n", " this.ws = websocket;\n", "\n", " this.supports_binary = this.ws.binaryType !== undefined;\n", "\n", " if (!this.supports_binary) {\n", " var warnings = document.getElementById('mpl-warnings');\n", " if (warnings) {\n", " warnings.style.display = 'block';\n", " warnings.textContent =\n", " 'This browser does not support binary websocket messages. ' +\n", " 'Performance may be slow.';\n", " }\n", " }\n", "\n", " this.imageObj = new Image();\n", "\n", " this.context = undefined;\n", " this.message = undefined;\n", " this.canvas = undefined;\n", " this.rubberband_canvas = undefined;\n", " this.rubberband_context = undefined;\n", " this.format_dropdown = undefined;\n", "\n", " this.image_mode = 'full';\n", "\n", " this.root = document.createElement('div');\n", " this.root.setAttribute('style', 'display: inline-block');\n", " this._root_extra_style(this.root);\n", "\n", " parent_element.appendChild(this.root);\n", "\n", " this._init_header(this);\n", " this._init_canvas(this);\n", " this._init_toolbar(this);\n", "\n", " var fig = this;\n", "\n", " this.waiting = false;\n", "\n", " this.ws.onopen = function () {\n", " fig.send_message('supports_binary', { value: fig.supports_binary });\n", " fig.send_message('send_image_mode', {});\n", " if (fig.ratio !== 1) {\n", " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", " }\n", " fig.send_message('refresh', {});\n", " };\n", "\n", " this.imageObj.onload = function () {\n", " if (fig.image_mode === 'full') {\n", " // Full images could contain transparency (where diff images\n", " // almost always do), so we need to clear the canvas so that\n", " // there is no ghosting.\n", " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", " }\n", " fig.context.drawImage(fig.imageObj, 0, 0);\n", " };\n", "\n", " this.imageObj.onunload = function () {\n", " fig.ws.close();\n", " };\n", "\n", " this.ws.onmessage = this._make_on_message_function(this);\n", "\n", " this.ondownload = ondownload;\n", "};\n", "\n", "mpl.figure.prototype._init_header = function () {\n", " var titlebar = document.createElement('div');\n", " titlebar.classList =\n", " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", " var titletext = document.createElement('div');\n", " titletext.classList = 'ui-dialog-title';\n", " titletext.setAttribute(\n", " 'style',\n", " 'width: 100%; text-align: center; padding: 3px;'\n", " );\n", " titlebar.appendChild(titletext);\n", " this.root.appendChild(titlebar);\n", " this.header = titletext;\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._init_canvas = function () {\n", " var fig = this;\n", "\n", " var canvas_div = (this.canvas_div = document.createElement('div'));\n", " canvas_div.setAttribute(\n", " 'style',\n", " 'border: 1px solid #ddd;' +\n", " 'box-sizing: content-box;' +\n", " 'clear: both;' +\n", " 'min-height: 1px;' +\n", " 'min-width: 1px;' +\n", " 'outline: 0;' +\n", " 'overflow: hidden;' +\n", " 'position: relative;' +\n", " 'resize: both;'\n", " );\n", "\n", " function on_keyboard_event_closure(name) {\n", " return function (event) {\n", " return fig.key_event(event, name);\n", " };\n", " }\n", "\n", " canvas_div.addEventListener(\n", " 'keydown',\n", " on_keyboard_event_closure('key_press')\n", " );\n", " canvas_div.addEventListener(\n", " 'keyup',\n", " on_keyboard_event_closure('key_release')\n", " );\n", "\n", " this._canvas_extra_style(canvas_div);\n", " this.root.appendChild(canvas_div);\n", "\n", " var canvas = (this.canvas = document.createElement('canvas'));\n", " canvas.classList.add('mpl-canvas');\n", " canvas.setAttribute('style', 'box-sizing: content-box;');\n", "\n", " this.context = canvas.getContext('2d');\n", "\n", " var backingStore =\n", " this.context.backingStorePixelRatio ||\n", " this.context.webkitBackingStorePixelRatio ||\n", " this.context.mozBackingStorePixelRatio ||\n", " this.context.msBackingStorePixelRatio ||\n", " this.context.oBackingStorePixelRatio ||\n", " this.context.backingStorePixelRatio ||\n", " 1;\n", "\n", " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", "\n", " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", " 'canvas'\n", " ));\n", " rubberband_canvas.setAttribute(\n", " 'style',\n", " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", " );\n", "\n", " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", " if (this.ResizeObserver === undefined) {\n", " if (window.ResizeObserver !== undefined) {\n", " this.ResizeObserver = window.ResizeObserver;\n", " } else {\n", " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", " this.ResizeObserver = obs.ResizeObserver;\n", " }\n", " }\n", "\n", " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", " var nentries = entries.length;\n", " for (var i = 0; i < nentries; i++) {\n", " var entry = entries[i];\n", " var width, height;\n", " if (entry.contentBoxSize) {\n", " if (entry.contentBoxSize instanceof Array) {\n", " // Chrome 84 implements new version of spec.\n", " width = entry.contentBoxSize[0].inlineSize;\n", " height = entry.contentBoxSize[0].blockSize;\n", " } else {\n", " // Firefox implements old version of spec.\n", " width = entry.contentBoxSize.inlineSize;\n", " height = entry.contentBoxSize.blockSize;\n", " }\n", " } else {\n", " // Chrome <84 implements even older version of spec.\n", " width = entry.contentRect.width;\n", " height = entry.contentRect.height;\n", " }\n", "\n", " // Keep the size of the canvas and rubber band canvas in sync with\n", " // the canvas container.\n", " if (entry.devicePixelContentBoxSize) {\n", " // Chrome 84 implements new version of spec.\n", " canvas.setAttribute(\n", " 'width',\n", " entry.devicePixelContentBoxSize[0].inlineSize\n", " );\n", " canvas.setAttribute(\n", " 'height',\n", " entry.devicePixelContentBoxSize[0].blockSize\n", " );\n", " } else {\n", " canvas.setAttribute('width', width * fig.ratio);\n", " canvas.setAttribute('height', height * fig.ratio);\n", " }\n", " canvas.setAttribute(\n", " 'style',\n", " 'width: ' + width + 'px; height: ' + height + 'px;'\n", " );\n", "\n", " rubberband_canvas.setAttribute('width', width);\n", " rubberband_canvas.setAttribute('height', height);\n", "\n", " // And update the size in Python. We ignore the initial 0/0 size\n", " // that occurs as the element is placed into the DOM, which should\n", " // otherwise not happen due to the minimum size styling.\n", " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", " fig.request_resize(width, height);\n", " }\n", " }\n", " });\n", " this.resizeObserverInstance.observe(canvas_div);\n", "\n", " function on_mouse_event_closure(name) {\n", " return function (event) {\n", " return fig.mouse_event(event, name);\n", " };\n", " }\n", "\n", " rubberband_canvas.addEventListener(\n", " 'mousedown',\n", " on_mouse_event_closure('button_press')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'mouseup',\n", " on_mouse_event_closure('button_release')\n", " );\n", " // Throttle sequential mouse events to 1 every 20ms.\n", " rubberband_canvas.addEventListener(\n", " 'mousemove',\n", " on_mouse_event_closure('motion_notify')\n", " );\n", "\n", " rubberband_canvas.addEventListener(\n", " 'mouseenter',\n", " on_mouse_event_closure('figure_enter')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'mouseleave',\n", " on_mouse_event_closure('figure_leave')\n", " );\n", "\n", " canvas_div.addEventListener('wheel', function (event) {\n", " if (event.deltaY < 0) {\n", " event.step = 1;\n", " } else {\n", " event.step = -1;\n", " }\n", " on_mouse_event_closure('scroll')(event);\n", " });\n", "\n", " canvas_div.appendChild(canvas);\n", " canvas_div.appendChild(rubberband_canvas);\n", "\n", " this.rubberband_context = rubberband_canvas.getContext('2d');\n", " this.rubberband_context.strokeStyle = '#000000';\n", "\n", " this._resize_canvas = function (width, height, forward) {\n", " if (forward) {\n", " canvas_div.style.width = width + 'px';\n", " canvas_div.style.height = height + 'px';\n", " }\n", " };\n", "\n", " // Disable right mouse context menu.\n", " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", " event.preventDefault();\n", " return false;\n", " });\n", "\n", " function set_focus() {\n", " canvas.focus();\n", " canvas_div.focus();\n", " }\n", "\n", " window.setTimeout(set_focus, 100);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'mpl-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " continue;\n", " }\n", "\n", " var button = (fig.buttons[name] = document.createElement('button'));\n", " button.classList = 'mpl-widget';\n", " button.setAttribute('role', 'button');\n", " button.setAttribute('aria-disabled', 'false');\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", "\n", " var icon_img = document.createElement('img');\n", " icon_img.src = '_images/' + image + '.png';\n", " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", " icon_img.alt = tooltip;\n", " button.appendChild(icon_img);\n", "\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " var fmt_picker = document.createElement('select');\n", " fmt_picker.classList = 'mpl-widget';\n", " toolbar.appendChild(fmt_picker);\n", " this.format_dropdown = fmt_picker;\n", "\n", " for (var ind in mpl.extensions) {\n", " var fmt = mpl.extensions[ind];\n", " var option = document.createElement('option');\n", " option.selected = fmt === mpl.default_extension;\n", " option.innerHTML = fmt;\n", " fmt_picker.appendChild(option);\n", " }\n", "\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "};\n", "\n", "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", " // which will in turn request a refresh of the image.\n", " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", "};\n", "\n", "mpl.figure.prototype.send_message = function (type, properties) {\n", " properties['type'] = type;\n", " properties['figure_id'] = this.id;\n", " this.ws.send(JSON.stringify(properties));\n", "};\n", "\n", "mpl.figure.prototype.send_draw_message = function () {\n", " if (!this.waiting) {\n", " this.waiting = true;\n", " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " var format_dropdown = fig.format_dropdown;\n", " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", " fig.ondownload(fig, format);\n", "};\n", "\n", "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", " var size = msg['size'];\n", " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", " fig._resize_canvas(size[0], size[1], msg['forward']);\n", " fig.send_message('refresh', {});\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", " var x0 = msg['x0'] / fig.ratio;\n", " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", " var x1 = msg['x1'] / fig.ratio;\n", " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", " x0 = Math.floor(x0) + 0.5;\n", " y0 = Math.floor(y0) + 0.5;\n", " x1 = Math.floor(x1) + 0.5;\n", " y1 = Math.floor(y1) + 0.5;\n", " var min_x = Math.min(x0, x1);\n", " var min_y = Math.min(y0, y1);\n", " var width = Math.abs(x1 - x0);\n", " var height = Math.abs(y1 - y0);\n", "\n", " fig.rubberband_context.clearRect(\n", " 0,\n", " 0,\n", " fig.canvas.width / fig.ratio,\n", " fig.canvas.height / fig.ratio\n", " );\n", "\n", " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", "};\n", "\n", "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", " // Updates the figure title.\n", " fig.header.textContent = msg['label'];\n", "};\n", "\n", "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", " var cursor = msg['cursor'];\n", " switch (cursor) {\n", " case 0:\n", " cursor = 'pointer';\n", " break;\n", " case 1:\n", " cursor = 'default';\n", " break;\n", " case 2:\n", " cursor = 'crosshair';\n", " break;\n", " case 3:\n", " cursor = 'move';\n", " break;\n", " }\n", " fig.rubberband_canvas.style.cursor = cursor;\n", "};\n", "\n", "mpl.figure.prototype.handle_message = function (fig, msg) {\n", " fig.message.textContent = msg['message'];\n", "};\n", "\n", "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", " // Request the server to send over a new figure.\n", " fig.send_draw_message();\n", "};\n", "\n", "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", " fig.image_mode = msg['mode'];\n", "};\n", "\n", "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", " for (var key in msg) {\n", " if (!(key in fig.buttons)) {\n", " continue;\n", " }\n", " fig.buttons[key].disabled = !msg[key];\n", " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", " if (msg['mode'] === 'PAN') {\n", " fig.buttons['Pan'].classList.add('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " } else if (msg['mode'] === 'ZOOM') {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.add('active');\n", " } else {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " }\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Called whenever the canvas gets updated.\n", " this.send_message('ack', {});\n", "};\n", "\n", "// A function to construct a web socket function for onmessage handling.\n", "// Called in the figure constructor.\n", "mpl.figure.prototype._make_on_message_function = function (fig) {\n", " return function socket_on_message(evt) {\n", " if (evt.data instanceof Blob) {\n", " /* FIXME: We get \"Resource interpreted as Image but\n", " * transferred with MIME type text/plain:\" errors on\n", " * Chrome. But how to set the MIME type? It doesn't seem\n", " * to be part of the websocket stream */\n", " evt.data.type = 'image/png';\n", "\n", " /* Free the memory for the previous frames */\n", " if (fig.imageObj.src) {\n", " (window.URL || window.webkitURL).revokeObjectURL(\n", " fig.imageObj.src\n", " );\n", " }\n", "\n", " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", " evt.data\n", " );\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " } else if (\n", " typeof evt.data === 'string' &&\n", " evt.data.slice(0, 21) === 'data:image/png;base64'\n", " ) {\n", " fig.imageObj.src = evt.data;\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " }\n", "\n", " var msg = JSON.parse(evt.data);\n", " var msg_type = msg['type'];\n", "\n", " // Call the \"handle_{type}\" callback, which takes\n", " // the figure and JSON message as its only arguments.\n", " try {\n", " var callback = fig['handle_' + msg_type];\n", " } catch (e) {\n", " console.log(\n", " \"No handler for the '\" + msg_type + \"' message type: \",\n", " msg\n", " );\n", " return;\n", " }\n", "\n", " if (callback) {\n", " try {\n", " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", " callback(fig, msg);\n", " } catch (e) {\n", " console.log(\n", " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", " e,\n", " e.stack,\n", " msg\n", " );\n", " }\n", " }\n", " };\n", "};\n", "\n", "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", "mpl.findpos = function (e) {\n", " //this section is from http://www.quirksmode.org/js/events_properties.html\n", " var targ;\n", " if (!e) {\n", " e = window.event;\n", " }\n", " if (e.target) {\n", " targ = e.target;\n", " } else if (e.srcElement) {\n", " targ = e.srcElement;\n", " }\n", " if (targ.nodeType === 3) {\n", " // defeat Safari bug\n", " targ = targ.parentNode;\n", " }\n", "\n", " // pageX,Y are the mouse positions relative to the document\n", " var boundingRect = targ.getBoundingClientRect();\n", " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", "\n", " return { x: x, y: y };\n", "};\n", "\n", "/*\n", " * return a copy of an object with only non-object keys\n", " * we need this to avoid circular references\n", " * http://stackoverflow.com/a/24161582/3208463\n", " */\n", "function simpleKeys(original) {\n", " return Object.keys(original).reduce(function (obj, key) {\n", " if (typeof original[key] !== 'object') {\n", " obj[key] = original[key];\n", " }\n", " return obj;\n", " }, {});\n", "}\n", "\n", "mpl.figure.prototype.mouse_event = function (event, name) {\n", " var canvas_pos = mpl.findpos(event);\n", "\n", " if (name === 'button_press') {\n", " this.canvas.focus();\n", " this.canvas_div.focus();\n", " }\n", "\n", " var x = canvas_pos.x * this.ratio;\n", " var y = canvas_pos.y * this.ratio;\n", "\n", " this.send_message(name, {\n", " x: x,\n", " y: y,\n", " button: event.button,\n", " step: event.step,\n", " guiEvent: simpleKeys(event),\n", " });\n", "\n", " /* This prevents the web browser from automatically changing to\n", " * the text insertion cursor when the button is pressed. We want\n", " * to control all of the cursor setting manually through the\n", " * 'cursor' event from matplotlib */\n", " event.preventDefault();\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", " // Handle any extra behaviour associated with a key event\n", "};\n", "\n", "mpl.figure.prototype.key_event = function (event, name) {\n", " // Prevent repeat events\n", " if (name === 'key_press') {\n", " if (event.which === this._key) {\n", " return;\n", " } else {\n", " this._key = event.which;\n", " }\n", " }\n", " if (name === 'key_release') {\n", " this._key = null;\n", " }\n", "\n", " var value = '';\n", " if (event.ctrlKey && event.which !== 17) {\n", " value += 'ctrl+';\n", " }\n", " if (event.altKey && event.which !== 18) {\n", " value += 'alt+';\n", " }\n", " if (event.shiftKey && event.which !== 16) {\n", " value += 'shift+';\n", " }\n", "\n", " value += 'k';\n", " value += event.which.toString();\n", "\n", " this._key_event_extra(event, name);\n", "\n", " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", " if (name === 'download') {\n", " this.handle_save(this, null);\n", " } else {\n", " this.send_message('toolbar_button', { name: name });\n", " }\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", " this.message.textContent = tooltip;\n", "};\n", "\n", "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", "// prettier-ignore\n", "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", "\n", "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", "\n", "mpl.default_extension = \"png\";/* global mpl */\n", "\n", "var comm_websocket_adapter = function (comm) {\n", " // Create a \"websocket\"-like object which calls the given IPython comm\n", " // object with the appropriate methods. Currently this is a non binary\n", " // socket, so there is still some room for performance tuning.\n", " var ws = {};\n", "\n", " ws.close = function () {\n", " comm.close();\n", " };\n", " ws.send = function (m) {\n", " //console.log('sending', m);\n", " comm.send(m);\n", " };\n", " // Register the callback with on_msg.\n", " comm.on_msg(function (msg) {\n", " //console.log('receiving', msg['content']['data'], msg);\n", " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", " ws.onmessage(msg['content']['data']);\n", " });\n", " return ws;\n", "};\n", "\n", "mpl.mpl_figure_comm = function (comm, msg) {\n", " // This is the function which gets called when the mpl process\n", " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", "\n", " var id = msg.content.data.id;\n", " // Get hold of the div created by the display call when the Comm\n", " // socket was opened in Python.\n", " var element = document.getElementById(id);\n", " var ws_proxy = comm_websocket_adapter(comm);\n", "\n", " function ondownload(figure, _format) {\n", " window.open(figure.canvas.toDataURL());\n", " }\n", "\n", " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", "\n", " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", " // web socket which is closed, not our websocket->open comm proxy.\n", " ws_proxy.onopen();\n", "\n", " fig.parent_element = element;\n", " fig.cell_info = mpl.find_output_cell(\"
\");\n", " if (!fig.cell_info) {\n", " console.error('Failed to find cell for figure', id, fig);\n", " return;\n", " }\n", " fig.cell_info[0].output_area.element.on(\n", " 'cleared',\n", " { fig: fig },\n", " fig._remove_fig_handler\n", " );\n", "};\n", "\n", "mpl.figure.prototype.handle_close = function (fig, msg) {\n", " var width = fig.canvas.width / fig.ratio;\n", " fig.cell_info[0].output_area.element.off(\n", " 'cleared',\n", " fig._remove_fig_handler\n", " );\n", " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", "\n", " // Update the output cell to use the data from the current canvas.\n", " fig.push_to_output();\n", " var dataURL = fig.canvas.toDataURL();\n", " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", " // the notebook keyboard shortcuts fail.\n", " IPython.keyboard_manager.enable();\n", " fig.parent_element.innerHTML =\n", " '';\n", " fig.close_ws(fig, msg);\n", "};\n", "\n", "mpl.figure.prototype.close_ws = function (fig, msg) {\n", " fig.send_message('closing', msg);\n", " // fig.ws.close()\n", "};\n", "\n", "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", " // Turn the data on the canvas into data in the output cell.\n", " var width = this.canvas.width / this.ratio;\n", " var dataURL = this.canvas.toDataURL();\n", " this.cell_info[1]['text/html'] =\n", " '';\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Tell IPython that the notebook contents must change.\n", " IPython.notebook.set_dirty(true);\n", " this.send_message('ack', {});\n", " var fig = this;\n", " // Wait a second, then push the new image to the DOM so\n", " // that it is saved nicely (might be nice to debounce this).\n", " setTimeout(function () {\n", " fig.push_to_output();\n", " }, 1000);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'btn-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " var button;\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " continue;\n", " }\n", "\n", " button = fig.buttons[name] = document.createElement('button');\n", " button.classList = 'btn btn-default';\n", " button.href = '#';\n", " button.title = name;\n", " button.innerHTML = '';\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " // Add the status bar.\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message pull-right';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "\n", " // Add the close button to the window.\n", " var buttongrp = document.createElement('div');\n", " buttongrp.classList = 'btn-group inline pull-right';\n", " button = document.createElement('button');\n", " button.classList = 'btn btn-mini btn-primary';\n", " button.href = '#';\n", " button.title = 'Stop Interaction';\n", " button.innerHTML = '';\n", " button.addEventListener('click', function (_evt) {\n", " fig.handle_close(fig, {});\n", " });\n", " button.addEventListener(\n", " 'mouseover',\n", " on_mouseover_closure('Stop Interaction')\n", " );\n", " buttongrp.appendChild(button);\n", " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", "};\n", "\n", "mpl.figure.prototype._remove_fig_handler = function (event) {\n", " var fig = event.data.fig;\n", " if (event.target !== this) {\n", " // Ignore bubbled events from children.\n", " return;\n", " }\n", " fig.close_ws(fig, {});\n", "};\n", "\n", "mpl.figure.prototype._root_extra_style = function (el) {\n", " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (el) {\n", " // this is important to make the div 'focusable\n", " el.setAttribute('tabindex', 0);\n", " // reach out to IPython and tell the keyboard manager to turn it's self\n", " // off when our div gets focus\n", "\n", " // location in version 3\n", " if (IPython.notebook.keyboard_manager) {\n", " IPython.notebook.keyboard_manager.register_events(el);\n", " } else {\n", " // location in version 2\n", " IPython.keyboard_manager.register_events(el);\n", " }\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", " var manager = IPython.notebook.keyboard_manager;\n", " if (!manager) {\n", " manager = IPython.keyboard_manager;\n", " }\n", "\n", " // Check for shift+enter\n", " if (event.shiftKey && event.which === 13) {\n", " this.canvas_div.blur();\n", " // select the cell after this one\n", " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", " IPython.notebook.select(index + 1);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " fig.ondownload(fig, null);\n", "};\n", "\n", "mpl.find_output_cell = function (html_output) {\n", " // Return the cell and output element which can be found *uniquely* in the notebook.\n", " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", " // IPython event is triggered only after the cells have been serialised, which for\n", " // our purposes (turning an active figure into a static one), is too late.\n", " var cells = IPython.notebook.get_cells();\n", " var ncells = cells.length;\n", " for (var i = 0; i < ncells; i++) {\n", " var cell = cells[i];\n", " if (cell.cell_type === 'code') {\n", " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", " var data = cell.output_area.outputs[j];\n", " if (data.data) {\n", " // IPython >= 3 moved mimebundle to data attribute of output\n", " data = data.data;\n", " }\n", " if (data['text/html'] === html_output) {\n", " return [cell, data, j];\n", " }\n", " }\n", " }\n", " }\n", "};\n", "\n", "// Register the function which deals with the matplotlib target/channel.\n", "// The kernel may be null if the page has been refreshed.\n", "if (IPython.notebook.kernel !== null) {\n", " IPython.notebook.kernel.comm_manager.register_target(\n", " 'matplotlib',\n", " mpl.mpl_figure_comm\n", " );\n", "}\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# EDIT PARAMETERS\n", "# ---------------------------------------------------\n", "BLINK_THRESH = 0.01\n", "MEDIAN_WINDOW = 7\n", "# ---------------------------------------------------\n", "\n", "%matplotlib notebook\n", "# Remove blinks and interpolate the curve\n", "isBlinking = df['blinkProb'] > BLINK_THRESH\n", "processedPupil = df['pupilSize']\n", "processedPupil[isBlinking] = np.nan\n", "processedPupil.interpolate(inplace=True)\n", "# Moving median filter\n", "processedPupil = processedPupil.rolling(MEDIAN_WINDOW,min_periods=1, center=True).median()\n", "df['processedPupil'] = processedPupil\n", "\n", "# Plotting\n", "f, ax = plt.subplots(figsize=(14,4))\n", "ax.plot(df['pupilSize'],label='Raw pupil')\n", "ax.plot(processedPupil, label='Preprocessed Pupil')\n", "ax.fill_between(df['frameN'], ax.get_ylim()[0], ax.get_ylim()[1],\n", " where=isBlinking, interpolate=True,\n", " facecolor='red', alpha=1,label='Blinking')\n", "ax.set_title('Pupil Area Preprocessing')\n", "ax.set_xlabel('Frame Number')\n", "ax.set_ylabel('Pupil Area (px)')\n", "ax.autoscale(enable=True, axis='x', tight=True)\n", "ax.legend(loc=0)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "owned-pierce", "metadata": {}, "source": [ "## Export data as a csv file\n", "The following section will export pupillometry data in a .CSV file. \n", "By default the file will be saved in the same folder as the movie, with the same filename and `_pupil` appended at the end. If you wish to give a custom name to the output file, you can edit the parameter `CUSTOM_NAME`. Doing this will use this name as the output filename instead." ] }, { "cell_type": "code", "execution_count": 122, "id": "light-clinic", "metadata": {}, "outputs": [], "source": [ "# EDIT PARAMETERS\n", "# ---------------------------------------------------\n", "CUSTOM_NAME = []\n", "# ---------------------------------------------------\n", "\n", "path, fN = os.path.split(VIDEOPATH)\n", "fN, ext = os.path.splitext(fN)\n", "fN = fN + '_pupil'\n", "\n", "if CUSTOM_NAME:\n", " fN = CUSTOM_NAME\n", "\n", "newFileName = path + os.path.sep + fN + '.csv'\n", "df.to_csv(newFileName, index=False) # Export to csv file" ] } ], "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.6.9" } }, "nbformat": 4, "nbformat_minor": 5 }