drowsiness_detector.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import imutils\n",
    "import time\n",
    "import timeit\n",
    "import dlib\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\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",
    "from threading import Timer\n",
    "from check_cam_fps import check_fps\n",
    "import make_train_data as mtd\n",
    "import light_remover as lr\n",
    "import ringing_alarm as alarm\n",
    "\n",
    "def eye_aspect_ratio(eye) :\n",
    "    A = dist.euclidean(eye[1], eye[5])\n",
    "    B = dist.euclidean(eye[2], eye[4])\n",
    "    C = dist.euclidean(eye[0], eye[3])\n",
    "    ear = (A + B) / (2.0 * C)\n",
    "    return ear\n",
    "    \n",
    "def init_open_ear() :\n",
    "    time.sleep(5)\n",
    "    print(\"open init time sleep\")\n",
    "    ear_list = []\n",
    "    th_message1 = Thread(target = init_message)\n",
    "    th_message1.deamon = True\n",
    "    th_message1.start()\n",
    "    for i in range(7) :\n",
    "        ear_list.append(both_ear)\n",
    "        time.sleep(1)\n",
    "    global OPEN_EAR\n",
    "    OPEN_EAR = sum(ear_list) / len(ear_list)\n",
    "    #print(\"open list =\", ear_list)\n",
    "    print(\"OPEN_EAR =\", OPEN_EAR, \"\\n\")\n",
    "\n",
    "def init_close_ear() : \n",
    "    time.sleep(2)\n",
    "    th_open.join()\n",
    "    time.sleep(5)\n",
    "    print(\"close init time sleep\")\n",
    "    ear_list = []\n",
    "    th_message2 = Thread(target = init_message)\n",
    "    th_message2.deamon = True\n",
    "    th_message2.start()\n",
    "    time.sleep(1)\n",
    "    for i in range(7) :\n",
    "        ear_list.append(both_ear)\n",
    "        time.sleep(1)\n",
    "    CLOSE_EAR = sum(ear_list) / len(ear_list)\n",
    "    global EAR_THRESH\n",
    "    EAR_THRESH = (((OPEN_EAR - CLOSE_EAR) / 2) + CLOSE_EAR) #EAR_THRESH means 50% of the being opened eyes state\n",
    "    #print(\"close list =\", ear_list)\n",
    "    print(\"CLOSE_EAR =\", CLOSE_EAR, \"\\n\")\n",
    "    print(\"The last EAR_THRESH's value :\",EAR_THRESH, \"\\n\")\n",
    "\n",
    "def init_message() :\n",
    "    print(\"init_message\")\n",
    "    alarm.sound_alarm(\"init_sound.mp3\")\n",
    "\n",
    "#####################################################################################################################\n",
    "#1. Variables for checking EAR.\n",
    "#2. Variables for detecting if user is asleep.\n",
    "#3. When the alarm rings, measure the time eyes are being closed.\n",
    "#4. When the alarm is rang, count the number of times it is rang, and prevent the alarm from ringing continuously.\n",
    "#5. We should count the time eyes are being opened for data labeling.\n",
    "#6. Variables for trained data generation and calculation fps.\n",
    "#7. Detect face & eyes.\n",
    "#8. Run the cam.\n",
    "#9. Threads to run the functions in which determine the EAR_THRESH. \n",
    "\n",
    "#1.\n",
    "OPEN_EAR = 0 #For init_open_ear()\n",
    "EAR_THRESH = 0 #Threashold value\n",
    "\n",
    "#2.\n",
    "#It doesn't matter what you use instead of a consecutive frame to check out drowsiness state. (ex. timer)\n",
    "EAR_CONSEC_FRAMES = 25 \n",
    "COUNTER = 0 #Frames counter.\n",
    "\n",
    "#3.\n",
    "closed_eyes_time = [] #The time eyes were being offed.\n",
    "TIMER_FLAG = False #Flag to activate 'start_closing' variable, which measures the eyes closing time.\n",
    "ALARM_FLAG = False #Flag to check if alarm has ever been triggered.\n",
    "\n",
    "#4. \n",
    "ALARM_COUNT = 0 #Number of times the total alarm rang.\n",
    "RUNNING_TIME = 0 #Variable to prevent alarm going off continuously.\n",
    "\n",
    "#5.    \n",
    "PREV_TERM = 0 #Variable to measure the time eyes were being opened until the alarm rang.\n",
    "\n",
    "#6. make trained data \n",
    "np.random.seed(30)\n",
    "power, nomal, short = mtd.start(25) #actually this three values aren't used now. (if you use this, you can do the plotting)\n",
    "#The array the actual test data is placed.\n",
    "test_data = []\n",
    "#The array the actual labeld data of test data is placed.\n",
    "result_data = []\n",
    "#For calculate fps\n",
    "prev_time = 0\n",
    "\n",
    "#7. \n",
    "print(\"loading facial landmark predictor...\")\n",
    "detector = dlib.get_frontal_face_detector()\n",
    "predictor = dlib.shape_predictor(\"shape_predictor_68_face_landmarks.dat\")\n",
    "\n",
    "(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS[\"left_eye\"]\n",
    "(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS[\"right_eye\"]\n",
    "\n",
    "#8.\n",
    "print(\"starting video stream thread...\")\n",
    "vs = VideoStream(src=0).start()\n",
    "time.sleep(1.0)\n",
    "\n",
    "#9.\n",
    "th_open = Thread(target = init_open_ear)\n",
    "th_open.deamon = True\n",
    "th_open.start()\n",
    "th_close = Thread(target = init_close_ear)\n",
    "th_close.deamon = True\n",
    "th_close.start()\n",
    "\n",
    "#####################################################################################################################\n",
    "\n",
    "while True:\n",
    "    frame = vs.read()\n",
    "    frame = imutils.resize(frame, width = 400)\n",
    "    \n",
    "    L, gray = lr.light_removing(frame)\n",
    "    #gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "    rects = detector(gray,0)\n",
    "    \n",
    "    #checking fps. If you want to check fps, just uncomment below two lines.\n",
    "    #prev_time, fps = check_fps(prev_time)\n",
    "    #cv2.putText(frame, \"fps : {:.2f}\".format(fps), (10,130), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200,30,20), 2)\n",
    "\n",
    "    for rect in rects:\n",
    "        shape = predictor(gray, rect)\n",
    "        shape = face_utils.shape_to_np(shape)\n",
    "\n",
    "        leftEye = shape[lStart:lEnd]\n",
    "        rightEye = shape[rStart:rEnd]\n",
    "        leftEAR = eye_aspect_ratio(leftEye)\n",
    "        rightEAR = eye_aspect_ratio(rightEye)\n",
    "\n",
    "        #(leftEAR + rightEAR) / 2 => both_ear. \n",
    "        both_ear = (leftEAR + rightEAR) * 500  #I multiplied by 1000 to enlarge the scope.\n",
    "\n",
    "        leftEyeHull = cv2.convexHull(leftEye)\n",
    "        rightEyeHull = cv2.convexHull(rightEye)\n",
    "        cv2.drawContours(frame, [leftEyeHull], -1, (0,255,0), 1)\n",
    "        cv2.drawContours(frame, [rightEyeHull], -1, (0,255,0), 1)\n",
    "        \n",
    "\n",
    "        if both_ear < EAR_THRESH :\n",
    "            if not TIMER_FLAG:\n",
    "                start_closing = timeit.default_timer()\n",
    "                TIMER_FLAG = True\n",
    "            COUNTER += 1\n",
    "\n",
    "            if COUNTER >= EAR_CONSEC_FRAMES:\n",
    "\n",
    "                mid_closing = timeit.default_timer()\n",
    "                closing_time = round((mid_closing-start_closing),3)\n",
    "\n",
    "                if closing_time >= RUNNING_TIME:\n",
    "                    if RUNNING_TIME == 0 :\n",
    "                        CUR_TERM = timeit.default_timer()\n",
    "                        OPENED_EYES_TIME = round((CUR_TERM - PREV_TERM),3)\n",
    "                        PREV_TERM = CUR_TERM\n",
    "                        RUNNING_TIME = 1.75\n",
    "\n",
    "                    RUNNING_TIME += 2\n",
    "                    ALARM_FLAG = True\n",
    "                    ALARM_COUNT += 1\n",
    "\n",
    "                    print(\"{0}st ALARM\".format(ALARM_COUNT))\n",
    "                    print(\"The time eyes is being opened before the alarm went off :\", OPENED_EYES_TIME)\n",
    "                    print(\"closing time :\", closing_time)\n",
    "                    test_data.append([OPENED_EYES_TIME, round(closing_time*10,3)])\n",
    "                    result = mtd.run([OPENED_EYES_TIME, closing_time*10], power, nomal, short)\n",
    "                    result_data.append(result)\n",
    "                    t = Thread(target = alarm.select_alarm, args = (result, ))\n",
    "                    t.deamon = True\n",
    "                    t.start()\n",
    "\n",
    "        else :\n",
    "            COUNTER = 0\n",
    "            TIMER_FLAG = False\n",
    "            RUNNING_TIME = 0\n",
    "\n",
    "            if ALARM_FLAG :\n",
    "                end_closing = timeit.default_timer()\n",
    "                closed_eyes_time.append(round((end_closing-start_closing),3))\n",
    "                print(\"The time eyes were being offed :\", closed_eyes_time)\n",
    "\n",
    "            ALARM_FLAG = False\n",
    "\n",
    "        cv2.putText(frame, \"EAR : {:.2f}\".format(both_ear), (300,130), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200,30,20), 2)\n",
    "\n",
    "    cv2.imshow(\"Frame\",frame)\n",
    "    key = cv2.waitKey(1) & 0xFF\n",
    "\n",
    "    if key == ord(\"q\"):\n",
    "        break\n",
    "\n",
    "cv2.destroyAllWindows()\n",
    "vs.stop()\n"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}