realTimeMaskDetectionModel11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><font size=4> Mask Detection from  Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the necessary packages\n",
    "from tensorflow.keras.applications.mobilenet_v2 import preprocess_input\n",
    "from tensorflow.keras.preprocessing.image import img_to_array\n",
    "from tensorflow.keras.models import load_model\n",
    "from imutils import paths\n",
    "import numpy as np\n",
    "import cv2\n",
    "import os\n",
    "from overLay.overLap import drawEmoji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load model & test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "CONF = .5\n",
    "imagePaths = list(paths.list_images(\"images\"))\n",
    "prototxtPath = r'faceDetector/deploy.prototxt'\n",
    "weightsPath = r'faceDetector/res10_300x300_ssd_iter_140000.caffemodel'\n",
    "faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)\n",
    "\n",
    "model = load_model(r'models/maskDetector11.model') # our trained model in root directory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " pre-process image & Check our detections result Funtion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def detect(image):\n",
    "#     image = cv2.imread(imagePaths[4]) # we are just testing 1st image \n",
    "    \n",
    "    withMaskColor, withoutMaskColor  = (0, 255, 0), (0, 0, 255)\n",
    "    font = cv2.FONT_HERSHEY_SIMPLEX\n",
    "\n",
    "    cpyImg = image.copy()\n",
    "    (h, w, _)= image.shape\n",
    "\n",
    "    #blob for image (image, scale, resize, location of face)\n",
    "    blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), (104.0, 177.0, 123.0 ))\n",
    "    faceNet.setInput(blob)\n",
    "    detections = faceNet.forward()\n",
    "\n",
    "\n",
    "    for i in range(0, detections.shape[2]):\n",
    "        confidence = detections[0, 0, i, 2]\n",
    "\n",
    "        if confidence > CONF:\n",
    "            #bounding box\n",
    "            bbox = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\n",
    "            (startX, startY, endX, endY) = bbox.astype(\"int\")\n",
    "\n",
    "            #ensure bounding box within dimensions of frame\n",
    "            (startX, startY)= (max(0, startX), max(0, startY))\n",
    "            (endX, endY) = (min(w-1, endX), min(h-1, endY))\n",
    "\n",
    "            #process to feed into model\n",
    "            face = image[startY: endY, startX: endX]\n",
    "            face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)\n",
    "            face = cv2.resize(face, (244,244))\n",
    "            face = img_to_array(face)\n",
    "            face = preprocess_input(face)\n",
    "            face = np.expand_dims(face, axis=0)\n",
    "\n",
    "            (mask, withoutMash) = model.predict(face)[0]\n",
    "\n",
    "            # display result\n",
    "\n",
    "            label = \"Mask\" if mask> withoutMash else \"No Mask\"\n",
    "            color = withMaskColor if label==\"Mask\" else withoutMaskColor\n",
    "\n",
    "            #adding accouricy\n",
    "            label = \"{}: {:.2f}%\".format(label, max(mask, withoutMash) * 100)\n",
    "\n",
    "            #display label along with rectangle\n",
    "            cv2.putText(image, label, (startX, startY-10), font, .5, color, 2)\n",
    "            cv2.rectangle(image, (startX, startY), (endX, endY), color, 2)\n",
    "            \n",
    "            # emoji Draw based on mask\n",
    "            if mask> withoutMash:\n",
    "                mode = True\n",
    "            else:\n",
    "                mode = False\n",
    "            drawEmoji(image, mode)\n",
    "    \n",
    "    return image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam = cv2.VideoCapture(0)\n",
    "\n",
    "writer = None\n",
    "saveLocally= True\n",
    "while True:\n",
    "    s, frame = cam.read()\n",
    "    \n",
    "    if not s:\n",
    "        break\n",
    "\n",
    "    frame = detect(frame)\n",
    "    cv2.imshow(\"Mask Detectot\", frame)\n",
    "    key = cv2.waitKey(10) & 0xFF\n",
    "    if key == ord(\"q\"):\n",
    "        break\n",
    "    #init save file\n",
    "    if saveLocally and writer is None:\n",
    "#         print(size)\n",
    "        fourcc =cv2.VideoWriter_fourcc(*\"MJPG\")\n",
    "        writer = cv2.VideoWriter('output.avi', fourcc, 20, (frame.shape[1], frame.shape[0]), True) \n",
    "    \n",
    "    if writer is not None:\n",
    "        writer.write(frame)\n",
    "writer.release()  \n",
    "cam.release()        \n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## we cant detect forground Image becasue \n",
    "It’s too obscured by the mask\n",
    "The dataset used to train the face detector did not contain example images of people wearing face masks\n",
    "## check on reltime Mask Detection "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}