Drowsiness_Alert.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the necessary packages\n",
    "from scipy.spatial import distance as dist\n",
    "from imutils.video import VideoStream \n",
    "from imutils import face_utils\n",
    "from threading import Thread\n",
    "import numpy as np\n",
    "import playsound\n",
    "#import argparse\n",
    "import imutils\n",
    "import time\n",
    "import dlib\n",
    "import cv2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sound_alarm(path):\n",
    "\t# play an alarm sound\n",
    "\tplaysound.playsound('./drowsiness-detection')\n",
    "\n",
    "def eye_aspect_ratio(eye):\n",
    "    # compute the euclidean distances between the two sets of\n",
    "    # vertical eye landmarks (x, y)-coordinates\n",
    "    A = dist.euclidean(eye[1], eye[5])\n",
    "    B = dist.euclidean(eye[2], eye[4])\n",
    "\n",
    "    # compute the euclidean distance between the horizontal\n",
    "    # eye landmark (x, y)-coordinates\n",
    "    C = dist.euclidean(eye[0], eye[3])\n",
    "\n",
    "    # compute the eye aspect ratio\n",
    "    ear = (A + B) / (2.0 * C)\n",
    "\n",
    "    # return the eye aspect ratio\n",
    "    return ear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] loading facial landmark predictor...\n"
     ]
    }
   ],
   "source": [
    "# construct the argument parse and parse the arguments\n",
    "#ap = argparse.ArgumentParser()\n",
    "#ap.add_argument(\"-p\", \"--shape-predictor\", required=True, help=\"C:/Users/kcsstore.com/CVND_Exercises/drowsiness-detection\")\n",
    "#.add_argument(\"-a\", \"--alarm\", type=str, default=\"\", help=\"C:/Users/kcsstore.com/CVND_Exercises/drowsiness-detection\")\n",
    "#ap.add_argument(\"-w\", \"--webcam\", type=int, default=0, help=\"27\") \n",
    "#args = vars(ap.parse_args())\n",
    " \n",
    "# define two constants, one for the eye aspect ratio to indicate\n",
    "# blink and then a second constant for the number of consecutive\n",
    "# frames the eye must be below the threshold for to set off the\n",
    "# alarm\n",
    "EYE_AR_THRESH = 0.3\n",
    "EYE_AR_CONSEC_FRAMES = 48\n",
    "\n",
    "# initialize the frame counter as well as a boolean used to\n",
    "# indicate if the alarm is going off\n",
    "COUNTER = 0\n",
    "ALARM_ON = False\n",
    "\n",
    "# initialize dlib's face detector (HOG-based) and then create\n",
    "# the facial landmark predictor\n",
    "print(\"[INFO] loading facial landmark predictor...\")\n",
    "detector = dlib.get_frontal_face_detector()\n",
    "predictor = dlib.shape_predictor('drowsiness-detection.dat')\n",
    "\n",
    "# grab the indexes of the facial landmarks for the left and\n",
    "# right eye, respectively\n",
    "(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS[\"left_eye\"]\n",
    "(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS[\"right_eye\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] starting video stream thread...\n"
     ]
    }
   ],
   "source": [
    "# start the video stream thread\n",
    "print(\"[INFO] starting video stream thread...\")\n",
    "#args = vars(ap.parse_args())\n",
    "vs = VideoStream().start()\n",
    "time.sleep(1.0)\n",
    "\n",
    "# loop over frames from the video stream\n",
    "while True:\n",
    "\t# grab the frame from the threaded video file stream, resize\n",
    "\t# it, and convert it to grayscale\n",
    "\t# channels)\n",
    "\tframe = vs.read()\n",
    "\tframe = imutils.resize(frame, width=450)\n",
    "\tgray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "\t# detect faces in the grayscale frame\n",
    "\trects = detector(gray, 0)\n",
    "\n",
    "\t# loop over the face detections\n",
    "\tfor rect in rects:\n",
    "\t\t# determine the facial landmarks for the face region, then\n",
    "\t\t# convert the facial landmark (x, y)-coordinates to a NumPy\n",
    "\t\t# array\n",
    "\t\tshape = predictor(gray, rect)\n",
    "\t\tshape = face_utils.shape_to_np(shape)\n",
    "\n",
    "\t\t# extract the left and right eye coordinates, then use the\n",
    "\t\t# coordinates to compute the eye aspect ratio for both eyes\n",
    "\t\tleftEye = shape[lStart:lEnd]\n",
    "\t\trightEye = shape[rStart:rEnd]\n",
    "\t\tleftEAR = eye_aspect_ratio(leftEye)\n",
    "\t\trightEAR = eye_aspect_ratio(rightEye)\n",
    "\n",
    "\t\t# average the eye aspect ratio together for both eyes\n",
    "\t\tear = (leftEAR + rightEAR) / 2.0\n",
    "\n",
    "\t\t# compute the convex hull for the left and right eye, then\n",
    "\t\t# visualize each of the eyes\n",
    "\t\tleftEyeHull = cv2.convexHull(leftEye)\n",
    "\t\trightEyeHull = cv2.convexHull(rightEye)\n",
    "\t\tcv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)\n",
    "\t\tcv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)\n",
    "\n",
    "\t\t# check to see if the eye aspect ratio is below the blink\n",
    "\t\t# threshold, and if so, increment the blink frame counter\n",
    "\t\tif ear < EYE_AR_THRESH:\n",
    "\t\t\tCOUNTER += 1\n",
    "\n",
    "\t\t\t# if the eyes were closed for a sufficient number of\n",
    "\t\t\t# then sound the alarm\n",
    "\t\t\tif COUNTER >= EYE_AR_CONSEC_FRAMES:\n",
    "\t\t\t\t# if the alarm is not on, turn it on\n",
    "\t\t\t\tif not ALARM_ON:\n",
    "\t\t\t\t\tALARM_ON = True\n",
    "\n",
    "\t\t\t\t\t# check to see if an alarm file was supplied,\n",
    "\t\t\t\t\t# and if so, start a thread to have the alarm\n",
    "\t\t\t\t\t# sound played in the background\n",
    "\t\t\t\t\t#if args[\"alarm\"] != \"\":\n",
    "\t\t\t\t\t#t = Thread(target=sound_alarm,args=('alarm.wav'))\n",
    "\t\t\t\t\t#t.deamon = True\n",
    "\t\t\t\t\t#t.start()\n",
    "\t\t\t\t\tfrom playsound import playsound\n",
    "\t\t\t\t\tplaysound('alarm.wav')\n",
    "                        # draw an alarm on the frame\n",
    "\t\t\t\tcv2.putText(frame, \"DROWSINESS ALERT!\", (10, 30),\n",
    "\t\t\t\t\tcv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)\n",
    "\n",
    "\t\t# otherwise, the eye aspect ratio is not below the blink\n",
    "\t\t# threshold, so reset the counter and alarm\n",
    "\t\telse:\n",
    "\t\t\tCOUNTER = 0\n",
    "\t\t\tALARM_ON = False\n",
    "\n",
    "\t\t# draw the computed eye aspect ratio on the frame to help\n",
    "\t\t# with debugging and setting the correct eye aspect ratio\n",
    "\t\t# thresholds and frame counters\n",
    "\t\tcv2.putText(frame, \"EAR: {:.2f}\".format(ear), (300, 30),\n",
    "\t\t\tcv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)\n",
    " \n",
    "\t# show the frame\n",
    "\tcv2.imshow(\"Frame\", frame)\n",
    "\tkey = cv2.waitKey(1) & 0xFF\n",
    " \n",
    "\t# if the `q` key was pressed, break from the loop\n",
    "\tif key == ord(\"q\"):\n",
    "\t\tbreak\n",
    "\n",
    "# do a bit of cleanup\n",
    "cv2.destroyAllWindows()\n",
    "vs.stop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}