Social_Distancing_Detector.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "RamcharanTeja64bit_Github_pro17",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "edEruu12DVqu"
      },
      "source": [
        "# **SOCIAL** **DISTANCING** **DETECTOR**\r\n",
        "                     -RamcharanTeja\r\n",
        "email:ramcharanteja.380@gmail.com\r\n",
        "\r\n",
        "Github:https://github.com/RamcharanTeja64bit\r\n",
        "\r\n",
        "Linkedin:https://www.linkedin.com/in/ramcharan-teja-256704182/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0yBYlgfqlYlG"
      },
      "source": [
        " **Intialising the threshold values of the distances between the persons**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kPXOB1zJhPKQ"
      },
      "source": [
        "# threshold= non-maxima suppression\n",
        "MIN_CONF = 0.3\n",
        "NMS_THRESH = 0.3\n",
        "\n",
        "# define the minimum safe distance (in pixels) that two people can be\n",
        "# from each other\n",
        "MIN_DISTANCE = 50"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iHcrvIQMLZQ2",
        "outputId": "d0079e45-8786-40e4-ca07-f906d28aded1"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mefw6DVRlyuQ"
      },
      "source": [
        "Performing Object Detection to detect people"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iQgUUsQRhqoA"
      },
      "source": [
        "import numpy as np\n",
        "import cv2\n",
        "\n",
        "def detect_people(frame, net, ln, personIdx=0):\n",
        "\t# grab the dimensions of the frame and  initialize the list of\n",
        "\t# results\n",
        "\t(H, W) = frame.shape[:2]\n",
        "\tresults = []\n",
        "\n",
        "\t# construct a blob from the input frame and then perform a forward\n",
        "\t# pass of the YOLO object detector, giving us our bounding boxes\n",
        "\tblob = cv2.dnn.blobFromImage(frame, 1 / 255.0, (416, 416),\n",
        "\t\tswapRB=True, crop=False)\n",
        "\tnet.setInput(blob)\n",
        "\tlayerOutputs = net.forward(ln)\n",
        "\n",
        "\t# initialize our lists of detected bounding boxes, centroids, and\n",
        "\t# confidences, respectively\n",
        "\tboxes = []\n",
        "\tcentroids = []\n",
        "\tconfidences = []\n",
        "\n",
        "\t# loop over each of the layer outputs\n",
        "\tfor output in layerOutputs:\n",
        "\t\t# loop over each of the detections\n",
        "\t\tfor detection in output:\n",
        "\t\t\t# extract the class ID and confidence (i.e., probability)\n",
        "\t\t\t# of the current object detection\n",
        "\t\t\tscores = detection[5:]\n",
        "\t\t\tclassID = np.argmax(scores)\n",
        "\t\t\tconfidence = scores[classID]\n",
        "\n",
        "\t\t\t# filter detections by (1) ensuring that the object\n",
        "\t\t\t# detected was a person and (2) that the minimum\n",
        "\t\t\t# confidence is met\n",
        "\t\t\tif classID == personIdx and confidence > MIN_CONF:\n",
        "\t\t\t\t# scale the bounding box coordinates back relative to\n",
        "\t\t\t\t# the size of the image, keeping in mind that YOLO\n",
        "\t\t\t\t# actually returns the center (x, y)-coordinates of\n",
        "\t\t\t\t# the bounding box followed by the boxes' width and\n",
        "\t\t\t\t# height\n",
        "\t\t\t\tbox = detection[0:4] * np.array([W, H, W, H])\n",
        "\t\t\t\t(centerX, centerY, width, height) = box.astype(\"int\")\n",
        "\n",
        "\t\t\t\t# use the center (x, y)-coordinates to derive the top\n",
        "\t\t\t\t# and and left corner of the bounding box\n",
        "\t\t\t\tx = int(centerX - (width / 2))\n",
        "\t\t\t\ty = int(centerY - (height / 2))\n",
        "\n",
        "\t\t\t\t# update our list of bounding box coordinates,\n",
        "\t\t\t\t# centroids, and confidences\n",
        "\t\t\t\tboxes.append([x, y, int(width), int(height)])\n",
        "\t\t\t\tcentroids.append((centerX, centerY))\n",
        "\t\t\t\tconfidences.append(float(confidence))\n",
        "\n",
        "\t# apply non-maxima suppression to suppress weak, overlapping\n",
        "\t# bounding boxes\n",
        "\tidxs = cv2.dnn.NMSBoxes(boxes, confidences, MIN_CONF, NMS_THRESH)\n",
        "\n",
        "\n",
        "\n",
        "\t# ensure at least one detection exists\n",
        "\tif len(idxs) > 0:\n",
        "\t\t# loop over the indexes we are keeping\n",
        "\t\tfor i in idxs.flatten():\n",
        "\t\t\t# extract the bounding box coordinates\n",
        "\t\t\t(x, y) = (boxes[i][0], boxes[i][1])\n",
        "\t\t\t(w, h) = (boxes[i][2], boxes[i][3])\n",
        "\n",
        "\t\t\t# update our results list to consist of the person\n",
        "\t\t\t# prediction probability, bounding box coordinates,\n",
        "\t\t\t# and the centroid\n",
        "\t\t\tr = (confidences[i], (x, y, x + w, y + h), centroids[i])\n",
        "\t\t\tresults.append(r)\n",
        "\n",
        "\t# return the list of results\n",
        "\treturn results"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NHLWA1WTmBlE"
      },
      "source": [
        "# Processing the Videos and making Predictions "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DMWw6mhGHj7S"
      },
      "source": [
        "# USAGE\n",
        "# python social_distance_detector.py --input pedestrians.mp4\n",
        "# python social_distance_detector.py --input pedestrians.mp4 --output output.avi\n",
        "\n",
        "# import the necessary packages\n",
        "from google.colab.patches import cv2_imshow\n",
        "from scipy.spatial import distance as dist\n",
        "import numpy as np\n",
        "import argparse\n",
        "import imutils\n",
        "import cv2\n",
        "import os\n",
        "\n",
        "# construct the argument parse and parse the arguments\n",
        "ap = argparse.ArgumentParser()\n",
        "ap.add_argument(\"-i\", \"--input\", type=str, default=\"\",\n",
        "\thelp=\"path to (optional) input video file\")\n",
        "ap.add_argument(\"-o\", \"--output\", type=str, default=\"\",\n",
        "\thelp=\"path to (optional) output video file\")\n",
        "ap.add_argument(\"-d\", \"--display\", type=int, default=1,\n",
        "\thelp=\"whether or not output frame should be displayed\")\n",
        "args = vars(ap.parse_args([\"--input\",\"/content/drive/MyDrive/Social-distance-detection-master/Social-distance-detection-master/pedestrians.mp4\",\"--output\",\"my_output.avi\",\"--display\",\"1\"]))\n",
        "\n",
        "# load the COCO class labels our YOLO model was trained on\n",
        "labelsPath = os.path.sep.join([\"/content/drive/MyDrive/Social-distance-detection-master/Social-distance-detection-master/yolo-coco/coco.names\"])\n",
        "LABELS = open(labelsPath).read().strip().split(\"\\n\")\n",
        "\n",
        "# derive the paths to the YOLO weights and model configuration\n",
        "weightsPath = os.path.sep.join([\"/content/drive/MyDrive/Social-distance-detection-master/Social-distance-detection-master/yolo-coco/yolov3 (1).weights\"])\n",
        "configPath = os.path.sep.join([\"/content/drive/MyDrive/Social-distance-detection-master/Social-distance-detection-master/yolo-coco/yolov3.cfg\"])\n",
        "\n",
        "# load our YOLO object detector trained on COCO dataset (80 classes)\n",
        "print(\"[INFO] loading YOLO from disk...\")\n",
        "net = cv2.dnn.readNetFromDarknet(configPath, weightsPath)\n",
        "\n",
        "# determine only the *output* layer names that we need from YOLO\n",
        "ln = net.getLayerNames()\n",
        "ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]\n",
        "\n",
        "# initialize the video stream and pointer to output video file\n",
        "print(\"[INFO] accessing video stream...\")\n",
        "vs = cv2.VideoCapture(args[\"input\"] if args[\"input\"] else 0)\n",
        "writer = None\n",
        "\n",
        "# loop over the frames from the video stream\n",
        "while True:\n",
        "\t# read the next frame from the file\n",
        "\t(grabbed, frame) = vs.read()\n",
        "\n",
        "\t# if the frame was not grabbed, then we have reached the end\n",
        "\t# of the stream\n",
        "\tif not grabbed:\n",
        "\t\tbreak\n",
        "\n",
        "\t# resize the frame and then detect people (and only people) in it\n",
        "\tframe = imutils.resize(frame, width=700)\n",
        "\tresults = detect_people(frame, net, ln,\n",
        "\t\tpersonIdx=LABELS.index(\"person\"))\n",
        "\n",
        "\t# initialize the set of indexes that violate the minimum social\n",
        "\t# distance\n",
        "\tviolate = set()\n",
        "\n",
        "\t# ensure there are *at least* two people detections (required in\n",
        "\t# order to compute our pairwise distance maps)\n",
        "\tif len(results) >= 2:\n",
        "\t\t# extract all centroids from the results and compute the\n",
        "\t\t# Euclidean distances between all pairs of the centroids\n",
        "\t\tcentroids = np.array([r[2] for r in results])\n",
        "\t\tD = dist.cdist(centroids, centroids, metric=\"euclidean\")\n",
        "\n",
        "\t\t# loop over the upper triangular of the distance matrix\n",
        "\t\tfor i in range(0, D.shape[0]):\n",
        "\t\t\tfor j in range(i + 1, D.shape[1]):\n",
        "\t\t\t\t# check to see if the distance between any two\n",
        "\t\t\t\t# centroid pairs is less than the configured number\n",
        "\t\t\t\t# of pixels\n",
        "\t\t\t\tif D[i, j] < MIN_DISTANCE:\n",
        "\t\t\t\t\t# update our violation set with the indexes of\n",
        "\t\t\t\t\t# the centroid pairs\n",
        "\t\t\t\t\tviolate.add(i)\n",
        "\t\t\t\t\tviolate.add(j)\n",
        "\n",
        "\t# loop over the results\n",
        "\tfor (i, (prob, bbox, centroid)) in enumerate(results):\n",
        "\t\t# extract the bounding box and centroid coordinates, then\n",
        "\t\t# initialize the color of the annotation\n",
        "\t\t(startX, startY, endX, endY) = bbox\n",
        "\t\t(cX, cY) = centroid\n",
        "\t\tcolor = (0, 255, 0)\n",
        "\n",
        "\t\t# if the index pair exists within the violation set, then\n",
        "\t\t# update the color\n",
        "\t\tif i in violate:\n",
        "\t\t\tcolor = (0, 0, 255)\n",
        "\n",
        "\t\t# draw (1) a bounding box around the person and (2) the\n",
        "\t\t# centroid coordinates of the person,\n",
        "\t\tcv2.rectangle(frame, (startX, startY), (endX, endY), color, 2)\n",
        "\t\tcv2.circle(frame, (cX, cY), 5, color, 1)\n",
        "\n",
        "\t# draw the total number of social distancing violations on the\n",
        "\t# output frame\n",
        "\ttext = \"Social Distancing Violations: {}\".format(len(violate))\n",
        "\tcv2.putText(frame, text, (10, frame.shape[0] - 25),\n",
        "\t\tcv2.FONT_HERSHEY_SIMPLEX, 0.85, (0, 0, 255), 3)\n",
        "\n",
        "\t# check to see if the output frame should be displayed to our\n",
        "\t# screen\n",
        "\tif args[\"display\"] > 0:\n",
        "\t\t# show the output frame\n",
        "\t\tcv2_imshow(frame)\n",
        "\t\tkey = cv2.waitKey(1) & 0xFF\n",
        "\n",
        "\t\t# if the `q` key was pressed, break from the loop\n",
        "\t\tif key == ord(\"q\"):\n",
        "\t\t\tbreak\n",
        "\n",
        "\t# if an output video file path has been supplied and the video\n",
        "\t# writer has not been initialized, do so now\n",
        "\tif args[\"output\"] != \"\" and writer is None:\n",
        "\t\t# initialize our video writer\n",
        "\t\tfourcc = cv2.VideoWriter_fourcc(*\"MJPG\")\n",
        "\t\twriter = cv2.VideoWriter(args[\"output\"], fourcc, 25,\n",
        "\t\t\t(frame.shape[1], frame.shape[0]), True)\n",
        "\n",
        "\t# if the video writer is not None, write the frame to the output\n",
        "\t# video file\n",
        "\tif writer is not None:\n",
        "\t\twriter.write(frame)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}