3_Aplicacion_del_Modelo_Final_con_la_CamaraWeb.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "3_Aplicacion_del_Modelo_Final_con_la_CamaraWeb.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/BrunoBustos96/DeteccionSomnolenciaCNN/blob/main/3_Aplicacion_del_Modelo_Final_con_la_CamaraWeb.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Implementación del modelo con la Cámara Web**\n",
        "\n",
        "* Se accede a la webcam\n",
        "* Se implementa la función `eye_cropper` para optimizar cada imagen suelta para el modelo\n",
        "* Pasar el fotograma recortado del ojo por el modelo para predecir si está cerrado o no\n",
        "* Si la predicción da que el sujeto está cerrando los ojos durante más de un determinado número de fotogramas, entonces lo alerta con un sonido"
      ],
      "metadata": {
        "id": "uoT2ZLj_oCqd"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RG0KvHJwEW8o"
      },
      "outputs": [],
      "source": [
        "# Para la inicialización de la cámara y la visión por computador\n",
        "import cv2\n",
        "# Librería que define tipos de datos representadas como matrices multidimensionales\n",
        "import numpy as np\n",
        "# playsound ejecuta sonidos de alerta\n",
        "from playsound import playsound\n",
        "#PIL permite la edicion de imágenes desde Python\n",
        "#Image provee funciones para cargar imagenes desde archivos\n",
        "#ImageDraw provee funcionalidades de graficos en 2D en objetos de Image, creando nuevas imagenes, retoque y anotación de imagenes\n",
        "from PIL import Image, ImageDraw\n",
        "#El modulo \"face_recognition\" es necesario para la detección y reconocimiento de rostros\n",
        "import face_recognition\n",
        "#Importar la biblioteca Keras para el trabajo de DeepLearning que puede funcionar sobre TensorFlow\n",
        "from tensorflow import keras\n",
        "#Serial: Conexión con el serial del arduino\n",
        "import serial\n",
        "\n",
        "#Abrimos el puerto serial del Arduino\n",
        "arduino = serial.Serial(\"COM4\", 9600)\n",
        "\n",
        "#Nos aseguramos de especificar la ruta del mejor modelo que hemos obtenido\n",
        "eye_model = keras.models.load_model('best_model5.h5')\n",
        "\n",
        "def eye_cropper(frame):\n",
        "\n",
        "    #Crear una variable para las coordenadas de los rasgos faciales\n",
        "    facial_features_list = face_recognition.face_landmarks(frame)\n",
        "\n",
        "    # Se crea un array para marcar la posición de las coordenadas de los ojos\n",
        "    # y añadimos las coordenadas de los ojos que no hayan sido encontrados\n",
        "    try:\n",
        "        eye = facial_features_list[0]['left_eye']\n",
        "    except:\n",
        "        try:\n",
        "            eye = facial_features_list[0]['right_eye']\n",
        "        except:\n",
        "            return\n",
        "\n",
        "\n",
        "\n",
        "    # Establecemos las coordenadas X y Y maximas de los ojos\n",
        "    x_max = max([coordinate[0] for coordinate in eye])\n",
        "    x_min = min([coordinate[0] for coordinate in eye])\n",
        "    y_max = max([coordinate[1] for coordinate in eye])\n",
        "    y_min = min([coordinate[1] for coordinate in eye])\n",
        "\n",
        "\n",
        "    # Establecemos el rango de las coordenadas X y Y\n",
        "    x_range = x_max - x_min\n",
        "    y_range = y_max - y_min\n",
        "\n",
        "    # Para asegurar que el ojo entero es capturado, calcular las coordenadas de un cuadrado que tenga\n",
        "    # 50% de brecha al eje mayor y hacerlo coincidir el rango menor con el rango mayor\n",
        "    if x_range > y_range:\n",
        "        right = round(.5*x_range) + x_max\n",
        "        left = x_min - round(.5*x_range)\n",
        "        bottom = round((((right-left) - y_range))/2) + y_max\n",
        "        top = y_min - round((((right-left) - y_range))/2)\n",
        "    else:\n",
        "        bottom = round(.5*y_range) + y_max\n",
        "        top = y_min - round(.5*y_range)\n",
        "        right = round((((bottom-top) - x_range))/2) + x_max\n",
        "        left = x_min - round((((bottom-top) - x_range))/2)\n",
        "\n",
        "\n",
        "    #Recortamos la imagen de acuerdo a las coordenadas determinadas anteriormente\n",
        "    cropped = frame[top:(bottom + 1), left:(right + 1)]\n",
        "\n",
        "    # Redimensionamos la imagen\n",
        "    cropped = cv2.resize(cropped, (80,80))\n",
        "    image_for_prediction = cropped.reshape(-1, 80, 80, 3)\n",
        "\n",
        "    return image_for_prediction\n",
        "\n",
        "\n",
        "# Iniciamos la Webcam\n",
        "cap = cv2.VideoCapture(0)\n",
        "w = cap.get(cv2.CAP_PROP_FRAME_WIDTH)\n",
        "h = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)\n",
        "print(cap.get(cv2.CAP_PROP_FPS))\n",
        "\n",
        "if not cap.isOpened():\n",
        "    raise IOError('No se pudo abrir la webcam')\n",
        "\n",
        "# Establecemos un contador\n",
        "counter = 0\n",
        "\n",
        "# Crear un bucle while que se ejecuta mientras la cámara esta en uso\n",
        "\n",
        "while True:\n",
        "\n",
        "    # Capturamos los fotogramas que son emitidos por la cámara\n",
        "    ret, frame = cap.read()\n",
        "\n",
        "    # Utilizamos cada dos fotogramas para gestionar la velocidad y el uso de la memoria\n",
        "    frame_count = 0\n",
        "    if frame_count == 0:\n",
        "        frame_count += 1\n",
        "        pass\n",
        "    else:\n",
        "        count = 0\n",
        "        continue\n",
        "\n",
        "    # Mandamos el frame a la función eye_cropper que nos retornará una imagen recortada para hacer la predicción\n",
        "    image_for_prediction = eye_cropper(frame)\n",
        "    try:\n",
        "        image_for_prediction = image_for_prediction / 255.0\n",
        "    except:\n",
        "        continue\n",
        "\n",
        "    # Obtenemos la predicción del modelo\n",
        "    prediction = eye_model.predict(image_for_prediction)\n",
        "\n",
        "    #Basado en la predicción, mostrar si es \"Ojos Abiertos\" u \"Ojos Cerrados\"\n",
        "    if prediction < 0.5:\n",
        "        counter = 0\n",
        "        status = 'Abiertos'\n",
        "\n",
        "        # Creamos un rectángulo\n",
        "        cv2.rectangle(frame, (round(w / 2) - 110, 20), (round(w / 2) + 180, 80), (38, 38, 38), -1)\n",
        "        cv2.putText(frame, status, (round(w / 2) - 104, 70), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 255, 0), 2, cv2.LINE_4)\n",
        "        x1, y1, w1, h1 = 0, 0, 225, 75\n",
        "        # Dibujamos rectangulos de fondo negro\n",
        "        cv2.rectangle(frame, (x1, x1), (x1 + w1 - 20, y1 + h1 - 20), (0, 0, 0), -1)\n",
        "        # Añadimos texto\n",
        "        cv2.putText(frame, 'ActivO', (x1 + int(w1 / 10), y1 + int(h1 / 2)), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0),\n",
        "                    2)\n",
        "    else:\n",
        "        counter = counter + 1\n",
        "        status = 'Cerrados'\n",
        "\n",
        "        cv2.rectangle(frame, (round(w / 2) - 110, 20), (round(w / 2) + 180, 80), (38, 38, 38), -1)\n",
        "\n",
        "        cv2.putText(frame, status, (round(w / 2) - 104, 70), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2, cv2.LINE_4)\n",
        "        x1, y1, w1, h1 = 0, 0, 225, 75\n",
        "        # Dibujamos rectangulos de fondo negro\n",
        "        cv2.rectangle(frame, (x1, x1), (x1 + w1 - 20, y1 + h1 - 20), (0, 0, 0), -1)\n",
        "        # Añadimos texto\n",
        "        cv2.putText(frame, 'Activo', (x1 + int(w1 / 10), y1 + int(h1 / 2)), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0),\n",
        "                    2)\n",
        "        #_|arduino.write(b'N')  # b un bit\n",
        "\n",
        "        # Si el contador es más que 3, reproducimos y mostramos la alerta de que el usuario se está durmiendo\n",
        "        if counter > 3:\n",
        "            x1, y1, w1, h1 = 400, 400, 400, 100\n",
        "\n",
        "            cv2.rectangle(frame, (round(w / 2) - 160, round(h) - 200), (round(w / 2) + 160, round(h) - 120),\n",
        "                          (0, 0, 255), -1)\n",
        "\n",
        "            cv2.putText(frame, 'No te duermas!', (round(w / 2) - 136, round(h) - 146), cv2.FONT_HERSHEY_SIMPLEX, 1,\n",
        "                        (0, 0, 0), 2, cv2.LINE_4)\n",
        "\n",
        "            cv2.imshow('Drowsiness detection', frame)\n",
        "            # Viendo si se presiona la letra k por teclado para detener la ejecución\n",
        "            k = cv2.waitKey(1)\n",
        "            #Sonido de alerta\n",
        "            playsound(r'D:\\SEMESTRE 1-2022\\Visión Artificial\\PROYECTO\\audios\\Despierta1231256.mp3')\n",
        "            arduino.write(b'R')  # b un bit\n",
        "            counter = 1\n",
        "            continue\n",
        "    cv2.imshow('Drowsiness detection', frame)\n",
        "    k = cv2.waitKey(1)\n",
        "    if k == 27:\n",
        "        break\n",
        "cap.release()\n",
        "cv2.destroyAllWindows()"
      ]
    }
  ]
}