ML_12_Camera.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.4.2'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv2.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Capture Image\n",
    "\n",
    "webcam = cv2.VideoCapture(0)   #parameter passed is index of camera used\n",
    "ret, frame = webcam.read()\n",
    "print(ret)\n",
    "webcam.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open Image in a new Window\n",
    "\n",
    "cv2.namedWindow('opencv_1',cv2.WINDOW_NORMAL)\n",
    "cv2.imshow('opencv_1', frame)\n",
    "cv2.waitKey(10)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x121030588>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(frame, cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write image to storage drive\n",
    "cv2.imwrite('Screen Shot 2018-06-23 at 08.51.28.png', frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "picture_BGR = cv2.imread('Screen Shot 2018-06-23 at 08.51.28.png',0)   # 0 for gray scale\n",
    "cv2.imshow('gray scale',picture_BGR)\n",
    "cv2.waitKey(10)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#To capture video\n",
    "webcamm = cv2.VideoCapture(0)\n",
    "cv2.namedWindow('open_cv_1', cv2.WINDOW_AUTOSIZE)\n",
    "\n",
    "while True:\n",
    "    ret, frame = webcamm.read()\n",
    "    cv2.imshow('open_cv_1',frame)\n",
    "    \n",
    "    #press q for closing window\n",
    "    # here 10 is millisecond\n",
    "    if cv2.waitKey(10)==ord('q'):\n",
    "        break\n",
    "webcamm.release()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#face Detection\n",
    "\n",
    "faceDetect = cv2.CascadeClassifier('xml/frontalface_alt.xml')   #frontalFace is inbuilt defined algo for detecting face\n",
    "cam = cv2.VideoCapture(0)\n",
    "\n",
    "cv2.namedWindow('Face', cv2.WINDOW_AUTOSIZE)\n",
    "\n",
    "while True:\n",
    "    ret, img = cam.read()\n",
    "    gray = cv2.cvtColor(img, cv2.COLOR_BGRA2GRAY)\n",
    "    faces = faceDetect.detectMultiScale(gray, scaleFactor=1.1,minNeighbors=3)\n",
    "    \n",
    "    for (x,y,w,h) in faces:\n",
    "        cv2.rectangle(img,(x,y),(x+w,y+h),(0,0,255),2)\n",
    "        \n",
    "    cv2.imshow('Face',img)\n",
    "    if cv2.waitKey(10)==ord('q'):\n",
    "        break\n",
    "        \n",
    "cam.release()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- scaleFactor - Parameter specifying how much the image size is reduced at each image scale.\n",
    "\n",
    "- min_neighbors - Parameter specifying how much neighbors each candidate rectangle should have to retain it.\n",
    "\n",
    "- minSize - Minimum possible object size. Objects smaller than that are ignored.\n",
    "\n",
    "- maxSize - maximum possible object isze. Objects larger than that are ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build Dataset to store detected faces\n",
    "#Steps - Detect -> Cut -> Normalize -> Resize -> Save\n",
    "\n",
    "#1 Detect Face \n",
    "def detect_face(frame):\n",
    "    detector = cv2.CascadeClassifier('xml/frontalface_alt.xml')\n",
    "    \n",
    "    faces = detector.detectMultiScale(frame, scaleFactor=1.3, minNeighbors=3)\n",
    "    \n",
    "    return faces\n",
    "\n",
    "#2 Cut Faces\n",
    "def cut_faces(image, face_coord):\n",
    "    faces = []\n",
    "    \n",
    "    for (x,y,w,h) in face_coord:\n",
    "        \n",
    "        faces.append(image[y : y+h, x : x+w])\n",
    "        \n",
    "    return faces\n",
    "\n",
    "#3 normalize faces bu\\y increasing pixel intensity(brightness)\n",
    "def normalize_intensity(images):\n",
    "    images_norm = []\n",
    "    for image in images:\n",
    "        is_color = len(image.shape) == 3\n",
    "        if is_color:\n",
    "            image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "        images_norm.append(cv2.equalizeHist(image))  #equalizeHist increases the brightness of image\n",
    "    return images_norm\n",
    "\n",
    "#4 Resize face\n",
    "# cv.INTER_AREA for shrinking & cv.INTER_CUBIC for zooming\n",
    "\n",
    "def resize_face(images, size = (47,62)):\n",
    "    image_resize = []\n",
    "    \n",
    "    for image in images:\n",
    "        if image.shape < size:\n",
    "            img_size = cv2.resize(image,size,interpolation=cv2.INTER_CUBIC)\n",
    "        else:\n",
    "            img_size = cv2.resize(image, size, interpolation=cv2.INTER_AREA)\n",
    "        image_resize.append(img_size)\n",
    "        \n",
    "    return image_resize\n",
    "\n",
    "# make pipeline \n",
    "def normalize_faces(frame, faces_coords):\n",
    "    faces = cut_faces(frame, faces_coords)\n",
    "    faces = normalize_intensity(faces)\n",
    "    \n",
    "    faces = resize_face(faces)\n",
    "    return faces\n",
    "\n",
    "#plot images\n",
    "def plot_show(image,title=''):\n",
    "    if len(image.shape)==3:\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "        \n",
    "    plt.axis('off')\n",
    "    plt.title(title)\n",
    "    plt.imshow(image, cmap='Greys_r')\n",
    "    plt.show\n",
    "    \n",
    "#Draw Rectangle for detected faces\n",
    "def draw_rectangle(image, coords):\n",
    "    for (x,y,w,h) in coords:\n",
    "        cv2.rectangle(image, (x,y), (x+w, y+h), (0,0,255), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "from IPython.display import clear_output\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "cam = cv2.VideoCapture(0)\n",
    "\n",
    "folder = 'people/'+input('Person:').lower()\n",
    "\n",
    "if not os.path.exists(folder):\n",
    "    os.mkdir(folder)\n",
    "    \n",
    "    flag_start_capturing = False\n",
    "    sample = 1\n",
    "    cv2.namedWindow('Face', cv2.WINDOW_AUTOSIZE)\n",
    "    \n",
    "    while True:\n",
    "        ret, frame = cam.read()\n",
    "        \n",
    "        \n",
    "        face_coord = detect_face(frame)\n",
    "        \n",
    "        if len(face_coord):\n",
    "            faces = normalize_faces(frame, face_coord)\n",
    "            cv2.imwrite(folder+'/'+str(sample)+'.jpg', faces[0])\n",
    "            plot_show(faces[0], 'Image Saved:'+str(sample))\n",
    "            clear_output(wait=True)\n",
    "            \n",
    "        if flag_start_capturing==True:\n",
    "            sample+=1\n",
    "            \n",
    "        draw_rectangle(frame, face_coord)\n",
    "        cv2.imshow('Face', frame)\n",
    "        keypress = cv2.waitKey(1)\n",
    "        \n",
    "        if keypress == ord('c'):\n",
    "            \n",
    "            if flag_start_capturing==False:\n",
    "                flag_start_capturing = True\n",
    "                \n",
    "        if sample == 200:\n",
    "            break\n",
    "            \n",
    "    cam.release()\n",
    "    cv2.destroyAllWindows()\n",
    "else:\n",
    "    print('This name already exists.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1882\n"
     ]
    }
   ],
   "source": [
    "basepath = '/Users/lalg/scikit_learn_data/lfw_home/lfw_funneled'\n",
    "images = os.listdir(basepath)\n",
    "print(len(images))\n",
    "data = images[:210]\n",
    "for i, folder in enumerate(data, start=1):\n",
    "    files = os.listdir(basepath+'/'+folder)\n",
    "    for k, img in enumerate(files, start=1):\n",
    "        if img.endswith('.jpg'):\n",
    "            frame=cv2.imread(basepath+'/'+folder+'/'+img,0)\n",
    "            \n",
    "            faces_coord = detect_face(frame)\n",
    "            if len(faces_coord):\n",
    "                faces = cut_faces(frame, faces_coord)\n",
    "                faces = normalize_intensity(faces)\n",
    "                faces = resize_face(faces)\n",
    "                cv2.imwrite('people/unknown/'+str(i)+'.jpg',faces[0])\n",
    "                \n",
    "                break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#collect dataset\n",
    "def collect_dataset():\n",
    "    images = []\n",
    "    labels = []\n",
    "    labels_dic = {}\n",
    "    people = [person for person in os.listdir('people/')]\n",
    "    #print(type(images))\n",
    "    for i, person in enumerate(people):\n",
    "        labels_dic[i] = person\n",
    "        for image in os.listdir('people/'+person):\n",
    "            if image.endswith('.jpg'):\n",
    "                images.append(cv2.imread('people/'+person+'/'+image,0))\n",
    "                #print(len(images))\n",
    "                labels.append(i)\n",
    "    return (images, np.array(labels), labels_dic)\n",
    "\n",
    "# def collect_dataset():\n",
    "#     images = []\n",
    "#     labels = []\n",
    "#     labels_dic = {}\n",
    "#     #people = [person for person in os.listdir(\"Male_female/\")]\n",
    "#     people = [person for person in os.listdir(\"people/\")]\n",
    "#     #people = [person for person in os.listdir(\"people/\")]\n",
    "#     for i, person in enumerate(people):\n",
    "#         labels_dic[i] = person\n",
    "#         for image in os.listdir(\"people/\" + person):\n",
    "#             if image.endswith('.jpg'):\n",
    "#                 images.append(cv2.imread(\"people/\" + person + '/' + image, 0))\n",
    "#                 labels.append(i)\n",
    "#     return (images, np.array(labels), labels_dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1] {0: 'ravi', 1: 'unknown'}\n"
     ]
    }
   ],
   "source": [
    "images, labels, labels_dic = collect_dataset()\n",
    "print(np.array(labels), labels_dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "401\n"
     ]
    }
   ],
   "source": [
    "print(len(images))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(401, 2914)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train = np.asarray(images)\n",
    "X_train.shape\n",
    "train = X_train.reshape(len(X_train), -1)\n",
    "X_train.shape\n",
    "train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Cummulative Explained Variance')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "pca1 = PCA()\n",
    "pca1.fit(train)\n",
    "plt.plot(np.cumsum(pca1.explained_variance_ratio_))\n",
    "plt.xlabel('Number of components')\n",
    "plt.ylabel('Cummulative Explained Variance')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "pca = PCA(n_components=0.99)\n",
    "new_train = pca.fit_transform(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import GridSearchCV, KFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_grid = {'C':[.0001,.001,.01,.1,1,10]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "kf = KFold(n_splits=5, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_svc = GridSearchCV(SVC(kernel='linear', probability=True), param_grid=param_grid,cv=kf, scoring='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=KFold(n_splits=5, random_state=None, shuffle=True),\n",
       "       error_score='raise',\n",
       "       estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='linear',\n",
       "  max_iter=-1, probability=True, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False),\n",
       "       fit_params=None, iid=True, n_jobs=1,\n",
       "       param_grid={'C': [0.0001, 0.001, 0.01, 0.1, 1, 10]},\n",
       "       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n",
       "       scoring='accuracy', verbose=0)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_svc.fit(new_train, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_svc.best_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'C': 0.0001}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_svc.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sklearn.svm.classes.SVC"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc1 = gs_svc.best_estimator_\n",
    "type(svc1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "filename = 'svc_face.pkl'\n",
    "f = open(filename, 'wb')\n",
    "pickle.dump(svc1, f)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "svc1 = pickle.load(open(filename, 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[-0.97559773]\n",
      "[[0.98225322 0.01774678]]\n",
      "[0] 0\n",
      "Ravi [[0.98225322 0.01774678]]\n"
     ]
    }
   ],
   "source": [
    "cam = cv2.VideoCapture(0)\n",
    "font=cv2.FONT_HERSHEY_PLAIN\n",
    "cv2.namedWindow(\"opencv_face\", cv2.WINDOW_AUTOSIZE)\n",
    "\n",
    "\n",
    "\n",
    "while True:\n",
    "    ret,frame = cam.read()\n",
    "    print(type(frame))\n",
    "    \n",
    "    \n",
    "    faces_coord = detect_face(frame) # detect more than one face\n",
    "    if len(faces_coord):\n",
    "        faces = normalize_faces(frame, faces_coord)\n",
    "        #faces = normalize_intensity(faces)\n",
    "        for i, face in enumerate(faces): # for each detected face\n",
    "            \n",
    "            \n",
    "            #cv2.imwrite('trainingData/female/picture_BGR5.jpg',face)\n",
    "            test = pca.transform(face.reshape(1,-1))    \n",
    "            #print test\n",
    "            #transform = test.reshape(1,-1)\n",
    "            #print transform\n",
    "            prob=svc1.predict_proba(test)\n",
    "            confidence = svc1.decision_function(test)\n",
    "            print (confidence)\n",
    "            print (prob)\n",
    "           \n",
    "            \n",
    "            \n",
    "            pred = svc1.predict(test)\n",
    "            print (pred,pred[0])\n",
    "           \n",
    "            name=labels_dic[pred[0]].capitalize()\n",
    "            print (name, prob)\n",
    "            \n",
    "            #pred = labels_dic[pred[0]].capitalize()\n",
    "            #threshold = .50\n",
    "            #print()\n",
    "            if prob[0][1]>.40:\n",
    "                \n",
    "                cv2.putText(frame, name,(faces_coord[i][0], faces_coord[i][1] - 10),\n",
    "                            cv2.FONT_HERSHEY_PLAIN, 2, (66, 53, 243), 2)\n",
    "            \n",
    "                \n",
    "            elif prob[0][1]>.50:\n",
    "                cv2.putText(frame,'unknown',(faces_coord[i][0], faces_coord[i][1] - 10),\n",
    "                            cv2.FONT_HERSHEY_PLAIN, 3, (66, 53, 243), 2)\n",
    "                \n",
    "                \n",
    "            #cv2.putText(frame,name,(x,y-10),font,2,(0,0,255),2,cv2.LINE_AA)\n",
    "            \n",
    "               \n",
    "           #cv2.putText(frame,'Unknown',(x,y-10),font,2,(0,0,255),2,cv2.LINE_AA)\n",
    "        clear_output(wait = True)\n",
    "        draw_rectangle(frame, faces_coord) # rectangle around face\n",
    "        \n",
    "    cv2.putText(frame, \"a to exit\", (5, frame.shape[0] - 5),cv2.FONT_HERSHEY_PLAIN, 1.3, (66, 53, 243), 2,\n",
    "                cv2.LINE_AA)\n",
    "    \n",
    "    cv2.imshow(\"opencv_face\", frame) # live feed in external\n",
    "    if cv2.waitKey(5) == 97:\n",
    "        break\n",
    "        \n",
    "cam.release()\n",
    "cv2.destroyAllWindows()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam.release()"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}