Preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:20:10.021358Z",
     "start_time": "2019-01-28T11:20:10.016509Z"
    }
   },
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:21:18.755904Z",
     "start_time": "2019-01-28T11:21:18.746478Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[68, 54, 73, 31],\n",
       " [95, 3, 14, 95],\n",
       " [78, 81, 47, 85],\n",
       " [60, 75, 60, 26],\n",
       " [27, 92, 94, 33],\n",
       " [4, 87, 82, 50],\n",
       " [48, 73, 61, 19],\n",
       " [61, 37, 32, 62],\n",
       " [6, 35, 70, 25],\n",
       " [29, 83, 57, 40],\n",
       " [28, 69, 31, 4],\n",
       " [69, 45, 30, 65],\n",
       " [44, 68, 52, 100],\n",
       " [24, 96, 94, 10],\n",
       " [48, 71, 61, 68],\n",
       " [77, 59, 87, 13],\n",
       " [3, 6, 49, 42],\n",
       " [12, 65, 68, 83],\n",
       " [53, 63, 80, 32],\n",
       " [15, 74, 47, 41]]"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final = []\n",
    "for i in range(20):\n",
    "    temp = []\n",
    "    for j in range(4):\n",
    "        temp.append(random.randint(1, 100))\n",
    "    final.append(temp)\n",
    "final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:29:09.769483Z",
     "start_time": "2019-01-28T11:29:09.759372Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[5, 5, 0, 0],\n",
       " [4, 10, 0, 0],\n",
       " [5, 15, 0, 0],\n",
       " [5, 20, 0, 0],\n",
       " [5, 25, 0, 0],\n",
       " [15, 5, 0, 0],\n",
       " [14, 10, 0, 0],\n",
       " [15, 15, 0, 0],\n",
       " [15, 20, 0, 0],\n",
       " [14, 25, 0, 0]]"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final = [[5, 5, 0, 0],\n",
    "         [4, 10, 0, 0],\n",
    "         [5, 15, 0, 0],\n",
    "         [5, 20, 0, 0],\n",
    "         [5, 25, 0, 0],\n",
    "         [15, 5, 0, 0],\n",
    "         [14, 10, 0, 0],\n",
    "         [15, 15, 0, 0],\n",
    "         [15, 20, 0, 0],\n",
    "         [14, 25, 0, 0]]\n",
    "final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:29:26.895960Z",
     "start_time": "2019-01-28T11:29:26.886864Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[5, 5, 0, 0],\n",
       " [15, 5, 0, 0],\n",
       " [4, 10, 0, 0],\n",
       " [14, 10, 0, 0],\n",
       " [5, 15, 0, 0],\n",
       " [15, 15, 0, 0],\n",
       " [5, 20, 0, 0],\n",
       " [15, 20, 0, 0],\n",
       " [5, 25, 0, 0],\n",
       " [14, 25, 0, 0]]"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new = sorted(final, key=lambda val: val[1])\n",
    "new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:29:46.968502Z",
     "start_time": "2019-01-28T11:29:46.959712Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[4, 10, 0, 0],\n",
       " [5, 5, 0, 0],\n",
       " [5, 15, 0, 0],\n",
       " [5, 20, 0, 0],\n",
       " [5, 25, 0, 0],\n",
       " [14, 10, 0, 0],\n",
       " [14, 25, 0, 0],\n",
       " [15, 5, 0, 0],\n",
       " [15, 15, 0, 0],\n",
       " [15, 20, 0, 0]]"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new = sorted(new, key=lambda val: val[0])\n",
    "new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aadhar Back Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:01:35.406675Z",
     "start_time": "2019-01-28T04:01:35.398583Z"
    }
   },
   "outputs": [],
   "source": [
    "# 1\n",
    "details = ['mn SIO oF qr AT AE Address S/O Shankar Thorvae', 'near ranvir krida mandal',\n",
    "           '1/12devki misra chawl bhatwad', '400084', 'Ghatkopar West Mumbai',\n",
    "           'Maharashtra 400084', 'helpuidaigovin wwwuidalgovin PO Box No 1947',\n",
    "           '1947', '1800 180 1947', 'Bengalury-580 001']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:02:03.404502Z",
     "start_time": "2019-01-28T04:02:03.401399Z"
    }
   },
   "outputs": [],
   "source": [
    "# 2\n",
    "details = ['Address ROOM NO B20', 'ANGAN APART DR', 'MUZUMDAR MARG NEAR',\n",
    "           'AXE FEAT FTATYT WEY', 'SPANDAN HOSPITAL', '421503', 'KULGAON Badiapur Kuigaon',\n",
    "           'Thane Maharashtra 421503', 'wenitigavin FO Bone 1941Seach S08 001']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:02:57.236706Z",
     "start_time": "2019-01-28T04:02:57.231305Z"
    }
   },
   "outputs": [],
   "source": [
    "# 3\n",
    "details = ['Address S/O Muralidharan', '8/0', '- Warier BARC COLONY 53-',\n",
    "           '400094 alkananda Anu Shakti Nagar', 'Mumbai Sub Urban', 'Maharashtra 400094',\n",
    "           'helpuidaigovin wwwuidaigovin PO Box No 1947', '1947', '1800 180 1947', 'Bengaluru-560 001']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:03:55.511732Z",
     "start_time": "2019-01-28T04:03:55.505104Z"
    }
   },
   "outputs": [],
   "source": [
    "# 4\n",
    "details = ['Address', 'D/O D/O Dnyaneshwar Kakade', 'Mukatabai Hospital H-9Room',\n",
    "           '- -', 'No-7RBKadam', 'MargBhatwadiBarvenagar', 'ghatkopar west 50 Mumbai',\n",
    "           '- 400084', 'Maharashtra - 400084', '8921 4402 3664', 'WWW', '1947',\n",
    "           'help uidalgovin', 'wwwuidaigovin']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:05:46.837433Z",
     "start_time": "2019-01-28T04:05:46.833902Z"
    }
   },
   "outputs": [],
   "source": [
    "# 5\n",
    "details = ['wen Are', 'FETAADRAARINDIAERR OF', 'Address', 'akot akola road chohotta Akot Akola',\n",
    "           'axKot aKkaia roag cnono Maharashtra - 444101', '- 444101', '9380 1178 5186',\n",
    "           'Aadhaar-Mera Aadhaar Meri Pehachan']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:06:38.382069Z",
     "start_time": "2019-01-28T04:06:38.377887Z"
    }
   },
   "outputs": [],
   "source": [
    "# 6\n",
    "details = ['UNIQUE IDENTIFICATION AUTHORITY OF INDIA', 'AADNAAR', 'Address',\n",
    "           'J-40/12 J-SECT N-2 CIDCO', '-40/12 - -2', 'JALNA ROAD Aurangabad',\n",
    "           'Aurangabad MH Aurangabad', 'Maharashtra 431001', '431001']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:10:08.055591Z",
     "start_time": "2019-01-28T04:10:08.052699Z"
    }
   },
   "outputs": [],
   "source": [
    "# 7\n",
    "details = ['Address Nagargaon Pal Kolhapur', 'WW ATE TN', 'Maharashtra 416209',\n",
    "           'np 416209', '7191 2085 0750', '1947', 'help uidaigovin',\n",
    "           'wwwuidalgovin', '1800 300 1947']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:09:43.984882Z",
     "start_time": "2019-01-28T04:09:43.979987Z"
    }
   },
   "outputs": [],
   "source": [
    "# 8\n",
    "details = ['Unique identification Authority of india', '7 1- Address Akshay Society C7 1- 2 NearnA enh ew',\n",
    "           '2 Sai Plaza Markel Sector 15 Air Navi AA a',\n",
    "           'Crewe me mews wy 15 Wer Mumbai Thane Airgii Maharashtra', '400708', '400708',\n",
    "           '8156 1305 9387', '8488', '1947', 'vil govin', '1800 300 1947', 'ww uidalgovin']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:09:10.032668Z",
     "start_time": "2019-01-28T04:09:10.022524Z"
    }
   },
   "outputs": [],
   "source": [
    "# 9\n",
    "details = ['10 aeeomddig', 'Unique Identification Authority of India',\n",
    "           'S/O Deranna Shetty Shiriya akmoakden amIckdeo eae corey ewes',\n",
    "           'Mouse Shiriya Kumbla Via', 'AA Bary slick mis ad ide', 'Shiriya Kasaragod',\n",
    "           'Kerala - 671321', 'sapg - 671321', '6408 9520 2', 'Nol']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cropped Aadhar Back Details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:37:01.722593Z",
     "start_time": "2019-01-28T11:37:01.718102Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['Address', 'D/O Dnyaneshwar Kakade', 'Mukatabai Hospital H-9Room', 'No-7RBKadam', 'MargBhatwadiBarve nagar', 'ghatkopar west s0 Mumbai', 'Maharashtra - 400084']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:15:49.998489Z",
     "start_time": "2019-01-28T11:15:49.995159Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['Address S/O Shankar Thorvae', 'THE', 'near ranvir krida mandal', '112devki misra chawl bhatwadi', 'Ghatkopar West Mumbai', 'Maharashtra 400084']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:16:22.782306Z",
     "start_time": "2019-01-28T11:16:22.777402Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['Address ROOM NO B/201', 'ANE', 'ANGAN APART DR', 'MUZUMDAR MARG NEAR', 'SPANDAN HOSPITAL', 'KULGAON Badiapur Kuigaon', 'Thane Maharashira 421503']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:16:29.597699Z",
     "start_time": "2019-01-28T11:16:29.593710Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['Address Nagargaon Pal Kolhapur', 'Maharashtra 416209']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:16:36.929519Z",
     "start_time": "2019-01-28T11:16:36.925745Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['iya', '- 671321']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T13:22:35.297956Z",
     "start_time": "2019-01-28T13:22:35.293014Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['Address', 'J-40/12 J-SECT N-2 CIDCO', 'JALNA ROAD Aurangabad', 'Aurangabad, (M.H.) Aurangabad', 'Maharashtra 431001']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:16:59.521322Z",
     "start_time": "2019-01-28T11:16:59.518121Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['7 1-', 'Address Akshay Society C-7 1- 2 Near', 'Mumbai Thane Airci Maharashtra', '400708']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:17:05.810105Z",
     "start_time": "2019-01-28T11:17:05.807756Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['Address S/O Muralidharan', 'Warier BARC COLONY 53-', '400094 alkananda Anu Shakti Nagar', 'Mumbai Sub Urban', 'Maharashtra 400094']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:17:17.383510Z",
     "start_time": "2019-01-28T11:17:17.378524Z"
    }
   },
   "outputs": [],
   "source": [
    "details = ['Address', 'akot akola road chohotta Akot Akola', '8151 Maharashtra - 444101']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T13:22:38.325182Z",
     "start_time": "2019-01-28T13:22:38.321218Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Address',\n",
       " 'J-40/12 J-SECT N-2 CIDCO',\n",
       " 'JALNA ROAD Aurangabad',\n",
       " 'Aurangabad, (M.H.) Aurangabad',\n",
       " 'Maharashtra 431001']"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T13:23:41.588016Z",
     "start_time": "2019-01-28T13:23:41.581743Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Address\n",
      "J-40/12 J-SECT N-2 CIDCO\n",
      "JALNA ROAD Aurangabad\n",
      "Aurangabad, (M.H.) Aurangabad\n",
      "Maharashtra 431001\n"
     ]
    }
   ],
   "source": [
    "for i in details:\n",
    "    text = re.sub('[^A-Za-z0-9-/,.() ]+', '', i)\n",
    "    print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T11:37:05.842376Z",
     "start_time": "2019-01-28T11:37:05.833009Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D/O Dnyaneshwar Kakade\n",
      "Mukatabai Hospital H-9Room\n",
      "No-7RBKadam\n",
      "MargBhatwadiBarve nagar\n",
      "ghatkopar west s0 Mumbai\n",
      "Maharashtra - 400084\n"
     ]
    }
   ],
   "source": [
    "imp = {'Address': ''}\n",
    "\n",
    "try:\n",
    "    if 'Address' in details[0]:\n",
    "        if details[0].split('Address', 1)[1].strip() != '':\n",
    "            imp[\"Address\"] = details[0].split('Address', 1)[1].strip()\n",
    "        for line in details[1:]:\n",
    "            imp[\"Address\"] += '\\n' + line\n",
    "            \n",
    "    elif 'Address' in details[1]:\n",
    "        if details[1].split('Address', 1)[1].strip() != '':\n",
    "            imp[\"Address\"] = details[1].split('Address', 1)[1].strip()\n",
    "        for line in details[2:]:\n",
    "            imp[\"Address\"] += '\\n' + line\n",
    "    \n",
    "    elif 'Address' in details[2]:\n",
    "        if details[2].split('Address', 1)[1].strip() != '':\n",
    "            imp[\"Address\"] = details[2].split('Address', 1)[1].strip()\n",
    "        for line in details[3:]:\n",
    "            imp[\"Address\"] += '\\n' + line\n",
    "    \n",
    "    else:\n",
    "        imp[\"Address\"] = 'Failed to read Address'\n",
    "except Exception as _:\n",
    "    imp[\"Address\"] = 'Failed to read Address'\n",
    "imp['Address'] = imp['Address'].strip()\n",
    "print(imp['Address'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T13:02:47.081684Z",
     "start_time": "2019-01-28T13:02:47.076778Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UPLOAD/dasd/adsad\n"
     ]
    }
   ],
   "source": [
    "s = 'UPLOAD/dasd/adsad/tes.jpg'\n",
    "print('/'.join(s.split('/')[:-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T07:11:48.146553Z",
     "start_time": "2019-01-28T07:11:43.264985Z"
    }
   },
   "outputs": [],
   "source": [
    "image = cv2.imread('ignore/aadhar_back/2.jpg')\n",
    "image = image[200:600, 200:600]\n",
    "cv2.imshow('image', image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T06:53:55.432967Z",
     "start_time": "2019-01-28T06:53:13.436587Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ",\n",
      "\n",
      "\n",
      "\n",
      "Address:\n",
      "\n",
      "D/O Dnyaneshwar Kakade,\n",
      "Mukatabai Hospital, H-9,Room\n",
      "No-7,RBKadam\n",
      "Marg,Bhatwadi,Barvenagar,\n",
      "ghatkopar west s0, Mumbai,\n",
      "Maharashtra - 400084\n",
      "fT Address SIO Shankar Thorvae,\n",
      "\n",
      "1 near ranvir krida mandal,\n",
      "\n",
      ", , 112,devki misra chawl bhatwadi\n",
      "Ghatkopar West, Mumbai,\n",
      "Maharashira, 400084\n",
      ",\n",
      "\n",
      "qx\n",
      ",\n",
      "\n",
      "Address ROOM NO B/201\n",
      "ANGAN APART, DR\n",
      "SPANDAN HOSPITAL, \n",
      "KULGAON, Badiaparr, Kuigaon,\n",
      "Thane, Maharashtra, 421503\n",
      " Address: Nagargaon, Pal, Kolhapur,\n",
      "Maharashtra, 416209\n",
      "iya\n",
      "\n",
      "\n",
      "\n",
      " /  :  ,\n",
      " , ,  , ,\n",
      "\n",
      "\n",
      " - 671321\n",
      "Lio ad Ah dA a di ddl\n",
      "\n",
      "Address:\n",
      "\n",
      "J-40/12, J-SECT, N-2 CIDCO\n",
      "JALNA ROAD, Aurangabad,\n",
      "Aurangabad (MH), Aurangabad\n",
      "\n",
      "Maharashtra, 431001\n",
      "Address: Akshay Society , C7, 1- 2, Near \n",
      "\n",
      "Sai Plaza Market, Sector 15, Airoli, Navi\n",
      "Mumbai, Thane, Airci  \n",
      "400708\n",
      "\n",
      "  \n",
      "\n",
      "1\n",
      "\n",
      "\n",
      "Address: S/O Muralidharan\n",
      ", Warier, BARC COLONY, 53-\n",
      "400094 alkananda, Anu Shakti Nagar,\n",
      "\n",
      "Mumbai( Sub Urban ),\n",
      "\n",
      "Maharashtra, 400094\n",
      "Address:\n",
      " akot akola road chohotta, Akot, Akola,\n",
      "S131, Maharashtra - 444101\n"
     ]
    }
   ],
   "source": [
    "for i in os.listdir('ignore/aadhar_back/'):\n",
    "    image = cv2.imread('ignore/aadhar_back/' + i, 0)\n",
    "#     cv2.imshow('og', image)\n",
    "#     cv2.waitKey(0)\n",
    "    height, width = image.shape\n",
    "\n",
    "    image = image[int(height * (15 / 100)):int(height * (70 / 100)), int(width * (40 / 100)):]\n",
    "#     image = cv2.Canny(image, 30, 150)\n",
    "    _, image = cv2.threshold(image, 150, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)\n",
    "#     image = cv2.dilate(image, np.ones((45, 5)))\n",
    "#     cv2.imshow('image', image)\n",
    "#     cv2.waitKey(0)\n",
    "#     cv2.destroyAllWindows()\n",
    "    text = pyt.image_to_string(image, lang='eng+hin+mar+mal', config=('--oem 1 --psm 3'))\n",
    "    text = re.sub('[^A-Za-z0-9-/():,\\n ]+', '', text)\n",
    "    print(text)\n",
    "# print(image.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T06:46:07.394620Z",
     "start_time": "2019-01-28T06:46:07.387823Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pytesseract as pyt\n",
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Perspective Transform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-28T04:13:51.206801Z",
     "start_time": "2019-01-28T04:13:51.077425Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-27T15:49:27.429990Z",
     "start_time": "2019-01-27T15:49:26.302944Z"
    }
   },
   "outputs": [],
   "source": [
    "image = cv2.imread('ignore/aadhar_back/20190124_171047.jpg')\n",
    "\n",
    "og = cv2.imread('ignore/aadhar_back/20190124_171047.jpg')\n",
    "image = cv2.circle(image, (1004, 624), 15, (0, 0, 255), -2)\n",
    "image = cv2.circle(image, (3380, 580), 15, (0, 0, 255), -2)\n",
    "image = cv2.circle(image, (392, 2040), 15, (0, 0, 255), -2)\n",
    "image = cv2.circle(image, (3260, 2500), 15, (0, 0, 255), -2)\n",
    "\n",
    "pts1 = np.float32([[1004, 624], [3380, 580], [392, 2040], [3260, 2500]])\n",
    "pts2 = np.float32([[0, 0], [1500, 0], [0, 1000], [1500, 1000]])\n",
    "\n",
    "matrix = cv2.getPerspectiveTransform(pts1, pts2)\n",
    "\n",
    "og = cv2.warpPerspective(og, matrix, (1500, 1000))\n",
    "\n",
    "image = cv2.resize(og, None, fx = 0.5, fy = 0.5)\n",
    "cv2.imwrite('ignore/aadhar_back/9.jpg', og)\n",
    "cv2.imshow('image', image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seven Segment Display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-22T01:22:21.846359Z",
     "start_time": "2019-01-22T01:22:20.181656Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-22T02:08:53.008855Z",
     "start_time": "2019-01-22T02:08:43.788268Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(-0.5, 2191.5, 1678.5, -0.5)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "og = cv2.imread('ignore/sevenseg/2019-01-21 20:41:40.908206.png')\n",
    "\n",
    "lab = cv2.cvtColor(og, cv2.COLOR_BGR2HSV)\n",
    "luminance, a, b = cv2.split(lab)\n",
    "\n",
    "lum = luminance.copy()\n",
    "test = luminance.copy()\n",
    "cv2.imshow('test', test)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()\n",
    "hist,bins = np.histogram(luminance,256,[0,256])\n",
    "\n",
    "mean = int((np.argmax(hist) + np.argmin(hist)) / 5)\n",
    "\n",
    "luminance[luminance > mean] = 255\n",
    "luminance[luminance <= mean] = 0\n",
    "\n",
    "plt.plot(hist)\n",
    "plt.show()\n",
    "\n",
    "blur = cv2.GaussianBlur(lum,(5, 5),0)\n",
    "his,bins = np.histogram(blur,256,[0,256])\n",
    "# meanl = int((np.argmax(his) + np.argmin(his)) / 4)\n",
    "# meanl = h\n",
    "lum = lum.ravel() / lum.max()\n",
    "# cv2.imshow('klum', lum)\n",
    "# cv2.wait\n",
    "# lum[lum <= meanl] = 0\n",
    "plt.plot(his)\n",
    "plt.show()\n",
    "\n",
    "fig, ax = plt.subplots(1, 2)\n",
    "ax1, ax2 = ax.ravel()\n",
    "ax1.imshow(test, cmap=plt.cm.gray)\n",
    "ax1.set_title('Original')\n",
    "ax1.axis('off')\n",
    "# ax2.imshow(lum, cmap=plt.cm.gray)\n",
    "# ax2.set_title('Skeleton of the image')\n",
    "# ax2.axis('off')\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T05:16:55.709337Z",
     "start_time": "2019-01-16T05:16:55.703126Z"
    }
   },
   "outputs": [],
   "source": [
    "values = [\"NOLG STTT\", \".MAHARASHTRA STATE MOTOR DRIVING LICENCE\", \"DL No MHO01 20180006033\", \"DOI 15-02-2018\",\n",
    "\"arty w\", \"Valid Till 14-02-2038 NT\", \"15-02-2013\", \"AUTHORISATION TO DRIVE FOLLOWING CLASS\", \"cov\", \n",
    "\"15-02-2018\", \"MCWG 15-02-2018\", \"DOB 11-12-1997 BG A\", \"Name BHUMIT ADIVAREKAR\", \"S/DW of JAY ADIVAREKAR\",\n",
    "\"Add 3 421 RAMDOOT BLDG\", \"M P ROAD CURRY ROAD\", \"Mumbai MH\", \"OF Nd\", \"PIN 400012Signature ID of Ags Arn\",\n",
    "\"PIN 400012\", \"If IAL EF ersSuing Authority MHO1\", \"Impression of Holde\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T05:16:56.005937Z",
     "start_time": "2019-01-16T05:16:56.002377Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'NOLG STTT', 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'DL No MHO01 20180006033', 3: 'DOI 15-02-2018', 4: 'arty w', 5: 'Valid Till 14-02-2038 NT', 6: '15-02-2013', 7: 'AUTHORISATION TO DRIVE FOLLOWING CLASS', 8: 'cov', 9: '15-02-2018', 10: 'MCWG 15-02-2018', 11: 'DOB 11-12-1997 BG A', 12: 'Name BHUMIT ADIVAREKAR', 13: 'S/DW of JAY ADIVAREKAR', 14: 'Add 3 421 RAMDOOT BLDG', 15: 'M P ROAD CURRY ROAD', 16: 'Mumbai MH', 17: 'OF Nd', 18: 'PIN 400012Signature ID of Ags Arn', 19: 'PIN 400012', 20: 'If IAL EF ersSuing Authority MHO1', 21: 'Impression of Holde'}\n"
     ]
    }
   ],
   "source": [
    "details = {}\n",
    "for idx, i in enumerate(values):\n",
    "    details[idx] = i\n",
    "print(details)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T07:59:18.411882Z",
     "start_time": "2019-01-16T07:59:18.404947Z"
    }
   },
   "outputs": [],
   "source": [
    "details1 = {0: '111 1', 1: '2 VIL ALMAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'DOI 05-11-2008', 3: '2 DL No MHO1 20080116201', 4: 'w aid Tiff 04-11-2028 NT', 5: 'FORM 7RULE 16 2', 6: 'DLD 24-08-2016', 7: 'RUL', 8: 'AUTHORISATION TO DRIVE FOLLOWING CLASS22 IT IANA', 9: 'OF VEHICLES THROUGHOUT INDIA', 10: 'MCWG 05-11-2008', 11: 'DOB 19-04-1989 BG', 12: 'Name ONAL TINWALA', 13: 'S/D/W of RAJAB TINWALA', 14: 'Add 2ND FLR R/21 43/47 JEEVANBHAI BLDG', 15: 'MASTAN TANK ST MUMBAI', 16: 'PIN 400008', 17: 'Signature/Thumb', 18: 'S$gnature ID of a name', 19: '117 750 49 01 2016280', 20: 'Impression of Holder'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T10:42:21.027664Z",
     "start_time": "2019-01-16T10:42:21.023186Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'THE UNION OF INDIA',\n",
       " 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE',\n",
       " 2: 'DL No MHO01 20090077155',\n",
       " 3: 'DOI 24-07-2009',\n",
       " 4: 'Valid Tilf 23-07-2029 NT',\n",
       " 5: 'FORM 7',\n",
       " 6: 'RULE 16 2',\n",
       " 7: 'AUTHORISATION TO DRIVE FOLLOWING CLASS',\n",
       " 8: 'OF VEHICLES THROUGHOUT INDIA',\n",
       " 9: 'DOI',\n",
       " 10: 'LMV 24-07-2009',\n",
       " 11: 'DOB 28-04-1990 BG',\n",
       " 12: 'Name VIDIT SHAH',\n",
       " 13: 'S/D/W of MANOJ SHAH',\n",
       " 14: 'NH AF FW Add 151/B KALPATARU RESIDENCY SION E',\n",
       " 15: 'MUMBAI',\n",
       " 16: 'Rab pd Sy -',\n",
       " 17: 'PIN 400022',\n",
       " 18: 'Signature/Thumb',\n",
       " 19: 'ID of',\n",
       " 20: 'Impression of Holder',\n",
       " 21: 'Gg ure oisSuing Authority MHO1 2009150'}"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "details1 = {0: 'THE UNION OF INDIA', 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'DL No MHO01 20090077155', 3: 'DOI 24-07-2009', 4: 'Valid Tilf 23-07-2029 NT', 5: 'FORM 7', 6: 'RULE 16 2', 7: 'AUTHORISATION TO DRIVE FOLLOWING CLASS', 8: 'OF VEHICLES THROUGHOUT INDIA', 9: 'DOI', 10: 'LMV 24-07-2009', 11: 'DOB 28-04-1990 BG', 12: 'Name VIDIT SHAH', 13: 'S/D/W of MANOJ SHAH', 14: 'NH AF FW Add 151/B KALPATARU RESIDENCY SION E', 15: 'MUMBAI', 16: 'Rab pd Sy -', 17: 'PIN 400022', 18: 'Signature/Thumb', 19: 'ID of', 20: 'Impression of Holder', 21: 'Gg ure oisSuing Authority MHO1 2009150'}\n",
    "details1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T10:42:27.783507Z",
     "start_time": "2019-01-16T10:42:27.777182Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'THE UNION OF INDIA',\n",
       " 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE',\n",
       " 2: 'DL No MH01 20060039783STH ANA',\n",
       " 3: 'DO 19-07-2006',\n",
       " 4: 'Vaid Till 18-07-2026 NT',\n",
       " 5: 'FORM',\n",
       " 6: 'DLD 25-03-2017',\n",
       " 7: 'FF Jim RULE 16 2',\n",
       " 8: 'AUTHORISATION TO DRIVE FOLLOWING CLASS',\n",
       " 9: 'OF VEHICLES THROUGHOUT INDIA',\n",
       " 10: 'Cov',\n",
       " 11: 'MCWG 19-07-2006',\n",
       " 12: 'LMV 19-07-2006',\n",
       " 13: 'DOB 12-03-1987 BG',\n",
       " 14: 'Name ABHISHEK BHAUD',\n",
       " 15: 'S/DMV of PRAKASH BHAUD',\n",
       " 16: 'Add 19 A 3RD FLR COLABA',\n",
       " 17: 'CHAMBER COLABA CROSS LANE',\n",
       " 18: 'MUMB3AI',\n",
       " 19: 'PIN 400005',\n",
       " 20: 'Signature/Thumb',\n",
       " 21: 'Signature ID of',\n",
       " 22: 'Jsuing Authority MHG1 2017284',\n",
       " 23: 'Impression of Holder'}"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "details1 = {0: 'THE UNION OF INDIA', 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'DL No MH01 20060039783STH ANA', 3: 'DO 19-07-2006', 4: 'Vaid Till 18-07-2026 NT', 5: 'FORM', 6: 'DLD 25-03-2017', 7: 'FF Jim RULE 16 2', 8: 'AUTHORISATION TO DRIVE FOLLOWING CLASS', 9: 'OF VEHICLES THROUGHOUT INDIA', 10: 'Cov', 11: 'MCWG 19-07-2006', 12: 'LMV 19-07-2006', 13: 'DOB 12-03-1987 BG', 14: 'Name ABHISHEK BHAUD', 15: 'S/DMV of PRAKASH BHAUD', 16: 'Add 19 A 3RD FLR COLABA', 17: 'CHAMBER COLABA CROSS LANE', 18: 'MUMB3AI', 19: 'PIN 400005', 20: 'Signature/Thumb', 21: 'Signature ID of', 22: 'Jsuing Authority MHG1 2017284', 23: 'Impression of Holder'}\n",
    "details1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-17T14:50:27.079805Z",
     "start_time": "2019-01-17T14:50:27.073116Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'THE UNION OF INDIA',\n",
       " 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE',\n",
       " 2: 'DOI 16-05-2016',\n",
       " 3: 'Valid Till 15-05-2036 NT',\n",
       " 4: 'FORM 7ire rr 4',\n",
       " 5: '16-10-2018',\n",
       " 6: 'Ise 3RULE 16 2',\n",
       " 7: 'AUTHORISATION TO DRIVE FOLLOWING CLASS',\n",
       " 8: 'OF VEHICLES THROUGHOUT INDIA',\n",
       " 9: 'cov',\n",
       " 10: 'LMV 16-05-2016',\n",
       " 11: 'DOB 04-09-1989 BG O',\n",
       " 12: 'Name GANESH PALVE',\n",
       " 13: 'S/DWW of SUBHASH PALVE',\n",
       " 14: 'Add SANTOSH NAGAR NR DHANANJAY NIWAS',\n",
       " 15: 'O T SECTION ULHASNAGAR- 4 DIST- THANE Ulhasnagar ------- -',\n",
       " 16: 'Ulhasnagar Thane MH',\n",
       " 17: 'PIN 421004',\n",
       " 18: 'Signature ID of',\n",
       " 19: 'Signature/Thumb',\n",
       " 20: 'IsSuing Authority MHO5',\n",
       " 21: 'Impression of Holder'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "details1 = {0: 'THE UNION OF INDIA', 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'DOI 16-05-2016', 3: 'Valid Till 15-05-2036 NT', 4: 'FORM 7ire rr 4', 5: '16-10-2018', 6: 'Ise 3RULE 16 2', 7: 'AUTHORISATION TO DRIVE FOLLOWING CLASS', 8: 'OF VEHICLES THROUGHOUT INDIA', 9: 'cov', 10: 'LMV 16-05-2016', 11: 'DOB 04-09-1989 BG O', 12: 'Name GANESH PALVE', 13: 'S/DWW of SUBHASH PALVE', 14: 'Add SANTOSH NAGAR NR DHANANJAY NIWAS', 15: 'O T SECTION ULHASNAGAR- 4 DIST- THANE Ulhasnagar ------- -', 16: 'Ulhasnagar Thane MH', 17: 'PIN 421004', 18: 'Signature ID of', 19: 'Signature/Thumb', 20: 'IsSuing Authority MHO5', 21: 'Impression of Holder'}\n",
    "details1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T09:23:24.045427Z",
     "start_time": "2019-01-16T09:23:24.031187Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'THE UNION OF INDIA',\n",
       " 1: 'aa a a a a a a a a a a a a EEEMAHARASHTRA STATE MOTOR DRIVING LICENCE',\n",
       " 2: 'GE DL No MH02 20090128158',\n",
       " 3: 'DO 27-07-2009',\n",
       " 4: 'Valid Till 26-07-2029 NT',\n",
       " 5: 'FORM',\n",
       " 6: 'AED 01-10-2011',\n",
       " 7: 'RULE 16 2',\n",
       " 8: 'AUTHORISATION TO DRIVE FOLLOWING CLASS',\n",
       " 9: 'OF VEHICLES THROUGHOUT INDIA',\n",
       " 10: 'DOJ',\n",
       " 11: 'LMV 19-09-2011',\n",
       " 12: 'MCWG 27-07-2009',\n",
       " 13: 'DOB 27-09-1986 BG',\n",
       " 14: 'Name AVANI PATEL',\n",
       " 15: 'S/D/W Of NAVIN PATEL',\n",
       " 16: 'Add D-603 GOKUL RESIDENCY THAUKAR VILLAGE',\n",
       " 17: 'KANDIVALI E',\n",
       " 18: 'MUMBAI',\n",
       " 19: 'PIN 400101',\n",
       " 20: 'Signature/Thumb',\n",
       " 21: 'Signature ID of',\n",
       " 22: 'Jsuing Authority MHO02 2011287',\n",
       " 23: 'Impression of Holder'}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "details1 = {0: 'THE UNION OF INDIA', 1: 'aa a a a a a a a a a a a a EEEMAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'GE DL No MH02 20090128158', 3: 'DO 27-07-2009', 4: 'Valid Till 26-07-2029 NT', 5: 'FORM', 6: 'AED 01-10-2011', 7: 'RULE 16 2', 8: 'AUTHORISATION TO DRIVE FOLLOWING CLASS', 9: 'OF VEHICLES THROUGHOUT INDIA', 10: 'DOJ', 11: 'LMV 19-09-2011',\n",
    "12: 'MCWG 27-07-2009', 13: 'DOB 27-09-1986 BG', 14: 'Name AVANI PATEL', 15: 'S/D/W Of NAVIN PATEL', 16: 'Add D-603 GOKUL RESIDENCY THAUKAR VILLAGE', 17: 'KANDIVALI E', 18: 'MUMBAI', 19: 'PIN 400101', 20: 'Signature/Thumb', 21: 'Signature ID of', 22: 'Jsuing Authority MHO02 2011287', 23: 'Impression of Holder'}\n",
    "details1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T06:31:00.875811Z",
     "start_time": "2019-01-16T06:31:00.865464Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'RENE fel Reig ir', 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'DOI 1 1502-2018', 3: 'DL No MH01 20180006033', 4: 'TM Fa', 5: 'Valid Till 14-02-2038 NT', 6: '15-02-2018', 7: 'FAIRS RULE 16 2', 8: 'AUTHORISATION TO DRIVE FOLLOWING CLASS', 9: 'OF VEHICLES THROUGHOUT INDIA', 10: 'CoV', 11: 'LMV 16-02-2018- mm maa', 12: 'MCWG 15-02-2018', 13: 'DOB 11-12-1997 BG A', 14: 'Name BHUMIT ADIVAREKAR', 15: 'S/DMW of VIJAY ADIVAREKAR', 16: 'Add 3 421 RAMDOOT BLDG', 17: 'MP RCAD CURRY ROAD', 18: 'Mumbai MH', 19: '-PIN 400012 yong FerransSignature 1D ofBE Ah', 20: 'PIN 400012', 21: 'Signature/Thumb', 22: 'impression jon of Holder'}\n"
     ]
    }
   ],
   "source": [
    "details1 = {0: 'RENE fel Reig ir', 1: 'MAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'DOI 1 1502-2018', 3: 'DL No MH01 20180006033', 4: 'TM Fa', 5: 'Valid Till 14-02-2038 NT', 6: '15-02-2018', 7: 'FAIRS RULE 16 2', 8: 'AUTHORISATION TO DRIVE FOLLOWING CLASS', 9: 'OF VEHICLES THROUGHOUT INDIA', 10: 'CoV', 11: 'LMV 16-02-2018- mm maa', 12: 'MCWG 15-02-2018', 13: 'DOB 11-12-1997 BG A', 14: 'Name BHUMIT ADIVAREKAR', 15: 'S/DMW of VIJAY ADIVAREKAR', 16: 'Add 3 421 RAMDOOT BLDG', 17: 'MP RCAD CURRY ROAD', 18: 'Mumbai MH', 19: '-PIN 400012 yong FerransSignature 1D ofBE Ah', 20: 'PIN 400012', 21: 'Signature/Thumb', 22: 'impression jon of Holder'}\n",
    "print(details1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-17T15:03:38.294867Z",
     "start_time": "2019-01-17T15:03:38.280080Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'THE UNION OF INDIA', 1: 'EE I MAHARASHTRA STATE MOTOR DRIVING LICENCE', 2: 'DL No', 3: 'DO 1 15-02-2018', 4: 'aoa ad', 5: '15-02-2018', 6: 'RULE 16 2', 7: 'AUTHORISATION TO DRIVE FOLLOWING CLASS', 8: 'OF VEHICLES THROUGHQUT INDIA', 9: 'Cov', 10: 'LMV 16-02-2018', 11: 'MCWG 15-02-2018', 12: 'DOB 11-12-1997 BG A', 13: 'Name BHUMIT ADIVAREKAR', 14: 'S/DMW of VIJAY ADIVAREKAR', 15: 'Add 3 421 RAMDOOT BLDG', 16: 'MP ROAD CURRY ROAD', 17: 'Mumbai MH', 18: 'Nad zn', 19: 'Azim Ure', 20: 'PIN 400012', 21: 'Signature/Thumb', 22: 'Signature ID ofas', 23: 'issuing Authority MHO1', 24: 'Impression of Holder'}\n"
     ]
    }
   ],
   "source": [
    "details1 = {0: 'THE UNION OF INDIA', 1: 'EE I MAHARASHTRA STATE MOTOR DRIVING LICENCE',\n",
    "            2: 'DL Noex MH01 20130006033', 3: 'DO 1 15-02-2018', 4: 'aoa ad', 5: '15-02-2018',\n",
    "            6: 'RULE 16 2', 7: 'AUTHORISATION TO DRIVE FOLLOWING CLASS',\n",
    "            8: 'OF VEHICLES THROUGHQUT INDIA', 9: 'Cov', 10: 'LMV 16-02-2018',\n",
    "            11: 'MCWG 15-02-2018', 12: 'DOB 11-12-1997 BG A', 13: 'Name BHUMIT ADIVAREKAR',\n",
    "            14: 'S/DMW of VIJAY ADIVAREKAR', 15: 'Add 3 421 RAMDOOT BLDG',\n",
    "            16: 'MP ROAD CURRY ROAD', 17: 'Mumbai MH', 18: 'Nad zn', 19: 'Azim Ure',\n",
    "            20: 'PIN 400012', 21: 'Signature/Thumb', 22: 'Signature ID ofas',\n",
    "            23: 'issuing Authority MHO1', 24: 'Impression of Holder'}\n",
    "print(details1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T05:16:56.907906Z",
     "start_time": "2019-01-16T05:16:56.894288Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NOLG STTT\n",
      "MAHARASHTRA STATE MOTOR DRIVING LICENCE\n",
      "DL No MHO01 20180006033\n",
      "DOI 15-02-2018\n",
      "arty w\n",
      "Valid Till 14-02-2038 NT\n",
      "15-02-2013\n",
      "AUTHORISATION TO DRIVE FOLLOWING CLASS\n",
      "cov\n",
      "15-02-2018\n",
      "MCWG 15-02-2018\n",
      "DOB 11-12-1997 BG A\n",
      "Name BHUMIT ADIVAREKAR\n",
      "S/DW of JAY ADIVAREKAR\n",
      "Add 3 421 RAMDOOT BLDG\n",
      "M P ROAD CURRY ROAD\n",
      "Mumbai MH\n",
      "OF Nd\n",
      "PIN 400012Signature ID of Ags Arn\n",
      "PIN 400012\n",
      "If IAL EF ersSuing Authority MHO1\n",
      "Impression of Holde\n"
     ]
    }
   ],
   "source": [
    "for i in values:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DL NO\n",
    "Name\n",
    "Fathers Name\n",
    "Add\n",
    "PIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-17T15:02:59.921577Z",
     "start_time": "2019-01-17T15:02:59.914666Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['THE UNION OF INDIA',\n",
       " 'EE I MAHARASHTRA STATE MOTOR DRIVING LICENCE',\n",
       " 'Di No',\n",
       " 'DO 1 15-02-2018',\n",
       " 'aoa ad',\n",
       " '15-02-2018',\n",
       " 'RULE 16 2',\n",
       " 'AUTHORISATION TO DRIVE FOLLOWING CLASS',\n",
       " 'OF VEHICLES THROUGHQUT INDIA',\n",
       " 'Cov',\n",
       " 'LMV 16-02-2018',\n",
       " 'MCWG 15-02-2018',\n",
       " 'DOB 11-12-1997 BG A',\n",
       " 'Name BHUMIT ADIVAREKAR',\n",
       " 'S/DMW of VIJAY ADIVAREKAR',\n",
       " 'Add 3 421 RAMDOOT BLDG',\n",
       " 'MP ROAD CURRY ROAD',\n",
       " 'Mumbai MH',\n",
       " 'Nad zn',\n",
       " 'Azim Ure',\n",
       " 'PIN 400012',\n",
       " 'Signature/Thumb',\n",
       " 'Signature ID ofas',\n",
       " 'issuing Authority MHO1',\n",
       " 'Impression of Holder']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "details1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-17T15:03:44.623309Z",
     "start_time": "2019-01-17T15:03:44.618037Z"
    }
   },
   "outputs": [],
   "source": [
    "details1 = [ text for text in details1.values() ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T02:47:19.811291Z",
     "start_time": "2019-01-21T02:47:19.806989Z"
    }
   },
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Licence Labels extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-17T15:03:46.985961Z",
     "start_time": "2019-01-17T15:03:46.972497Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', '']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'Address': '3 421 RAMDOOT BLDG MP ROAD CURRY ROAD',\n",
       " 'DL NO': '',\n",
       " 'Date of Birth': '11-12-1997',\n",
       " \"Father's Name\": 'VIJAY ADIVAREKAR',\n",
       " 'Name': 'BHUMIT ADIVAREKAR',\n",
       " 'Pin Code': '400012'}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imp = {}\n",
    "num = 0\n",
    "for idx in range(len(details1)):\n",
    "    if 'DL No' in details1[idx]:\n",
    "        imp[\"DL NO\"] = details1[idx].split('DL No')[1].strip()\n",
    "    elif 'Di No' in details1[idx]:\n",
    "        imp[\"DL NO\"] = details1[idx].split('Di No')[1].strip()\n",
    "#         del details1[idx]\n",
    "    elif details1[idx].startswith('DOB'):\n",
    "        dob = re.findall(\"([0-9]{2}\\-[0-9]{2}\\-[0-9]{4})\", details1[idx].split(' ', 1)[1])[0]\n",
    "        #imp[\"DOB\"] = details1[idx].split(' ', 1)[1].strip().split(r\"[0-9]{0,2}\\-[0-9]{0,2}\\-[0-9]{0,4}\", 1)[0]\n",
    "        imp[\"Date of Birth\"] = dob\n",
    "#         del details1[idx]\n",
    "        imp[\"Name\"] = details1[idx + 1].split(' ', 1)[1].strip()\n",
    "#         del details1[idx + 1]\n",
    "        try:\n",
    "            imp[\"Father's Name\"] = details1[idx + 2].split('of',1)[1].strip()\n",
    "#             del details1[idx + 2]\n",
    "        except Exception as _:\n",
    "            imp[\"Father's Name\"] = details1[idx + 2].split('Of',1)[1].strip()\n",
    "#             del details1[idx + 2]\n",
    "        i = 4\n",
    "        address = details1[idx + 3].split('Add', 1)[1].strip()\n",
    "#         del details1[idx + 3]\n",
    "        while not details1[idx + i].startswith('PIN') and i < 8:\n",
    "            if details1[idx + i].isupper() != True:\n",
    "#                 del details1[idx + i]\n",
    "                i += 1\n",
    "                continue\n",
    "            address += ' ' + details1[idx + i]\n",
    "#             del details1[idx + i]\n",
    "            i += 1\n",
    "        imp[\"Address\"] = address\n",
    "        imp[\"Pin Code\"] = details1[idx + i].split(' ', 1)[1]\n",
    "#         del details1[idx + i]\n",
    "        break\n",
    "    elif details1[idx].startswith('Name'):\n",
    "        dob = re.findall(\"([0-9]{2}\\-[0-9]{2}\\-[0-9]{4})\", details1[idx - 1].split(' ', 1)[1])[0]\n",
    "        imp[\"Date of Birth\"] = dob\n",
    "#         del details1[idx - 1]\n",
    "        imp[\"Name\"] = details1[idx][4:].strip()\n",
    "#         del details1[idx]\n",
    "        try:\n",
    "            imp[\"Father's Name\"] = details1[idx + 2].split('of',1)[1].strip()\n",
    "#             del details1[idx + 2]\n",
    "        except Exception as _:\n",
    "            imp[\"Father's Name\"] = details1[idx + 2].split('Of',1)[1].strip()\n",
    "#             del details1[idx + 2]\n",
    "        i = 3\n",
    "        address = details1[idx + 2].split('Add', 1)[1].strip()\n",
    "#         del details1[idx + 2]\n",
    "        while not details1[idx + i].startswith('PIN') and i < 7:\n",
    "            if details1[idx + i].isupper() != True:\n",
    "#                 del details1[idx + i]\n",
    "                i += 1\n",
    "                continue\n",
    "            address += ' ' + details1[idx + i]\n",
    "#             del details1[idx + i]\n",
    "            i += 1\n",
    "        imp[\"Address\"] = address\n",
    "        imp[\"Pin Code\"] = details1[idx + i].split(' ', 1)[1]\n",
    "#         del details1[idx + i]\n",
    "        break\n",
    "imp\n",
    "# details1\n",
    "# print(details1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T03:01:11.138489Z",
     "start_time": "2019-01-21T03:01:11.132083Z"
    }
   },
   "outputs": [],
   "source": [
    "aadhar = {0: 'MOHAMMED MUTEEULLAH MOHAMMED', 1: 'WH a4 / Yeaar of Birth 1a994', 2: 'EY / Male', 3: '4622 7574 0201'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T14:20:23.059047Z",
     "start_time": "2019-01-16T14:20:23.055410Z"
    }
   },
   "outputs": [],
   "source": [
    "aadhar = {0: 'AFA', 1: 'Praneet Shrihari Bomma', 2: 'DOB 04-10-1996', 3: '2808 4878 6547'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T02:56:00.711636Z",
     "start_time": "2019-01-21T02:56:00.704931Z"
    }
   },
   "outputs": [],
   "source": [
    "aadhar = {0: 'Vidit Manoj Shah', 1: '/ 008 28/04/1990 Wik', 2: '/ MALE', 3: '4455 8760 7069', 4: 'AT-1T7 -'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T03:06:05.296549Z",
     "start_time": "2019-01-21T03:06:05.290918Z"
    }
   },
   "outputs": [],
   "source": [
    "aadhar = {0: 'GOVERNMENT OF INDIA', 1: 'Praneet Shrihari Bomma', 2: 'DOaB 04-10-1996', 3: 'Ea EFs', 4: 'RIE', 5: 'GenderMale', 6: '2808 4878 6547'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T12:42:48.033395Z",
     "start_time": "2019-01-16T12:42:48.023274Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'GOVERNMENT OF INDIA',\n",
       " 1: 'Praneet Shrihari Bomma',\n",
       " 2: 'DOB 04-10-1996',\n",
       " 3: 'Ea EFs',\n",
       " 4: 'RIE',\n",
       " 5: 'GenderMale',\n",
       " 6: '2808 4878 6547'}"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aadhar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T13:54:33.438226Z",
     "start_time": "2019-01-21T13:54:33.422021Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: ' CSUPR6644H',\n",
       " 1: '08/11/1997',\n",
       " 2: 'DATE OF BIRTH',\n",
       " 3: 'NAME',\n",
       " 4: 'BRIJ BIHARI SINGH',\n",
       " 5: 'VIPUL SINGH RAGHUVANSHI',\n",
       " 6: 'FATHERS NAME',\n",
       " 7: '§ SEES',\n",
       " 8: '© AES WRE'}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pan = {0:\" CSUPR6644H\",1:\"08/11/1997\",2:\"DATE OF BIRTH\",3:\"NAME\",\n",
    "       4:\"BRIJ BIHARI SINGH\",5:\"VIPUL SINGH RAGHUVANSHI\",6:\"FATHERS NAME\",\n",
    "       7:\"§ SEES\",8:\"© AES WRE\"}\n",
    "pan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T03:06:07.878932Z",
     "start_time": "2019-01-21T03:06:07.874321Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2808 4878 6547',\n",
       " 'GenderMale',\n",
       " 'RIE',\n",
       " 'Ea EFs',\n",
       " 'DOaB 04-10-1996',\n",
       " 'Praneet Shrihari Bomma',\n",
       " 'GOVERNMENT OF INDIA']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp = []\n",
    "for i, j in aadhar.items():\n",
    "    temp.append(j)\n",
    "temp = temp[::-1]\n",
    "temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aadhar Labels Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T03:06:10.839952Z",
     "start_time": "2019-01-21T03:06:10.814828Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Aadhar No': '2808 4878 6547',\n",
       " 'Date of Birth': '04-10-1996',\n",
       " 'Gender': 'Male',\n",
       " 'Name': 'Praneet Shrihari Bomma'}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imp = {}\n",
    "\n",
    "for idx in range(len(temp)):\n",
    "    if re.search(\"[0-9]{4}\\s[0-9]{4}\\s[0-9]{4}\", temp[idx]):\n",
    "        try:\n",
    "            imp['Aadhar No'] = re.findall(\"[0-9]{4}\\s[0-9]{4}\\s[0-9]{4}\", temp[idx])[0]\n",
    "        except Exception as _:\n",
    "            imp['Aadhar No'] = \"Not Found\"\n",
    "        if temp[idx + 1].endswith(\"Female\") or temp[idx + 1].endswith(\"FEMALE\"):\n",
    "            imp[\"Gender\"] = \"Female\"\n",
    "        elif temp[idx + 1].endswith(\"Male\") or temp[idx + 1].endswith(\"MALE\"):\n",
    "            imp[\"Gender\"] = \"Male\"\n",
    "        elif temp[idx + 2].endswith(\"Female\") or temp[idx + 2].endswith(\"FEMALE\"):\n",
    "            imp[\"Gender\"] = \"Female\"\n",
    "        elif temp[idx + 2].endswith(\"Male\") or temp[idx + 2].endswith(\"MALE\"):\n",
    "            imp[\"Gender\"] = \"Male\"\n",
    "        elif temp[idx + 3].endswith(\"Female\") or temp[idx + 3].endswith(\"FEMALE\"):\n",
    "            imp[\"Gender\"] = \"Female\"\n",
    "        elif temp[idx + 3].endswith(\"Male\") or temp[idx + 3].endswith(\"MALE\"):\n",
    "            imp[\"Gender\"] = \"Male\"\n",
    "    elif re.search(\"[0-9]{2}\\-|/[0-9]{2}\\-|/[0-9]{4}\", temp[idx]):\n",
    "        try:\n",
    "            imp[\"Date of Birth\"] = re.findall(\"[0-9]{2}\\-[0-9]{2}\\-[0-9]{4}\", temp[idx])[0]\n",
    "        except Exception as e:\n",
    "            imp[\"Date of Birth\"] = re.findall(\"[0-9]{2}/[0-9]{2}/[0-9]{4}\", temp[idx])[0]\n",
    "        imp[\"Name\"] = temp[idx + 1]\n",
    "    elif \"Year of Birth\" in temp[idx]:\n",
    "        try:\n",
    "            imp[\"Year of Birth\"] = re.findall(\"[0-9]{4}\", temp[idx])[0]\n",
    "        except Exception as _:\n",
    "            imp[\"Year of Birth\"] = \"Not Found\"\n",
    "        imp[\"Name\"] = temp[idx + 1]\n",
    "    elif re.search(\"[0-9]{4}\", temp[idx]):\n",
    "        try:\n",
    "            imp[\"Year of Birth\"] = re.findall(\"[0-9]{4}\", temp[idx])[0]\n",
    "        except Exception as e:\n",
    "            imp[\"Year of Birth\"] = \"Not Found\"\n",
    "        imp[\"Name\"] = temp[idx + 1]\n",
    "    elif len(temp[idx].split(' ')) > 2:\n",
    "        if 'GOVERNMENT' in temp[idx] or 'OF' in temp[idx] or 'INDIA' in temp[idx]:\n",
    "            continue\n",
    "        else:\n",
    "            imp[\"Name\"] = temp[idx]\n",
    "            \n",
    "imp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pan Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T14:02:43.945833Z",
     "start_time": "2019-01-16T14:02:43.942377Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['28/04/1990']"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check = \"/ 008 28/04/1990 Wik\"\n",
    "re.findall(\"[0-9]{2}/[0-9]{2}/[0-9]{4}\", check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-18T02:33:13.317079Z",
     "start_time": "2019-01-18T02:33:13.312199Z"
    }
   },
   "outputs": [],
   "source": [
    "sting = \"GOVERNMENT OF INDIA\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-18T02:34:45.375171Z",
     "start_time": "2019-01-18T02:34:45.363540Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HERE\n"
     ]
    }
   ],
   "source": [
    "if \"GOVERNaMENT\" or \"OaF\" in sting:\n",
    "    print(\"HERE\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T03:00:02.475831Z",
     "start_time": "2019-01-21T03:00:02.466948Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here\n"
     ]
    }
   ],
   "source": [
    "test = ['check', 'test', 'okay']\n",
    "\n",
    "if 'check' in test or 'taest' in test or 'oakay' in test:\n",
    "    print(\"here\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-21T03:03:01.000182Z",
     "start_time": "2019-01-21T03:03:00.993592Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['HEllo', 'thren', '', 'ow']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'HEllo thren  ow'\n",
    "s.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-15T09:40:29.758288Z",
     "start_time": "2019-01-15T09:40:05.776293Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = cv2.imread('ignore/mp6.jpg', 0)\n",
    "# img = cv2.resize(img, (600, 300))\n",
    "# img = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 15, 5)\n",
    "\n",
    "kernel_sharpening = np.array([[-1,-1,-1], \n",
    "                              [-1, 9,-1],\n",
    "                              [-1,-1,-1]])\n",
    "\n",
    "hist,bins = np.histogram(img,256,[0,256])\n",
    "plt.plot(hist), \n",
    "plt.show()\n",
    "mean = int((np.argmax(hist) + np.argmin(hist)) / 2)\n",
    "\n",
    "\n",
    "\n",
    "# img = cv2.GaussianBlur(img, (5, 5), 0)\n",
    "# img = cv2.adaptiveThreshold(img,255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,15,5)\n",
    "_, img = cv2.threshold(img, np.argmax(hist) - 15, 255, cv2.THRESH_BINARY)\n",
    "# img = cv2.GaussianBlur(img, (5, 5), 0)\n",
    "# img = cv2.filter2D(img, -1, kernel_sharpening)\n",
    "\n",
    "kernel = np.ones((5, 2), np.uint8)\n",
    "\n",
    "# test = cv2.morphologyEx(OBinary, cv2.MORPH_OPEN, kernel)\n",
    "# test = cv2.dilate(img, kernel, iterations = 1)\n",
    "\n",
    "# test = cv2.Canny(test, 30, 150)\n",
    "\n",
    "# _, ctrs_line, _ = cv2.findContours(test.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "# sorted_ctrs_line = sorted(ctrs_line, key=lambda ctr: cv2.boundingRect(ctr)[1])\n",
    "# # img = cv2.copyMakeBorder(img, 40, 40, 40, 40, cv2.BORDER_CONSTANT)\n",
    "# # img = cv2.resize(img, (32, 32))\n",
    "# cv2.imshow('test', test)\n",
    "# cv2.waitKey(0)\n",
    "# cv2.destroyAllWindows()\n",
    "# for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "#     x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "#     if w_line * h_line < 200 or h_line < 20:\n",
    "#         continue\n",
    "#     print(x_line, y_line, w_line, h_line)\n",
    "#     cropped_line = img[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "#     cropped_line = cv2.copyMakeBorder(cropped_line, 1,1,1,1,cv2.BORDER_CONSTANT)\n",
    "#     cropped_line = cv2.resize(cropped_line, (32, 32))\n",
    "#     cropped_line = cv2.copyMakeBorder(cropped_line, 2,2,2,2,cv2.BORDER_CONSTANT)\n",
    "#     cropped_line = cv2.resize(cropped_line, (32, 32))\n",
    "#     cv2.imshow('test', cropped_line)\n",
    "#     cv2.waitKey(0)\n",
    "#     cv2.destroyAllWindows()\n",
    "#     output = model.predict_classes(cropped_line.reshape(-1, 32, 32, 1))\n",
    "#     print(output)\n",
    "\n",
    "# for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "#     # getting coordinates of the line contour\n",
    "#     x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "    \n",
    "cv2.imshow('test', img)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()\n",
    "\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-15T07:27:56.755181Z",
     "start_time": "2019-01-15T07:27:56.750565Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-15T07:49:59.449334Z",
     "start_time": "2019-01-15T07:49:57.395831Z"
    }
   },
   "outputs": [],
   "source": [
    "img = cv2.imread('ignore/test1.jpg', 0)\n",
    "# img = cv2.resize(img, (600, 300))\n",
    "# img = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 15, 5)\n",
    "\n",
    "kernel_sharpening = np.array([[-1,-1,-1], \n",
    "                              [-1, 9,-1],\n",
    "                              [-1,-1,-1]])\n",
    "# img = cv2.GaussianBlur(img, (5, 5), 0)\n",
    "# img = cv2.adaptiveThreshold(img,255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,15,5)\n",
    "_, img = cv2.threshold(img, 212, 255, cv2.THRESH_BINARY_INV)\n",
    "# img = cv2.GaussianBlur(img, (5, 5), 0)\n",
    "# img = cv2.filter2D(img, -1, kernel_sharpening)\n",
    "\n",
    "kernel = np.ones((5, 2), np.uint8)\n",
    "\n",
    "# test = cv2.morphologyEx(OBinary, cv2.MORPH_OPEN, kernel)\n",
    "# test = cv2.dilate(img, kernel, iterations = 1)\n",
    "\n",
    "# test = cv2.Canny(test, 30, 150)\n",
    "\n",
    "# _, ctrs_line, _ = cv2.findContours(test.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "# sorted_ctrs_line = sorted(ctrs_line, key=lambda ctr: cv2.boundingRect(ctr)[1])\n",
    "# # img = cv2.copyMakeBorder(img, 40, 40, 40, 40, cv2.BORDER_CONSTANT)\n",
    "# # img = cv2.resize(img, (32, 32))\n",
    "# cv2.imshow('test', test)\n",
    "# cv2.waitKey(0)\n",
    "# cv2.destroyAllWindows()\n",
    "# for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "#     x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "#     if w_line * h_line < 200 or h_line < 20:\n",
    "#         continue\n",
    "#     print(x_line, y_line, w_line, h_line)\n",
    "#     cropped_line = img[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "#     cropped_line = cv2.copyMakeBorder(cropped_line, 1,1,1,1,cv2.BORDER_CONSTANT)\n",
    "#     cropped_line = cv2.resize(cropped_line, (32, 32))\n",
    "#     cropped_line = cv2.copyMakeBorder(cropped_line, 2,2,2,2,cv2.BORDER_CONSTANT)\n",
    "#     cropped_line = cv2.resize(cropped_line, (32, 32))\n",
    "#     cv2.imshow('test', cropped_line)\n",
    "#     cv2.waitKey(0)\n",
    "#     cv2.destroyAllWindows()\n",
    "#     output = model.predict_classes(cropped_line.reshape(-1, 32, 32, 1))\n",
    "#     print(output)\n",
    "\n",
    "# for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "#     # getting coordinates of the line contour\n",
    "#     x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "    \n",
    "cv2.imshow('test', img)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()\n",
    "\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-05T03:46:52.985210Z",
     "start_time": "2019-01-05T03:46:52.959157Z"
    }
   },
   "outputs": [],
   "source": [
    "def pre_process(template_type, image_path):\n",
    "    image = cv2.imread(image_path)\n",
    "    \n",
    "    kernel_sharpening = np.array([[-1,-1,-1], \n",
    "                              [-1, 9,-1],\n",
    "                              [-1,-1,-1]])\n",
    "#     image = cv2.medianBlur(image, 5)\n",
    "#     image = cv2.filter2D(image, -1, kernel_sharpening)\n",
    "#     image = cv2.medianBlur(image, 5)\n",
    "#     image = cv2.filter2D(image, -1, kernel_sharpening)\n",
    "#     image = cv2.medianBlur(image, 5)\n",
    "\n",
    "    image = cv2.GaussianBlur(image, (5, 5), 0)\n",
    "    image = cv2.filter2D(image, -1, kernel_sharpening)\n",
    "    image = cv2.GaussianBlur(image, (5, 5), 0)\n",
    "    image = cv2.filter2D(image, -1, kernel_sharpening)\n",
    "    image = cv2.GaussianBlur(image, (5, 5), 0)\n",
    "#     showImage('luminance', image)\n",
    "    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)\n",
    "\n",
    "    luminance, a, b = cv2.split(lab)\n",
    "\n",
    "    hist,bins = np.histogram(luminance,256,[0,256])\n",
    "\n",
    "    mean = int((np.argmax(hist) + np.argmin(hist)) / 2)\n",
    "\n",
    "    luminance[luminance > mean] = 255\n",
    "    luminance[luminance <= mean] = 0\n",
    "\n",
    "#     cv2.imwrite('luminance.jpg', luminance)\n",
    "\n",
    "    template = cv2.imread(template_type, 0)\n",
    "    \n",
    "    ret3, template = cv2.threshold(template, 220, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
    "\n",
    "    luminance = np.subtract(template, luminance)\n",
    "    \n",
    "    kernel = np.ones((2, 2), np.uint8)\n",
    "    luminance = cv2.erode(luminance, kernel, iterations=1)\n",
    "    \n",
    "    luminance = np.invert(luminance)\n",
    "#     showImage('luminance', luminance)\n",
    "#     text = pyt.image_to_string(luminance)\n",
    "#     data = text.replace(\"#\", \"4\").replace(\"'\", \"\").replace('\"', '').replace('!', 'I').replace(']', 'I').upper().split('\\n')\n",
    "    \n",
    "    return luminance\n",
    "\n",
    "def get_text(image):\n",
    "    \n",
    "    # getting edges of the text in image\n",
    "    image_edges = cv2.Canny(image, 30, 150)\n",
    "    \n",
    "    \n",
    "    # dilating image to detect individual lines\n",
    "    kernel_line = np.ones((2, 100), np.uint8)\n",
    "    dilated_line = cv2.dilate(image_edges, kernel_line, iterations=1)\n",
    "    \n",
    "    # finding contours of the line\n",
    "    im2, ctrs_line, hier = cv2.findContours(dilated_line.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    sorted_ctrs_line = sorted(ctrs_line, key=lambda ctr: cv2.boundingRect(ctr)[1])\n",
    "    \n",
    "    text = []\n",
    "\n",
    "    for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "        # getting coordinates of the line contour\n",
    "        x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "        if w_line * h_line < 3000 or w_line * h_line > 50000 or h_line <= 20:\n",
    "            continue\n",
    "        cropped_line = image[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "        # cropped_line = np.invert(cropped_line)\n",
    "        cropped_line= cv2.copyMakeBorder(cropped_line,10,10,10,10,cv2.BORDER_CONSTANT,value=[255, 255, 255])\n",
    "#         showImage('test', cropped_line)\n",
    "        line_text = pyt.image_to_string(cropped_line)\n",
    "        line_text = line_text.replace('/', 'i').replace(\"#\", \"4\").replace(\"'\", \"\").replace('\"', '').replace('!', 'I').replace(']', 'I').upper()\n",
    "        if line_text != '':\n",
    "#             print(line_text)\n",
    "            text.append(line_text)\n",
    "    return text\n",
    "\n",
    "def showImage(title, image):\n",
    "    cv2.imshow(title, image)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-05T01:53:50.023102Z",
     "start_time": "2019-01-05T01:53:42.846430Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CSUPR6644H\n",
      "FOR WR AM { FATHERS NAME\n",
      "['CSUPR6644H', 'FOR WR AM { FATHERS NAME']\n"
     ]
    }
   ],
   "source": [
    "test = pre_process('pancard_template.jpg', 'test4.png')\n",
    "text = get_text(test)\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-05T02:26:21.200242Z",
     "start_time": "2019-01-05T02:26:21.195126Z"
    }
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-05T03:47:45.360442Z",
     "start_time": "2019-01-05T03:47:02.318709Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CSUPR6644H']\n",
      "['CSUPRBB644H', 'WIIPUL SINGH RAGHUVANSHI', '©»\\n&\\n(3\\n=\\nW\\nSA', '2RIJ BIHARI SINGH', 'ZEEI']\n",
      "['CSUPRBB644H', 'WIIPUL SINGH RAGHUVANSHI', '©»\\n&\\n(3\\n=\\nW\\nSA', '2RIJ BIHARI SINGH', 'ZEEI']\n",
      "['CSUPRGSO44H', 'A\\n{=\\nA\\n\\n—V', 'VIPUL SINGH RAGHUVANSHII', 'ES RE\\nTY OND ME', 'BRIJ BIHARI SINGH', '08I11I1897']\n",
      "['CSUPRG644H', 'A NAME', 'VIPUL SINGH RAGHUVANSHI', 'TOT HT ITH I FATHERS NAME', 'BRI1J BIHAR} SINGH', '~~ ~ . .\\nHA RT DE. DATE OF BIRTH', '08I11I1997']\n",
      "['CSUPR6644H']\n",
      "['CSUPRGBE44H', 'ATH I NAME', 'VIPUL SINGH RAGHUVANSHI', 'T9QT EHT 1H I FATHERS NAME', 'BRIJ BIHARI SINGH']\n",
      "['CSUPRG643H', 'AE']\n",
      "['VIPUL SINGH RAGRHUVARNSHI', 'BRIJ BIHARI SINGH', 'LOIS', '08I11I1997', 'LR, ON\\nETA RE RR A RE TT A A A LTT YL I IMCS THR YUMEINT LPT 4 YT LARRY LN} LLP']\n",
      "['CSUPR6644H', 'J I NAME', 'VIPUL SINGH RAGHUVANSHI', '{OAT &T 99 I FATHERS NAME', 'BRIJ BIHARI SINGH']\n",
      "['[180\\n\\nLE']\n",
      "['[180\\n\\nLE']\n",
      "['CSUPR6644H', 'I NLAME', 'VIE JL SINGH RAGHUVANSHI', 'TFT WT AY I FATHERS NAME', 'BRIJ BIHARI SINGH']\n",
      "['CSUPRG644H', 'A NAME', 'VIPUL SINGH RAGHUVANSHI', 'TOT HT ITH I FATHERS NAME', 'BRI1J BIHAR} SINGH', '~~ ~ . .\\nHA RT DE. DATE OF BIRTH', '08I11I1997']\n",
      "['CSUPR6644H', 'J I NAME', 'VIPUL SINGH RAGHUVANSHI', '{OAT &T 99 I FATHERS NAME', 'BRIJ BIHARI SINGH']\n",
      "['CSUPRG644H', 'VYHPUL SINGH RAGHUVANSHI', 'ON', '2RIJ BIHARI SINGH', '08I11I1997']\n",
      "['CSUPR6644H', 'HY I NAME', 'BRIJ BIHARI SINGH']\n",
      "['CSUPR6644H', 'LE FR DM 2 ER', 'OT J MAME', 'VIPUL SINGH RAGHUVANSHI', '3\\n\\nZT TRY\\n\\n“IN', 'BRIJ BIHARI SINGH', 'A']\n",
      "['CSUPRGG44H', '“TQ I NAME']\n",
      "['CSUPR6644H', 'QJ1¥ I NAME', '{OAR SHT ATH I FATHERS NAME', 'BRIJ BIHARI SINGH']\n",
      "['CSUPR6644H', '2\\n\\nJD\\n\\n4\\n\\nI NAME', 'VIPUL SINGH RAGHUVANSHI', 'FOAT 657 TH I FATHERS NAME', 'BRIJ BIHARI SINGH']\n",
      "['5\\n\\nLO\\nFRG\\n\\n \\n\\nLL I 0-1', 'FAN\\n\\nJAN\\n\\nSHI', 'ARM', '08I11I1997']\n",
      "['CSUPRG6644H']\n",
      "['CSUPRBB644H', 'WIIPUL SINGH RAGHUVANSHI', '©»\\n&\\n(3\\n=\\nW\\nSA', '2RIJ BIHARI SINGH', 'ZEEI']\n"
     ]
    }
   ],
   "source": [
    "for i in os.listdir('pancards/'):\n",
    "    test = pre_process('pancard_template.jpg', 'pancards/' + i)\n",
    "    text = get_text(test)\n",
    "    print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-08T11:07:56.820017Z",
     "start_time": "2019-01-08T11:07:56.815225Z"
    }
   },
   "outputs": [],
   "source": [
    "def clean_text(text_list):\n",
    "    my_list = []\n",
    "    for i in text_list:\n",
    "        if i != ' ' or i != '  ' or i != '':\n",
    "            i = re.sub('[^A-Za-z0-9-/ ]+', '', i)\n",
    "            shortword = re.compile(r'\\W*\\b[^0-9/]\\w{1,2}\\b')\n",
    "            i = shortword.sub('', i)\n",
    "            i = i.lstrip()\n",
    "            i = i.rstrip()\n",
    "            i = re.sub('\\s{2,}', '', i) \n",
    "            if i == '':\n",
    "                continue\n",
    "            my_list.append(i)\n",
    "    return my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-15T07:33:04.064151Z",
     "start_time": "2019-01-15T07:33:02.784969Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pytesseract as pyt\n",
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-15T09:12:45.792701Z",
     "start_time": "2019-01-15T09:12:41.787805Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(801, 1421, 3)\n",
      "229\n"
     ]
    }
   ],
   "source": [
    "image = cv2.imread('ignore/test1.jpg')\n",
    "# image = cv2.resize(image, None, fx = 0.3, fy = 0.3)\n",
    "# cv2.imshow('title', image)\n",
    "# cv2.waitKey(0)\n",
    "# image = image[450:1080, 0:900]\n",
    "print(image.shape)\n",
    "\n",
    "kernel_sharpening = np.array([[-1,-1,-1], \n",
    "                              [-1, 9,-1],\n",
    "                              [-1,-1,-1]])\n",
    "\n",
    "image = cv2.GaussianBlur(image, (5, 5), 0)\n",
    "image = cv2.filter2D(image, -1, kernel_sharpening)\n",
    "image = cv2.GaussianBlur(image, (3, 3), 0)\n",
    "image = cv2.filter2D(image, -1, kernel_sharpening)\n",
    "image = cv2.GaussianBlur(image, (3, 3), 0)\n",
    "\n",
    "# cv2.imshow('title', image)\n",
    "# cv2.waitKey(0)\n",
    "\n",
    "lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)\n",
    "luminance, a, b = cv2.split(lab)\n",
    "\n",
    "# luminance, a, b = cv2.split(image)\n",
    "# b,bins = np.histogram(luminance,256,[0,256])\n",
    "# g,bins = np.histogram(a,256,[0,256])\n",
    "# r,bins = np.histogram(b,256,[0,256])\n",
    "# plt.plot(b), \n",
    "# plt.show()\n",
    "# plt.plot(g)\n",
    "# plt.show()\n",
    "# plt.plot(r)\n",
    "# plt.show()\n",
    "\n",
    "# cv2.imshow('title', b)\n",
    "# cv2.waitKey(0)\n",
    "\n",
    "hist,bins = np.histogram(luminance,256,[0,256])\n",
    "\n",
    "print(np.argmax(hist))\n",
    "\n",
    "luminance = np.clip(luminance, np.argmax(hist) - 15, np.argmax(hist) + 15)\n",
    "\n",
    "luminance[luminance == np.argmax(hist) - 15] = 0\n",
    "luminance[luminance == np.argmax(hist) + 15] = 255\n",
    "luminance[luminance == 255] = 0\n",
    "# luminance[(luminance > np.argmax(hist) - 15) and (luminance < np.argmax(hist) + 15)] = 255\n",
    "\n",
    "# luminance[luminance > np.argmax(hist) - 15] = 255\n",
    "# luminance[luminance < np.argmax(hist) - 15] = 0\n",
    "# luminance[luminance < np.argmax(hist) + 15] = 255\n",
    "# luminance[luminance > np.argmax(hist) + 15] = 255\n",
    "\n",
    "# mean = int((np.argmax(hist) + np.argmin(hist)) / 2)\n",
    "\n",
    "# mean = np.argmax(hist)\n",
    "# plt.plot(hist)\n",
    "# plt.show()\n",
    "# luminance[luminance > mean] = 255\n",
    "# luminance[luminance <= mean] = 0\n",
    "\n",
    "# image = cv2.GaussianBlur(image, (3, 3), 0)\n",
    "# image = cv2.filter2D(image, -1, kernel_sharpening)\n",
    "# image = cv2.Laplacian(image, cv2.CV_64F)\n",
    "# image = cv2.Canny(image, 0, 10)\n",
    "\n",
    "# showImage('lines', dilated_line)\n",
    "\n",
    "# # finding contours of the line\n",
    "# _, ctrs_line, _ = cv2.findContours(image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "# sorted_ctrs_line = sorted(ctrs_line, key=lambda ctr: cv2.boundingRect(ctr)[3])\n",
    "\n",
    "# x_line, y_line, w_line, h_line = cv2.boundingRect(sorted_ctrs_line[-1])\n",
    "# print(x_line, y_line, w_line, h_line)\n",
    "\n",
    "# cropped_line = image[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "\n",
    "# for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "#     # getting coordinates of the line contour\n",
    "#     x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "#     if w_line * h_line < 3000 or w_line * h_line > 50000:\n",
    "#         continue\n",
    "\n",
    "#     cropped_line = image[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "#     blac = np.invert(cropped_line)\n",
    "#     cv2.imwrite('bdgdfg' + str(i) + '.jpg', blac)\n",
    "\n",
    "#     testing = og_image[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "\n",
    "cv2.imshow('title', luminance)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "text = pyt.image_to_string(luminance, config=('--oem 1 --psm 3'))\n",
    "data = text.replace(\"#\", \"4\").replace(\"'\", \"\").replace('\"', '').replace('!', 'I').replace(']', 'I').upper().split('\\n')\n",
    "# clean_text(data)\n",
    "# print(data)\n",
    "# cv2.imshow('title', luminance)\n",
    "# cv2.waitKey(0)\n",
    "# cv2.imshow('title', cv2.resize(a, None, fx = 0.5, fy = 0.5))\n",
    "# cv2.waitKey(0)\n",
    "# cv2.imshow('title', cv2.resize(b, None, fx = 0.5, fy = 0.5))\n",
    "# cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BE CE\n",
    "INCOME TAX DEPARTMENT ZL GOVLOF INDIA\n",
    "= SET = IE\n",
    "PERMANENT ACCOUNT NUMBER CARD\n",
    "CSUPR6644H\n",
    "RE MAME\n",
    "VIPUL SINGH RAGHUVANSHI\n",
    "ATT ITH [ FATHERS NAME\n",
    "BRIJ BIHARI SINGH\n",
    "TEETER D > OF BIR\n",
    "08/11/1997\n",
    "WIPED\n",
    "GTATHY [ SIGNATURE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-31T05:34:09.568414Z",
     "start_time": "2018-12-31T05:33:59.334766Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "import shutil\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "import thinning\n",
    "import pytesseract as pyt\n",
    "import imutils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-31T05:34:09.601346Z",
     "start_time": "2018-12-31T05:34:09.597362Z"
    }
   },
   "outputs": [],
   "source": [
    "def showImage(title, image):\n",
    "    cv2.imshow(title, image)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-31T10:09:07.687539Z",
     "start_time": "2018-12-31T10:08:58.408741Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1080, 1920)\n",
      "172\n",
      "129\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "' ‘ MH01 20150001078 ‘u-12-f/(J14\n",
      "\n",
      "._ Vv\n",
      "\n",
      "(arc ', 09-12-2034 (NT)\n",
      "COV ‘1:\n",
      "LMV 10—12-2014\n",
      "\n",
      "MCWG 10—12—2014\n",
      "\n",
      ".3ij 04-10-1996 5;\")\n",
      "\n",
      "Name PRANEET BOMMA\n",
      "\n",
      "S/DM O/ SHRIHARI BOMMA\n",
      "\n",
      "Add 307 SUKH SAGAR NEW PRABHADEVI ROAD\n",
      "PRABHADEW MUMBAI\n",
      "\n",
      "PIN 400025\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image = cv2.imread('IP/licence_image2.png')\n",
    "\n",
    "# Create our shapening kernel, it must equal to one eventually\n",
    "kernel_sharpening = np.array([[-1,-1,-1], \n",
    "                              [-1, 9,-1],\n",
    "                              [-1,-1,-1]])\n",
    "# applying the sharpening kernel to the input image & displaying it.\n",
    "# image = cv2.filter2D(image, -1, kernel_sharpening)\n",
    "\n",
    "# showImage('test', image)\n",
    "\n",
    "lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)\n",
    "\n",
    "showImage('test', lab)\n",
    "\n",
    "l, a, b = cv2.split(lab)\n",
    "lm = l.copy()\n",
    "la = l.copy()\n",
    "aa = a.copy()\n",
    "bb = b.copy()\n",
    "\n",
    "hist,bins = np.histogram(l,256,[0,256])\n",
    "hista,bins = np.histogram(a,256,[0,256])\n",
    "histb,bins = np.histogram(b,256,[0,256])\n",
    "plt.plot(hist), plt.plot(hista)\n",
    "# plt.plot(hista), plt.plot(histb)\n",
    "plt.show()\n",
    "\n",
    "# lm -= 100\n",
    "# lm[lm < 0] = 0\n",
    "print(lm.shape)\n",
    "print(np.argmax(hist))\n",
    "mean = int((np.argmax(hist) + np.argmin(hist)) / 2)\n",
    "max_a = np.argmax(hista)\n",
    "print(max_a)\n",
    "# kernel = np.ones((2, 2), np.uint8)\n",
    "# lm = cv2.erode(lm, kernel, iterations = 2)\n",
    "\n",
    "bb = cv2.filter2D(bb, -1, kernel_sharpening)\n",
    "\n",
    "showImage('test', lm)\n",
    "\n",
    "# aa[aa > int(120)] = 255\n",
    "# aa[aa <= int(120)] = 0\n",
    "\n",
    "showImage('test', aa)\n",
    "showImage('test', bb)\n",
    "\n",
    "lm[lm > mean] = 255\n",
    "lm[lm <= mean] = 0\n",
    "\n",
    "# aa[aa > 150] = 255\n",
    "# aa[aa <= 150] = 0\n",
    "\n",
    "# bb[bb > 95] = 255\n",
    "# bb[bb <= 95] = 0\n",
    "\n",
    "# la += 40\n",
    "# la[la > 255] = 255\n",
    "\n",
    "# lab = cv2.merge(l, a, b)\n",
    "# laba = np.concatenate((la, a, b))\n",
    "# # laba = np.invert(laba)\n",
    "# # print(np.max(l))\n",
    "# showImage('test', laba)\n",
    "\n",
    "hist,bins = np.histogram(lm,256,[0,256])\n",
    "plt.plot(hist)\n",
    "plt.show()\n",
    "labm = np.concatenate((lm, aa, bb))\n",
    "\n",
    "\n",
    "\n",
    "# lm = cv2.morphologyEx(lm, cv2.MORPH_OPEN, kernel)\n",
    "# lm = cv2.erode(lm, kernel, iterations = 2)\n",
    "# lm = cv2.dilate(lm, kernel, iterations = 3)\n",
    "\n",
    "template = cv2.imread('IP/license_template.jpg', 0)\n",
    "ret3, template = cv2.threshold(template, 220, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
    "\n",
    "lm = np.subtract(template, lm)\n",
    "\n",
    "lm = np.invert(lm)\n",
    "showImage('test', lm)\n",
    "\n",
    "text = pyt.image_to_string(lm)\n",
    "print(text)\n",
    "\n",
    "showImage('test', lm)\n",
    "\n",
    "cv2.imwrite('tess.jpg', lm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-05T01:07:48.827047Z",
     "start_time": "2019-01-05T01:07:45.592574Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "import shutil\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "import thinning\n",
    "import pytesseract as pyt\n",
    "import imutils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-05T01:07:48.901413Z",
     "start_time": "2019-01-05T01:07:48.882000Z"
    }
   },
   "outputs": [],
   "source": [
    "def getText(template, image):\n",
    "    \n",
    "    template = cv2.imread(template, 0)\n",
    "#     showImage('og', template)\n",
    "#     testing = image\n",
    "    \n",
    "    image = cv2.imread(image, 0)\n",
    "    ret3, template = cv2.threshold(template, 220, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n",
    "    global og_image\n",
    "    og_image = image\n",
    "#     testing = cv2.imread(testing)\n",
    "#     testing = increase_brightness(testing)\n",
    "#     showImage('testing', testing)\n",
    "#     testing = cv2.cvtColor(testing, cv2.COLOR_BGR2GRAY)\n",
    "#     kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])\n",
    "#     testing = cv2.filter2D(testing, -1, kernel)\n",
    "#     kernel = np.ones((3, 3), np.uint8)\n",
    "#     testing = cv2.dilate(testing, kernel, iterations = 1)\n",
    "#     ret3, testing = cv2.threshold(testing, 220, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n",
    "#     thresh = np.invert(testing)\n",
    "#     testing1 = cv2.Canny(testing, 30, 150)\n",
    "#     kernel = np.ones((3, 3), np.uint8)\n",
    "#     testing = cv2.dilate(testing1, kernel, iterations = 1)\n",
    "#     testing = np.subtract(thresh, testing)\n",
    "#     showImage('testing', testing)\n",
    "#     cv2.imwrite('bright.jpg', testing)\n",
    "    \n",
    "    # Sharpening the image\n",
    "    kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])\n",
    "    unsharp_image = cv2.filter2D(image, -1, kernel)\n",
    "    \n",
    "#     cv2.imshow('og', unsharp_image)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()\n",
    "\n",
    "    # Adaptive Thresholding\n",
    "    # OBinary = cv2.adaptiveThreshold(unsharp_image,255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,15,5)\n",
    "\n",
    "    # Thresholding\n",
    "    ret3, OBinary = cv2.threshold(unsharp_image, 220, 255, cv2.THRESH_BINARY_INV+ cv2.THRESH_OTSU)\n",
    "\n",
    "    showImage('testing', OBinary)\n",
    "#     OBinary = cv2.medianBlur(OBinary, 5)\n",
    "#     OBinary = cv2.bilateralFilter(OBinary,12,25,25)\n",
    "#     cv2.imwrite('nonbilateral.jpg', OBinary)\n",
    "    kernel = np.ones((2, 2), np.uint8)\n",
    "#     \n",
    "#     OBinary = cv2.morphologyEx(OBinary, cv2.MORPH_OPEN, kernel)\n",
    "    OBinary = cv2.erode(OBinary, kernel, iterations = 3)\n",
    "#     OBinary = cv2.medianBlur(OBinary, 3)\n",
    "    showImage('testing', OBinary)\n",
    "#     showImage(\"subtracted\", OBinary)\n",
    "    \n",
    "    # Eroding\n",
    "#     kernel = np.ones((3, 3), np.uint8)\n",
    "#     OBinary = cv2.erode(OBinary, kernel, iterations = 1)\n",
    "    \n",
    "    subtract = np.subtract(OBinary, template)\n",
    "    showImage('testing', subtract)\n",
    "    text = pyt.image_to_string(subtract)\n",
    "    text = text.replace('/', 'i').replace(\"#\", \"4\").replace(\"'\", \"\").replace('\"', '').replace('!', 'I').replace(']', 'I').upper()\n",
    "#     if text == '':\n",
    "#         continue\n",
    "#     print(text)\n",
    "    \n",
    "    testing = imutils.skeletonize(subtract, size=(3, 3))\n",
    "#     showImage('testing', testing)\n",
    "    \n",
    "    get_lines(subtract)\n",
    "    \n",
    "#     showImage(\"subtracted\", subtract)\n",
    "\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "    \n",
    "def showImage(title, image):\n",
    "    cv2.imshow(title, image)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "\n",
    "def get_lines(image):\n",
    "    \n",
    "    # getting edges of the text in image\n",
    "    image_edges = cv2.Canny(image, 30, 150)\n",
    "    \n",
    "    # dilating image to detect individual lines\n",
    "    kernel_line = np.ones((2, 100), np.uint8)\n",
    "    dilated_line = cv2.dilate(image_edges, kernel_line, iterations=1)\n",
    "    \n",
    "    showImage('lines', dilated_line)\n",
    "    \n",
    "    # finding contours of the line\n",
    "    im2, ctrs_line, hier = cv2.findContours(dilated_line.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    sorted_ctrs_line = sorted(ctrs_line, key=lambda ctr: cv2.boundingRect(ctr)[1])\n",
    "    \n",
    "    for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "        # getting coordinates of the line contour\n",
    "        x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "        if w_line * h_line < 3000 or w_line * h_line > 50000:\n",
    "            continue\n",
    "            \n",
    "        cropped_line = image[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "        blac = np.invert(cropped_line)\n",
    "        cv2.imwrite('bdgdfg' + str(i) + '.jpg', blac)\n",
    "        \n",
    "        testing = og_image[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "        \n",
    "        ret3, testing = cv2.threshold(testing, 220, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n",
    "        testing = np.invert(testing)\n",
    "        testing = imutils.skeletonize(testing, size=(3, 3))\n",
    "        cv2.imwrite('casdsad' + str(i) + '.jpg', testing)\n",
    "        kernel = np.ones((3, 3), np.uint8)\n",
    "        testing = cv2.dilate(testing, kernel, iterations = 1)\n",
    "        cv2.imwrite('asdsad' + str(i) + '.jpg', testing)\n",
    "        \n",
    "        text = pyt.image_to_string(cropped_line)\n",
    "        text = text.replace('/', 'i').replace(\"#\", \"4\").replace(\"'\", \"\").replace('\"', '').replace('!', 'I').replace(']', 'I').upper()\n",
    "        if text == '':\n",
    "            continue\n",
    "        print(text)\n",
    "        \n",
    "def increase_brightness(img, value=60):\n",
    "    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n",
    "    h, s, v = cv2.split(hsv)\n",
    "\n",
    "#     lim = 255 - value\n",
    "#     v[v > lim] = 255\n",
    "#     v[v <= lim] += value\n",
    "    v += 255\n",
    "    v[v > 255] = 255\n",
    "    print(np.max(v))\n",
    "\n",
    "    final_hsv = cv2.merge((h, s, v))\n",
    "    img = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-28T10:11:49.687500Z",
     "start_time": "2018-12-28T10:11:49.351035Z"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "'break' outside loop (<ipython-input-5-eae237d2ec83>, line 21)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-5-eae237d2ec83>\"\u001b[0;36m, line \u001b[0;32m21\u001b[0m\n\u001b[0;31m    break\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m 'break' outside loop\n"
     ]
    }
   ],
   "source": [
    "image = cv2.imread('IP/pancard.jpg')\n",
    "\n",
    "hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) \n",
    "lower_red = np.array([110,50,50]) \n",
    "upper_red = np.array([130,255,255])\n",
    "\n",
    "mask = cv2.inRange(hsv, lower_red, upper_red) \n",
    "  \n",
    "# The bitwise and of the frame and mask is done so  \n",
    "# that only the blue coloured objects are highlighted  \n",
    "# and stored in res \n",
    "res = cv2.bitwise_and(image,image, mask= mask) \n",
    "cv2.imshow('frame',image) \n",
    "cv2.imshow('mask',mask) \n",
    "cv2.imshow('res',res) \n",
    "  \n",
    "# This displays the frame, mask  \n",
    "# and res which we created in 3 separate windows. \n",
    "k = cv2.waitKey(0\n",
    "                \n",
    "# Destroys all of the HighGUI windows. \n",
    "cv2.destroyAllWindows() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working on thinned image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-27T06:14:35.031681Z",
     "start_time": "2018-12-27T06:14:34.721886Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "import shutil\n",
    "import numpy as np\n",
    "from matplotlib.pyplot import imshow\n",
    "from PIL import Image\n",
    "import thinning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-27T06:55:31.891493Z",
     "start_time": "2018-12-27T06:55:31.884669Z"
    }
   },
   "outputs": [],
   "source": [
    "def pre_processing(path):\n",
    "    \n",
    "    # Read Image\n",
    "    img = cv2.imread(path)\n",
    "    \n",
    "    # Grayscale step\n",
    "    grayscaled = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "    # Noise Clearing step\n",
    "    noise_cleared = cv2.fastNlMeansDenoising(grayscaled, None, 4, 7, 21)\n",
    "    \n",
    "    # Adaptive Thresholding\n",
    "    OBinary = cv2.adaptiveThreshold(noise_cleared,255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV,15,5)\n",
    "    \n",
    "    kernel = np.ones((3, 3), np.uint8)\n",
    "    OBinary = cv2.erode(OBinary, kernel, iterations = 1)\n",
    "    \n",
    "    thinned = thinning.guo_hall_thinning(OBinary)\n",
    "    cv2.imshow('test', thinned)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "    # Thresholding\n",
    "    ret3, OBinary = cv2.threshold(noise_cleared, 250, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
    "    thinned = thinning.guo_hall_thinning(OBinary)\n",
    "    cv2.imshow('test', thinned)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "    \n",
    "    global og_image\n",
    "    og_image = OBinary\n",
    "    \n",
    "    # Eroding\n",
    "    kernel = np.ones((3, 3), np.uint8)\n",
    "    OBinary = cv2.erode(OBinary, kernel, iterations = 1)\n",
    "    \n",
    "    return OBinary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convert image into matrix of image rows and image columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-27T05:41:35.531971Z",
     "start_time": "2018-12-27T05:41:35.358566Z"
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "this function convert image into matrix of image rows\n",
    "'''\n",
    "\n",
    "\n",
    "def imgToMatrixR(img):\n",
    "    # get dimensions\n",
    "    height, width = img.shape\n",
    "    matrix = []\n",
    "    # getting pixels values for all rows\n",
    "    for i in range(0, height):\n",
    "        row = []\n",
    "        for j in range(0, width):\n",
    "            row.append(img[i, j])\n",
    "        matrix.append(row)\n",
    "    return matrix\n",
    "\n",
    "\n",
    "'''\n",
    "this function convert image into matrix of image columns\n",
    "'''\n",
    "\n",
    "\n",
    "def imgToMatrixC(img):\n",
    "    # get dimensions\n",
    "    height, width = img.shape\n",
    "    matrix = []\n",
    "    # getting pixels values for all columns\n",
    "    for i in range(0, width):\n",
    "        col = []\n",
    "        for j in range(0, height):\n",
    "            col.append(img[j, i])\n",
    "        matrix.append(col)\n",
    "    return matrix\n",
    "\n",
    "\n",
    "'''\n",
    "this function count a specific value (parameter p) in matrix\n",
    "'''\n",
    "\n",
    "\n",
    "def countPixel(matrix, p):\n",
    "    counter = []\n",
    "    for k in range(0, len(matrix)):\n",
    "        counter.append(matrix[k].count(p))\n",
    "    return counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Line Segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-27T05:41:35.681996Z",
     "start_time": "2018-12-27T05:41:35.558750Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_lines(image):\n",
    "    \n",
    "    # getting edges of the text in image\n",
    "    image_edges = cv2.Canny(image, 30, 150)\n",
    "    \n",
    "    # dilating image to detect individual lines\n",
    "    kernel_line = np.ones((3, 25), np.uint8)\n",
    "    dilated_line = cv2.dilate(image_edges, kernel_line, iterations=1)\n",
    "    \n",
    "    # finding contours of the line\n",
    "    im2, ctrs_line, hier = cv2.findContours(dilated_line.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    sorted_ctrs_line = sorted(ctrs_line, key=lambda ctr: cv2.boundingRect(ctr)[1])\n",
    "    \n",
    "    for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "        # getting coordinates of the line contour\n",
    "        x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "        if w_line * h_line < 3000 or w_line * h_line > 50000:\n",
    "            continue\n",
    "            \n",
    "#         get_words(x_line, y_line, w_line, h_line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Word Segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-27T05:41:35.795022Z",
     "start_time": "2018-12-27T05:41:35.694121Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_words(x, y, w, h):\n",
    "\n",
    "    cropped_line = pre_processed[y:y + h, x:x + w]\n",
    "    # getting edges of the text in image\n",
    "    \n",
    "    # Edge Detection\n",
    "    image_edges = cv2.Canny(cropped_line, 30, 150)\n",
    "    \n",
    "    kernel_word = np.ones((3, 12), np.uint8)\n",
    "    dilated_word = cv2.dilate(image_edges, kernel_word, iterations=1)\n",
    "    \n",
    "    # Getting contours from the line\n",
    "    im2, ctrs_word, hier = cv2.findContours(dilated_word.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    sorted_ctrs_word = sorted(ctrs_word, key=lambda ctr: cv2.boundingRect(ctr)[0])\n",
    "    \n",
    "    for i, ctr_word in enumerate(sorted_ctrs_word):\n",
    "        # getting coordinates of the word contour\n",
    "        x_word, y_word, w_word, h_word = cv2.boundingRect(ctr_word)\n",
    "        \n",
    "        adjusted_x = x + x_word\n",
    "        adjusted_y = y + y_word\n",
    "        \n",
    "        cropped_word = pre_processed[adjusted_y:adjusted_y + h_word, adjusted_x:adjusted_x + w_word]\n",
    "        \n",
    "        get_characters(adjusted_x, adjusted_y, w_word, h_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Character Segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-27T05:41:35.950887Z",
     "start_time": "2018-12-27T05:41:35.812228Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_characters(x, y, w, h):\n",
    "\n",
    "    cropped_word = pre_processed[y:y + h, x:x + w]\n",
    "    \n",
    "    kernel_word = np.ones((5, 3), np.uint8)\n",
    "    cropped_word = cv2.dilate(cropped_word, kernel_word, iterations=1)\n",
    "    \n",
    "#     cv2.imshow('test', cropped_word)\n",
    "#     cv2.waitKey(0)\n",
    "#     cv2.destroyAllWindows()\n",
    "    \n",
    "    # get image dimension\n",
    "    height, width = cropped_word.shape\n",
    "    \n",
    "    # convert image to matrix of columns\n",
    "    matrix = imgToMatrixC(cropped_word)\n",
    "    \n",
    "    # count white pixels in each column\n",
    "    white_counter = countPixel(matrix, 255)\n",
    "    \n",
    "    # determine potential segmentation columns (psc).\n",
    "    # psc is any column contains no or one white bixel at most , last column in image is also a psc .\n",
    "    psc = [0]\n",
    "    for p in range(0, len(white_counter)):\n",
    "        if white_counter[p] <= 2 or p >= len(white_counter) - 1:\n",
    "            psc.append(p)\n",
    "            \n",
    "    # determine segmentation columns (sc)\n",
    "    # sc is the average column between each sequence set of psc , average = summ of columns index/count of columns\n",
    "    sc = []\n",
    "    summ = 0\n",
    "    count = 0\n",
    "    for n in range(0, len(psc) - 1):\n",
    "        summ = summ + psc[n]\n",
    "        count = count + 1\n",
    "        # combine each set of sequence black columns into only one sc ,last column is also a sc\n",
    "        if psc[n] + 3 < psc[n + 1] or n >= len(psc) - 2:\n",
    "            sc.append(int(summ / count))\n",
    "            summ = 0\n",
    "            count = 0\n",
    "            \n",
    "    # segment image into chars\n",
    "    for c in range(0, len(sc) - 1):\n",
    "        crop_img = og_image[y:y + height, x + sc[c]:x + sc[c + 1] + 2]\n",
    "        if crop_img.shape[0] < 20 or crop_img.shape[0] * crop_img.shape[1] < 300:\n",
    "            continue\n",
    "        global j\n",
    "        j += 1\n",
    "        directory= \"output/characters\"\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "        cv2.imwrite(directory+\"/\"+str(j)+\".png\", crop_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-27T07:10:15.922797Z",
     "start_time": "2018-12-27T06:55:37.619690Z"
    }
   },
   "outputs": [],
   "source": [
    "pre_processed = pre_processing('licence.jpg')\n",
    "image = pre_processed.copy()\n",
    "j = 0\n",
    "# get_lines(image)\n",
    "# get_words(lines[80], img)\n",
    "# for i in lines:\n",
    "#     print(i[2] * i[3])\n",
    "#     get_words(i, img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-27T07:17:08.126245Z",
     "start_time": "2018-12-27T07:17:07.843741Z"
    }
   },
   "outputs": [],
   "source": [
    "import pytesseract as pyt\n",
    "import cv2\n",
    "import os\n",
    "import shutil\n",
    "import numpy as np\n",
    "from matplotlib.pyplot import imshow\n",
    "from PIL import Image\n",
    "import thinning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-26T09:27:27.786301Z",
     "start_time": "2018-12-26T09:27:27.761191Z"
    }
   },
   "outputs": [],
   "source": [
    "def pre_processing(path):\n",
    "    # Read Image\n",
    "    img = cv2.imread(path)\n",
    "\n",
    "    # scaling\n",
    "    height, width = img.shape[:2]\n",
    "    #     scaled = img\n",
    "    #     if height < 1600 and width < 1200:\n",
    "    #         scaled = cv2.resize(img, (2 * width, 2* height), interpolation=cv2.INTER_LINEAR)\n",
    "    #         # cv2.imwrite('(0)scaled.jpg', scaled)\n",
    "\n",
    "    # Deskew step\n",
    "    #     deskewed = deskew(scaled)\n",
    "    # cv2.imwrite(\"(1)deskewed.jpg\", deskewed)\n",
    "\n",
    "    # Grayscale step\n",
    "    grayscaled = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "    # cv2.imwrite(\"(2)grayscale.jpg\", grayscaled)\n",
    "\n",
    "    # Noise Clearing step\n",
    "    noise_cleared = cv2.fastNlMeansDenoising(grayscaled, None, 4, 7, 21)\n",
    "    cv2.imwrite(\"(3)denoise.jpg\", noise_cleared)\n",
    "    \n",
    "#     x = np.random.randn(10000)  # example data, random normal distribution\n",
    "#     num_bins = 50\n",
    "#     n, bins, patches = plt.hist(x, num_bins, normed=1, facecolor=\"green\", alpha=0.5)\n",
    "#     plt.xlabel(r\"Description of $x$ coordinate (units)\")\n",
    "#     plt.ylabel(r\"Description of $y$ coordinate (units)\")\n",
    "#     plt.title(r\"Histogram title here (remove for papers)\")\n",
    "#     plt.show();\n",
    "    \n",
    "    \n",
    "    '''\n",
    "    # GAUSSIAN's thresholding\n",
    "    GBinary = cv2.adaptiveThreshold(noise_cleared,255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,15,5)\n",
    "    # cv2.imwrite(\"(4)binarization.jpg\", GBinary)\n",
    "    '''\n",
    "\n",
    "    # Otsu's thresholding after Gaussian filtering\n",
    "#     blur = cv2.GaussianBlur(noise_cleared, (5, 5), 0)\n",
    "#     cv2.imwrite(\"(4)thresbinarization.jpg\", blur)\n",
    "    OBinary = cv2.adaptiveThreshold(noise_cleared,255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,15,5)\n",
    "    ret3, OBinary = cv2.threshold(OBinary, 250, 255,\n",
    "                                  cv2.THRESH_BINARY+ cv2.THRESH_OTSU)\n",
    "    cv2.imwrite(\"(4)thresbinarization.jpg\", OBinary)\n",
    "    kernel = np.ones((3, 3), np.uint8)\n",
    "#     print(type(kernel))\n",
    "#     kernel = np.array([[1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0],\n",
    "#                        [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0]], np.uint8)\n",
    "#     print(type(kernel))\n",
    "    print(kernel)\n",
    "    OBinary = cv2.erode(OBinary, kernel, iterations = 1)\n",
    "\n",
    "#     if os.path.exists(\"output\"):\n",
    "#         shutil.rmtree(\"output\")\n",
    "#     os.makedirs(\"output\")\n",
    "#     cv2.imwrite(\"output/Preprocessed.png\", OBinary)\n",
    "\n",
    "    return OBinary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convert image into matrix of image rows and image columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-26T09:27:28.762143Z",
     "start_time": "2018-12-26T09:27:28.756539Z"
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "this function convert image into matrix of image rows\n",
    "'''\n",
    "\n",
    "\n",
    "def imgToMatrixR(img):\n",
    "    # get dimensions\n",
    "    height, width = img.shape\n",
    "    matrix = []\n",
    "    # getting pixels values for all rows\n",
    "    for i in range(0, height):\n",
    "        row = []\n",
    "        for j in range(0, width):\n",
    "            row.append(img[i, j])\n",
    "        matrix.append(row)\n",
    "    return matrix\n",
    "\n",
    "\n",
    "'''\n",
    "this function convert image into matrix of image columns\n",
    "'''\n",
    "\n",
    "\n",
    "def imgToMatrixC(img):\n",
    "    # get dimensions\n",
    "    height, width = img.shape\n",
    "    matrix = []\n",
    "    # getting pixels values for all columns\n",
    "    for i in range(0, width):\n",
    "        col = []\n",
    "        for j in range(0, height):\n",
    "            col.append(img[j, i])\n",
    "        matrix.append(col)\n",
    "    return matrix\n",
    "\n",
    "\n",
    "'''\n",
    "this function count a specific value (parameter p) in matrix\n",
    "'''\n",
    "\n",
    "\n",
    "def countPixel(matrix, p):\n",
    "    counter = []\n",
    "    for k in range(0, len(matrix)):\n",
    "        counter.append(matrix[k].count(p))\n",
    "    return counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Line Segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-26T09:27:30.274345Z",
     "start_time": "2018-12-26T09:27:30.269836Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_lines(image):\n",
    "    # getting edges of the text in image\n",
    "    image_edges = cv2.Canny(image, 30, 150)\n",
    "\n",
    "    # dilating image /=to detect individual lines\n",
    "    kernel_line = np.ones((3, 25), np.uint8)\n",
    "    dilated_line = cv2.dilate(image_edges, kernel_line, iterations=1)\n",
    "\n",
    "    # finding contours of the line\n",
    "    im2, ctrs_line, hier = cv2.findContours(\n",
    "        dilated_line.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    sorted_ctrs_line = sorted(\n",
    "        ctrs_line, key=lambda ctr: cv2.boundingRect(ctr)[1])\n",
    "    #     image = cv2.drawContours(image, sorted_ctrs_line, -1, (255,255,0), 5)\n",
    "\n",
    "    for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "        # getting coordinates of the line contour\n",
    "        x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "        if w_line * h_line < 3000 or w_line * h_line > 50000:\n",
    "            continue\n",
    "\n",
    "\n",
    "#         lines.append(xywh)\n",
    "        get_words(x_line, y_line, w_line, h_line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Word Segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-26T09:33:27.635101Z",
     "start_time": "2018-12-26T09:33:27.629604Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_words(x, y, w, h):\n",
    "\n",
    "    cropped_line = pre_processed[y:y + h, x:x + w]\n",
    "    # getting edges of the text in image\n",
    "    global j\n",
    "    j += 1\n",
    "    directory= \"output/lines_og\"\n",
    "    if not os.path.exists(directory):\n",
    "        os.makedirs(directory)\n",
    "#     cropped_word = pre_processed[adjusted_y:adjusted_y + h_word, adjusted_x:adjusted_x + w_word]\n",
    "    cv2.imwrite(directory+\"/\"+str(j)+\".png\", cropped_line)\n",
    "    \n",
    "    dilated_word = cv2.Canny(cropped_line, 30, 150)\n",
    "\n",
    "    # dilating image /=to detect individual words\n",
    "    kernel_word = np.ones((3, 10), np.uint8)\n",
    "#     dilated_word = cv2.dilate(image_edges, kernel_word, iterations=1)\n",
    "\n",
    "    # finding contours of the word\n",
    "    im2, ctrs_word, hier = cv2.findContours(\n",
    "        dilated_word.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    sorted_ctrs_word = sorted(\n",
    "        ctrs_word, key=lambda ctr: cv2.boundingRect(ctr)[1])\n",
    "\n",
    "    for i, ctr_word in enumerate(sorted_ctrs_word):\n",
    "        # getting coordinates of the word contour\n",
    "        x_word, y_word, w_word, h_word = cv2.boundingRect(ctr_word)\n",
    "        adjusted_x = x + x_word\n",
    "        adjusted_y = y + y_word\n",
    "        directory= \"output/words_og\"\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "        cropped_word = pre_processed[adjusted_y:adjusted_y + h_word, adjusted_x:adjusted_x + w_word]\n",
    "        cv2.imwrite(directory+\"/\"+str(i)+\".png\", cropped_word)\n",
    "#         get_characters(adjusted_x, adjusted_y, w_word, h_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Character Segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-26T11:08:25.387116Z",
     "start_time": "2018-12-26T11:08:25.366602Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_characters(x, y, w, h):\n",
    "\n",
    "    cropped_word = pre_processed[y:y + h, x:x + w]\n",
    "    #     print(cropped_word.shape)\n",
    "    global i\n",
    "    i += 1\n",
    "    directory= \"output/words_og\"\n",
    "    if not os.path.exists(directory):\n",
    "        os.makedirs(directory)\n",
    "    cv2.imwrite(directory+\"/\"+str(i)+\".png\", cropped_word)\n",
    "    \n",
    "    kernel = np.ones((1, 1), np.uint8)\n",
    "#     print(kernel)\n",
    "    thinned = cv2.erode(cropped_word, kernel, iterations = 1)\n",
    "#     cropped_word = cv2.Canny(cropped_word, 30, 150)\n",
    "    \n",
    "    directory= \"output/words_eroded\"\n",
    "    if not os.path.exists(directory):\n",
    "        os.makedirs(directory)\n",
    "    cv2.imwrite(directory+\"/\"+str(i)+\".png\", thinned)\n",
    "    \n",
    "    cropped_word = thinning.guo_hall_thinning(thinned)\n",
    "    \n",
    "    directory= \"output/words_thinned\"\n",
    "    if not os.path.exists(directory):\n",
    "        os.makedirs(directory)\n",
    "    cv2.imwrite(directory+\"/\"+str(i)+\".png\", cropped_word)\n",
    "    \n",
    "#     cv2.imshow('test', cropped_word)\n",
    "#     cv2.waitKey(0)\n",
    "#     cv2.destroyAllWindows()\n",
    "    # get image dimension\n",
    "    height, width = cropped_word.shape\n",
    "\n",
    "    # convert image to matrix of columns\n",
    "    matrix = imgToMatrixC(cropped_word)\n",
    "\n",
    "    # count white pixels in each column\n",
    "    white_counter = countPixel(matrix, 255)\n",
    "\n",
    "    # determine potential segmentation columns (psc).\n",
    "    # psc is any column contains no or one white bixel at most , last column in image is also a psc .\n",
    "    psc = [0]\n",
    "    for p in range(0, len(white_counter)):\n",
    "        if white_counter[p] <= 4 or p >= len(white_counter) - 1:\n",
    "            psc.append(p)\n",
    "\n",
    "    # determine segmentation columns (sc)\n",
    "    # sc is the average column between each sequence set of psc , average = summ of columns index/count of columns\n",
    "    sc = []\n",
    "    summ = 0\n",
    "    count = 0\n",
    "    for n in range(0, len(psc) - 1):\n",
    "        summ = summ + psc[n]\n",
    "        count = count + 1\n",
    "        # combine each set of sequence black columns into only one sc ,last column is also a sc\n",
    "        if psc[n] + 2 < psc[n + 1] or n >= len(psc) - 1:\n",
    "            sc.append(int(summ / count))\n",
    "            summ = 0\n",
    "            count = 0\n",
    "\n",
    "    # segment image into chars\n",
    "    for c in range(0, len(sc) - 1):\n",
    "        crop_img = cropped_word[0:height, sc[c]:sc[c + 1] + 2]\n",
    "#         cv2.imshow('test', crop_img)\n",
    "#         cv2.waitKey(0)\n",
    "#         cv2.destroyAllWindows()\n",
    "\n",
    "\n",
    "#         crop_img = clearBounds_horiz(crop_img)\n",
    "#         crop_img = clearBounds_vert(crop_img)\n",
    "#         crop_img = cv2.resize(crop_img, (64, 128), interpolation=cv2.INTER_LINEAR)\n",
    "#         directory= \"output/line \" + str(lineNum)+\"/word \"+str(wordNum)\n",
    "#         if not os.path.exists(directory):\n",
    "#             os.makedirs(directory)\n",
    "#         cv2.imwrite(directory+\"/\"+str(c)+\".png\", crop_img)\n",
    "#         lines[lineNum].append(crop_img)\n",
    "#         if c == (len(sc) - 2):\n",
    "#             lines[lineNum].append(\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-26T11:08:27.789570Z",
     "start_time": "2018-12-26T11:08:27.785158Z"
    }
   },
   "outputs": [],
   "source": [
    "# '''\n",
    "# this function segment words into chars\n",
    "# lineNum and wordNum parameters used for naming \n",
    "# segmentation technique consists of 3 steps :\n",
    "#     1- define potential segmentation columns that contains no or only one white pixels.\n",
    "#     2- filter potential segmentation columns by determine segmentation columns which the crop operation depends on .\n",
    "#     3- segment the image into segments (chars).\n",
    "# '''\n",
    "# def char_segment(binary,lineNum,wordNum):\n",
    "#     # get image dimension\n",
    "#     height, width = binary.shape\n",
    "#     # convert image to matrix of columns\n",
    "#     matrix = imgToMatrixC(binary)\n",
    "#     # count black pixels in each column\n",
    "#     black_counter = countPixel(matrix,0)\n",
    "\n",
    "#     # determine potential segmentation columns (psc).\n",
    "#     # psc is any column contains no or one black bixel at most , last column in image is also a psc .\n",
    "#     psc = [0]\n",
    "#     for p in range(0, len(black_counter)):\n",
    "#         if black_counter[p] <= 1 or p >= len(black_counter) - 2:\n",
    "#             psc.append(p)\n",
    "\n",
    "#     # determine segmentation columns (sc)\n",
    "#     # sc is the average column between each sequence set of psc , average = summ of columns index/count of columns\n",
    "#     sc = []\n",
    "#     summ = 0\n",
    "#     count = 0\n",
    "#     for n in range(0, len(psc) - 1):\n",
    "#         summ = summ + psc[n]\n",
    "#         count = count + 1\n",
    "#         # combine each set of sequence white columns into only one sc ,last column is also a sc\n",
    "#         if psc[n] + 3 < psc[n + 1] or n >= len(psc) - 2:\n",
    "#             sc.append(int(summ / count))\n",
    "#             summ = 0\n",
    "#             count = 0\n",
    "\n",
    "#     global lines\n",
    "#     # segment image into chars\n",
    "#     for c in range(0, len(sc) - 1):\n",
    "#         crop_img = binary[0:height, sc[c]:sc[c + 1]+2]\n",
    "#         crop_img = clearBounds_horiz(crop_img)\n",
    "#         crop_img = clearBounds_vert(crop_img)\n",
    "#         crop_img = cv2.resize(crop_img, (64, 128), interpolation=cv2.INTER_LINEAR)\n",
    "#         directory= \"output/line \" + str(lineNum)+\"/word \"+str(wordNum)\n",
    "#         if not os.path.exists(directory):\n",
    "#             os.makedirs(directory)\n",
    "#         cv2.imwrite(directory+\"/\"+str(c)+\".png\", crop_img)\n",
    "#         lines[lineNum].append(crop_img)\n",
    "#         if c == (len(sc) - 2):\n",
    "#             lines[lineNum].append(\",\")\n",
    "#     print(\"HERE\")\n",
    "#     print(lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-26T11:08:28.750705Z",
     "start_time": "2018-12-26T11:08:28.748536Z"
    }
   },
   "outputs": [],
   "source": [
    "# from skimage.morphology import skeletonize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-26T07:46:03.003557Z",
     "start_time": "2018-12-26T07:46:02.966293Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 0 0 0]\n",
      " [1 1 0 0 0]\n",
      " [1 1 0 0 0]\n",
      " [1 1 0 0 0]\n",
      " [1 1 0 0 0]\n",
      " [1 1 0 0 0]\n",
      " [1 1 0 0 0]]\n",
      "[[1 1 0 0 0]\n",
      " [1 1 0 0 0]\n",
      " [1 1 0 0 0]\n",
      " [0 0 0 0 0]\n",
      " [0 0 0 0 0]\n",
      " [0 0 0 0 0]\n",
      " [0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "cropped_word = cv2.imread('62.png', 0)\n",
    "\n",
    "kernel = np.array([[1, 1, 0, 0, 0], [1, 1, 0, 0, 0], [1, 1, 0, 0, 0], [1, 1, 0, 0, 0],\n",
    "                       [1, 1, 0, 0, 0], [1, 1, 0, 0, 0], [1, 1, 0, 0, 0]], np.uint8)\n",
    "print(kernel)\n",
    "eroded = cv2.erode(cropped_word, kernel, iterations = 1)\n",
    "dkernel = np.array([[1, 1, 0, 0, 0], [1, 1, 0, 0, 0], [1, 1, 0, 0, 0], [0, 0, 0, 0, 0],\n",
    "                       [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], np.uint8)\n",
    "print(dkernel)\n",
    "dilated = cv2.dilate(cropped_word, dkernel, iterations = 1)\n",
    "# Dilation then Erosion\n",
    "cropped_word = cv2.morphologyEx(eroded, cv2.MORPH_OPEN, kernel)\n",
    "\n",
    "directory= \"output/characters\"\n",
    "if not os.path.exists(directory):\n",
    "    os.makedirs(directory)\n",
    "cv2.imwrite(directory+\"/eroded\"+str(i)+\".png\", eroded)\n",
    "cv2.imwrite(directory+\"/dilated\"+str(i)+\".png\", dilated)\n",
    "cv2.imwrite(directory+\"/\"+str(i)+\".png\", cropped_word)\n",
    "i += 1\n",
    "height, width = cropped_word.shape\n",
    "\n",
    "# convert image to matrix of columns\n",
    "matrix = imgToMatrixC(cropped_word)\n",
    "\n",
    "# count white pixels in each column\n",
    "white_counter = countPixel(matrix, 255)\n",
    "\n",
    "# determine potential segmentation columns (psc).\n",
    "# psc is any column contains no or one white bixel at most , last column in image is also a psc .\n",
    "psc = [0]\n",
    "for p in range(0, len(white_counter)):\n",
    "    if white_counter[p] <= 2 or p >= len(white_counter) - 1:\n",
    "        psc.append(p)\n",
    "\n",
    "# determine segmentation columns (sc)\n",
    "# sc is the average column between each sequence set of psc , average = summ of columns index/count of columns\n",
    "sc = []\n",
    "summ = 0\n",
    "count = 0\n",
    "for n in range(0, len(psc) - 1):\n",
    "    summ = summ + psc[n]\n",
    "    count = count + 1\n",
    "    # combine each set of sequence black columns into only one sc ,last column is also a sc\n",
    "    if psc[n] + 3 < psc[n + 1] or n >= len(psc) - 2:\n",
    "        sc.append(int(summ / count))\n",
    "        summ = 0\n",
    "        count = 0\n",
    "\n",
    "# segment image into chars\n",
    "for c in range(0, len(sc) - 1):\n",
    "    crop_img = cropped_word[0:height, sc[c]:sc[c + 1] + 2]\n",
    "    directory= \"output/characters\"\n",
    "    if not os.path.exists(directory):\n",
    "        os.makedirs(directory)\n",
    "    cv2.imwrite(directory+\"/\"+str(i)+\".png\", crop_img)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thinning example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import cv2\n",
    "import thinning\n",
    "import numpy as np\n",
    "\n",
    "img = cv2.imread(\"./cropped.jpg\", 0)\n",
    "adap = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C,\n",
    "                             cv2.THRESH_BINARY, 11, 2)\n",
    "\n",
    "ret, img = cv2.threshold(img, 200, 255,\n",
    "                         cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
    "# img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "kernel = np.ones((4, 4), np.uint8)\n",
    "\n",
    "thinned = cv2.erode(img, kernel, iterations=1)\n",
    "thinned = thinning.guo_hall_thinning(img)\n",
    "\n",
    "resized = cv2.resize(thinned, None, fx=0.5, fy=0.5)\n",
    "cv2.imwrite(\"./thinned.png\", resized)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing denoising"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import thinning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.imread(\"licence.jpg\",0)\n",
    "\n",
    "denoised = cv2.fastNlMeansDenoising(img, None, 6, 7, 21)\n",
    "\n",
    "kernel = np.ones((3, 3), np.uint8)\n",
    "\n",
    "thinned = cv2.erode(img, kernel, iterations = 1)\n",
    "\n",
    "adapgaussian = cv2.adaptiveThreshold(denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)\n",
    "adapgaussian = cv2.erode(adapgaussian, kernel, iterations = 1)\n",
    "adapgaussian = thinning.guo_hall_thinning(adapgaussian)\n",
    "adapgaussian = cv2.resize(adapgaussian, None, fx = 0.5, fy = 0.5)\n",
    "\n",
    "noisedgaussian = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)\n",
    "noisedgaussian = cv2.erode(noisedgaussian, kernel, iterations = 1)\n",
    "noisedgaussian = thinning.guo_hall_thinning(noisedgaussian)\n",
    "noisedgaussian = cv2.resize(noisedgaussian, None, fx = 0.5, fy = 0.5)\n",
    "\n",
    "adapmean = cv2.adaptiveThreshold(denoised, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 11, 2)\n",
    "adapmean = cv2.erode(adapmean, kernel, iterations = 1)\n",
    "adapmean = thinning.guo_hall_thinning(adapmean)\n",
    "adapmean = cv2.resize(adapmean, None, fx = 0.5, fy = 0.5)\n",
    "\n",
    "noisedmean = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 11, 2)\n",
    "noisedmean = cv2.erode(noisedmean, kernel, iterations = 1)\n",
    "noisedmean = thinning.guo_hall_thinning(noisedmean)\n",
    "noisedmean = cv2.resize(noisedmean, None, fx = 0.5, fy = 0.5)\n",
    "\n",
    "cv2.imshow('Denoised mean', adapmean)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "cv2.imshow('noised mean', noisedmean)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "cv2.imshow('Denoised gaussian', adapgaussian)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "cv2.imshow('noised gaussian', noisedgaussian)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1 1]\n",
      " [1 1 1 1]\n",
      " [1 1 1 1]\n",
      " [1 1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "image = cv2.imread('licence.jpg', 0)\n",
    "cv2.imshow('Edges after contouring', image)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "# image = cv2.GaussianBlur(image, (3, 3), 0)\n",
    "# kernel = np.array([[-1, 2, -1],\n",
    "#                    [-1, 2, -1],\n",
    "#                    [-1, 2, -1]])\n",
    "kernel = np.ones((4, 4), np.uint8)\n",
    "print(kernel)\n",
    "# image = cv2.dilate(image, kernel, iterations = 1)\n",
    "\n",
    "ret, threshold = cv2.threshold(image, 200, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
    "\n",
    "erosion = cv2.erode(threshold, kernel, iterations = 1)\n",
    "cv2.imshow('Erosion', erosion)\n",
    "cv2.waitKey()\n",
    "\n",
    "# closing = cv2.morphologyEx(threshold, cv2.MORPH_CLOSE, kernel)\n",
    "# cv2.imshow('Closing', closing)\n",
    "# cv2.waitKey()\n",
    "\n",
    "resized = cv2.resize(erosion, None, fx = 0.5, fy = 0.5)\n",
    "cv2.imshow('Edges after contouring', resized)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "edges = cv2.Canny(threshold, 30, 200)\n",
    "cv2.imshow('Edges', edges)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import skimage.io as io\n",
    "\"load image data\"\n",
    "# Img_Original =  io.imread( 'download.jpeg')      # Gray image, rgb images need pre-conversion\n",
    "Img_Original = cv2.imread('cropped.jpg', 0)\n",
    "\"Convert gray images to binary images using Otsu's method\"\n",
    "from skimage.filters import threshold_otsu\n",
    "Otsu_Threshold = threshold_otsu(Img_Original)   \n",
    "BW_Original = Img_Original < Otsu_Threshold    # must set object region as 1, background region as 0 !\n",
    "\n",
    "# def neighbours(x,y,image):\n",
    "#     \"Return 8-neighbours of image point P1(x,y), in a clockwise order\"\n",
    "#     img = image\n",
    "#     x_1, y_1, x1, y1 = x-1, y-1, x+1, y+1\n",
    "#     return [ img[x_1][y], img[x_1][y1], img[x][y1], img[x1][y1],     # P2,P3,P4,P5\n",
    "#                 img[x1][y], img[x1][y_1], img[x][y_1], img[x_1][y_1] ]    # P6,P7,P8,P9\n",
    "\n",
    "# def transitions(neighbours):\n",
    "#     \"No. of 0,1 patterns (transitions from 0 to 1) in the ordered sequence\"\n",
    "#     n = neighbours + neighbours[0:1]      # P2, P3, ... , P8, P9, P2\n",
    "#     return sum( (n1, n2) == (0, 1) for n1, n2 in zip(n, n[1:]) )  # (P2,P3), (P3,P4), ... , (P8,P9), (P9,P2)\n",
    "\n",
    "# def zhangSuen(image):\n",
    "#     \"the Zhang-Suen Thinning Algorithm\"\n",
    "#     Image_Thinned = image.copy()  # deepcopy to protect the original image\n",
    "#     changing1 = changing2 = 1        #  the points to be removed (set as 0)\n",
    "#     while changing1 or changing2:   #  iterates until no further changes occur in the image\n",
    "#         # Step 1\n",
    "#         changing1 = []\n",
    "#         rows, columns = Image_Thinned.shape[0],Image_Thinned.shape[1]               # x for rows, y for columns\n",
    "#         for x in range(1, rows - 1):                     # No. of  rows\n",
    "#             for y in range(1, columns - 1):            # No. of columns\n",
    "#                 P2,P3,P4,P5,P6,P7,P8,P9 = n = neighbours(x, y, Image_Thinned)\n",
    "                \n",
    "#                 if (Image_Thinned[x][y] == 1     and    # Condition 0: Point P1 in the object regions \n",
    "#                     2 <= sum(n) <= 6   and    # Condition 1: 2<= N(P1) <= 6\n",
    "#                     transitions(n) == 1 and    # Condition 2: S(P1)=1  \n",
    "#                     P2 * P4 * P6 == 0  and    # Condition 3   \n",
    "#                     P4 * P6 * P8 == 0):         # Condition 4\n",
    "#                     changing1.append((x,y))\n",
    "#         for x, y in changing1: \n",
    "#             Image_Thinned[x][y] = 0\n",
    "#         # Step 2\n",
    "#         changing2 = []\n",
    "#         for x in range(1, rows - 1):\n",
    "#             for y in range(1, columns - 1):\n",
    "#                 P2,P3,P4,P5,P6,P7,P8,P9 = n = neighbours(x, y, Image_Thinned)\n",
    "#                 if (Image_Thinned[x][y] == 1   and        # Condition 0\n",
    "#                     2 <= sum(n) <= 6  and       # Condition 1\n",
    "#                     transitions(n) == 1 and      # Condition 2\n",
    "#                     P2 * P4 * P8 == 0 and       # Condition 3\n",
    "#                     P2 * P6 * P8 == 0):            # Condition 4\n",
    "#                     changing2.append((x,y))    \n",
    "#         for x, y in changing2: \n",
    "#             Image_Thinned[x][y] = 0\n",
    "#     return Image_Thinned\n",
    "\n",
    "def neighbours_vec(image):\n",
    "    return image[2:,1:-1], image[2:,2:], image[1:-1,2:], image[:-2,2:], image[:-2,1:-1],     image[:-2,:-2], image[1:-1,:-2], image[2:,:-2]\n",
    "\n",
    "def transitions_vec(P2, P3, P4, P5, P6, P7, P8, P9):\n",
    "    return ((P3-P2) > 0).astype(int) + ((P4-P3) > 0).astype(int) + \\\n",
    "    ((P5-P4) > 0).astype(int) + ((P6-P5) > 0).astype(int) + \\\n",
    "    ((P7-P6) > 0).astype(int) + ((P8-P7) > 0).astype(int) + \\\n",
    "    ((P9-P8) > 0).astype(int) + ((P2-P9) > 0).astype(int)\n",
    "\n",
    "def zhangSuen_vec(image, iterations):\n",
    "    for iter in range (1, iterations):\n",
    "        print(iter)\n",
    "        # step 1    \n",
    "        P2,P3,P4,P5,P6,P7,P8,P9 = neighbours_vec(image)\n",
    "        condition0 = image[1:-1,1:-1]\n",
    "        condition4 = P4*P6*P8\n",
    "        condition3 = P2*P4*P6\n",
    "        condition2 = transitions_vec(P2, P3, P4, P5, P6, P7, P8, P9) == 1\n",
    "        condition1 = (2 <= P2+P3+P4+P5+P6+P7+P8+P9) * (P2+P3+P4+P5+P6+P7+P8+P9 <= 8)\n",
    "        cond = (condition0 == 1) * (condition4 == 0) * (condition3 == 0) * (condition2 == 1) * (condition1 == 1)\n",
    "        changing1 = numpy.where(cond == 1)\n",
    "        image[changing1[0]+1,changing1[1]+1] = 0\n",
    "        # step 2\n",
    "        P2,P3,P4,P5,P6,P7,P8,P9 = neighbours_vec(image)\n",
    "        condition0 = image[1:-1,1:-1]\n",
    "        condition4 = P2*P6*P8\n",
    "        condition3 = P2*P4*P8\n",
    "        condition2 = transitions_vec(P2, P3, P4, P5, P6, P7, P8, P9) == 1\n",
    "        condition1 = (2 <= P2+P3+P4+P5+P6+P7+P8+P9) * (P2+P3+P4+P5+P6+P7+P8+P9 <= 6)\n",
    "        cond = (condition0 == 1) * (condition4 == 0) * (condition3 == 0) * (condition2 == 1) * (condition1 == 1)\n",
    "        changing2 = numpy.where(cond == 1)\n",
    "        image[changing2[0]+1,changing2[1]+1] = 0\n",
    "    return image\n",
    " \n",
    "\n",
    "\"Apply the algorithm on images\"\n",
    "BW_Skeleton = zhangSuen(BW_Original)\n",
    "# BW_Skeleton = BW_Original\n",
    "\"Display the results\"\n",
    "fig, ax = plt.subplots(1, 2)\n",
    "ax1, ax2 = ax.ravel()\n",
    "ax1.imshow(BW_Original, cmap=plt.cm.gray)\n",
    "ax1.set_title('Original binary image')\n",
    "ax1.axis('off')\n",
    "ax2.imshow(BW_Skeleton, cmap=plt.cm.gray)\n",
    "ax2.set_title('Skeleton of the image')\n",
    "ax2.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.imread('cropped.jpg',0)\n",
    "size = np.size(img)\n",
    "skel = np.zeros(img.shape,np.uint8)\n",
    " \n",
    "ret,img = cv2.threshold(img,127,255,0)\n",
    "element = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))\n",
    "done = False\n",
    " \n",
    "while( not done):\n",
    "    eroded = cv2.erode(img,element)\n",
    "    temp = cv2.dilate(eroded,element)\n",
    "    temp = cv2.subtract(img,temp)\n",
    "    skel = cv2.bitwise_or(skel,temp)\n",
    "    img = eroded.copy()\n",
    " \n",
    "    zeros = size - cv2.countNonZero(img)\n",
    "    if zeros==size:\n",
    "        done = True\n",
    " \n",
    "cv2.imshow(\"skel\",skel)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True  True  True ...  True  True  True]\n",
      " [ True  True  True ...  True  True  True]\n",
      " [ True  True  True ...  True  True  True]\n",
      " ...\n",
      " [ True  True  True ...  True  True  True]\n",
      " [ True  True  True ...  True  True  True]\n",
      " [ True  True  True ...  True  True  True]]\n",
      "[[False False False ... False False False]\n",
      " [False False False ... False False False]\n",
      " [False False False ... False False False]\n",
      " ...\n",
      " [False False False ... False False False]\n",
      " [False False False ... False False False]\n",
      " [False False False ... False False False]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from skimage.morphology import skeletonize\n",
    "from skimage import data\n",
    "import matplotlib.pyplot as plt\n",
    "from skimage.util import invert\n",
    "\n",
    "# Invert the horse image\n",
    "print(data.horse())\n",
    "image = invert(data.horse())\n",
    "print(image)\n",
    "\n",
    "# perform skeletonization\n",
    "skeleton = skeletonize(image)\n",
    "\n",
    "# display results\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(8, 4),\n",
    "                         sharex=True, sharey=True)\n",
    "\n",
    "ax = axes.ravel()\n",
    "\n",
    "ax[0].imshow(image, cmap=plt.cm.gray)\n",
    "ax[0].axis('off')\n",
    "ax[0].set_title('original', fontsize=20)\n",
    "\n",
    "ax[1].imshow(skeleton, cmap=plt.cm.gray)\n",
    "ax[1].axis('off')\n",
    "ax[1].set_title('skeleton', fontsize=20)\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.imread('licence.jpg')\n",
    "image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "ret, threshold = cv2.threshold(image, 200, 255, cv2.THRESH_BINARY_INV)\n",
    "\n",
    "edges = cv2.Canny(image, 50, 220)\n",
    "resized = cv2.resize(edges, None, fx = 0.5, fy = 0.5)\n",
    "cv2.imshow('Edges', resized)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "# Find Contours\n",
    "_, contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "cv2.drawContours(edges, contours, -1, (0,255,0), 2)\n",
    "edges = cv2.resize(edges, None, fx = 0.5, fy = 0.5)\n",
    "cv2.imshow('Edges after contouring', edges)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kernel = np.ones((10, 1), np.uint8)\n",
    "    img_dilation = cv2.dilate(word, kernel, iterations=1)\n",
    "    im2, ctrs, hier = cv2.findContours(img_dilation.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    sorted_ctrs = sorted(ctrs, key=lambda ctr: cv2.boundingRect(ctr)[0])\n",
    "    character_list = []\n",
    "    for i, ctr in enumerate(sorted_ctrs):\n",
    "        # Get bounding box\n",
    "        x, y, w, h = cv2.boundingRect(ctr)\n",
    "        #dimensions = [x, y, w, h]\n",
    "        # Getting ROI\n",
    "        roi = word[y:y + h, x:x + w]\n",
    "        squared = makeSquare(roi)\n",
    "        final = resize_to_pixel(28, squared)\n",
    "        letter = characterPrediction(final)\n",
    "        character_list.append(letter)\n",
    "    return character_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Line Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Word Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Character Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Drawing Contours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Contours found = 742\n"
     ]
    }
   ],
   "source": [
    "# Image with shapes\n",
    "image = cv2.imread('abc.jpg')\n",
    "cv2.imshow('Original', image)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "resized = cv2.resize(image, None, fx = 2, fy = 2)\n",
    "\n",
    "# Grayscale\n",
    "gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)\n",
    "#gray_blur = cv2.GaussianBlur(gray, (3, 3), 0)\n",
    "# Find Canny Edges\n",
    "edges = cv2.Canny(gray, 30, 200)\n",
    "cv2.imshow('Edges', edges)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "# Find Contours\n",
    "_, contours, hierarchy = cv2.findContours(edges, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\n",
    "cv2.imshow('Edges after contouring', edges)\n",
    "cv2.waitKey()\n",
    "\n",
    "print('Number of Contours found = ' + str(len(contours)))\n",
    "\n",
    "#contours = np.array(contours).reshape((-1,1,2)).astype(np.int32)\n",
    "cv2.drawContours(resized, contours, -1, (0,255,0), 2)\n",
    "\n",
    "cv2.imshow('Contours', resized)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T02:23:59.322824Z",
     "start_time": "2019-01-16T02:23:59.319450Z"
    }
   },
   "outputs": [],
   "source": [
    "def pre_processing(path):\n",
    "\n",
    "    img = cv2.imread(path, 0)\n",
    "    showImage('main image', img)\n",
    "    hist,bins = np.histogram(img,256,[0,256])\n",
    "\n",
    "    _, img = cv2.threshold(img, np.argmax(hist) - 15, 255, cv2.THRESH_BINARY)\n",
    "    \n",
    "    # Deskew step\n",
    "#     deskewed = deskew(img)\n",
    "    # cv2.imwrite(\"(1)deskewed.jpg\", deskewed)\n",
    "\n",
    "    # Noise Clearing step\n",
    "    noise_cleared = cv2.fastNlMeansDenoising(img, None, 4, 7, 21)\n",
    "    # cv2.imwrite(\"(3)denoise.jpg\", noise_cleared)\n",
    "    \n",
    "    lines_removed = lineRemoval(noise_cleared)\n",
    "    \n",
    "    character_segmentation(lines_removed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T02:23:59.575142Z",
     "start_time": "2019-01-16T02:23:59.343023Z"
    }
   },
   "outputs": [],
   "source": [
    "def showImage(title, img):\n",
    "    cv2.imshow(title, img)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T02:26:32.964337Z",
     "start_time": "2019-01-16T02:26:32.955428Z"
    }
   },
   "outputs": [],
   "source": [
    "def character_segmentation(img):\n",
    "    height = img.shape[0] / 3\n",
    "    img = np.invert(img)\n",
    "    \n",
    "    kernel = np.ones((40, 1))\n",
    "    \n",
    "    dilated = cv2.dilate(img, np.ones((1, 1)), iterations = 1)\n",
    "    dilated = cv2.dilate(img, kernel, iterations = 1)\n",
    "    \n",
    "    canny = cv2.Canny(dilated, 30, 150)\n",
    "    \n",
    "    showImage('image', canny)\n",
    "    \n",
    "    _, ctrs_line, _ = cv2.findContours(dilated.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    sorted_ctrs_line = sorted(ctrs_line, key=lambda ctr: cv2.boundingRect(ctr)[0])\n",
    "#     img = cv2.copyMakeBorder(img, 40, 40, 40, 40, cv2.BORDER_CONSTANT)\n",
    "# # img = cv2.resize(img, (32, 32))\n",
    "\n",
    "    for i, ctr_line in enumerate(sorted_ctrs_line):\n",
    "        x_line, y_line, w_line, h_line = cv2.boundingRect(ctr_line)\n",
    "        if h_line < height:\n",
    "            continue\n",
    "#         print(x_line, y_line, w_line, h_line)\n",
    "        cropped_line = img[y_line:y_line + h_line, x_line:x_line + w_line]\n",
    "#         cropped_line = cv2.copyMakeBorder(cropped_line, 2, 2, 2, 2, cv2.BORDER_CONSTANT)\n",
    "#         showImage('image', cropped_line)\n",
    "        \n",
    "        cropped_line = cv2.resize(cropped_line, (20, 20), None)\n",
    "        cropped_line = cv2.copyMakeBorder(cropped_line, 6, 6, 6, 6, cv2.BORDER_CONSTANT)\n",
    "#         cropped_line = cv2.resize(cropped_line, (32, 32), None)\n",
    "        showImage('image', cropped_line)\n",
    "        output = model.predict_classes(cropped_line.reshape(-1, 32, 32, 1))\n",
    "#         probab = model.predict_proba(cropped_line.reshape(-1, 32, 32, 1))\n",
    "        probab = model.predict(cropped_line.reshape(-1, 32, 32, 1))\n",
    "        print(probab, output)\n",
    "\n",
    "#         cropped_line = cv2.copyMakeBorder(cropped_line, 2,2,2,2,cv2.BORDER_CONSTANT)\n",
    "#         cropped_line = cv2.resize(cropped_line, (32, 32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T06:56:17.239192Z",
     "start_time": "2019-01-16T06:56:01.288883Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/praneet/envs/deeplearning/lib/python3.5/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded Model from disk\n"
     ]
    }
   ],
   "source": [
    "from keras.models import model_from_json\n",
    "import tensorflow as tf\n",
    "\n",
    "json_file = open('../../Seven_Segment_Display_Prediction/models/model.json', 'r')\n",
    "loaded_model_json = json_file.read()\n",
    "json_file.close()\n",
    "model = model_from_json(loaded_model_json)\n",
    "# load weights into new model\n",
    "model.load_weights(\"../../Seven_Segment_Display_Prediction/models/model.h5\")\n",
    "print(\"Loaded Model from disk\")\n",
    "\n",
    "# compile and evaluate model\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T02:24:00.241393Z",
     "start_time": "2019-01-16T02:23:59.691147Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded Model from disk\n"
     ]
    }
   ],
   "source": [
    "graph = tf.get_default_graph()\n",
    "graph = tf.Graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T02:24:29.273144Z",
     "start_time": "2019-01-16T02:24:27.512947Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "import shutil\n",
    "import numpy as np\n",
    "from matplotlib.pyplot import imshow\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T02:26:44.573321Z",
     "start_time": "2019-01-16T02:26:35.878966Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]] [0]\n",
      "[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]] [0]\n",
      "[[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]] [3]\n",
      "[[0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]] [6]\n",
      "[[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]] [3]\n",
      "[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]] [0]\n",
      "[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]] [0]\n"
     ]
    }
   ],
   "source": [
    "pre_processing('ignore/test1.jpg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Potential Segmentation Columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-01-16T02:24:39.779115Z",
     "start_time": "2019-01-16T02:24:39.741067Z"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "import shutil\n",
    "import numpy as np\n",
    "from matplotlib.pyplot import imshow\n",
    "from PIL import Image\n",
    "\n",
    "'''\n",
    "this function convert image into matrix of image rows\n",
    "'''\n",
    "def imgToMatrixR(img):\n",
    "    # get dimensions\n",
    "    height, width = img.shape\n",
    "    matrix = []\n",
    "    # getting pixels values for all rows\n",
    "    for i in range(0, height):\n",
    "        row = []\n",
    "        for j in range(0, width):\n",
    "            row.append(img[i,j])\n",
    "        matrix.append(row)\n",
    "    return matrix\n",
    "\n",
    "'''\n",
    "this function convert image into matrix of image columns\n",
    "'''\n",
    "def imgToMatrixC(img):\n",
    "    # get dimensions\n",
    "    height, width = int(img.shape[1] / 2)\n",
    "    matrix = []\n",
    "    # getting pixels values for all columns\n",
    "    for i in range(0, width):\n",
    "        col = []\n",
    "        for j in range(0, height):\n",
    "            col.append(img[j, i])\n",
    "        matrix.append(col)\n",
    "    return matrix\n",
    "\n",
    "'''\n",
    "this function count a specific value (parameter p) in matrix\n",
    "'''\n",
    "def countPixel(matrix,p):\n",
    "    counter = []\n",
    "    for k in range(0, len(matrix)):\n",
    "        counter.append(matrix[k].count(p))\n",
    "    return counter\n",
    "\n",
    "'''\n",
    "this function searches for underlines  and replace the pixels that formed it with white pixels \n",
    "'''\n",
    "def lineRemoval(img):\n",
    "    min_length=140\n",
    "    matrix = imgToMatrixR(img)\n",
    "    for i in range(0, len(matrix)):\n",
    "        row=matrix[i]\n",
    "        start=-1\n",
    "        end=0\n",
    "        conn=0\n",
    "        for j in range(0, len(row)):\n",
    "            if (row[j]==0):\n",
    "                conn=conn+1\n",
    "                # first point in the line .\n",
    "                if( start == -1 ):\n",
    "                    start = j\n",
    "                # last point in the row .\n",
    "                if( j == len(row)-1 ):\n",
    "                    end =j\n",
    "                    if (conn > min_length):\n",
    "                        img[i-2:i+4, start:end+1] = 255\n",
    "                    start = -1\n",
    "                    end = 0\n",
    "                    conn = 0\n",
    "            # end of the line\n",
    "            else:\n",
    "                end =j\n",
    "                if (conn >min_length):\n",
    "                    img[i-2:i+4, start:end+1] = 255\n",
    "                start = -1\n",
    "                end = 0\n",
    "                conn = 0\n",
    "#     showImage('after line', img)\n",
    "    return img\n",
    "\n",
    "'''\n",
    "this function clears all horizontal boundaries around the input image\n",
    "'''\n",
    "def clearBounds_horiz(img):\n",
    "#     showImage('before horizontal', img)\n",
    "    height, width = img.shape\n",
    "    matrix = imgToMatrixR(img)\n",
    "    white_counter = countPixel(matrix,255)\n",
    "\n",
    "    for i in range (0,height):\n",
    "        if(white_counter[i]>= width-1):\n",
    "            img = img[1:height,0:width]\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    new_height, width = img.shape\n",
    "    for i in range (1,height):\n",
    "        if(white_counter[height-i]>= width-1):\n",
    "            img = img[0:new_height-i,0:width]\n",
    "        else:\n",
    "            break\n",
    "#     showImage('after horizontal', img)\n",
    "    return img\n",
    "\n",
    "'''\n",
    "this function clears all vertical boundaries around the input image\n",
    "'''\n",
    "def clearBounds_vert(img):\n",
    "#     showImage('before vertical', img)\n",
    "    height, width = img.shape\n",
    "    matrix = imgToMatrixC(img)\n",
    "    white_counter = countPixel(matrix,255)\n",
    "\n",
    "    for i in range (0,width):\n",
    "        if(white_counter[i]>= height-1):\n",
    "            img = img[0:height,1:width]\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    height, new_width = img.shape\n",
    "    for i in range (1,width):\n",
    "        if(white_counter[width-i]>= height-1):\n",
    "            img = img[0:height,0:new_width-i]\n",
    "        else:\n",
    "            break\n",
    "#     showImage('after vertical', img)\n",
    "    return img\n",
    "\n",
    "'''\n",
    "this function makes lines of text perfectly horizontal.\n",
    "'''\n",
    "def deskew(img):\n",
    "    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "    gray = cv2.bitwise_not(gray)\n",
    "    thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\n",
    "    coords = np.column_stack(np.where(thresh > 0))\n",
    "    angle = cv2.minAreaRect(coords)[-1]\n",
    "    if angle < -45:\n",
    "        angle = -(90 + angle)\n",
    "    else:\n",
    "        angle = -angle\n",
    "    (h, w) = img.shape[:2]\n",
    "    center = (w // 2, h // 2)\n",
    "    M = cv2.getRotationMatrix2D(center, angle, 1.0)\n",
    "    rotated = cv2.warpAffine(img, M, (w, h),flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)\n",
    "    return rotated\n",
    "\n",
    "\n",
    "'''\n",
    "this function applies a set of preprocessing operations to the input image, function output is a binarized image.\n",
    "operations are scaling , grayscaling , noise clearing , gaussian's thresholding and remove underlines.\n",
    "finally the function calls lineSegment function to segment the image into lines.\n",
    "'''\n",
    "# def pre_processing(path):\n",
    "#     # Read Image\n",
    "#     img = cv2.imread(path)\n",
    "\n",
    "#     # scaling\n",
    "#     height, width = img.shape[:2]\n",
    "#     scaled = img\n",
    "#     if height < 1600 and width < 1200:\n",
    "#         scaled = cv2.resize(img, (2 * width, 2* height), interpolation=cv2.INTER_LINEAR)\n",
    "#         # cv2.imwrite('(0)scaled.jpg', scaled)\n",
    "\n",
    "#     # Deskew step\n",
    "#     deskewed = deskew(scaled)\n",
    "#     # cv2.imwrite(\"(1)deskewed.jpg\", deskewed)\n",
    "\n",
    "#     # Grayscale step\n",
    "#     grayscaled = cv2.cvtColor(deskewed, cv2.COLOR_BGR2GRAY)\n",
    "#     # cv2.imwrite(\"(2)grayscale.jpg\", grayscaled)\n",
    "\n",
    "#     # Noise Clearing step\n",
    "#     noise_cleared = cv2.fastNlMeansDenoising(grayscaled, None, 4, 7, 21)\n",
    "#     # cv2.imwrite(\"(3)denoise.jpg\", noise_cleared)\n",
    "\n",
    "#     '''\n",
    "#     # GAUSSIAN's thresholding\n",
    "#     GBinary = cv2.adaptiveThreshold(noise_cleared,255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,15,5)\n",
    "#     # cv2.imwrite(\"(4)binarization.jpg\", GBinary)\n",
    "#     '''\n",
    "\n",
    "#     # Otsu's thresholding after Gaussian filtering\n",
    "#     blur = cv2.GaussianBlur(noise_cleared, (5, 5), 0)\n",
    "#     ret3, OBinary = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n",
    "#     # cv2.imwrite(\"(4)binarization.jpg\", OBinary)\n",
    "    \n",
    "#     if os.path.exists(\"output\"):\n",
    "#        shutil.rmtree(\"output\")\n",
    "#     os.makedirs(\"output\")\n",
    "#     cv2.imwrite(\"output/Preprocessed.png\", OBinary)\n",
    "\n",
    "#     line_segment(OBinary)\n",
    "    \n",
    "#     return lines\n",
    "'''\n",
    "this function segment the binarized image into lines\n",
    "segmentation technique consists of 3 steps :\n",
    "    1- define potential segmentation rows that contains no or 20 black pixels at most.\n",
    "    2- filter the potential segmentation rows and determine only segmentation rows which the crop operation depends on.\n",
    "    3- segment the image into lines.\n",
    "'''\n",
    "def line_segment(binary):\n",
    "    # get dimensions\n",
    "    height, width = binary.shape\n",
    "    # convert image into matrix of rows\n",
    "    matrix = imgToMatrixR(binary)\n",
    "    # count black pixels in each row\n",
    "    black_counter =countPixel(matrix,0)\n",
    "\n",
    "    # determine potential segmentation rows (psr)\n",
    "    # psr is any row contains 0-2 black pixels, last row in image is also a psr .\n",
    "    psr=[0]\n",
    "    for i in range(0, len(black_counter)):\n",
    "        if black_counter[i] <= 2 or i >= len(black_counter) - 2:\n",
    "            psr.append(i)\n",
    "\n",
    "    # determine segmentation rows sr\n",
    "    # sr is the index where we segment the image\n",
    "    sr = []\n",
    "    count = 0\n",
    "    for n in range(0, len(psr) - 1):\n",
    "        # combine each set of sequence white rows into only one sr\n",
    "        if psr[n] + 3 < psr[n + 1] or n >= len(psr) - 2:\n",
    "            sr.append(psr[n - int(count/2)])\n",
    "            count=0\n",
    "        else:\n",
    "            count += 1\n",
    "\n",
    "    # segment image into lines\n",
    "    global lines\n",
    "    for c in range(0, len(sr) - 1):\n",
    "        crop_img = binary[sr[c]:sr[c + 1], 0:width]\n",
    "        img = lineRemoval(crop_img)\n",
    "        img = clearBounds_horiz(img)\n",
    "        img = clearBounds_vert(img)\n",
    "        directory=\"output/line \"+str(c)\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "        cv2.imwrite(\"output/line \"+str(c)+\"/line \" + str(c) + \".png\", img)\n",
    "        # Call function to Segment the line into words then chars\n",
    "        lines.append([])\n",
    "        word_segment(img, c)\n",
    "        lines[c].append(\",\")\n",
    "\n",
    "'''\n",
    "this function segment lines into columns then words\n",
    "lineNum parameter used for naming, flag parameter refers to the type of segmentation.\n",
    "segmentation technique consists of 4 steps :\n",
    "    1- define potential segmentation columns that contains no or only two black pixels.\n",
    "    2- filter the potential segmentation columns,determine only segmentation columns which the crop operation depends on\n",
    "    3- segment the image into segments (column)\n",
    "    4- recursive call to segment columns into words\n",
    "'''\n",
    "def word_segment(binary, lineNum):\n",
    "    word_threshold=7\n",
    "\n",
    "    # get image dimension\n",
    "    height, width = binary.shape\n",
    "    # convert image to matrix of columns\n",
    "    matrix = imgToMatrixC(binary)\n",
    "    # count black pixels in each column\n",
    "    black_counter = countPixel(matrix,0)\n",
    "\n",
    "    # determine potential segmentation columns (psc).\n",
    "    # psc is any column contains no or two black pixel at most , last column in image is also a psc .\n",
    "    psc = [0]\n",
    "    for p in range(0, len(black_counter)):\n",
    "        if black_counter[p] <= 2 or p >= len(black_counter) - 2:\n",
    "            psc.append(p)\n",
    "\n",
    "    # determine segmentation columns (sc)\n",
    "    # sc is the index where we segment the image .\n",
    "    sc = []\n",
    "    count = 0\n",
    "    for n in range(0, len(psc) - 1):\n",
    "        # first column is sc\n",
    "        if n == 0:\n",
    "            sc.append(psc[n])\n",
    "            count = 0\n",
    "        # last column is also sc\n",
    "        elif n >= len(psc) - 2:\n",
    "            sc.append(psc[n])\n",
    "            count = 0\n",
    "\n",
    "        # combine each set of sequence white columns into only one sc\n",
    "        elif psc[n] + 3 < psc[n + 1] :\n",
    "            # space between words >= threshold value, low values is a space between chars not words.\n",
    "            if count >= word_threshold :\n",
    "                sc.append(psc[n -int(count/2)])\n",
    "            count = 0\n",
    "\n",
    "        else:\n",
    "            count += 1\n",
    "\n",
    "    for c in range(0, len(sc) - 1):\n",
    "        crop_img = binary[0:height, sc[c]:sc[c + 1] + 2]\n",
    "        directory = \"output/line \" + str(lineNum)+\"/word \" + str(c)\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "        cv2.imwrite(directory + \"/word \" + str(c) + \".png\", crop_img)\n",
    "        char_segment(crop_img, lineNum, c)\n",
    "\n",
    "'''\n",
    "this function segment words into chars\n",
    "lineNum and wordNum parameters used for naming \n",
    "segmentation technique consists of 3 steps :\n",
    "    1- define potential segmentation columns that contains no or only one black pixels.\n",
    "    2- filter potential segmentation columns by determine segmentation columns which the crop operation depends on .\n",
    "    3- segment the image into segments (chars).\n",
    "'''\n",
    "def char_segment(binary,lineNum,wordNum):\n",
    "    # get image dimension\n",
    "    height, width = binary.shape\n",
    "    # convert image to matrix of columns\n",
    "    matrix = imgToMatrixC(binary)\n",
    "    # count black pixels in each column\n",
    "    black_counter = countPixel(matrix,0)\n",
    "\n",
    "    # determine potential segmentation columns (psc).\n",
    "    # psc is any column contains no or one black bixel at most , last column in image is also a psc .\n",
    "    psc = [0]\n",
    "    for p in range(0, len(black_counter)):\n",
    "        if black_counter[p] <= 1 or p >= len(black_counter) - 2:\n",
    "            psc.append(p)\n",
    "\n",
    "    # determine segmentation columns (sc)\n",
    "    # sc is the average column between each sequence set of psc , average = summ of columns index/count of columns\n",
    "    sc = []\n",
    "    summ = 0\n",
    "    count = 0\n",
    "    for n in range(0, len(psc) - 1):\n",
    "        summ = summ + psc[n]\n",
    "        count = count + 1\n",
    "        # combine each set of sequence white columns into only one sc ,last column is also a sc\n",
    "        if psc[n] + 3 < psc[n + 1] or n >= len(psc) - 2:\n",
    "            sc.append(int(summ / count))\n",
    "            summ = 0\n",
    "            count = 0\n",
    "\n",
    "    global lines\n",
    "    # segment image into chars\n",
    "    for c in range(0, len(sc) - 1):\n",
    "        crop_img = binary[0:height, sc[c]:sc[c + 1]+2]\n",
    "        crop_img = clearBounds_horiz(crop_img)\n",
    "        crop_img = clearBounds_vert(crop_img)\n",
    "        crop_img = cv2.resize(crop_img, (64, 128), interpolation=cv2.INTER_LINEAR)\n",
    "        directory= \"output/line \" + str(lineNum)+\"/word \"+str(wordNum)\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "        cv2.imwrite(directory+\"/\"+str(c)+\".png\", crop_img)\n",
    "        lines[lineNum].append(crop_img)\n",
    "        if c == (len(sc) - 2):\n",
    "            lines[lineNum].append(\",\")\n",
    "    print(\"HERE\")\n",
    "    print(lines)\n",
    "\n",
    "\n",
    "# Preprocessing function Calling\n",
    "lines =[]\n",
    "# lines = g(\"Test\\\\testcase1.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 202,
   "position": {
    "height": "224px",
    "left": "1539px",
    "right": "20px",
    "top": "158px",
    "width": "342px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "block",
   "window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}