notebooks/403-action-recognition-webcam/403-action-recognition-webcam.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "tags": []
   },
   "source": [
    "# Human Action Recognition with OpenVINO™\n",
    "\n",
    "> **Note:** This notebook has been moved to a new branch named \"latest\". [Click here](https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/action-recognition-webcam/action-recognition-webcam.ipynb) to get the most updated version of the notebook. This branch is deprecated.\n",
    "\n",
    "This notebook demonstrates live human action recognition with OpenVINO, using the [Action Recognition Models](https://docs.openvino.ai/2020.2/usergroup13.html) from [Open Model Zoo](https://github.com/openvinotoolkit/open_model_zoo), specifically an [Encoder](https://docs.openvino.ai/2020.2/_models_intel_action_recognition_0001_encoder_description_action_recognition_0001_encoder.html) and a [Decoder](https://docs.openvino.ai/2020.2/_models_intel_action_recognition_0001_decoder_description_action_recognition_0001_decoder.html). Both models create a sequence to sequence (`\"seq2seq\"`) \\[1\\] system to identify the human activities for [Kinetics-400 dataset](https://deepmind.com/research/open-source/kinetics). The models use the Video Transformer approach with ResNet34 encoder \\[2\\]. The notebook shows how to create the following pipeline:\n",
    "\n",
    "<img align='center' src=\"https://user-images.githubusercontent.com/10940214/148401661-477aebcd-f2d0-4771-b107-4b37f94d0b1e.jpeg\" alt=\"drawing\" width=\"1000\"/>\n",
    "\n",
    "Final part of this notebook shows live inference results from a webcam. Additionally, you can also upload a video file.\n",
    "\n",
    "**NOTE**: To use a webcam, you must run this Jupyter notebook on a computer with a webcam. If you run on a server, the webcam will not work. However, you can still do inference on a video in the final step.\n",
    "\n",
    "---\n",
    "\n",
    "\\[1\\] seq2seq: Deep learning models that take a sequence of items to the input and output. In this case, input: video frames, output: actions sequence. This `\"seq2seq\"` is composed of an encoder and a decoder. The encoder captures `\"context\"` of the inputs to be analyzed by the decoder, and finally gets the human action and confidence.\n",
    "\n",
    "\\[2\\] [Video Transformer](https://en.wikipedia.org/wiki/Transformer_(machine_learning_model)) and [ResNet34](https://pytorch.org/vision/main/models/generated/torchvision.models.resnet34.html).\n",
    "\n",
    "\n",
    "\n",
    "#### Table of contents:\n\n",
    "- [Imports](#Imports)\n",
    "- [The models](#The-models)\n",
    "    - [Download the models](#Download-the-models)\n",
    "    - [Load your labels](#Load-your-labels)\n",
    "    - [Load the models](#Load-the-models)\n",
    "        - [Model Initialization function](#Model-Initialization-function)\n",
    "        - [Initialization for Encoder and Decoder](#Initialization-for-Encoder-and-Decoder)\n",
    "    - [Helper functions](#Helper-functions)\n",
    "    - [AI Functions](#AI-Functions)\n",
    "    - [Main Processing Function](#Main-Processing-Function)\n",
    "    - [Run Action Recognition](#Run-Action-Recognition)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install -q \"openvino-dev>=2024.0.0\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Imports\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import collections\n",
    "import os\n",
    "import time\n",
    "from typing import Tuple, List\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "from IPython import display\n",
    "import openvino as ov\n",
    "from openvino.runtime.ie_api import CompiledModel\n",
    "\n",
    "# Fetch `notebook_utils` module\n",
    "import urllib.request\n",
    "urllib.request.urlretrieve(\n",
    "    url='https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/main/notebooks/utils/notebook_utils.py',\n",
    "    filename='notebook_utils.py'\n",
    ")\n",
    "import notebook_utils as utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The models\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "### Download the models\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Use the `download_ir_model`, a function from the `notebook_utils` file. It automatically creates a directory structure and downloads the selected model.\n",
    "\n",
    "In this case you can use `\"action-recognition-0001\"` as a model name, and the system automatically downloads the two models `\"action-recognition-0001-encoder\"` and `\"action-recognition-0001-decoder\"`\n",
    "\n",
    "> **NOTE**: If you want to download another model, such as `\"driver-action-recognition-adas-0002\"` (`\"driver-action-recognition-adas-0002-encoder\"` + `\"driver-action-recognition-adas-0002-decoder\"`), replace the name of the model in the code below. Using a model outside the list can require different pre- and post-processing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# A directory where the model will be downloaded.\n",
    "base_model_dir = \"model\"\n",
    "# The name of the model from Open Model Zoo.\n",
    "model_name = \"action-recognition-0001\"\n",
    "# Selected precision (FP32, FP16, FP16-INT8).\n",
    "precision = \"FP16\"\n",
    "model_path_decoder = (\n",
    "    f\"model/intel/{model_name}/{model_name}-decoder/{precision}/{model_name}-decoder.xml\"\n",
    ")\n",
    "model_path_encoder = (\n",
    "    f\"model/intel/{model_name}/{model_name}-encoder/{precision}/{model_name}-encoder.xml\"\n",
    ")\n",
    "encoder_url = f\"https://storage.openvinotoolkit.org/repositories/open_model_zoo/temp/{model_name}/{model_name}-encoder/{precision}/{model_name}-encoder.xml\"\n",
    "decoder_url = f\"https://storage.openvinotoolkit.org/repositories/open_model_zoo/temp/{model_name}/{model_name}-decoder/{precision}/{model_name}-decoder.xml\"\n",
    "\n",
    "if not os.path.exists(model_path_decoder):\n",
    "    utils.download_ir_model(decoder_url, Path(model_path_decoder).parent)\n",
    "if not os.path.exists(model_path_encoder):\n",
    "    utils.download_ir_model(encoder_url, Path(model_path_encoder).parent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load your labels\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "This tutorial uses [Kinetics-400 dataset](https://deepmind.com/research/open-source/kinetics), and also provides the text file embedded into this notebook. \n",
    "\n",
    "> **NOTE**: If you want to run `\"driver-action-recognition-adas-0002\"` model, replace the `kinetics.txt` file to `driver_actions.txt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download the text from the openvino_notebooks storage\n",
    "vocab_file_path = utils.download_file(\n",
    "    \"https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/text/kinetics.txt\",\n",
    "    directory=\"data\"\n",
    ")\n",
    "\n",
    "with vocab_file_path.open(mode='r') as f:\n",
    "    labels = [line.strip() for line in f]\n",
    "\n",
    "print(labels[0:9], np.shape(labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Load the models\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Load the two models for this particular architecture, Encoder and Decoder. Downloaded models are located in a fixed structure, indicating a vendor, the name of the model, and a precision.\n",
    "\n",
    " 1. Initialize OpenVINO Runtime.\n",
    " 2. Read the network from `*.bin` and `*.xml` files (weights and architecture).\n",
    " 3. Compile the model for specified device.\n",
    " 4. Get input and output names of nodes.\n",
    "\n",
    "Only a few lines of code are required to run the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select device from dropdown list for running inference using OpenVINO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "\n",
    "core = ov.Core()\n",
    "device = widgets.Dropdown(\n",
    "    options=core.available_devices + [\"AUTO\"],\n",
    "    value='AUTO',\n",
    "    description='Device:',\n",
    "    disabled=False,\n",
    ")\n",
    "\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model Initialization function\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize OpenVINO Runtime.\n",
    "core = ov.Core()\n",
    "\n",
    "\n",
    "def model_init(model_path: str, device: str) -> Tuple:\n",
    "    \"\"\"\n",
    "    Read the network and weights from a file, load the\n",
    "    model on CPU and get input and output names of nodes\n",
    "\n",
    "    :param: \n",
    "            model: model architecture path *.xml\n",
    "            device: inference device\n",
    "    :retuns:\n",
    "            compiled_model: Compiled model \n",
    "            input_key: Input node for model\n",
    "            output_key: Output node for model\n",
    "    \"\"\"\n",
    "\n",
    "    # Read the network and corresponding weights from a file.\n",
    "    model = core.read_model(model=model_path)\n",
    "    # Compile the model for specified device.\n",
    "    compiled_model = core.compile_model(model=model, device_name=device)\n",
    "    # Get input and output names of nodes.\n",
    "    input_keys = compiled_model.input(0)\n",
    "    output_keys = compiled_model.output(0)\n",
    "    return input_keys, output_keys, compiled_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initialization for Encoder and Decoder\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Encoder initialization\n",
    "input_key_en, output_keys_en, compiled_model_en = model_init(model_path_encoder, device.value)\n",
    "# Decoder initialization\n",
    "input_key_de, output_keys_de, compiled_model_de = model_init(model_path_decoder, device.value)\n",
    "\n",
    "# Get input size - Encoder.\n",
    "height_en, width_en = list(input_key_en.shape)[2:]\n",
    "# Get input size - Decoder.\n",
    "frames2decode = list(input_key_de.shape)[0:][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper functions\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Use the following helper functions for preprocessing and postprocessing frames:\n",
    "\n",
    "1. Preprocess the input image before running the Encoder model. (`center_crop` and `adaptative_resize`)\n",
    "2. Decode top-3 probabilities into label names. (`decode_output`)\n",
    "3. Draw the Region of Interest (ROI) over the video. (`rec_frame_display`)\n",
    "4. Prepare the frame for displaying label names over the video. (`display_text_fnc`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def center_crop(frame: np.ndarray) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Center crop squared the original frame to standardize the input image to the encoder model\n",
    "\n",
    "    :param frame: input frame\n",
    "    :returns: center-crop-squared frame\n",
    "    \"\"\"\n",
    "    img_h, img_w, _ = frame.shape\n",
    "    min_dim = min(img_h, img_w)\n",
    "    start_x = int((img_w - min_dim) / 2.0)\n",
    "    start_y = int((img_h - min_dim) / 2.0)\n",
    "    roi = [start_y, (start_y + min_dim), start_x, (start_x + min_dim)]\n",
    "    return frame[start_y : (start_y + min_dim), start_x : (start_x + min_dim), ...], roi\n",
    "\n",
    "\n",
    "def adaptive_resize(frame: np.ndarray, size: int) -> np.ndarray:\n",
    "    \"\"\"\n",
    "     The frame going to be resized to have a height of size or a width of size\n",
    "\n",
    "    :param frame: input frame\n",
    "    :param size: input size to encoder model\n",
    "    :returns: resized frame, np.array type\n",
    "    \"\"\"\n",
    "    h, w, _ = frame.shape\n",
    "    scale = size / min(h, w)\n",
    "    w_scaled, h_scaled = int(w * scale), int(h * scale)\n",
    "    if w_scaled == w and h_scaled == h:\n",
    "        return frame\n",
    "    return cv2.resize(frame, (w_scaled, h_scaled))\n",
    "\n",
    "\n",
    "def decode_output(probs: np.ndarray, labels: np.ndarray, top_k: int = 3) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Decodes top probabilities into corresponding label names\n",
    "\n",
    "    :param probs: confidence vector for 400 actions\n",
    "    :param labels: list of actions\n",
    "    :param top_k: The k most probable positions in the list of labels\n",
    "    :returns: decoded_labels: The k most probable actions from the labels list\n",
    "              decoded_top_probs: confidence for the k most probable actions\n",
    "    \"\"\"\n",
    "    top_ind = np.argsort(-1 * probs)[:top_k]\n",
    "    out_label = np.array(labels)[top_ind.astype(int)]\n",
    "    decoded_labels = [out_label[0][0], out_label[0][1], out_label[0][2]]\n",
    "    top_probs = np.array(probs)[0][top_ind.astype(int)]\n",
    "    decoded_top_probs = [top_probs[0][0], top_probs[0][1], top_probs[0][2]]\n",
    "    return decoded_labels, decoded_top_probs\n",
    "\n",
    "\n",
    "def rec_frame_display(frame: np.ndarray, roi) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Draw a rec frame over actual frame\n",
    "\n",
    "    :param frame: input frame\n",
    "    :param roi: Region of interest, image section processed by the Encoder\n",
    "    :returns: frame with drawed shape\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    cv2.line(frame, (roi[2] + 3, roi[0] + 3), (roi[2] + 3, roi[0] + 100), (0, 200, 0), 2)\n",
    "    cv2.line(frame, (roi[2] + 3, roi[0] + 3), (roi[2] + 100, roi[0] + 3), (0, 200, 0), 2)\n",
    "    cv2.line(frame, (roi[3] - 3, roi[1] - 3), (roi[3] - 3, roi[1] - 100), (0, 200, 0), 2)\n",
    "    cv2.line(frame, (roi[3] - 3, roi[1] - 3), (roi[3] - 100, roi[1] - 3), (0, 200, 0), 2)\n",
    "    cv2.line(frame, (roi[3] - 3, roi[0] + 3), (roi[3] - 3, roi[0] + 100), (0, 200, 0), 2)\n",
    "    cv2.line(frame, (roi[3] - 3, roi[0] + 3), (roi[3] - 100, roi[0] + 3), (0, 200, 0), 2)\n",
    "    cv2.line(frame, (roi[2] + 3, roi[1] - 3), (roi[2] + 3, roi[1] - 100), (0, 200, 0), 2)\n",
    "    cv2.line(frame, (roi[2] + 3, roi[1] - 3), (roi[2] + 100, roi[1] - 3), (0, 200, 0), 2)\n",
    "    # Write ROI over actual frame\n",
    "    FONT_STYLE = cv2.FONT_HERSHEY_SIMPLEX\n",
    "    org = (roi[2] + 3, roi[1] - 3)\n",
    "    org2 = (roi[2] + 2, roi[1] - 2)\n",
    "    FONT_SIZE = 0.5\n",
    "    FONT_COLOR = (0, 200, 0)\n",
    "    FONT_COLOR2 = (0, 0, 0)\n",
    "    cv2.putText(frame, \"ROI\", org2, FONT_STYLE, FONT_SIZE, FONT_COLOR2)\n",
    "    cv2.putText(frame, \"ROI\", org, FONT_STYLE, FONT_SIZE, FONT_COLOR)\n",
    "    return frame\n",
    "\n",
    "\n",
    "def display_text_fnc(frame: np.ndarray, display_text: str, index: int):\n",
    "    \"\"\"\n",
    "    Include a text on the analyzed frame\n",
    "\n",
    "    :param frame: input frame\n",
    "    :param display_text: text to add on the frame\n",
    "    :param index: index line dor adding text\n",
    "\n",
    "    \"\"\"\n",
    "    # Configuration for displaying images with text.\n",
    "    FONT_COLOR = (255, 255, 255)\n",
    "    FONT_COLOR2 = (0, 0, 0)\n",
    "    FONT_STYLE = cv2.FONT_HERSHEY_DUPLEX\n",
    "    FONT_SIZE = 0.7\n",
    "    TEXT_VERTICAL_INTERVAL = 25\n",
    "    TEXT_LEFT_MARGIN = 15\n",
    "    # ROI over actual frame\n",
    "    (processed, roi) = center_crop(frame)\n",
    "    # Draw a ROI over actual frame.\n",
    "    frame = rec_frame_display(frame, roi)\n",
    "    # Put a text over actual frame.\n",
    "    text_loc = (TEXT_LEFT_MARGIN, TEXT_VERTICAL_INTERVAL * (index + 1))\n",
    "    text_loc2 = (TEXT_LEFT_MARGIN + 1, TEXT_VERTICAL_INTERVAL * (index + 1) + 1)\n",
    "    cv2.putText(frame, display_text, text_loc2, FONT_STYLE, FONT_SIZE, FONT_COLOR2)\n",
    "    cv2.putText(frame, display_text, text_loc, FONT_STYLE, FONT_SIZE, FONT_COLOR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### AI Functions\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "<img align='center' src=\"https://user-images.githubusercontent.com/10940214/148401661-477aebcd-f2d0-4771-b107-4b37f94d0b1e.jpeg\" alt=\"drawing\" width=\"1000\"/>\n",
    "\n",
    "Following the pipeline above, you will use the next functions to:\n",
    "\n",
    "1. Preprocess a frame before running the Encoder. (`preprocessing`)\n",
    "2. Encoder Inference per frame. (`encoder`)\n",
    "3. Decoder inference per set of frames. (`decoder`)\n",
    "4. Normalize the Decoder output to get confidence values per action recognition label. (`softmax`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocessing(frame: np.ndarray, size: int) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Preparing frame before Encoder.\n",
    "    The image should be scaled to its shortest dimension at \"size\"\n",
    "    and cropped, centered, and squared so that both width and\n",
    "    height have lengths \"size\". The frame must be transposed from\n",
    "    Height-Width-Channels (HWC) to Channels-Height-Width (CHW).\n",
    "\n",
    "    :param frame: input frame\n",
    "    :param size: input size to encoder model\n",
    "    :returns: resized and cropped frame\n",
    "    \"\"\"\n",
    "    # Adaptative resize\n",
    "    preprocessed = adaptive_resize(frame, size)\n",
    "    # Center_crop\n",
    "    (preprocessed, roi) = center_crop(preprocessed)\n",
    "    # Transpose frame HWC -> CHW\n",
    "    preprocessed = preprocessed.transpose((2, 0, 1))[None,]  # HWC -> CHW\n",
    "    return preprocessed, roi\n",
    "\n",
    "\n",
    "def encoder(\n",
    "    preprocessed: np.ndarray,\n",
    "    compiled_model: CompiledModel\n",
    ") -> List:\n",
    "    \"\"\"\n",
    "    Encoder Inference per frame. This function calls the network previously\n",
    "    configured for the encoder model (compiled_model), extracts the data\n",
    "    from the output node, and appends it in an array to be used by the decoder.\n",
    "\n",
    "    :param: preprocessed: preprocessing frame\n",
    "    :param: compiled_model: Encoder model network\n",
    "    :returns: encoder_output: embedding layer that is appended with each arriving frame\n",
    "    \"\"\"\n",
    "    output_key_en = compiled_model.output(0)\n",
    "    \n",
    "    # Get results on action-recognition-0001-encoder model\n",
    "    infer_result_encoder = compiled_model([preprocessed])[output_key_en]\n",
    "    return infer_result_encoder\n",
    "\n",
    "\n",
    "def decoder(encoder_output: List, compiled_model_de: CompiledModel) -> List:\n",
    "    \"\"\"\n",
    "    Decoder inference per set of frames. This function concatenates the embedding layer\n",
    "    froms the encoder output, transpose the array to match with the decoder input size.\n",
    "    Calls the network previously configured for the decoder model (compiled_model_de), extracts\n",
    "    the logits and normalize those to get confidence values along specified axis.\n",
    "    Decodes top probabilities into corresponding label names\n",
    "\n",
    "    :param: encoder_output: embedding layer for 16 frames\n",
    "    :param: compiled_model_de: Decoder model network\n",
    "    :returns: decoded_labels: The k most probable actions from the labels list\n",
    "              decoded_top_probs: confidence for the k most probable actions\n",
    "    \"\"\"\n",
    "    # Concatenate sample_duration frames in just one array\n",
    "    decoder_input = np.concatenate(encoder_output, axis=0)\n",
    "    # Organize input shape vector to the Decoder (shape: [1x16x512]]\n",
    "    decoder_input = decoder_input.transpose((2, 0, 1, 3))\n",
    "    decoder_input = np.squeeze(decoder_input, axis=3)\n",
    "    output_key_de = compiled_model_de.output(0)\n",
    "    # Get results on action-recognition-0001-decoder model\n",
    "    result_de = compiled_model_de([decoder_input])[output_key_de]\n",
    "    # Normalize logits to get confidence values along specified axis\n",
    "    probs = softmax(result_de - np.max(result_de))\n",
    "    # Decodes top probabilities into corresponding label names\n",
    "    decoded_labels, decoded_top_probs = decode_output(probs, labels, top_k=3)\n",
    "    return decoded_labels, decoded_top_probs\n",
    "\n",
    "\n",
    "def softmax(x: np.ndarray) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Normalizes logits to get confidence values along specified axis\n",
    "    x: np.array, axis=None\n",
    "    \"\"\"\n",
    "    exp = np.exp(x)\n",
    "    return exp / np.sum(exp, axis=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "tags": []
   },
   "source": [
    "### Main Processing Function\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Running action recognition function will run in different operations, either a webcam or a video file. See the list of procedures below:\n",
    "\n",
    "1. Create a video player to play with target fps (`utils.VideoPlayer`).\n",
    "2. Prepare a set of frames to be encoded-decoded.\n",
    "3. Run AI functions\n",
    "4. Visualize the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def run_action_recognition(\n",
    "    source: str = \"0\",\n",
    "    flip: bool = True,\n",
    "    use_popup: bool = False,\n",
    "    compiled_model_en: CompiledModel = compiled_model_en,\n",
    "    compiled_model_de: CompiledModel = compiled_model_de,\n",
    "    skip_first_frames: int = 0,\n",
    "):\n",
    "    \"\"\"\n",
    "    Use the \"source\" webcam or video file to run the complete pipeline for action-recognition problem\n",
    "    1. Create a video player to play with target fps\n",
    "    2. Prepare a set of frames to be encoded-decoded\n",
    "    3. Preprocess frame before Encoder\n",
    "    4. Encoder Inference per frame\n",
    "    5. Decoder inference per set of frames\n",
    "    6. Visualize the results\n",
    "\n",
    "    :param: source: webcam \"0\" or video path\n",
    "    :param: flip: to be used by VideoPlayer function for flipping capture image\n",
    "    :param: use_popup: False for showing encoded frames over this notebook, True for creating a popup window.\n",
    "    :param: skip_first_frames: Number of frames to skip at the beginning of the video.\n",
    "    :returns: display video over the notebook or in a popup window\n",
    "\n",
    "    \"\"\"\n",
    "    size = height_en  # Endoder input size - From Cell 5_9\n",
    "    sample_duration = frames2decode  # Decoder input size - From Cell 5_7\n",
    "    # Select frames per second of your source.\n",
    "    fps = 30\n",
    "    player = None\n",
    "    try:\n",
    "        # Create a video player.\n",
    "        player = utils.VideoPlayer(source, flip=flip, fps=fps, skip_first_frames=skip_first_frames)\n",
    "        # Start capturing.\n",
    "        player.start()\n",
    "        if use_popup:\n",
    "            title = \"Press ESC to Exit\"\n",
    "            cv2.namedWindow(title, cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_AUTOSIZE)\n",
    "\n",
    "        processing_times = collections.deque()\n",
    "        processing_time = 0\n",
    "        encoder_output = []\n",
    "        decoded_labels = [0, 0, 0]\n",
    "        decoded_top_probs = [0, 0, 0]\n",
    "        counter = 0\n",
    "        # Create a text template to show inference results over video.\n",
    "        text_inference_template = \"Infer Time:{Time:.1f}ms,{fps:.1f}FPS\"\n",
    "        text_template = \"{label},{conf:.2f}%\"\n",
    "\n",
    "        while True:\n",
    "            counter = counter + 1\n",
    "\n",
    "            # Read a frame from the video stream.\n",
    "            frame = player.next()\n",
    "            if frame is None:\n",
    "                print(\"Source ended\")\n",
    "                break\n",
    "\n",
    "            scale = 1280 / max(frame.shape)\n",
    "\n",
    "            # Adaptative resize for visualization.\n",
    "            if scale < 1:\n",
    "                frame = cv2.resize(frame, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)\n",
    "\n",
    "            # Select one frame every two for processing through the encoder.\n",
    "            # After 16 frames are processed, the decoder will find the action,\n",
    "            # and the label will be printed over the frames.\n",
    "\n",
    "            if counter % 2 == 0:\n",
    "                # Preprocess frame before Encoder.\n",
    "                (preprocessed, _) = preprocessing(frame, size)\n",
    "\n",
    "                # Measure processing time.\n",
    "                start_time = time.time()\n",
    "\n",
    "                # Encoder Inference per frame\n",
    "                encoder_output.append(encoder(preprocessed, compiled_model_en))\n",
    "\n",
    "                # Decoder inference per set of frames\n",
    "                # Wait for sample duration to work with decoder model.\n",
    "                if len(encoder_output) == sample_duration:\n",
    "                    decoded_labels, decoded_top_probs = decoder(encoder_output, compiled_model_de)\n",
    "                    encoder_output = []\n",
    "\n",
    "                # Inference has finished. Display the results.\n",
    "                stop_time = time.time()\n",
    "\n",
    "                # Calculate processing time.\n",
    "                processing_times.append(stop_time - start_time)\n",
    "\n",
    "                # Use processing times from last 200 frames.\n",
    "                if len(processing_times) > 200:\n",
    "                    processing_times.popleft()\n",
    "\n",
    "                # Mean processing time [ms]\n",
    "                processing_time = np.mean(processing_times) * 1000\n",
    "                fps = 1000 / processing_time\n",
    "\n",
    "            # Visualize the results.\n",
    "            for i in range(0, 3):\n",
    "                display_text = text_template.format(\n",
    "                    label=decoded_labels[i],\n",
    "                    conf=decoded_top_probs[i] * 100,\n",
    "                )\n",
    "                display_text_fnc(frame, display_text, i)\n",
    "\n",
    "            display_text = text_inference_template.format(Time=processing_time, fps=fps)\n",
    "            display_text_fnc(frame, display_text, 3)\n",
    "\n",
    "            # Use this workaround if you experience flickering.\n",
    "            if use_popup:\n",
    "                cv2.imshow(title, frame)\n",
    "                key = cv2.waitKey(1)\n",
    "                # escape = 27\n",
    "                if key == 27:\n",
    "                    break\n",
    "            else:\n",
    "                # Encode numpy array to jpg.\n",
    "                _, encoded_img = cv2.imencode(\".jpg\", frame, params=[cv2.IMWRITE_JPEG_QUALITY, 90])\n",
    "                # Create an IPython image.\n",
    "                i = display.Image(data=encoded_img)\n",
    "                # Display the image in this notebook.\n",
    "                display.clear_output(wait=True)\n",
    "                display.display(i)\n",
    "\n",
    "    # ctrl-c\n",
    "    except KeyboardInterrupt:\n",
    "        print(\"Interrupted\")\n",
    "    # Any different error\n",
    "    except RuntimeError as e:\n",
    "        print(e)\n",
    "    finally:\n",
    "        if player is not None:\n",
    "            # Stop capturing.\n",
    "            player.stop()\n",
    "        if use_popup:\n",
    "            cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run Action Recognition\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Find out how the model works in a video file. [Any format supported](https://docs.opencv.org/4.5.1/dd/d43/tutorial_py_video_display.html) by OpenCV will work. You can press the stop button anytime while the video file is running, and it will activate the webcam for the next step.\n",
    "\n",
    "> **NOTE**: Sometimes, the video can be cut off if there are corrupted frames. In that case, you can convert it. If you experience any problems with your video, use the [HandBrake](https://handbrake.fr/) and select the MPEG format.\n",
    "\n",
    "if you want to use a web camera as an input source for the demo, please change the value of `USE_WEBCAM` variable to True and specify `cam_id` (the default value is 0, which can be different in multi-camera systems)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [],
    "test_replace": {
     "additional_options = {\"skip_first_frames\": 600, \"flip\": False} if not USE_WEBCAM else {\"flip\": True}\n": "additional_options = {\"skip_first_frames\": 1800, \"flip\": False} if not USE_WEBCAM else {\"flip\": True}\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "USE_WEBCAM = False\n",
    "\n",
    "cam_id = 0\n",
    "video_file = \"https://archive.org/serve/ISSVideoResourceLifeOnStation720p/ISS%20Video%20Resource_LifeOnStation_720p.mp4\"\n",
    "\n",
    "source = cam_id if USE_WEBCAM else video_file\n",
    "additional_options = {\"skip_first_frames\": 600, \"flip\": False} if not USE_WEBCAM else {\"flip\": True}\n",
    "run_action_recognition(source=source, use_popup=False, **additional_options)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Edit Metadata",
  "kernelspec": {
   "display_name": "openvino_env",
   "language": "python",
   "name": "openvino_env"
  },
  "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.11.5"
  },
  "openvino_notebooks": {
   "imageUrl": "https://user-images.githubusercontent.com/10940214/151552326-642d6e49-f5a0-4fc1-bf14-ae3f457e1fec.gif",
   "tags": {
    "categories": [
     "Live Demos"
    ],
    "libraries": [],
    "other": [],
    "tasks": [
     "Image Classification"
    ]
   }
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}