Gesture Based Visually Writing System- Codes With DCR.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-09T12:17:47.747902Z",
     "start_time": "2020-08-09T12:17:28.354244Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import imutils\n",
    "import time\n",
    "from dcr.recognition import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-09T12:17:47.757846Z",
     "start_time": "2020-08-09T12:17:47.750864Z"
    }
   },
   "outputs": [],
   "source": [
    "def show(img, figsize=(10, 10)):\n",
    "    figure = plt.figure(figsize=figsize)\n",
    "    plt.imshow(img)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-09T12:30:10.330134Z",
     "start_time": "2020-08-09T12:28:13.722915Z"
    },
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:74: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:517: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:4138: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3976: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:133: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:174: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:181: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:186: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:190: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:199: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:206: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\engine\\saving.py:292: UserWarning: No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "  warnings.warn('No training configuration found in save file: '\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction accuracy for  श  is  99.99 %\n"
     ]
    }
   ],
   "source": [
    "def running_average(bg_img, image, aweight):\n",
    "    if bg_img is None:\n",
    "        bg_img = image.copy().astype(\"float\")\n",
    "    else:\n",
    "        cv2.accumulateWeighted(image, bg_img, aweight)    \n",
    "    return bg_img\n",
    "\n",
    "def get_contours(bg_img, image, threshold=10):\n",
    "    \n",
    "    # abs diff betn img and bg\n",
    "    diff = cv2.absdiff(bg_img.astype(\"uint8\"), image)    \n",
    "    _, th = cv2.threshold(diff, threshold, 255, cv2.THRESH_BINARY)\n",
    "    (cnts, _) = cv2.findContours(th.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    \n",
    "    if len(cnts) == 0:\n",
    "        return None\n",
    "    else:\n",
    "        max_cnt = max(cnts, key=cv2.contourArea)\n",
    "        return th, max_cnt\n",
    "\n",
    "#accumulate weight variable\n",
    "aweight = 0.5\n",
    "# strat the camera\n",
    "cam = cv2.VideoCapture(0)\n",
    "# ROI box\n",
    "top, right, bottom, left = 250, 400, 480, 640\n",
    "# count frame\n",
    "num_frames=0\n",
    "# writing canvas\n",
    "canvas = None\n",
    "# thickness\n",
    "t=3\n",
    "# draw color(ink color)\n",
    "draw_color = (0, 255, 0)\n",
    "# pointer color\n",
    "pointer_color = (255, 0, 0)\n",
    "# mode flag\n",
    "erase = False\n",
    "# flag to indicate take average\n",
    "take_average=True\n",
    "#bg image\n",
    "bg_img=None\n",
    "# loop while everything is true\n",
    "while True:\n",
    "    # read the camera result\n",
    "    (ret, frame) = cam.read()\n",
    "    # if camera has read frame\n",
    "    if ret:\n",
    "        # wait for 1ms to key press\n",
    "        key = cv2.waitKey(1) & 0xFF\n",
    "        frame = imutils.resize(frame, width=700)\n",
    "        # flip to remove mirror effect\n",
    "        frame = cv2.flip(frame, 1)\n",
    "        # clone it to not mess with real frame\n",
    "        clone = frame.copy()\n",
    "        h, w = frame.shape[:2]\n",
    "        # take roi, to send it onto contour/average extraction\n",
    "        roi = frame[top:bottom, right:left]\n",
    "        # roi to grayscale\n",
    "        gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)\n",
    "        # add GaussianBlur to eliminate some noise\n",
    "        gray = cv2.GaussianBlur(gray, (7, 7), 0)\n",
    "        \n",
    "        # if to take average and num frames on average taking is lesser than \n",
    "        if num_frames<100 and take_average==True:\n",
    "            # perform running average\n",
    "            bg_img = running_average(bg_img, gray, aweight)\n",
    "            # put frame number on frame\n",
    "            cv2.putText(clone, str(num_frames), (100, 100),\n",
    "                                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 5)\n",
    "            num_frames+=1\n",
    "        # if not to take average\n",
    "        else:\n",
    "            num_frames=0                        \n",
    "            # take our segmented hand\n",
    "            hand = get_contours(bg_img, gray)\n",
    "            take_average=False\n",
    "            if hand is not None:\n",
    "                \n",
    "                # if pressed x, erase\n",
    "                if chr(key) == \"x\":\n",
    "                    draw_color = (255, 255, 255)\n",
    "                    pointer_color = (0, 0, 255)\n",
    "                    erase = True\n",
    "                if chr(key) == \"c\":\n",
    "                    draw_color = (0, 255, 0)\n",
    "                    pointer_color = (255, 0, 0)\n",
    "                    erase = False\n",
    "                #idle\n",
    "                if chr(key) == \"z\":\n",
    "                    erase = None\n",
    "                    pointer_color = (0, 0, 0)                   \n",
    "                # restart system\n",
    "                if chr(key) == \"r\":\n",
    "                    take_average=True\n",
    "                    canvas = None\n",
    "                if chr(key) == \"e\":\n",
    "                    canvas = None\n",
    "                    drawn = np.zeros(drawn.shape)+255\n",
    "                \n",
    "                \n",
    "                                    \n",
    "                thresholded, segmented = hand\n",
    "                cv2.drawContours(clone, [segmented+(right,top)], -1, (0, 0, 255))   \n",
    "                \n",
    "                tshape = thresholded.shape\n",
    "                sshape = segmented.shape\n",
    "                new_segmented = segmented.reshape(sshape[0], sshape[-1])\n",
    "                m = new_segmented.min(axis=0)\n",
    "                \n",
    "                if type(canvas) == type(None):\n",
    "                    canvas = np.zeros((tshape[0], tshape[1], 3))+255\n",
    "                \n",
    "                c = np.zeros(canvas.shape, dtype=np.uint8)\n",
    "                cv2.circle(c, (m[0], m[1]), 5, pointer_color, -3)\n",
    "                cv2.circle(clone, (right+m[0], top+m[1]), 5, pointer_color, -3)\n",
    "                \n",
    "                if erase==True:\n",
    "                    cv2.circle(canvas, (m[0], m[1]), 5, draw_color, -3)\n",
    "                    erimg=cv2.circle(canvas.copy(), (m[0], m[1]), 5, (0, 0, 0), -3)            \n",
    "                    cv2.circle(c, (m[0], m[1]), 5, (0, 0, 255), -3)\n",
    "                    e = cv2.erode(erimg, (3, 3), iterations=5)\n",
    "                    drawn = cv2.resize(e, (clone.shape[1], clone.shape[0]))\n",
    "                    c = cv2.resize(c, (clone.shape[1], clone.shape[0]))\n",
    "                    drawn_new = drawn+c\n",
    "                    cv2.imshow(\"Drawing\", drawn+c)\n",
    "                    erimg=cv2.circle(canvas.copy(), (m[0], m[1]), 5, (255, 255, 255), -3)            \n",
    "                    cv2.circle(c, (m[0], m[1]), 5, (0, 0, 255), -3)\n",
    "                    e = cv2.erode(erimg, (3, 3), iterations=5)\n",
    "                    drawn = cv2.resize(e, (clone.shape[1], clone.shape[0]))                    \n",
    "                elif erase==False:\n",
    "                    #cv2.imshow(\"Thresholded\", c)\n",
    "                    cv2.circle(canvas, (m[0], m[1]), 5, draw_color, -3)\n",
    "                    e = cv2.erode(canvas, (3, 3), iterations=5)\n",
    "                    drawn = cv2.resize(e, (clone.shape[1], clone.shape[0]))\n",
    "                    c = cv2.resize(c, (clone.shape[1], clone.shape[0]))\n",
    "                    drawn_new = drawn+c\n",
    "                    cv2.imshow(\"Drawing\", drawn+c)\n",
    "                elif erase == None:\n",
    "                    canvas_shape = canvas.shape\n",
    "                    clone_shape = clone.shape\n",
    "                    eshape = (clone_shape[0]/canvas_shape[0], clone_shape[1]/canvas_shape[1])\n",
    "                    m[0] = int(eshape[1]*m[0])\n",
    "                    m[1] = int(eshape[0]*m[1])\n",
    "                    drawn = cv2.resize(drawn, (clone.shape[1], clone.shape[0]))\n",
    "                    dc = drawn.copy()  \n",
    "                    cv2.circle(dc, (m[0], m[1]), 10, pointer_color, -3)\n",
    "                    \n",
    "                    cv2.imshow(\"Drawing\", dc)\n",
    "                \n",
    "        if chr(key) == \"s\":\n",
    "            show(drawn)\n",
    "            d = drawn.copy().astype(np.uint8) \n",
    "            r = recognition(cv2.cvtColor(d, cv2.COLOR_BGR2GRAY), 'show')\n",
    "            cv2.imshow(\"Detection\", r)\n",
    "            \n",
    "        # draw a ROI\n",
    "        cv2.rectangle(clone, (left, top), (right, bottom), (0, 255, 0), 2)\n",
    "        # show live feed\n",
    "        cv2.imshow(\"Feed\", clone)\n",
    "        \n",
    "        if key == 32:\n",
    "            cv2.imwrite(\"Captured.png\", clone)\n",
    "        # if pressed  escape, loop out and stop processing\n",
    "        if key==27:\n",
    "            break\n",
    "cam.release()\n",
    "cv2.destroyAllWindows()\n",
    "    \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-01T10:40:23.468831Z",
     "start_time": "2020-08-01T10:40:21.952965Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prediction accuracy for  क  is  100.00 %\n"
     ]
    }
   ],
   "source": [
    "# r = recognition(cv2.cvtColor(drawn, cv2.COLOR_BGR2GRAY), 'show')\n",
    "drawn = cv2.imread(\"ka.png\", 0)\n",
    "d = drawn.copy().astype(np.uint8)          \n",
    "# cv2.cvtColor(d, cv2.COLOR_BGR2GRAY)\n",
    "recognition(d, 'show')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-01T10:32:30.170119Z",
     "start_time": "2020-08-01T10:32:30.154634Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'F:\\\\Desktop\\\\work\\\\Gesture Based Method'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "os.getcwd()"
   ]
  },
  {
   "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.7.4"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}