Contour Based Writing- New VUI, Adding Slider, More Colors, New Animation and Code Optimization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Contour Based Writing- New VUI, Adding Slider, More Colors, New Animation and Code Optimization\n",
    "\n",
    "## Contents\n",
    "* [Introduction](#Introduction)\n",
    "* [Credits](#Credits)\n",
    "* [Motivation](#Motivation)\n",
    "* [Dependencies](#Dependencies)\n",
    "* [VUI: Visual User Interface](#VUI:-Visual-User-Interface)\n",
    "* [Canvas](#Canvas)\n",
    "* [Contour Writing](#Contour-Writing)\n",
    "* [Finally](#Finally)\n",
    "* [What Next?](#What-Next?)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "If i have to write about part, then this is the 4th part or 4th version of <b>Gesture Based Visually Writing System</b>. If you have read my previous blogs on this same topic then you probably know that how much have i progressed from the early version. <b><i>The first best version of anything will be the imporvements of shortcoming.</i></b> I am applying same concept. On previous versions, there were lots of problems, one of them is the structured way of the code. Now on this version, i am using the Object Oriented Way, any concept of OOP will be enough to understand the codes following. And minor image processing concept along with beginner OpenCV knowledge will be enough to know everything about on this blog. But for the better understanding of this project requires <b>primary prerequisite to understand the concepts and algorithms used on this blog are to view my previous blogs</b>. Because i am explaining little this time. Follow the [Before Anything](#Before-Anything) section for more information.\n",
    "\n",
    "### What now?\n",
    "* Now on this blog, i will be sharing new and more optimized and scalable way of writing codes to perform this task. I am introducing the OOP way.\n",
    "* I will also add new mode. And that mode is the most essential one. A slider to change size of a pointer.\n",
    "\n",
    "The entire system can be divided onto 3 parts. And if i have to make a diagram then it will be something like below.\n",
    "<img src=\"Assets/oop.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VUI\n",
    "A class representing Visual User Interface, which will lie above the canvas and it contains icons, and interacting panel. Some common methods are written inside the box and the communication medium between the classes is vai object and sometimes attributes. One example of communication is, the class Contour Writing sends the current location of pointer to VUI and VUI shows the pointer on VUI region (if lies). Then the view applies animation on icons, and tries to set mode. Then VUI's current window is sent back along with running mode.\n",
    "\n",
    "### Canvas\n",
    "A class representing writing place. Contour writing sends thep pointer location and running mode and the operation happens on canvas. Operations generally are Draw. erase and move. Finally, the written canvas is sent back.\n",
    "\n",
    "### Contour Writing\n",
    "A class that handles all other classes and performs contour extraction task using OpenCV. This class is responsible for many things and one of them is pointer assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Before Anything\n",
    "Before anything, i am requesting you to view my previous blogs and only then return to this blog. Because the blogs below are the earlier version of the codes and concepts. I am still using same concepts and also you will be amazed to see how much i have progressed. I am only going to describe what is happening here on very little. Hence, if you are new to this project then it is best idea to view them. Please view them serially.\n",
    "* [Gesture Based Visually Writing System Using OpenCV and Python](https://acharyaramkrishna.com.np/2020/08/01/gesture-based-visually-writing-system-using-opencv-and-python/)\n",
    "* [Gesture Based Visually Writing System: Adding Visual User Interface](https://acharyaramkrishna.com.np/2020/08/11/gesture-based-visually-writing-system-make-a-visual-user-interface/)\n",
    "* [Gesture Based Visually Writing System: Adding Virtual Animationn, New Mode and New VUI](https://acharyaramkrishna.com.np/2020/08/14/gesture-based-visually-writing-system-adding-virtual-animation-new-mode-and-new-vui/)\n",
    "\n",
    "## Credits\n",
    "I want to give credits of this blogs to everyone on [LinkedIn](https://linkedin.com/in/ramkrishna-acharya-91a217183/) who reacted, shared and commented my previous blog and on [Twitter](https://twitter.com/QuassarianViper) also (most of retweets was from bots lol). I am very grateful that my [this LinkedIn post about previous version](https://www.linkedin.com/posts/ramkrishna-acharya-91a217183_opencv-computervision-python-activity-6699919193124548608-bJI-) got more than 2.2k reactions and nearly 30k views. I never thought that this will gain so much attention and here i am improving it again. \n",
    "If i have to take a name and reason for credits:-\n",
    "* [Sagar Dhungel](https://www.linkedin.com/in/sagardhungel/): Who motivates me to write more.\n",
    "* [Suraj Bista](https://www.linkedin.com/in/suraj-bista-282830126): Who motivates me to write more.\n",
    "* [Pitambar Mahato](https://www.linkedin.com/in/pitambar-mahato-245621140/): Who reads my all blogs and gives feedbacks.\n",
    "* [Kamal Gautam](https://): Who reads my all blogs and gives feedbacks.\n",
    "* [Indra Poudel](https://): Who helped me find issues on blogs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Motivation\n",
    "I am highly motivated by the support people gave me on [LinkedIn](https://www.linkedin.com/posts/ramkrishna-acharya-91a217183_opencv-computervision-python-activity-6699919193124548608-bJI-)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dependencies\n",
    "As usual, importing dependencies on earlier of the code run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-19T04:39:51.179229Z",
     "start_time": "2020-08-19T04:39:51.171266Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import imutils\n",
    "\n",
    "def show(img, figsize=(10, 10)):\n",
    "    figure = plt.figure(figsize=figsize)\n",
    "    plt.imshow(img)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VUI: Visual User Interface\n",
    "I don't know if the term VUI for Visual User Interface is already used and if this term is right one now to use. But i am using it anyway on the purpose that we are interacting with video frames. This time instead of a simple variable, i am using a new and robust way of defining VUI. A VUI Class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize Class\n",
    "The class is initialized with default parameters and setting useful parameters ahead of program run.\n",
    "\n",
    "```python\n",
    "class VUI:\n",
    "    \"\"\"\n",
    "        A class for visual user interface. Recommended to use default parameters.\n",
    "    \"\"\"\n",
    "    def __init__(self, icons_dir=\"icons/\", window_size=(525, 700, 3), vui_part=20):\n",
    "        \"\"\"\n",
    "            icons_dir: directory to use icons from.\n",
    "            window_size: size of an vui window. Recommended to use equal of final window.\n",
    "            vui_part: How much % of rows from top will be used to stack icons?\n",
    "        \n",
    "        \"\"\"\n",
    "        self.idir = icons_dir\n",
    "        self.window = np.zeros(window_size).astype(np.uint8)\n",
    "        self.size = window_size\n",
    "        self.vui_part = int(vui_part/100 * self.size[0])\n",
    "        self.dd_part = (self.vui_part, int(50/100 * self.size[0]))\n",
    "        \n",
    "        self.modes = [fname.split(\".\")[0] for fname in os.listdir(self.idir)]\n",
    "        self.icon_size = (int(self.size[1]/len(self.modes)), self.vui_part) # c, r\n",
    "        \n",
    "        self.current_icons = []\n",
    "        self.anim_scale = 0.5\n",
    "        self.anim_color = [5, 15, 2]\n",
    "        self.prev_mode = \"move\"\n",
    "        self.current_mode = \"move\"\n",
    "        self.running_mode = None \n",
    "        self.hover=None\n",
    "        \n",
    "        self.mode_count = 1\n",
    "        self.max_count = 5\n",
    "        self.color_count = 1\n",
    "        self.max_color = 5\n",
    "        \n",
    "        self.current_pointer = (100, 100)\n",
    "        self.canvas_pointer = None\n",
    "        \n",
    "        self.draw_color = (0, 0, 255)\n",
    "        self.previous_color = (0, 0, 255)\n",
    "        self.current_color = (0, 0, 255)\n",
    "        self.pointer_color = (100, 200, 200)\n",
    "        self.point = (10, -3)\n",
    "        self.colors=None\n",
    "        \n",
    "        self.icons = self.prepare_icons()\n",
    "        self.get_window()\n",
    "```\n",
    "\n",
    "* `idir`: holds icons directory.\n",
    "* `window`: holds VUI window. Initally blank image.\n",
    "* `vui_part`: how much of rows from top row to use for icons?\n",
    "* `dd_part`: how much of the rows from top row to use for dropdown?\n",
    "* `modes`: available modes. Normally name of the images under idir.\n",
    "* `icon_size`: size of each icon on vui_part. Format (cols, rows).\n",
    "* `current_icons`: list to store icons on every frame.\n",
    "* `anim_scale`: animation scale. How to increase/decrease the icon size?\n",
    "* `anim_color`: animation color for icons\n",
    "* `prev_mode`: previous mode, default is move.\n",
    "* `current_mode`: current mode, default is move.\n",
    "* `running_mode`: running mode, default is None.\n",
    "* `hover`: if cursor is above vui region.\n",
    "* `mode_count`: count number of times pointer contiously lied above current icon. Default 1.\n",
    "* `max_count`: how many times current mode be repeated to change running mode to current mode?\n",
    "* `color_count`: same as mode_count but for color.\n",
    "* `max_count`: same as max_count but for color.\n",
    "* `current_pointer`: where is pointer located currently? value modified by other classes.\n",
    "* `canvas_pointer`: where is pointer right now on canvas?\n",
    "* `draw_color`: current draw color. Red default.\n",
    "* `previous_color`: where did cursor lied on previous dropdown of color?\n",
    "* `current_color`: where is cursor lying on current dropdown of color?\n",
    "* `pointer_color`: which color should the pointer be of.\n",
    "* `point`: value to tune pointer size. (radius, thickness)\n",
    "* `colors`: list of colors in RGB for chosing colors\n",
    "* `icons`: value set by method `prepare_icons`.\n",
    "\n",
    "Each and every attribute has its own usecase and i tried to make it lesser. Some variables like count, current/previous are important to change modes/colors so they must be tuned properly. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Prepare Icons\n",
    "A method to prepare icons and their respective modes. It is called initially while class initialization.\n",
    "```python\n",
    "    def prepare_icons(self):\n",
    "        \"\"\"\n",
    "            A method to prepare icons on initial frame.\n",
    "            Method sets 4 new attributes.\n",
    "            cols: List to store (y1, y2) of icon.\n",
    "            icon_position: Dictionary to store (y1, y2) as key and corresponding image as value\n",
    "            current_icons: A dictionary initialized with initial icons. Changed on every frame when cursor lies above it.\n",
    "            mode_pos: Mode as key and its icon's (y1, y2) as value.\n",
    "        \"\"\"\n",
    "        cols = np.linspace(0, self.size[1]-1, len(self.modes)+1).astype(np.int64)\n",
    "        cols = [(cols[i], cols[i+1]) for i in range(len(cols)-1)]\n",
    "        \n",
    "        icon_pos = {}\n",
    "        mode_pos = {}\n",
    "        for i, image_name in enumerate(os.listdir(self.idir)):\n",
    "            img = cv2.imread(self.idir+image_name)\n",
    "            img = cv2.resize(img, (cols[i][1]-cols[i][0], self.vui_part))\n",
    "            icon_pos[cols[i]] = img\n",
    "            mode_pos[self.modes[i]] = cols[i]\n",
    "        self.cols = cols   \n",
    "        self.icon_position = icon_pos\n",
    "        self.current_icons = icon_pos\n",
    "        self.mode_pos = mode_pos\n",
    "```\n",
    "#### What is happening here?\n",
    "* Method starts by creating an array of columns for icons. If we have 9 icons, then to stack them how many lines are required? 10.\n",
    "* Then we modify that array into list of tuple. Store (y1, y2) for each column.\n",
    "* Initialize dictionaries `icon_pos` and `mode_pos`.\n",
    "* For each image on icons directory:\n",
    "    * Read image and resize it to shape that fits completely on cols.\n",
    "    * Store img on `icon_pos`, key be cols and value be image.\n",
    "    * Store cols on `mode_pos`, key as mode name and value as cols.\n",
    "* Make attributes for `cols`, `icon_position`, `current_icons`, `mode_pos`.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Set Colors\n",
    "This method is used to change the color of pointer/draw when pointer lies above it for some frames. We can change color from dropdown menu. Colors are either provided from outside of use default.\n",
    "```python\n",
    "    def set_colors(self, col=None, new_colors=None):\n",
    "        \"\"\"\n",
    "            A method to set colors when pointer lies above color icon.\n",
    "            Initially used subset of {Red, Green, Blue}\n",
    "            col:- column where current pointer lies.\n",
    "            new_colors:- If to use other colors.\n",
    "            \n",
    "            Method returns list of available colors on dropdown menu. \n",
    "            Changes the draw color, pointer color upon condition meet.\n",
    "        \"\"\"\n",
    "        # earlier pointer was clipped within the vui\n",
    "        pointer = self.canvas_pointer\n",
    "        pointer = (pointer[1], self.vui_part+ pointer[0])\n",
    "        if new_colors is None:\n",
    "            r = np.array([0, 0, 255])\n",
    "            g = np.array([0, 255, 0])\n",
    "            b = np.array([255, 0, 0])\n",
    "            colors = [r, g, b]\n",
    "            colors_new = [colors[i]+colors[i+1] for i in range(len(colors)-1)]\n",
    "            colors.extend(colors_new)\n",
    "            self.colors = colors\n",
    "        else:\n",
    "            self.colors = new_colors\n",
    "        rows = np.linspace(self.dd_part[0], self.dd_part[1], len(self.colors)+1).astype(np.int64)\n",
    "        rows = [(rows[i], rows[i+1]) for i in range(len(rows)-1)]\n",
    "        self.color_pos = {}\n",
    "        for row, color in zip(rows, colors):\n",
    "            self.color_pos[row] = color\n",
    "            if row[0]<=pointer[1]<row[1] and col[0]<=pointer[0]<col[1]:\n",
    "                self.current_color = (color.tolist())\n",
    "                if self.current_color == self.previous_color:\n",
    "                    self.color_count+=1\n",
    "                else:\n",
    "                    self.previous_color=self.current_color\n",
    "                    self.color_count = 1\n",
    "                if self.color_count>=self.max_color:\n",
    "                    self.draw_color=self.current_color\n",
    "                self.pointer_color = (np.abs(np.array([200, 200, 100])-color).tolist())\n",
    "            self.current_window[row[0]:row[1], col[0]:col[1]] = color\n",
    "        \n",
    "        return self.colors\n",
    "```\n",
    "* Method takes the pointer as canvas's pointer because we only use the pointer of VUI on `vui_part` only.\n",
    "* We edited the pointer to make it fit on our case. The swapping is require because we have pointer on (y, x) format mostly.\n",
    "* We initialize `colors` from condition checks.\n",
    "* Since colors are chosed form dropdown, colors are stackked top to down. Hence find rows that divides colors.\n",
    "* If current pointer's x coordinate lies within any of color's row then the `color_count` is increased.\n",
    "* When `color_count` reaches `max_count` we change the pointer color and draw color.\n",
    "* We also have to change the window's color on those region where current color's position is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Get window\n",
    "This method is called from other methods.\n",
    "```python\n",
    "    def get_window(self):\n",
    "        \"\"\"\n",
    "            A method to return a VUI window upon called. Sets pointer on VUI canvas.\n",
    "        \"\"\"\n",
    "        self.current_window = np.zeros_like(self.window).astype(np.uint8)\n",
    "        for col, img in self.current_icons.items():\n",
    "            self.current_window[:self.vui_part, col[0]:col[1]] = img\n",
    "        if self.running_mode == \"color\":\n",
    "            self.set_colors(col=self.cols[self.modes.index(\"color\")])\n",
    "        if self.current_pointer is not None and self.current_pointer[0]>0:\n",
    "            cv2.circle(self.current_window, (self.current_pointer[1], self.current_pointer[0]), self.point[0], self.pointer_color, self.point[1])\n",
    "        \n",
    "        return self.current_window\n",
    "```\n",
    "* Starts by initializing new blank image.\n",
    "* Loop through `current_icons`'s key and values, set the icon image on exact position of `vui_part`.\n",
    "* When `running_mode` is color we have to show dropdown hence call `set_colors` method and pass the column where current pointer is.\n",
    "* Finally draw a pointer on window and return."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Update VUI\n",
    "This method is called from the main class of writing. Method performs too many things here. This method calls other methods also to perform operations like changing color, changing mode etc.\n",
    "```python\n",
    "    def update_vui(self, pointer=(100, 100), cpointer=(10, 100)):\n",
    "        \"\"\"\n",
    "            A method to update the entire VUI properties and state.\n",
    "            pointer: Current pointer on VUI part.\n",
    "            cpointer: Current pointer on Canvas.\n",
    "            \n",
    "            cpointer is useful when working with color mode.\n",
    "        \"\"\"\n",
    "        self.current_pointer = pointer\n",
    "        self.canvas_pointer = cpointer\n",
    "        #print(pointer, canvas_pointer)\n",
    "        current_icons = {}\n",
    "        self.hover=None\n",
    "        if pointer[0]<=self.vui_part:\n",
    "            for col, mode in zip(self.cols, self.modes):\n",
    "                icon = self.icon_position[col].copy()\n",
    "                ishape = icon.shape\n",
    "                \n",
    "                #print(mode)\n",
    "                if col[0]<pointer[1]<=col[1]:\n",
    "                    # pointer is above this icon now animate it.\n",
    "                    self.current_mode = mode\n",
    "                    zeros_icon = np.zeros_like(icon).astype(np.uint8)\n",
    "                    \n",
    "                    f = self.anim_scale*self.mode_count\n",
    "                    r = int(ishape[0] * f)\n",
    "                    c = int(ishape[1] * f)\n",
    "                    icon = cv2.resize(icon, (c, r))\n",
    "                    if f > 1:\n",
    "                        rd = int((r - ishape[0])/2)\n",
    "                        cd = int((c - ishape[1])/2)\n",
    "                        \n",
    "                        zeros_icon[:, :] = icon[rd:ishape[0]+rd, cd:ishape[1]+cd] \n",
    "                    else:\n",
    "                        rd = int((ishape[0] - r)/2)\n",
    "                        cd = int((ishape[1] - c)/2)\n",
    "                        rdd, cdd = 0, 0\n",
    "                        if ishape[0]-rd-rd > r:\n",
    "                            rdd=1\n",
    "                        if ishape[1]-cd-cd > c:\n",
    "                            cdd=1\n",
    "                        #print(icon.shape, ishape, rd, abs(r-rd), cd, abs(c-cd))\n",
    "                        zeros_icon[rd:ishape[0]-rd-rdd, cd:ishape[1]-cd-cdd] = icon[::] \n",
    "                            \n",
    "                    current_icons[col] = zeros_icon.astype(np.uint8) + np.uint8(np.array(self.anim_color)*self.mode_count)\n",
    "                    \n",
    "                    \n",
    "                    if self.prev_mode == self.current_mode:\n",
    "                        self.mode_count += 1\n",
    "                    else:\n",
    "                        self.prev_mode = self.current_mode\n",
    "                        self.mode_count = 1\n",
    "                    if self.mode_count >= self.max_count:\n",
    "                        self.running_mode = self.current_mode\n",
    "                        self.mode_count = 1\n",
    "                        self.hover = True\n",
    "                        \n",
    "                else:\n",
    "                    current_icons[col] = icon\n",
    "                \n",
    "            self.current_icons = current_icons\n",
    "        else:\n",
    "            self.mode_count = 1\n",
    "                    \n",
    "        return self.get_window()\n",
    "```\n",
    "\n",
    "* Take `vui_pointer` and set it to `current_pointer`. \n",
    "* Take `canvas_pointer` and set it too.\n",
    "* Initialize dictionary to store `current_icons`. We store the changed icon here along with unchanged.\n",
    "* Initialize `hover` to None.\n",
    "* Proceed below only when current x axis lies below the `vui_part`. i.e if pointer is on icons panel.\n",
    "* Loop through columns of icons and modes at same time.\n",
    "    * Take icon lying on this column.\n",
    "    * If current pointer's column lies within the columns:\n",
    "        * Set current mode.\n",
    "        * Create blank image of icon shape as `zeros_icon`. \n",
    "        * Find the scale factor by multiple of mode counts.\n",
    "        * Find new row/column for this icon. We are scaling icon to make it look like animating.\n",
    "        * Make new icon's center and original icon's center same and insert it into blank image.\n",
    "        * Store `zeros_icon` on `current_icons`.\n",
    "        * Perform count checkings. And change mode when mode count reaches max. Set hover to True.\n",
    "    * Else:\n",
    "         * Store icon on `current_icon`. Because pointer is not above this icon so leave it as it is.\n",
    "* Return the output of `get_window` method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test Class: VUI\n",
    "To test the class, we will call the method `update_vui` by passing it a pointer. To make sure our dropdown is working fine i will set pointer to color's region. And to show animating like effect, i will call it multiple times. See the result below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-19T10:12:13.568152Z",
     "start_time": "2020-08-19T10:12:11.245943Z"
    },
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x2160 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "vui = VUI()\n",
    "show(vui.window)\n",
    "\n",
    "fig = plt.figure(figsize=(30, 30))\n",
    "ax = fig.subplots(2, 3, sharex='col', sharey='row')\n",
    "\n",
    "for i in range(2):\n",
    "    for j in range(3):\n",
    "        ax[i][j].imshow(vui.update_vui())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From above image, it is clear that our dropdown is working fine and the icon is also changing its color and size at the same time. Hence test passed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Canvas\n",
    "The canvas we will use will also be a class. It is not much complicated than VUI class because its task is to only write/erase on that position where pointer lies. Erase is much easier if we specified the background color eariler and whenever the pointer lies, draw a circle there with background color.\n",
    "\n",
    "### Initialize: Canvas\n",
    "Initialize a class with default and essential parameters. Follow the docstring for more information.\n",
    "```python\n",
    "class Canvas:\n",
    "    def __init__(self, window_size=(525, 700, 3), draw_color=(100, 100, 100), \n",
    "                 pointer_color=(0, 0, 0), bg_color=(25, 25, 25), mode=\"move\", \n",
    "                 point=(10, -3), vui=None, ssize=(300, 50, 3)):\n",
    "        \"\"\"\n",
    "            A method to initialize canvas.\n",
    "            window_size: size of a canvas window.\n",
    "            draw_color: drawing color in RGB.\n",
    "            pointer_color: pointer color in RGB.\n",
    "            bg_color: background color in RGB.\n",
    "            mode: running mode.\n",
    "            point: tuple of (pointer radius, thickness)\n",
    "            vui: VUI object.\n",
    "            ssize: Slider's size.\n",
    "        \n",
    "        \"\"\"\n",
    "        self.size=window_size\n",
    "        self.draw_color=draw_color\n",
    "        self.pointer_color = pointer_color\n",
    "        self.bg_color = bg_color\n",
    "        self.window = np.zeros(self.size, dtype=np.uint8)\n",
    "        self.canvas= self.window.copy()+bg_color\n",
    "        self.mode = mode\n",
    "        self.pointer = None\n",
    "        self.point = point\n",
    "        self.current_window = self.window+self.canvas\n",
    "        self.vui = vui\n",
    "        self.ssize = ssize\n",
    "        self.sregion = ()\n",
    "```\n",
    "* Canvas is initialized with background color.\n",
    "* Current window must include the pointer and the real canvas. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Update Window\n",
    "A method which performs draw/erase/move on canvas and shows pointer.\n",
    "```python\n",
    "    def update_window(self, mode, pointer=(400, 100)):\n",
    "        \"\"\"\n",
    "            mode: running mode\n",
    "            pointer: where is pointer now?\n",
    "        \"\"\"\n",
    "        self.mode = mode\n",
    "        self.vui.mode=mode\n",
    "        self.pointer = pointer\n",
    "        self.draw_color=self.vui.draw_color\n",
    "        self.pointer_color = self.vui.pointer_color\n",
    "        #self.pointer = (np.clip(self.vui.vui_part, pointer[0], self.size[0]), pointer[1])\n",
    "        #print(\"c\", self.draw_color)\n",
    "        swindow = np.zeros(self.size).astype(np.uint8)\n",
    "        #print(pointer)\n",
    "        if 0<pointer[0]<self.ssize[0] and 0<pointer[1]<self.ssize[1]:\n",
    "            swindow=self.slider(spoint=pointer[0])\n",
    "            self.mode = \"move\"\n",
    "                      \n",
    "        if self.mode == \"draw\":\n",
    "            cv2.circle(self.canvas, (self.pointer[1], self.pointer[0]), self.point[0], self.draw_color, self.point[1])\n",
    "            self.current_window = self.window+self.canvas+swindow\n",
    "            cv2.circle(self.current_window, (self.pointer[1], self.pointer[0]), self.point[0], self.pointer_color, self.point[1])\n",
    "            \n",
    "        elif self.mode == \"erase\":\n",
    "            cv2.circle(self.canvas, (self.pointer[1], self.pointer[0]), self.point[0], self.bg_color, self.point[1])\n",
    "            self.current_window = self.window+self.canvas+swindow\n",
    "            cv2.circle(self.current_window, (self.pointer[1], self.pointer[0]), self.point[0], self.pointer_color, self.point[1])\n",
    "            \n",
    "        else:\n",
    "            self.current_window = self.window+self.canvas+swindow\n",
    "            cv2.circle(self.current_window, (self.pointer[1], self.pointer[0]), self.point[0], self.pointer_color, self.point[1])\n",
    "            \n",
    "        #show(self.canvas)\n",
    "        #show(self.current_window)\n",
    "        return self.current_window\n",
    "```\n",
    "* Some attributes are set initially from VUI object and parameters.\n",
    "* Initialize slider to blank image.\n",
    "* When pointer lies on slider region, then call slider window and change mode to move.\n",
    "* If mode is draw, \n",
    "    * Draw circle on pointer position with current properties of draw on canvas. \n",
    "    * Create current window.\n",
    "    * Draw circle on current window with pointer color.\n",
    "* If mode is erase,\n",
    "    * Draw circle on pointer position with current properties of draw on canvas. i.g background color\n",
    "    * Create current window.\n",
    "    * Draw circle on current window with pointer color.\n",
    "* Else:\n",
    "    * Create current window and draw a circle on pointer position with pointer color. \n",
    "* Return current window."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Slider\n",
    "This is new concept on this version. I am using slider to change the size of pointer. Isn't it interesting?\n",
    "```python\n",
    "     def slider(self, size=(300, 30, 3), spoint=50, scolor=(100, 55, 100)):\n",
    "        \"\"\"\n",
    "            A method to change the pointer size by moving a slider.\n",
    "            size: size of slider region.\n",
    "            spoint: slider point, generally row position of pointer.\n",
    "            scolor: slider color\n",
    "        \"\"\"\n",
    "        swidth=10\n",
    "        #swidth=int(5/50*spoint)\n",
    "        #swidth = np.clip(swidth, 5, spoint)\n",
    "        swindow=np.zeros(self.size).astype(np.uint8)\n",
    "        swindow[:self.ssize[0], 0:self.ssize[1]] += np.uint8([255, 255, 255])  \n",
    "        r1 = np.clip(spoint-swidth, swidth, self.ssize[0]-swidth)\n",
    "        r2 = np.clip(spoint+swidth, swidth, self.ssize[0]-swidth)\n",
    "        spoint = int(10/50 * spoint)\n",
    "        #print(r1, r2, spoint)\n",
    "        \n",
    "        \n",
    "        swindow[r1:r2, :self.ssize[1]] = scolor\n",
    "        self.point=(spoint, self.point[1])\n",
    "        #cv2.imshow(\"slider\", swindow.astype(np.uint8))\n",
    "        return swindow.astype(np.uint8)   \n",
    "```\n",
    "* Method starts by defining new variable `swidth`, which is slider width.\n",
    "* New blank image is made to store slider.\n",
    "* Slider is made by making a rectangle on the spoint row, we add width on both top/bottom of slider.\n",
    "* Change our pointer size relative to the the slider position.\n",
    "* Return the slider window.\n",
    "\n",
    "### Method: Clear\n",
    "A method to clear the window and canvas when clear mode is enabled.\n",
    "```python\n",
    "    def clear(self):\n",
    "        self.window = np.zeros(self.size, dtype=np.uint8)\n",
    "        self.canvas= self.window.copy()+self.bg_color\n",
    "```\n",
    "Both canvas and window is returned to their original state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test: Canvas\n",
    "Lets test our canvas. The output should look like below. I am testing it to work with slider and draw both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-19T11:07:33.641257Z",
     "start_time": "2020-08-19T11:07:26.747929Z"
    },
    "code_folding": [
     0,
     1
    ],
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Draw with normal pointer move.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x2160 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Draw with slider move.\n"
     ]
    },
    {
     "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",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "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 2160x2160 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Draw with new pointer.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x2160 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erase with new pointer.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x2160 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "c = Canvas(vui=VUI())\n",
    "\n",
    "print(\"Draw with normal pointer move.\")\n",
    "# draw the color first.\n",
    "fig = plt.figure(figsize=(30, 30))\n",
    "ax = fig.subplots(2, 3, sharex='col', sharey='row')\n",
    "p = 0\n",
    "for i in range(2):\n",
    "    for j in range(3):\n",
    "        ax[i][j].imshow(c.update_window(mode=\"draw\", pointer=(400, 100+p)))\n",
    "        p+=20\n",
    "plt.show()\n",
    "\n",
    "print(\"Draw with slider move.\")\n",
    "# test the slider\n",
    "fig = plt.figure(figsize=(30, 30))\n",
    "ax = fig.subplots(2, 3, sharex='col', sharey='row')\n",
    "p=0\n",
    "for i in range(2):\n",
    "    for j in range(3):\n",
    "        ax[i][j].imshow(c.update_window(mode=\"draw\", pointer=(50+p, 10)))\n",
    "        p+=20\n",
    "plt.show()\n",
    "\n",
    "print(\"Draw with new pointer.\")\n",
    "# Draw again the slider has increased\n",
    "fig = plt.figure(figsize=(30, 30))\n",
    "ax = fig.subplots(2, 3, sharex='col', sharey='row')\n",
    "p = 0\n",
    "for i in range(2):\n",
    "    for j in range(3):\n",
    "        ax[i][j].imshow(c.update_window(mode=\"draw\", pointer=(400, 100+p)))\n",
    "        p+=20\n",
    "plt.show()\n",
    "\n",
    "print(\"Erase with new pointer.\")\n",
    "# erase it now\n",
    "fig = plt.figure(figsize=(30, 30))\n",
    "ax = fig.subplots(2, 3, sharex='col', sharey='row')\n",
    "p = 0\n",
    "for i in range(2):\n",
    "    for j in range(3):\n",
    "        ax[i][j].imshow(c.update_window(mode=\"erase\", pointer=(400, 100+p)))\n",
    "        p+=20\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The test above is done on draw mode and erase with different pointer size. What have i done?\n",
    "* Made a figure and subplots for 6 images.\n",
    "* Draw a color on canvas at pointer position at different position.\n",
    "* Make pointer position at slider region and made it move.\n",
    "* Draw with new pointer size.\n",
    "* Erase with new pointer size.\n",
    "\n",
    "Test passed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contour Writing\n",
    "A class to perform overall operation using contours. I have worked hard to maintain the codes here by updating previous codes.\n",
    "\n",
    "### Initialize: Contour Writing\n",
    "Instead of using a distinct variable for each ROIs, i thought of using dictionaries to store particular property only. The keys of a dictionary will be ROI name and value will be the type of data to store.\n",
    "```python\n",
    "class ContourWriting:\n",
    "    \"\"\"\n",
    "        A class to bind all other classes uses.\n",
    "    \"\"\"\n",
    "    def __init__(self, count_mode=5, avg_frames=100, \n",
    "                 rois={\"droi\":[250, 400, 480, 681],\n",
    "                       \"mroi\":[100, 10, 300, 225], \n",
    "                       \"vroi\":[150, 400, 240, 681]}, \n",
    "                 icons_dir=\"icons/\", aweight=0.5):\n",
    "        \"\"\"\n",
    "            count_mode: max count\n",
    "            avg_frames: number of frames to take average\n",
    "            rois: types of ROIS. Keys draw, move, vui and values [top, right, bottom, left]\n",
    "            icons_dir: icons's directory\n",
    "            aweight: value of delta on running average.\n",
    "        \n",
    "        \n",
    "        \"\"\"\n",
    "        self.aweight = aweight\n",
    "        self.avg_frames=avg_frames\n",
    "        self.roi_boxes = rois\n",
    "        self.roi_averages = {key:None for key in rois.keys()}\n",
    "        self.roi_grays = {key:None for key in rois.keys()}\n",
    "        self.roi_masks = {key:None for key in rois.keys()}\n",
    "        self.roi_pointer = {key:None for key in rois.keys()}\n",
    "        self.roi_counts = {key:None for key in rois.keys()}\n",
    "        self.size = (525, 700)\n",
    "        self.set_pointer()\n",
    "        self.vui = VUI()\n",
    "        self.canvas_shape = (self.size[0]-self.vui.vui_part, self.size[1], 3) \n",
    "    \n",
    "        self.canvas = Canvas(window_size=self.canvas_shape, vui=self.vui)\n",
    "        self.running_mode = self.vui.running_mode\n",
    "        \n",
    "        self.force_modes=None\n",
    "        self.fcount_mode=count_mode\n",
    "        self.fcurrent_count=0\n",
    "        self.fprev_mode = \"move\"\n",
    "        self.check_force_mode()\n",
    "        \n",
    "```\n",
    "\n",
    "* `roi_averages`: to store average image of each roi.\n",
    "* `roi_grays`: to store grayscale image of each roi.\n",
    "* `roi_masks`: to store mask image of each roi.\n",
    "* `roi_pointer`: to store pointer position on each roi.\n",
    "* `roi_counts`: to store the counts of contour points on each roi.\n",
    "* `set_pointer`: method to set pointer on respective position.\n",
    "* `vui`: attribute to store object of `VUI` class.\n",
    "* `canvas_shape`: must be below `vui_part`.\n",
    "* `force_modes`: name of force modes from force or `mroi`.\n",
    "* `check_force_mode`: method to perform check on `mroi`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Main\n",
    "A method to call from outside and handles all the tasks.\n",
    "\n",
    "```python\n",
    "    def main(self):\n",
    "        cam = cv2.VideoCapture(0) \n",
    "        self.num_frames = 0\n",
    "        self.take_average=True\n",
    "        while True:\n",
    "            (ret, frame) = cam.read()\n",
    "            if ret:\n",
    "                self.key = cv2.waitKey(1) & 0xFF\n",
    "                frame = imutils.resize(frame, width=self.size[1])\n",
    "                frame = cv2.flip(frame, 1)\n",
    "                clone = frame.copy()\n",
    "                gray = cv2.cvtColor(clone, cv2.COLOR_BGR2GRAY)\n",
    "                self.set_grays(gray)\n",
    "                self.size = frame.shape\n",
    "                #print(self.roi_grays)\n",
    "                \n",
    "                # if to take average and num frames on average taking is lesser than \n",
    "                if self.num_frames<self.avg_frames and self.take_average==True:\n",
    "                    self.running_average()\n",
    "                    cv2.putText(clone, str(self.num_frames), (100, 100),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 1)\n",
    "                    self.num_frames+=1\n",
    "                else:\n",
    "                    self.take_average=False\n",
    "                    clone = self.find_contours(clone)\n",
    "                    fmode = self.check_force_mode() \n",
    "                    vui = self.vui.update_vui(pointer=self.roi_pointer[\"vroi\"], cpointer=self.roi_pointer[\"droi\"])\n",
    "                    if self.vui.hover is not None:\n",
    "                        self.running_mode = self.vui.running_mode   \n",
    "                    if  self.roi_counts[\"mroi\"] is not None:\n",
    "                        if self.roi_counts[\"vroi\"] is not None:\n",
    "                            if self.roi_counts[\"mroi\"]-5 > self.roi_counts[\"vroi\"] and fmode is not None:\n",
    "                                self.running_mode = fmode\n",
    "                            else:\n",
    "                                self.running_mode = self.vui.running_mode       \n",
    "                        else:\n",
    "                            self.running_mode = fmode\n",
    "                    self.perform_mode()\n",
    "                    self.vui.running_mode=self.running_mode\n",
    "                    canvas = self.canvas.update_window(mode=self.running_mode, \n",
    "                                                       pointer=self.roi_pointer[\"droi\"]).astype(np.uint8)\n",
    "                    final_window = self.get_window(canvas=canvas, vui=vui)\n",
    "                    cv2.imshow(\"CW\", final_window)\n",
    "                    \n",
    "                    self.roi_pointer[\"vroi\"] = (-1, -1)\n",
    "                    \n",
    "                clone = self.make_rectangles(clone)\n",
    "                cv2.imshow(\"Feed\", clone)\n",
    "                if self.key==27:\n",
    "                    break\n",
    "        cam.release()\n",
    "        cv2.destroyAllWindows()\n",
    "\n",
    "```\n",
    "* Starts by initializing camera.\n",
    "* Initialize `num_frames` to `0`, and `take_average` to `True`.\n",
    "* While true perform below:\n",
    "    * Read each frame and read success parameter.\n",
    "    * If frame has been read, perform below:\n",
    "        * Initialize key check.\n",
    "        * Resize the frame and flip it to make it mirror effect.\n",
    "        * Convert frame to graysclae and pass it to `set_grays()` method to find grayscale on each ROIs.\n",
    "        * If `num_frames` is smaller than `avg_frames` and `take_average` is `True`,\n",
    "            * Call `running_average()`.\n",
    "            * Put frame number on frame.\n",
    "            * Increase `num_frames`.\n",
    "        * Else:\n",
    "            * Set `take_average` to `False`.\n",
    "            * Call `find_contours()` to get current contours.\n",
    "            * Call `check_force_mode()` method to check on `mroi`.\n",
    "            * Call `update_vui()` of VUI by passing it current pointer of VUI ROI and draw ROI.\n",
    "            * If `hover` is not `None`:\n",
    "                * Then set running mode to running mode of VUI.\n",
    "            * If counts of contour points on `mroi` is greater than `vroi`'s then try to set running mode to force mode.\n",
    "            * Else set running_mode to running mode of VUI.\n",
    "            * Finally perfomr the mode action.\n",
    "            * Set running mode of VUI to running mode.\n",
    "            * Call `update_window()` of Canvas by passing it running mode and pointer of draw ROI.\n",
    "            * Finally call `get_window()` method by passing current canvas and vui.\n",
    "            * Show the current writing window.\n",
    "            * Set ROI of VUI to (-1, -1) to prevent false pointer.\n",
    "            * Call `make_rectangles()` to make rectangle for each ROIs.\n",
    "        * Show `clone` image.\n",
    "        * Exit loop on exit mode.\n",
    "    * Release camera and destroy all windows.\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-19T10:54:35.291202Z",
     "start_time": "2020-08-19T10:54:30.839222Z"
    }
   },
   "source": [
    "### Method: Set Grays\n",
    "```python\n",
    "    def set_grays(self, gray_frame):\n",
    "        \"\"\"\n",
    "            Takes current grayscale frame and sets roi_grays dictionary.\n",
    "        \"\"\"\n",
    "        for rname, box in self.roi_boxes.items():\n",
    "            top, right, bottom, left = box\n",
    "            gray_roi = gray_frame[top:bottom, right:left]\n",
    "            gray_roi=cv2.GaussianBlur(gray_roi, (7, 7), 0)\n",
    "            self.roi_grays[rname] = gray_roi\n",
    "```\n",
    "* Loop through each bounding box of each ROI.\n",
    "    * Take top, right, bottom, left coordinates of box and crop that region from grayscale frame.\n",
    "    * Add some blur to that cropped region and add set it to `roi_grays` to corresponding `rname` key."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Running Average\n",
    "A method to perform running average on every ROIs.\n",
    "```python\n",
    "    def running_average(self):\n",
    "        for rname, roi in self.roi_averages.items():\n",
    "            gimg = self.roi_grays[rname]\n",
    "            if roi is None:\n",
    "                roi = gimg.copy().astype(\"float\")\n",
    "            else:\n",
    "                cv2.accumulateWeighted(gimg, roi, self.aweight)\n",
    "            self.roi_averages[rname] = roi\n",
    "```\n",
    "* Take averages of each ROI and perform Running average.\n",
    "* Set average value to `roi_averages`'s corresponding `rname` key.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Find Contours\n",
    "```python\n",
    "    def find_contours(self, clone, threshold=10):\n",
    "        \"\"\"\n",
    "            A method to find contours on each ROIs, draw maximum contours and \n",
    "            then set pointer relative to VUI and Canvas.\n",
    "            clone: current clone of frame.\n",
    "            threshold: thresholding value.\n",
    "        \"\"\"\n",
    "        self.roi_counts = {key:None for key in self.roi_counts.keys()}\n",
    "        for rname, ravg in self.roi_averages.items():\n",
    "            # abs diff betn img and bg\n",
    "            top, right, bottom, left = self.roi_boxes[rname]\n",
    "            diff = cv2.absdiff(ravg.astype(\"uint8\"), self.roi_grays[rname])    \n",
    "            _, th = cv2.threshold(diff, threshold, 255, cv2.THRESH_BINARY)\n",
    "            (cnts, _) = cv2.findContours(th.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "            m = (-1, -1)\n",
    "            if len(cnts)!=0:\n",
    "                max_cnt = max(cnts, key=cv2.contourArea)\n",
    "                cv2.drawContours(clone, [max_cnt+(right,top)], -1, (0, 0, 255))   \n",
    "                sshape = max_cnt.shape\n",
    "                new_segmented = max_cnt.reshape(sshape[0], sshape[-1])\n",
    "                m = new_segmented.min(axis=0)\n",
    "                cv2.circle(clone, (right+m[0], top+m[1]), 15, self.vui.pointer_color, -3)\n",
    "                self.roi_counts[rname] = len(max_cnt)\n",
    "                # translate m of this roi to window shape\n",
    "                #if len(max_cnt)>10:    \n",
    "\n",
    "                if rname!=\"mroi\":\n",
    "                    pshape = self.size\n",
    "                    if rname==\"vroi\":\n",
    "                        pshape = (self.vui.vui_part, self.vui.size[1])\n",
    "                    if rname==\"droi\":\n",
    "                        pshape = self.canvas_shape\n",
    "                    h = bottom - top\n",
    "                    l = left - right\n",
    "\n",
    "\n",
    "                    m = (int((m[0]/l)*pshape[1]), int((m[1]/h)*pshape[0]))    \n",
    "                else:\n",
    "                    m = (right+m[0], top+m[1])\n",
    "                       \n",
    "                self.roi_pointer[rname]=(m[1], m[0])\n",
    "                \n",
    "        return clone  \n",
    "```\n",
    "A method to find contours on each ROIs, draw maximum contours and then set pointer relative to VUI and Canvas.\n",
    "* Initialize roi_counts with keys as each ROIs and values as None.\n",
    "* Loop through  average of each ROIs.\n",
    "    * Take current gray of this ROI and find absolute difference.\n",
    "    * Threshold the difference image to binary and find contours.\n",
    "    * Set m to (-1, -1) initially.\n",
    "    * If length of contours is greater then:\n",
    "        * Find max contour and draw it on frame clone.\n",
    "        * Find minimum point of contour and draw a pointer on that point.\n",
    "        * Insert contour counts to each ROIs.\n",
    "        * Perform pointer translation relative to mroi, vroi and droi.\n",
    "    * Finally, set `roi_pointer` to each ROI.\n",
    "* Return clone."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Check Force Mode\n",
    "Note that we have 2 ROIs that can change the running mode but when to use which? Force mode is used from the `mroi` section and other modes are used from `vroi` section. \n",
    "```python\n",
    "    def check_force_mode(self):\n",
    "        top, right, bottom, left = self.roi_boxes[\"mroi\"]\n",
    "        if self.force_modes is None:\n",
    "            x=np.linspace(right, left, 4).astype(np.int64)\n",
    "            x=[(x[i],x[i+1]) for i in range(len(x)-1)]\n",
    "            force_modes = [\"move\", \"draw\", \"erase\"]\n",
    "            force_modes = {x[i]:force_modes[i] for i in range(len(x))}\n",
    "            #print(force_modes)\n",
    "            self.force_modes = force_modes\n",
    "        elif self.roi_pointer[\"mroi\"][0]>0:\n",
    "            mpointer = self.roi_pointer[\"mroi\"]\n",
    "            \n",
    "            for col, mode in self.force_modes.items():\n",
    "                \n",
    "                if col[0]<=mpointer[1]<col[1]:\n",
    "                    #print(col, mpointer)\n",
    "                    if self.fprev_mode==mode:\n",
    "                        self.fcurrent_count+=1\n",
    "                    else:\n",
    "                        self.fcurrent_count=0\n",
    "                        self.fprev_mode=mode\n",
    "                    if self.fcurrent_count>=self.fcount_mode:\n",
    "                        #print(\"f \", mode)\n",
    "                        #self.fcurrent_count=0\n",
    "                        \n",
    "                        return mode\n",
    "```\n",
    "* Take a top, right, bottom, left from `mroi` key's value on `roi_boxes`.\n",
    "* Then `foce_modes` is checked if is `None` or not.\n",
    "    * Divide the ROI Box into parts equal to `force_modes`. By default use `move, draw, erase`.\n",
    "    * Create a dictionary with column as key and value as mode name.\n",
    "    * Set `force_modes` attribute.\n",
    "* Else length of contours on `mroi` is greater than 0, then take pointer.\n",
    "    * Loop through each columns, mode on `force_modes`: \n",
    "        * If the y coordinate of pointer is within the range of column for this mode then set do check previous and current mode."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Perform Mode\n",
    "I have used 9 modes total. Until now, draw, erase, move, color have been used but now for remaining modes, we have to perform some action. Lets define a method for that too.\n",
    "```python\n",
    "    def perform_mode(self):\n",
    "        if self.running_mode==\"clear\":\n",
    "            self.canvas.clear()\n",
    "            self.running_mode=\"move\"\n",
    "        if self.running_mode==\"restart\":\n",
    "            self.take_average =True\n",
    "            self.num_frames=0\n",
    "            self.running_mode=\"move\"\n",
    "            self.canvas.clear()\n",
    "        if self.running_mode==\"save\":\n",
    "            #cv2.imshow(\"canvas\", self.canvas.canvas.astype(np.uint8))\n",
    "            cv2.imwrite(\"canvas.png\", self.canvas.canvas.astype(np.uint8))\n",
    "            #cv2.destroyWindow(\"canvas\")\n",
    "            self.running_mode=\"move\"\n",
    "        if self.running_mode==\"exit\":\n",
    "            self.key=27\n",
    "        if self.running_mode==\"detect\":\n",
    "            self.running_mode=\"move\"\n",
    "            self.detector()\n",
    "    \n",
    "```\n",
    "* If running mode is clear, then call the `clear()` method of `canvas`'s object.\n",
    "* If running mode is restart, \n",
    "    * Set `take average=True`\n",
    "    * Set `num_frames = 0`\n",
    "    * Set `running_mode=\"move\"`.\n",
    "    * Call the `clear()` method of `canvas`'s object.\n",
    "* If running mode is save:\n",
    "    * Save current canvas draw on disk and change running mode to move.\n",
    "* If running mode is exit, then change current key to 27.\n",
    "* If running mode is detect, then change running mode to move and call detector method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Detector\n",
    "A method that takes current canvas and performs detection using detection model like OCR. For now, i am using Tesseract.\n",
    "```python\n",
    "    def detector(self):\n",
    "        img = self.canvas.canvas.astype(np.uint8)\n",
    "        op = pytesseract.image_to_string(img, lang=\"eng\", nice=\"1\")\n",
    "        print(\"Detected: \", op)\n",
    "```\n",
    "* To install pytesseract is easy. But you have to install another installation file on windows to make it run.\n",
    "* If you have any problems regarding installation of pytesseract then leave me mail or comment.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Get Window\n",
    "A method that binds window of VUI and Canvas to make them look like one and return new window.\n",
    "```python\n",
    "    def get_window(self, canvas, vui):\n",
    "        final_window = vui.copy()\n",
    "        canvas_cpy = canvas.copy()\n",
    "        vshape = vui.shape\n",
    "        cshape = canvas.shape\n",
    "        #print(self.running_mode)\n",
    "        if self.running_mode == \"color\":\n",
    "            # get part where color lies and make those part of canvas_bg black\n",
    "            cp = self.vui.mode_pos[self.running_mode]\n",
    "            canvas[:self.vui.dd_part[1]-self.vui.vui_part, cp[0]:cp[1]] = vui[self.vui.vui_part:self.vui.dd_part[1], cp[0]:cp[1]]\n",
    "            \n",
    "            \n",
    "        final_window[self.vui.vui_part:, :] = canvas\n",
    "        cp = self.roi_pointer[\"droi\"]\n",
    "        cp = (cp[1], cp[0]+self.vui.vui_part)\n",
    "        point = self.canvas.point\n",
    "        cv2.circle(final_window,  cp, point[0], self.canvas.pointer_color, point[1])\n",
    "        return final_window\n",
    "    \n",
    "```\n",
    "* A simple indexing will be enough to perform this operation.\n",
    "* Take the canvas window(not the canvas itself) and vui window.\n",
    "* If running mode is color, then there is dropdown to be shown.\n",
    "    * Prepare the indices there lies only the dropdown of color.\n",
    "* Assign the canvas to parts below the `vui_part` of VUI because, those parts includes icons.\n",
    "* Finally draw the pointer on new window. It is not necessary though.\n",
    "* Return the final window."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method: Make Rectangles\n",
    "A method to make rectangles on the clone of frame so that we can notice where our finger is moving in front of the camera. Also this method will add text to each rectangles.\n",
    "\n",
    "```python\n",
    "    def make_rectangles(self, clone):\n",
    "        # make rectangle for everything, add text on middle of it\n",
    "        for rname, box in self.roi_boxes.items():\n",
    "            cv2.putText(clone, f\"Curr. Mode: {self.running_mode}\", (400, 100),\n",
    "                                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
    "            top, right, bottom, left = box\n",
    "            mid = int((top+bottom)/2), int((left+right)/2) \n",
    "            if rname == \"droi\":\n",
    "                cv2.rectangle(clone, (left, top), (right, bottom), (0, 255, 0), 2)\n",
    "                cv2.putText(clone, rname, (mid[1], mid[0]),\n",
    "                                       cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2)\n",
    "            if rname == \"mroi\":\n",
    "                \n",
    "                cv2.rectangle(clone, (left, top), (int((left + right)/3), bottom), (0, 255, 0), 2)\n",
    "                cv2.rectangle(clone, (int((left + right)/3), top), (2*int((left + right)/3), bottom), (0, 255, 0), 2)\n",
    "                cv2.rectangle(clone, (2*int((left + right)/3), top), (right, bottom), (0, 255, 0), 2)\n",
    "                cv2.putText(clone, str(\"Mv\"), (int((right)/1), int((top+bottom)/2)),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
    "                cv2.putText(clone, str(\"Dr\"), (int((left + right)/3), int((top+bottom)/2)),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
    "                cv2.putText(clone, str(\"Er\"), (2*int((left + right)/3), int((top+bottom)/2)),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
    "            if rname == \"vroi\":\n",
    "                gb_indices = int((left-right)/len(self.vui.modes))\n",
    "                gb_indices = np.arange(right, left, gb_indices)\n",
    "                gb_indices[-1] = gb_indices[-1]+1\n",
    "                for i in range(len(gb_indices)-1):\n",
    "                    _gleft = gb_indices[i]\n",
    "                    _gright = gb_indices[i+1]\n",
    "                    cv2.rectangle(clone, (_gleft, top), (_gright, bottom), (255, 0, 255), 3)\n",
    "                    cv2.putText(clone, self.vui.modes[i][:2], (_gleft+2, int((top+bottom)/2)),\n",
    "                                                       cv2.FONT_HERSHEY_SIMPLEX, 0.75, (255, 0, 255), 2)\n",
    "        return clone\n",
    "```\n",
    "Simple operation is happening here.\n",
    "* For each ROIs:\n",
    "    * Take top, right, bottom, left then find midpoint of this box.\n",
    "    * Draw the rectangle ofor each ROIs. And divide the Rectangle on parts if necessary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test: Contour Writing\n",
    "Combine everything and lets try to make our system run. We will create and object of class `ContourWriting` and call its `main()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-19T14:46:53.451484Z",
     "start_time": "2020-08-19T14:43:18.458524Z"
    }
   },
   "outputs": [],
   "source": [
    "gw = ContourWriting(avg_frames=150, aweight=0.9)\n",
    "gw.main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Output should look like the video below.\n",
    "<figure>\n",
    "<video src = \"Assets/slider_final.mp4\" width=\"100%\" controls autoplay loop> </video>\n",
    "<figcaption style = \"text-align:left; font-style:italic\">Animation and New VUI</figcaption>\n",
    "</figure> \n",
    "\n",
    "I am highly recommending you to tune your `max_count` variables around the VUI class and ContourWriting class if you are working on more noisy room. Above video was taken on night hence there are many flickering poins on frames but tuning the count values works fine.\n",
    "\n",
    "Test passed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finally\n",
    "The final version of code should look like below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-19T14:39:51.529149Z",
     "start_time": "2020-08-19T14:39:50.495543Z"
    },
    "code_folding": [
     0,
     201,
     293,
     297,
     329,
     333,
     341,
     349,
     383,
     423,
     443,
     469,
     473,
     492
    ]
   },
   "outputs": [],
   "source": [
    "class VUI:\n",
    "    \"\"\"\n",
    "        A class for visual user interface. Recommended to use default parameters.\n",
    "    \"\"\"\n",
    "    def __init__(self, icons_dir=\"icons/\", window_size=(525, 700, 3), vui_part=20, max_count=15):\n",
    "        \"\"\"\n",
    "            icons_dir: directory to use icons from.\n",
    "            window_size: size of an vui window. Recommended to use equal of final window.\n",
    "            vui_part: How much % of rows from top will be used to stack icons?\n",
    "        \n",
    "        \"\"\"\n",
    "        self.idir = icons_dir\n",
    "        self.window = np.zeros(window_size).astype(np.uint8)\n",
    "        self.size = window_size\n",
    "        self.vui_part = int(vui_part/100 * self.size[0])\n",
    "        self.dd_part = (self.vui_part, int(50/100 * self.size[0]))\n",
    "        \n",
    "        self.modes = [fname.split(\".\")[0] for fname in os.listdir(self.idir)]\n",
    "        self.icon_size = (int(self.size[1]/len(self.modes)), self.vui_part) # c, r\n",
    "        \n",
    "        self.current_icons = []\n",
    "        self.anim_scale = 0.5\n",
    "        self.anim_color = [5, 15, 2]\n",
    "        self.prev_mode = \"move\"\n",
    "        self.current_mode = \"move\"\n",
    "        self.running_mode = None \n",
    "        self.hover=None\n",
    "        \n",
    "        self.mode_count = 1\n",
    "        self.max_count = max_count\n",
    "        self.color_count = 1\n",
    "        self.max_color = 5\n",
    "        \n",
    "        self.current_pointer = (100, 100)\n",
    "        self.canvas_pointer = None\n",
    "        \n",
    "        self.draw_color = (0, 0, 255)\n",
    "        self.previous_color = (0, 0, 255)\n",
    "        self.current_color = (0, 0, 255)\n",
    "        self.pointer_color = (100, 200, 200)\n",
    "        self.point = (10, -3)\n",
    "        self.colors=None\n",
    "        \n",
    "        self.icons = self.prepare_icons()\n",
    "        self.get_window()\n",
    "        \n",
    "    def prepare_icons(self):\n",
    "        \"\"\"\n",
    "            A method to prepare icons on initial frame.\n",
    "            Method sets 4 new attributes.\n",
    "            cols: List to store (y1, y2) of icon.\n",
    "            icon_position: Dictionary to store (y1, y2) as key and corresponding image as value\n",
    "            current_icons: A dictionary initialized with initial icons. Changed on every frame when cursor lies above it.\n",
    "            mode_pos: Mode as key and its icon's (y1, y2) as value.\n",
    "        \"\"\"\n",
    "        icons = []\n",
    "        cols = np.linspace(0, self.size[1]-1, len(self.modes)+1).astype(np.int64)\n",
    "        cols = [(cols[i], cols[i+1]) for i in range(len(cols)-1)]\n",
    "        \n",
    "        icon_pos = {}\n",
    "        mode_pos = {}\n",
    "        for i, image_name in enumerate(os.listdir(self.idir)):\n",
    "            img = cv2.imread(self.idir+image_name)\n",
    "            img = cv2.resize(img, (cols[i][1]-cols[i][0], self.vui_part))\n",
    "            icon_pos[cols[i]] = img\n",
    "            mode_pos[self.modes[i]] = cols[i]\n",
    "        self.cols = cols   \n",
    "        self.icon_position = icon_pos\n",
    "        self.current_icons = icon_pos\n",
    "        self.mode_pos = mode_pos\n",
    "        \n",
    "    def set_colors(self, col=None, new_colors=None):\n",
    "        \"\"\"\n",
    "            A method to set colors when pointer lies above color icon.\n",
    "            Initially used subset of {Red, Green, Blue}\n",
    "            col:- column where current pointer lies.\n",
    "            new_colors:- If to use other colors.\n",
    "            \n",
    "            Method returns list of available colors on dropdown menu. \n",
    "            Changes the draw color, pointer color upon condition meet.\n",
    "        \"\"\"\n",
    "        # earlier pointer was clipped within the vui\n",
    "        pointer = self.canvas_pointer\n",
    "        pointer = (pointer[1], self.vui_part+ pointer[0])\n",
    "        if new_colors is None:\n",
    "            r = np.array([0, 0, 255])\n",
    "            g = np.array([0, 255, 0])\n",
    "            b = np.array([255, 0, 0])\n",
    "            colors = [r, g, b]\n",
    "            colors_new = [colors[i]+colors[i+1] for i in range(len(colors)-1)]\n",
    "            colors.extend(colors_new)\n",
    "            self.colors = colors\n",
    "        else:\n",
    "            self.colors = new_colors\n",
    "        rows = np.linspace(self.dd_part[0], self.dd_part[1], len(self.colors)+1).astype(np.int64)\n",
    "        rows = [(rows[i], rows[i+1]) for i in range(len(rows)-1)]\n",
    "        self.color_pos = {}\n",
    "        for row, color in zip(rows, colors):\n",
    "            self.color_pos[row] = color\n",
    "            if row[0]<=pointer[1]<row[1] and col[0]<=pointer[0]<col[1]:\n",
    "                self.current_color = (color.tolist())\n",
    "                if self.current_color == self.previous_color:\n",
    "                    self.color_count+=1\n",
    "                else:\n",
    "                    self.previous_color=self.current_color\n",
    "                    self.color_count = 1\n",
    "                if self.color_count>=self.max_color:\n",
    "                    self.draw_color=self.current_color\n",
    "                self.pointer_color = (np.abs(np.array([200, 200, 100])-color).tolist())\n",
    "            self.current_window[row[0]:row[1], col[0]:col[1]] = color\n",
    "        \n",
    "        return self.colors  \n",
    "    def get_window(self):\n",
    "        \"\"\"\n",
    "            A method to return a VUI window upon called. Sets pointer on VUI canvas.\n",
    "        \"\"\"\n",
    "        self.current_window = np.zeros_like(self.window).astype(np.uint8)\n",
    "        for col, img in self.current_icons.items():\n",
    "            self.current_window[:self.vui_part, col[0]:col[1]] = img\n",
    "        if self.running_mode == \"color\":\n",
    "            self.set_colors(col=self.cols[self.modes.index(\"color\")])\n",
    "        if self.current_pointer is not None and self.current_pointer[0]>0:\n",
    "            cv2.circle(self.current_window, (self.current_pointer[1], self.current_pointer[0]), self.point[0], self.pointer_color, self.point[1])\n",
    "        \n",
    "        return self.current_window\n",
    "    def update_vui(self, pointer=(100, 100), cpointer=(10, 100)):\n",
    "        \"\"\"\n",
    "            A method to update the entire VUI properties and state.\n",
    "            pointer: Current pointer on VUI part.\n",
    "            cpointer: Current pointer on Canvas.\n",
    "            \n",
    "            cpointer is useful when working with color mode.\n",
    "        \"\"\"\n",
    "        self.current_pointer = pointer\n",
    "        self.canvas_pointer = cpointer\n",
    "        #print(pointer, canvas_pointer)\n",
    "        current_icons = {}\n",
    "        self.hover=None\n",
    "        if pointer[0]<=self.vui_part:\n",
    "            for col, mode in zip(self.cols, self.modes):\n",
    "                icon = self.icon_position[col].copy()\n",
    "                ishape = icon.shape\n",
    "                \n",
    "                #print(mode)\n",
    "                if col[0]<pointer[1]<=col[1]:\n",
    "                    # pointer is above this icon now animate it.\n",
    "                    self.current_mode = mode\n",
    "                    zeros_icon = np.zeros_like(icon).astype(np.uint8)\n",
    "                    \n",
    "                    f = self.anim_scale*self.mode_count\n",
    "                    r = int(ishape[0] * f)\n",
    "                    c = int(ishape[1] * f)\n",
    "                    icon = cv2.resize(icon, (c, r))\n",
    "                    if f > 1:\n",
    "                        rd = int((r - ishape[0])/2)\n",
    "                        cd = int((c - ishape[1])/2)\n",
    "                        \n",
    "                        zeros_icon[:, :] = icon[rd:ishape[0]+rd, cd:ishape[1]+cd] \n",
    "                    else:\n",
    "                        rd = int((ishape[0] - r)/2)\n",
    "                        cd = int((ishape[1] - c)/2)\n",
    "                        rdd, cdd = 0, 0\n",
    "                        if ishape[0]-rd-rd > r:\n",
    "                            rdd=1\n",
    "                        if ishape[1]-cd-cd > c:\n",
    "                            cdd=1\n",
    "                        #print(icon.shape, ishape, rd, abs(r-rd), cd, abs(c-cd))\n",
    "                        zeros_icon[rd:ishape[0]-rd-rdd, cd:ishape[1]-cd-cdd] = icon[::] \n",
    "                            \n",
    "                    current_icons[col] = zeros_icon.astype(np.uint8) + np.uint8(np.array(self.anim_color)*self.mode_count)\n",
    "                    \n",
    "                    \n",
    "                    if self.prev_mode == self.current_mode:\n",
    "                        self.mode_count += 1\n",
    "                    else:\n",
    "                        self.prev_mode = self.current_mode\n",
    "                        self.mode_count = 1\n",
    "                    if self.mode_count >= self.max_count:\n",
    "                        self.running_mode = self.current_mode\n",
    "                        self.mode_count = 1\n",
    "                        self.hover = True\n",
    "                        \n",
    "                else:\n",
    "                    current_icons[col] = icon\n",
    "                \n",
    "            self.current_icons = current_icons\n",
    "        else:\n",
    "            self.mode_count = 1\n",
    "                    \n",
    "        return self.get_window()\n",
    "                \n",
    "            \n",
    "        \n",
    "                  \n",
    "# vui = VUI()\n",
    "# #show(vui.window)\n",
    "# vui.update_vui()\n",
    "# vui.update_vui()\n",
    "# vui.update_vui(pointer=(200, 100))\n",
    "# vui.update_vui(pointer=(200, 100))\n",
    "\n",
    "class Canvas:\n",
    "    def __init__(self, window_size=(525, 700, 3), draw_color=(100, 100, 100), \n",
    "                 pointer_color=(0, 0, 0), bg_color=(25, 25, 25), mode=\"move\", \n",
    "                 point=(10, -3), vui=None, ssize=(300, 50, 3)):\n",
    "        \"\"\"\n",
    "            A method to initialize canvas.\n",
    "            window_size: size of a canvas window.\n",
    "            draw_color: drawing color in RGB.\n",
    "            pointer_color: pointer color in RGB.\n",
    "            bg_color: background color in RGB.\n",
    "            mode: running mode.\n",
    "            point: tuple of (pointer radius, thickness)\n",
    "            vui: VUI object.\n",
    "            ssize: Slider's size.\n",
    "        \n",
    "        \"\"\"\n",
    "        self.size=window_size\n",
    "        self.draw_color=draw_color\n",
    "        self.pointer_color = pointer_color\n",
    "        self.bg_color = bg_color\n",
    "        self.window = np.zeros(self.size, dtype=np.uint8)\n",
    "        self.canvas= self.window.copy()+bg_color\n",
    "        self.mode = mode\n",
    "        self.pointer = None\n",
    "        self.point = point\n",
    "        self.current_window = self.window+self.canvas\n",
    "        self.vui = vui\n",
    "        self.ssize = ssize\n",
    "        self.sregion = ()\n",
    "        \n",
    "    def slider(self, size=(300, 30, 3), spoint=50, scolor=(100, 55, 100)):\n",
    "        \"\"\"\n",
    "            A method to change the pointer size by moving a slider.\n",
    "            size: size of slider region.\n",
    "            spoint: slider point, generally row position of pointer.\n",
    "            scolor: slider color\n",
    "        \"\"\"\n",
    "        swidth=10\n",
    "        #swidth=int(5/50*spoint)\n",
    "        #swidth = np.clip(swidth, 5, spoint)\n",
    "        swindow=np.zeros(self.size).astype(np.uint8)\n",
    "        swindow[:self.ssize[0], 0:self.ssize[1]] += np.uint8([255, 255, 255])  \n",
    "        r1 = np.clip(spoint-swidth, swidth, self.ssize[0]-swidth)\n",
    "        r2 = np.clip(spoint+swidth, swidth, self.ssize[0]-swidth)\n",
    "        spoint = int(10/50 * spoint)\n",
    "        #print(r1, r2, spoint)\n",
    "        \n",
    "        \n",
    "        swindow[r1:r2, :self.ssize[1]] = scolor\n",
    "        self.point=(spoint, self.point[1])\n",
    "        #cv2.imshow(\"slider\", swindow.astype(np.uint8))\n",
    "        return swindow.astype(np.uint8)   \n",
    "    def clear(self):\n",
    "        self.window = np.zeros(self.size, dtype=np.uint8)\n",
    "        self.canvas= self.window.copy()+self.bg_color\n",
    "    def update_window(self, mode, pointer=(400, 100)):\n",
    "        \"\"\"\n",
    "            mode: running mode\n",
    "            pointer: where is pointer now?\n",
    "        \"\"\"\n",
    "        self.mode = mode\n",
    "        self.vui.mode=mode\n",
    "        self.pointer = pointer\n",
    "        self.draw_color=self.vui.draw_color\n",
    "        self.pointer_color = self.vui.pointer_color\n",
    "        #self.pointer = (np.clip(self.vui.vui_part, pointer[0], self.size[0]), pointer[1])\n",
    "        #print(\"c\", self.draw_color)\n",
    "        swindow = np.zeros(self.size).astype(np.uint8)\n",
    "        #print(pointer)\n",
    "        if 0<pointer[0]<self.ssize[0] and 0<pointer[1]<self.ssize[1]:\n",
    "            swindow=self.slider(spoint=pointer[0])\n",
    "            self.mode = \"move\"\n",
    "            #self.pointer = (pointer[0], pointer[1]+self.ssize[1])\n",
    "            #self.pointer_color = self.bg_color\n",
    "        if self.mode == \"draw\":\n",
    "            cv2.circle(self.canvas, (self.pointer[1], self.pointer[0]), self.point[0], self.draw_color, self.point[1])\n",
    "            self.current_window = self.window+self.canvas+swindow\n",
    "            cv2.circle(self.current_window, (self.pointer[1], self.pointer[0]), self.point[0], self.pointer_color, self.point[1])\n",
    "            \n",
    "        elif self.mode == \"erase\":\n",
    "            cv2.circle(self.canvas, (self.pointer[1], self.pointer[0]), self.point[0], self.bg_color, self.point[1])\n",
    "            self.current_window = self.window+self.canvas+swindow\n",
    "            cv2.circle(self.current_window, (self.pointer[1], self.pointer[0]), self.point[0], self.pointer_color, self.point[1])\n",
    "            \n",
    "        else:\n",
    "            self.current_window = self.window+self.canvas+swindow\n",
    "            cv2.circle(self.current_window, (self.pointer[1], self.pointer[0]), self.point[0], self.pointer_color, self.point[1])\n",
    "            \n",
    "        #show(self.canvas)\n",
    "        #show(self.current_window)\n",
    "        return self.current_window\n",
    "    \n",
    "class ContourWriting:\n",
    "    \"\"\"\n",
    "        A class to bind all other classes uses.\n",
    "    \"\"\"\n",
    "    def __init__(self, count_mode=10, avg_frames=100, \n",
    "                 rois={\"droi\":[200, 400, 430, 681],\n",
    "                       \"mroi\":[80, 10, 150, 225], \n",
    "                       \"vroi\":[100, 400, 200, 681]}, \n",
    "                 icons_dir=\"icons/\", aweight=0.5):\n",
    "        \"\"\"\n",
    "            rois: types of ROIS(draw, move, vui)\n",
    "        \n",
    "        \"\"\"\n",
    "        self.aweight = aweight\n",
    "        self.avg_frames=avg_frames\n",
    "        self.roi_boxes = rois\n",
    "        self.roi_averages = {key:None for key in rois.keys()}\n",
    "        self.roi_grays = {key:None for key in rois.keys()}\n",
    "        self.roi_masks = {key:None for key in rois.keys()}\n",
    "        self.roi_pointer = {key:None for key in rois.keys()}\n",
    "        self.roi_counts = {key:None for key in rois.keys()}\n",
    "        self.size = (525, 700)\n",
    "        self.set_pointer()\n",
    "        self.vui = VUI()\n",
    "        self.canvas_shape = (self.size[0]-self.vui.vui_part, self.size[1], 3) \n",
    "    \n",
    "        self.canvas = Canvas(window_size=self.canvas_shape, vui=self.vui, bg_color=[255, 255, 255])\n",
    "        self.running_mode = self.vui.running_mode\n",
    "        \n",
    "        self.force_modes=None\n",
    "        self.fcount_mode=count_mode\n",
    "        self.fcurrent_count=0\n",
    "        self.fprev_mode = \"move\"\n",
    "        self.check_force_mode()\n",
    "        \n",
    "        \n",
    "    def set_pointer(self):\n",
    "        for rname, pointer in self.roi_pointer.items():\n",
    "            top, right, bottom, left = self.roi_boxes[rname]\n",
    "            self.roi_pointer[rname] = (int((left+right)/2), int((top+bottom)/2))\n",
    "    def running_average(self):\n",
    "        for rname, roi in self.roi_averages.items():\n",
    "            gimg = self.roi_grays[rname]\n",
    "            if roi is None:\n",
    "                roi = gimg.copy().astype(\"float\")\n",
    "            else:\n",
    "                cv2.accumulateWeighted(gimg, roi, self.aweight)\n",
    "            self.roi_averages[rname] = roi\n",
    "    def set_grays(self, gray_frame):\n",
    "        for rname, box in self.roi_boxes.items():\n",
    "            top, right, bottom, left = box\n",
    "            gray_roi = gray_frame[top:bottom, right:left]\n",
    "            #gray_roi = cv2.bilateralFilter(gray_roi, 9, 15, 15)\n",
    "            gray_roi=cv2.GaussianBlur(gray_roi, (7, 7), 0)\n",
    "            self.roi_grays[rname] = gray_roi\n",
    "            \n",
    "    def make_rectangles(self, clone):\n",
    "        cv2.putText(clone, f\"Curr. Mode: {self.running_mode}\", (self.roi_boxes[\"vroi\"][1], self.roi_boxes[\"vroi\"][0]-20),\n",
    "                                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)           \n",
    "        # make rectangle for everything, add text on middle of it\n",
    "        for rname, box in self.roi_boxes.items():\n",
    "            top, right, bottom, left = box\n",
    "            mid = int((top+bottom)/2), int((left+right)/2) \n",
    "            if rname == \"droi\":\n",
    "                cv2.rectangle(clone, (left, top), (right, bottom), (0, 255, 0), 2)\n",
    "                cv2.putText(clone, rname, (mid[1], mid[0]),\n",
    "                                       cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2)\n",
    "            if rname == \"mroi\":\n",
    "                \n",
    "                cv2.rectangle(clone, (left, top), (int((left + right)/3), bottom), (0, 255, 0), 2)\n",
    "                cv2.rectangle(clone, (int((left + right)/3), top), (2*int((left + right)/3), bottom), (0, 255, 0), 2)\n",
    "                cv2.rectangle(clone, (2*int((left + right)/3), top), (right, bottom), (0, 255, 0), 2)\n",
    "                cv2.putText(clone, str(\"Mv\"), (int((right)/1), int((top+bottom)/2)),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
    "                cv2.putText(clone, str(\"Dr\"), (int((left + right)/3), int((top+bottom)/2)),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
    "                cv2.putText(clone, str(\"Er\"), (2*int((left + right)/3), int((top+bottom)/2)),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
    "            if rname == \"vroi\":\n",
    "                gb_indices = int((left-right)/len(self.vui.modes))\n",
    "                gb_indices = np.arange(right, left, gb_indices)\n",
    "                gb_indices[-1] = gb_indices[-1]+1\n",
    "                for i in range(len(gb_indices)-1):\n",
    "                    _gleft = gb_indices[i]\n",
    "                    _gright = gb_indices[i+1]\n",
    "                    cv2.rectangle(clone, (_gleft, top), (_gright, bottom), (255, 0, 255), 3)\n",
    "                    cv2.putText(clone, self.vui.modes[i][:2], (_gleft+2, int((top+bottom)/2)),\n",
    "                                                       cv2.FONT_HERSHEY_SIMPLEX, 0.75, (255, 0, 255), 2)\n",
    "        return clone\n",
    "    \n",
    "    def find_contours(self, clone, threshold=10):\n",
    "        self.roi_counts = {key:None for key in self.roi_counts.keys()}\n",
    "        for rname, ravg in self.roi_averages.items():\n",
    "            # abs diff betn img and bg\n",
    "            top, right, bottom, left = self.roi_boxes[rname]\n",
    "            diff = cv2.absdiff(ravg.astype(\"uint8\"), self.roi_grays[rname])    \n",
    "            _, th = cv2.threshold(diff, threshold, 255, cv2.THRESH_BINARY)\n",
    "            (cnts, _) = cv2.findContours(th.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "            m = (-1, -1)\n",
    "            if len(cnts)!=0:\n",
    "                max_cnt = max(cnts, key=cv2.contourArea)\n",
    "                cv2.drawContours(clone, [max_cnt+(right,top)], -1, (0, 0, 255))   \n",
    "                sshape = max_cnt.shape\n",
    "                new_segmented = max_cnt.reshape(sshape[0], sshape[-1])\n",
    "                m = new_segmented.min(axis=0)\n",
    "                cv2.circle(clone, (right+m[0], top+m[1]), 15, self.vui.pointer_color, -3)\n",
    "                self.roi_counts[rname] = len(max_cnt)\n",
    "                # translate m of this roi to window shape\n",
    "                #if len(max_cnt)>10:    \n",
    "\n",
    "                if rname!=\"mroi\":\n",
    "                    pshape = self.size\n",
    "                    if rname==\"vroi\":\n",
    "                        pshape = (self.vui.vui_part, self.vui.size[1])\n",
    "                    if rname==\"droi\":\n",
    "                        # make it self.canvas.shape\n",
    "                        #pshape = (self.canvas_shape[0], self.canvas_shape[1]-self.canvas.ssize[1]) \n",
    "                        pshape=self.canvas_shape\n",
    "                    h = bottom - top\n",
    "                    l = left - right\n",
    "\n",
    "\n",
    "                    m = (int((m[0]/l)*pshape[1]), int((m[1]/h)*pshape[0]))    \n",
    "                else:\n",
    "                    m = (right+m[0], top+m[1])\n",
    "        \n",
    "                self.roi_pointer[rname]=(m[1], m[0])\n",
    "                \n",
    "        return clone    \n",
    "    \n",
    "    def get_window(self, canvas, vui):\n",
    "        final_window = vui.copy()\n",
    "        canvas_cpy = canvas.copy()\n",
    "        vshape = vui.shape\n",
    "        cshape = canvas.shape\n",
    "        #print(self.running_mode)\n",
    "        if self.running_mode == \"color\":\n",
    "            # get part where color lies and make those part of canvas_bg black\n",
    "            cp = self.vui.mode_pos[self.running_mode]\n",
    "            canvas[:self.vui.dd_part[1]-self.vui.vui_part, cp[0]:cp[1]] = vui[self.vui.vui_part:self.vui.dd_part[1], cp[0]:cp[1]]\n",
    "            \n",
    "            #show(canvas)\n",
    "        #else:#\n",
    "        final_window[self.vui.vui_part:, :] = canvas\n",
    "        cp = self.roi_pointer[\"droi\"]\n",
    "        cp = (cp[1], cp[0]+self.vui.vui_part)\n",
    "        point = self.canvas.point\n",
    "        cv2.circle(final_window,  cp, point[0], self.canvas.pointer_color, point[1])\n",
    "        return final_window\n",
    "    \n",
    "    def check_force_mode(self):\n",
    "        top, right, bottom, left = self.roi_boxes[\"mroi\"]\n",
    "        if self.force_modes is None:\n",
    "            x=np.linspace(right, left, 4).astype(np.int64)\n",
    "            x=[(x[i],x[i+1]) for i in range(len(x)-1)]\n",
    "            force_modes = [\"move\", \"draw\", \"erase\"]\n",
    "            force_modes = {x[i]:force_modes[i] for i in range(len(x))}\n",
    "            #print(force_modes)\n",
    "            self.force_modes = force_modes\n",
    "        elif self.roi_pointer[\"mroi\"][0]>0:\n",
    "            mpointer = self.roi_pointer[\"mroi\"]\n",
    "            \n",
    "            for col, mode in self.force_modes.items():\n",
    "                \n",
    "                if col[0]<=mpointer[1]<col[1]:\n",
    "                    #print(col, mpointer)\n",
    "                    if self.fprev_mode==mode:\n",
    "                        self.fcurrent_count+=1\n",
    "                    else:\n",
    "                        self.fcurrent_count=0\n",
    "                        self.fprev_mode=mode\n",
    "                    if self.fcurrent_count>=self.fcount_mode:\n",
    "                        #print(\"f \", mode)\n",
    "                        #self.fcurrent_count=0\n",
    "                        \n",
    "                        return mode\n",
    "    def detector(self):\n",
    "        img = self.canvas.canvas.astype(np.uint8)\n",
    "        op = pytesseract.image_to_string(img, lang=\"eng\", nice=\"1\")\n",
    "        print(\"Detected: \", op)\n",
    "    def perform_mode(self):\n",
    "        if self.running_mode==\"clear\":\n",
    "            self.canvas.clear()\n",
    "            self.running_mode=\"move\"\n",
    "        if self.running_mode==\"restart\":\n",
    "            self.take_average =True\n",
    "            self.num_frames=0\n",
    "            self.running_mode=\"move\"\n",
    "            self.canvas.clear()\n",
    "        if self.running_mode==\"save\":\n",
    "            #cv2.imshow(\"canvas\", self.canvas.canvas.astype(np.uint8))\n",
    "            cv2.imwrite(\"canvas.png\", self.canvas.canvas.astype(np.uint8))\n",
    "            #cv2.destroyWindow(\"canvas\")\n",
    "            self.running_mode=\"move\"\n",
    "        if self.running_mode==\"exit\":\n",
    "            self.key=27\n",
    "        if self.running_mode==\"detect\":\n",
    "            self.running_mode=\"move\"\n",
    "            self.detector()\n",
    "    def main(self):\n",
    "        cam = cv2.VideoCapture(0) \n",
    "        self.num_frames = 0\n",
    "        self.take_average=True\n",
    "        while True:\n",
    "            (ret, frame) = cam.read()\n",
    "            if ret:\n",
    "                self.key = cv2.waitKey(1) & 0xFF\n",
    "                frame = imutils.resize(frame, width=self.size[1])\n",
    "                frame = cv2.flip(frame, 1)\n",
    "                clone = frame.copy()\n",
    "                gray = cv2.cvtColor(clone, cv2.COLOR_BGR2GRAY)\n",
    "                self.set_grays(gray)\n",
    "                self.size = frame.shape\n",
    "                \n",
    "                # if to take average and num frames on average taking is lesser than \n",
    "                if self.num_frames<self.avg_frames and self.take_average==True:\n",
    "                    self.running_average()\n",
    "                    cv2.putText(clone, str(self.num_frames), (self.roi_boxes[\"mroi\"][1], self.roi_boxes[\"mroi\"][0]-5),\n",
    "                                           cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 1)\n",
    "                    self.num_frames+=1\n",
    "                else:\n",
    "                    self.take_average=False\n",
    "                    clone = self.find_contours(clone)\n",
    "                    fmode = self.check_force_mode() \n",
    "                    #vui = self.vui.get_window()\n",
    "                    vui = self.vui.update_vui(pointer=self.roi_pointer[\"vroi\"], cpointer=self.roi_pointer[\"droi\"])\n",
    "                    if self.vui.hover is not None:\n",
    "                        self.running_mode = self.vui.running_mode   \n",
    "                    if  self.roi_counts[\"mroi\"] is not None:\n",
    "                        if self.roi_counts[\"vroi\"] is not None:\n",
    "                            if self.roi_counts[\"mroi\"]-5 > self.roi_counts[\"vroi\"] and fmode is not None:\n",
    "                                self.running_mode = fmode\n",
    "                            else:\n",
    "                                self.running_mode = self.vui.running_mode       \n",
    "                        else:\n",
    "                            self.running_mode = fmode\n",
    "                    self.perform_mode()\n",
    "                    self.vui.running_mode=self.running_mode\n",
    "                    canvas = self.canvas.update_window(mode=self.running_mode, \n",
    "                                                       pointer=self.roi_pointer[\"droi\"]).astype(np.uint8)\n",
    "                    final_window = self.get_window(canvas=canvas, vui=vui)\n",
    "                    cv2.imshow(\"CW\", final_window)\n",
    "                    \n",
    "                    self.roi_pointer[\"vroi\"] = (-1, -1)\n",
    "                    \n",
    "                clone = self.make_rectangles(clone)\n",
    "                cv2.imshow(\"Feed\", clone)\n",
    "                if self.key==27:\n",
    "                    break\n",
    "        cam.release()\n",
    "        cv2.destroyAllWindows()\n",
    "\n",
    "gw = ContourWriting(avg_frames=150, aweight=0.5)\n",
    "gw.main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I am going to point out features and shortcomings of this system now. \n",
    "\n",
    "### Codes\n",
    "Codes to current version of the system is available on link below and if it is not, then hit the comment or leave me message (LinkedIn or Twitter or mail me).\n",
    "* [Contour Based Writing](https://github.com/q-viper/Contour-Based-Writing/)\n",
    "\n",
    "### Features\n",
    "* A slider can be used to change size of pointer.\n",
    "* Code is refactored and made OOP.\n",
    "* Dual hand can be used to change modes draw/move/erase pointer.\n",
    "* Color can be picked from dropdown like fashion. We can add as many color as we want.\n",
    "* Total of 9 modes available.\n",
    "\n",
    "### Shortcomings\n",
    "Shortcomings are most helpful to find new feature on next version. Well here are plenty of them.\n",
    "* The system is usable by contour of anything. Hence some gesture confirming model must be used.\n",
    "* Also on above video, there can be seen pointer moving rapidly on the VUI regions. It is not always acceptable by users. Hence it must be eliminated soon.\n",
    "\n",
    "### Ideas\n",
    "* What if we can create a model that can classify gesture and we can define a certain gesture for certain mode?\n",
    "\n",
    "## What Next?\n",
    "I will try to solve shortcomings on next time. But i am interested to make this system run on mobile phones too. As per now, i am thinking of taking frames from device camera and process it. Then use some API call to get those frame. I might use Unity. I am highly excited to try using LSTMs and other state of the art Deep Learning Algorithms to make this system more awesome but i don't have internet access (other than cellular data) to do broad research."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why not read more?\n",
    "* [Deploying a RASA Chatbot on Android using Unity3d](https://acharyaramkrishna.com.np/2020/08/04/deploying-a-simple-rasa-chatbot-on-unity3d-project-to-make-a-chatbot-for-android-devices/)\n",
    "* [Gesture Based Visually Writing System Using OpenCV and Python](https://acharyaramkrishna.com.np/2020/08/01/gesture-based-visually-writing-system-using-opencv-and-python/)\n",
    "* [Logistic Regression from Scratch](https://acharyaramkrishna.com.np/2020/08/11/writing-a-logistic-regression-class-from-scratch/)\n",
    "* [Linear Regression from Scratch](https://acharyaramkrishna.com.np/2020/08/07/writing-a-linear-regression-class-from-scratch-using-python/)\n",
    "* [Writing Popular ML Optimizers from Scratch](https://acharyaramkrishna.com.np/2020/06/05/writing-popular-machine-learning-optimizers-from-scratch-on-python/)\n",
    "* [Feed Forward Neural Network from Scratch](https://acharyaramkrishna.com.np/2020/05/31/writing-a-deep-neural-network-from-scratch-on-python/)\n",
    "* [Convolutional Neural Networks from Scratch](https://acharyaramkrishna.com.np/2020/06/05/convolutional-neural-networks-from-scratch-on-python/)\n",
    "* [Writing a Simple Image Processing Class from Scratch](https://acharyaramkrishna.com.np/2020/05/31/image-processing-class-from-scratch-on-python/)\n",
    "* [Naive Bayes for text classifications: Scratch to Framework](https://acharyaramkrishna.com.np/2020/03/04/text-classification-using-naive-bayes-scratch-to-the-framework/)\n",
    "* [Simple OCR for Devanagari Handwritten Text](https://acharyaramkrishna.com.np/2020/02/25/building-ocr-for-devanagari-handwritten-character/)"
   ]
  }
 ],
 "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": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}