centroid_tracker_py.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "centroid_tracker.py",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nJfAjC8HXjvJ"
      },
      "outputs": [],
      "source": [
        "#Requirements.\n",
        "\n",
        "import cv2\n",
        "from collections import OrderedDict\n",
        "import imutils\n",
        "import numpy as np\n",
        "from scipy.spatial import distance as dist"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Testing concepts implemented into the centroid tracker.\n",
        "#Included comments in print statements to make this cell's output \n",
        "#easier to follow!\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "np.random.seed(42)\n",
        "tracked_centroids = np.random.uniform(size=(2,2))\n",
        "print(\"The coordinates for centroids that have been tracked on the previous \\n\"\n",
        "      \"frame of the video (format: [x-coordinate, y-coordinate]). \\n\",\n",
        "      tracked_centroids, \"\\n\")\n",
        "\n",
        "plt.scatter(tracked_centroids[:,0], tracked_centroids[:,1], c=(\"blue\", \"red\"))\n",
        "plt.tick_params(axis=\"both\", which=\"both\", top=False, bottom=False, left=False, right=False, labeltop=False, labelbottom=False, labelleft=False, labelright=False)\n",
        "plt.annotate(\"centroid 1\", tracked_centroids[0])\n",
        "plt.annotate(\"centroid 2\", tracked_centroids[1])\n",
        "plt.title(\"Frame 1\")\n",
        "plt.xlim(0, 1)\n",
        "plt.ylim(0, 1)\n",
        "plt.show()\n",
        "\n",
        "untracked_centroids = np.random.uniform(size=(3,2))\n",
        "print(\"\\nThe coordinates for centroids on the current frame. \\n\", \n",
        "      untracked_centroids, \"\\n\")\n",
        "\n",
        "plt.scatter(untracked_centroids[:,0], untracked_centroids[:,1], c=(\"purple\"))\n",
        "plt.tick_params(axis=\"both\", which=\"both\", top=False, bottom=False, left=False, right=False, labeltop=False, labelbottom=False, labelleft=False, labelright=False)\n",
        "plt.annotate(\"centroid ?\", untracked_centroids[0])\n",
        "plt.annotate(\"centroid ?\", untracked_centroids[1])\n",
        "plt.annotate(\"centroid ?\", untracked_centroids[2])\n",
        "plt.title(\"Frame 2\")\n",
        "plt.xlim(0, 1)\n",
        "plt.ylim(0, 1)\n",
        "plt.show()\n",
        "\n",
        "inter_frame_distance = dist.cdist(tracked_centroids, untracked_centroids)\n",
        "print(\"\\nThe Euclidean distances between centroids on the previous and current \\n\"\n",
        "      \"frame. Each row in this array represents a previously tracked centroid \\n\"\n",
        "      \"and each column represents a newly detected centroid on the current \\n\"\n",
        "      \"video frame. Thus, the first value in the array (row 1, column 1) is the \\n\"\n",
        "      \"distance between the first tracked object centroid and the first \\n\"\n",
        "      \"untracked object centroid. The value in (row 2, column 3) is the \\n\"\n",
        "      \"distance between the second tracked object and the third untracked \\n\"\n",
        "      \"object and so on. \\n\", \n",
        "      inter_frame_distance, \"\\n\")\n",
        "\n",
        "print(\"The smallest distances to an untracked centroid for each previously \\n\"\n",
        "      \"tracked centroid. \\n\",\n",
        "      inter_frame_distance.min(axis=1), \"\\n\")\n",
        "\n",
        "row_indexes = inter_frame_distance.min(axis=1).argsort()\n",
        "print(\"The indexes of the smallest distances to an untracked centroid for \\n\"\n",
        "      \"each previously tracked centroid with respect to rows in the Euclidean \\n\"\n",
        "      \"distance array. They are sorted from least to greatest distance. \\n\",\n",
        "      row_indexes, \"\\n\")\n",
        "      \n",
        "column_indexes = inter_frame_distance.argmin(axis=1)[row_indexes]\n",
        "print(\"The indexes of the smallest distances to an untracked centroid for \\n\"\n",
        "      \"each previously tracked centroid with respect to columns in the \\n\"\n",
        "      \"Euclidean distance array. They are sorted from least to greatest distance. \\n\"\n",
        "      \"In this example, the smallest distances are in the second (index 1) and \\n\"\n",
        "      \"third (index 2) columns of the Euclidean distances array. \\n\",\n",
        "      column_indexes, \"\\n\")\n",
        "\n",
        "print(\"An array of the row and column indexes that refer to the smallest \\n\"\n",
        "      \"distances from previously tracked centroids to new centroids in the \\n\"\n",
        "      \"Euclidean distances array. These indexes are sorted from smallest to \\n\"\n",
        "      \"largest distance. In this example, index[1, 2] in the Euclidean distance \\n\"\n",
        "      \"array refers to the value in (row 2, column 3) which is the smallest \\n\"\n",
        "      \"distance in the array. The next index [0, 1] refers to the value in \\n\"\n",
        "      \"(row 1, column 2). This means that the second tracked centroid will be \\n\"\n",
        "      \"matched with and considered to be the same object as the third newly \\n\"\n",
        "      \"detected centroid, and the first tracked centroid will be matched with \\n\"\n",
        "      \"and considered the same object as the second newly detected centroid. \\n\"\n",
        "      \"The last newly detected point is left unmatched and is considered a new \\n\"\n",
        "      \"object's centroid. \\n\", \n",
        "      list(zip(row_indexes, column_indexes)), \"\\n\")\n",
        "\n",
        "plt.scatter(np.append(tracked_centroids[:,0], untracked_centroids[:,0]), np.append(tracked_centroids[:,1], untracked_centroids[:,1]), c=(\"blue\", \"red\", \"purple\", \"blue\", \"red\"))\n",
        "plt.tick_params(axis=\"both\", which=\"both\", top=False, bottom=False, left=False, right=False, labeltop=False, labelbottom=False, labelleft=False, labelright=False)\n",
        "plt.annotate(\"centroid 1, frame 1\", tracked_centroids[0])\n",
        "plt.annotate(\"centroid 2, frame 1\", tracked_centroids[1])\n",
        "plt.annotate(\"new centroid\", untracked_centroids[0])\n",
        "plt.annotate(\"centroid 1, frame 2\", untracked_centroids[1])\n",
        "plt.annotate(\"centroid 2, frame 2\", untracked_centroids[2])\n",
        "plt.title(\"Frame 1 & 2\")\n",
        "plt.xlim(0, 1)\n",
        "plt.ylim(0, 1)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "kdDXIim2F5k_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "0f130bfc-8b9c-4463-c719-5c3aa943f92d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The coordinates for centroids that have been tracked on the previous \n",
            "frame of the video (format: [x-coordinate, y-coordinate]). \n",
            " [[0.37454012 0.95071431]\n",
            " [0.73199394 0.59865848]] \n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "The coordinates for centroids on the current frame. \n",
            " [[0.15601864 0.15599452]\n",
            " [0.05808361 0.86617615]\n",
            " [0.60111501 0.70807258]] \n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "The Euclidean distances between centroids on the previous and current \n",
            "frame. Each row in this array represents a previously tracked centroid \n",
            "and each column represents a newly detected centroid on the current \n",
            "video frame. Thus, the first value in the array (row 1, column 1) is the \n",
            "distance between the first tracked object centroid and the first \n",
            "untracked object centroid. The value in (row 2, column 3) is the \n",
            "distance between the second tracked object and the third untracked \n",
            "object and so on. \n",
            " [[0.82421549 0.32755369 0.33198071]\n",
            " [0.72642889 0.72506609 0.17058938]] \n",
            "\n",
            "The smallest distances to an untracked centroid for each previously \n",
            "tracked centroid. \n",
            " [0.32755369 0.17058938] \n",
            "\n",
            "The indexes of the smallest distances to an untracked centroid for \n",
            "each previously tracked centroid with respect to rows in the Euclidean \n",
            "distance array. They are sorted from least to greatest distance. \n",
            " [1 0] \n",
            "\n",
            "The indexes of the smallest distances to an untracked centroid for \n",
            "each previously tracked centroid with respect to columns in the \n",
            "Euclidean distance array. They are sorted from least to greatest distance. \n",
            "In this example, the smallest distances are in the second (index 1) and \n",
            "third (index 2) columns of the Euclidean distances array. \n",
            " [2 1] \n",
            "\n",
            "An array of the row and column indexes that refer to the smallest \n",
            "distances from previously tracked centroids to new centroids in the \n",
            "Euclidean distances array. These indexes are sorted from smallest to \n",
            "largest distance. In this example, index[1, 2] in the Euclidean distance \n",
            "array refers to the value in (row 2, column 3) which is the smallest \n",
            "distance in the array. The next index [0, 1] refers to the value in \n",
            "(row 1, column 2). This means that the second tracked centroid will be \n",
            "matched with and considered to be the same object as the third newly \n",
            "detected centroid, and the first tracked centroid will be matched with \n",
            "and considered the same object as the second newly detected centroid. \n",
            "The last newly detected point is left unmatched and is considered a new \n",
            "object's centroid. \n",
            " [(1, 2), (0, 1)] \n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Centroid tracker that records the unique objects in a video.\n",
        "\n",
        "class CentroidTracker():\n",
        "  def __init__(self, max_time_out_of_frame = 60):\n",
        "    self.max_time_out_of_frame = max_time_out_of_frame \n",
        "    #the maximum number of frames an object can be out of frame before being \n",
        "    #considered a disappeared object\n",
        "    self.next_object_id = 0 \n",
        "    #the next unique id of an object that is assigned once an object is \n",
        "    #considered a disappeared object\n",
        "    self.objects = OrderedDict() \n",
        "    #a dictionary storing all of the object ids as keys and their respective \n",
        "    #centroid x,y coordinates as values\n",
        "    self.disappeared_objects = OrderedDict() \n",
        "    #a dictionary storing object ids as keys and the number of frames they \n",
        "    #have been out of frame as values\n",
        "\n",
        "  #add new objects and their respective centroid coordinates\n",
        "  def register_new_object(self, centroid):\n",
        "    self.objects[self.next_object_id] = centroid \n",
        "    #the value returned from the object dictionary key is the centroid of that\n",
        "    #object\n",
        "    self.disappeared_objects[self.next_object_id] = 0 \n",
        "    #the number of frames an object has been out of frame starts at zero\n",
        "    self.next_object_id += 1 \n",
        "    #a new object id is created for when a disappeared object is eventually \n",
        "    #deregistered\n",
        "\n",
        "  #remove objects that have been out of frame for the maximum allowed time\n",
        "  def deregister_object(self, object_id):\n",
        "    del self.objects[object_id]\n",
        "    del self.disappeared_objects[object_id]\n",
        "\n",
        "  #update the dictionary of tracked objects when objects are registered\n",
        "  #or deregistered\n",
        "  def update_objects(self, bounding_boxes):\n",
        "    #if there are no objects detected, mark any previously existing objects \n",
        "    #as disappeared and increment the time they've been out of frame\n",
        "    if len(bounding_boxes) == 0:\n",
        "      for object_id in list(self.disappeared_objects.keys()):\n",
        "        self.disappeared_objects[object_id] +=1\n",
        "        \n",
        "        #if the object has disappeared for the maximum number of frames, \n",
        "        #deregister the object\n",
        "        if self.disappeared_objects[object_id] > self.max_time_out_of_frame:\n",
        "          self.deregister_object(object_id)\n",
        "      \n",
        "      #finish the method early because there are no objects to update\n",
        "      return self.objects\n",
        "    \n",
        "    #for all the detected bounding boxes (i.e. objects), find their centroids \n",
        "    #and register them\n",
        "    current_frame_centroids = np.zeros((len(bounding_boxes), 2), dtype=\"int\")\n",
        "    for (i, (start_x_coord, start_y_coord, end_x_coord, end_y_coord)) in enumerate(bounding_boxes):\n",
        "      x_coordinate = int((start_x_coord + end_y_coord) /2.0)\n",
        "      y_coordinate = int((start_y_coord + end_x_coord) /2.0)\n",
        "      current_frame_centroids[i] = (x_coordinate, y_coordinate)\n",
        "\n",
        "      if len(self.objects) == 0:\n",
        "        for i in range(0, len(current_frame_centroids)):\n",
        "          self.register(current_frame_centroids[i])\n",
        "\n",
        "      #match a centroid from a previous frame to a centroid on the current \n",
        "      #frame by minimizing the Euclidean distance between them\n",
        "      else:\n",
        "        object_ids = list(self.objects.keys())\n",
        "        object_centroids = list(self.objects.values())\n",
        "        inter_frame_distance = dist.cdist(np.array(object_centroids), current_frame_centroids)\n",
        "        row_indexes = inter_frame_distance.min(axis=1).argsort()\n",
        "        column_indexes = inter_frame_distance.argmin(axis=1)[row_indexes]\n",
        "        \n",
        "        #find centroids on the current frame that have the smallest distance to\n",
        "        #a centroid on the previous frame and have not yet been matched with a \n",
        "        #centroid from the previous frame\n",
        "        searched_rows = set()\n",
        "        searched_columns = set()\n",
        "        for (row, column) in zip(row_indexes, column_indexes):\n",
        "          if row in searched_rows | column in searched_columns:\n",
        "            continue\n",
        "          object_id = object_ids[row]\n",
        "          self.objects[object_id] = current_frame_centroids[column]\n",
        "          self.disappeared_objects[object_id] = 0\n",
        "          searched_rows.add(row)\n",
        "          searched_columns.add(column)\n",
        "\n",
        "        #dealing with objects that have been lost or disappeared\n",
        "        unsearched_rows = set(range(0, inter_frame_distance.shape[0])).difference(searched_rows)\n",
        "        unsearched_columns = set(range(0, inter_frame_distance.shape[1])).difference(searched_columns)\n",
        "        if inter_frame_distance.shape[0] >= inter_frame_distance.shape[1]:\n",
        "          for row in unsearched_rows:\n",
        "            object_id = object_ids[row]\n",
        "            self.disappeared_objects[object_id] += 1\n",
        "            if self.disappeared_objects[object_id] > self.max_time_out_of_frame:\n",
        "              self.deregister_object[object_id]\n",
        "            else:\n",
        "              for column in unsearched_columns:\n",
        "                self.register_new_object(current_frame_centroids[column])\n",
        "        \n",
        "        #return the updateddictionary of trackable objects for current \n",
        "        #video frame\n",
        "        return self.objects\n"
      ],
      "metadata": {
        "id": "7uxLowewfUby"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}