Aadhaar_OCR.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Aadhaar_OCR.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ip2b7spdXYA"
      },
      "source": [
        "# Mount Google Drive if working on Colab\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount(\"/drive\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1j0qmCHvcXqI"
      },
      "source": [
        "# Install Required Libraries from PyPI\n",
        "\n",
        "!sudo apt install tesseract-ocr\n",
        "!pip install pytesseract\n",
        "!pip install ISR\n",
        "!pip install pdf2image\n",
        "!pip install img2pdf\n",
        "!sudo apt-get install poppler-utils\n",
        "!pip install regex"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-_PCWR-ldNrK"
      },
      "source": [
        "# Import required packages\n",
        "\n",
        "import cv2\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import regex as re\n",
        "from PIL import Image\n",
        "import pytesseract as ocr\n",
        "from ISR.models import RRDN\n",
        "from google.colab.patches import cv2_imshow\n",
        "from pdf2image import convert_from_path\n",
        "import img2pdf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y4_qua_Ouze0"
      },
      "source": [
        "# Load Pretrained ESRGAN Model\n",
        "\n",
        "SR_Model = RRDN(weights='gans')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AbsjAIlPm-9r"
      },
      "source": [
        "# Verhoeff Algorithm\n",
        "\n",
        "multiplication_table = (\n",
        "    (0, 1, 2, 3, 4, 5, 6, 7, 8, 9),\n",
        "    (1, 2, 3, 4, 0, 6, 7, 8, 9, 5),\n",
        "    (2, 3, 4, 0, 1, 7, 8, 9, 5, 6),\n",
        "    (3, 4, 0, 1, 2, 8, 9, 5, 6, 7),\n",
        "    (4, 0, 1, 2, 3, 9, 5, 6, 7, 8),\n",
        "    (5, 9, 8, 7, 6, 0, 4, 3, 2, 1),\n",
        "    (6, 5, 9, 8, 7, 1, 0, 4, 3, 2),\n",
        "    (7, 6, 5, 9, 8, 2, 1, 0, 4, 3),\n",
        "    (8, 7, 6, 5, 9, 3, 2, 1, 0, 4),\n",
        "    (9, 8, 7, 6, 5, 4, 3, 2, 1, 0))\n",
        "\n",
        "permutation_table = (\n",
        "    (0, 1, 2, 3, 4, 5, 6, 7, 8, 9),\n",
        "    (1, 5, 7, 6, 2, 8, 3, 0, 9, 4),\n",
        "    (5, 8, 0, 3, 7, 9, 6, 1, 4, 2),\n",
        "    (8, 9, 1, 6, 0, 4, 3, 5, 2, 7),\n",
        "    (9, 4, 5, 3, 1, 2, 6, 8, 7, 0),\n",
        "    (4, 2, 8, 6, 5, 7, 3, 9, 0, 1),\n",
        "    (2, 7, 9, 3, 8, 0, 6, 4, 1, 5),\n",
        "    (7, 0, 4, 6, 9, 1, 3, 2, 5, 8))\n",
        "\n",
        "def compute_checksum(number):\n",
        "    \n",
        "    \"\"\"Calculate the Verhoeff checksum over the provided number. The checksum\n",
        "    is returned as an int. Valid numbers should have a checksum of 0.\"\"\"\n",
        "    \n",
        "    # transform number list\n",
        "    number = tuple(int(n) for n in reversed(str(number)))\n",
        "    \n",
        "    # calculate checksum\n",
        "    checksum = 0\n",
        "    \n",
        "    for i, n in enumerate(number):\n",
        "        checksum = multiplication_table[checksum][permutation_table[i % 8][n]]\n",
        "    \n",
        "    return checksum"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_wu4NE0gGgx7"
      },
      "source": [
        "# Search Possible UIDs with Bounding Boxes\n",
        "\n",
        "def Regex_Search(bounding_boxes):\n",
        "\n",
        "  possible_UIDs = []\n",
        "  Result = \"\"\n",
        "\n",
        "  for character in range(len(bounding_boxes)):\n",
        "    if len(bounding_boxes[character])!=0:\n",
        "      Result += bounding_boxes[character][0]\n",
        "    else:\n",
        "      Result += '?'\n",
        "\n",
        "  matches = [match.span() for match in re.finditer(r'\\d{12}',Result,overlapped=True)]\n",
        "\n",
        "  for match in matches :\n",
        "\n",
        "    UID = int(Result[match[0]:match[1]])\n",
        "    \n",
        "    if compute_checksum(UID)==0 and UID%10000!=1947:\n",
        "       possible_UIDs.append([UID,match[0]])\n",
        "\n",
        "  possible_UIDs = np.array(possible_UIDs)\n",
        "  return possible_UIDs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NsqMutr0IfOM"
      },
      "source": [
        "# Mask found UIDs using OpenCV\n",
        "\n",
        "def Mask_UIDs (image_path,possible_UIDs,bounding_boxes,rtype,SR=False,SR_Ratio=[1,1]):\n",
        "\n",
        "  img = cv2.imread(image_path)\n",
        "\n",
        "  if rtype==2:\n",
        "    img = cv2.rotate(img,cv2.ROTATE_90_COUNTERCLOCKWISE)\n",
        "  elif rtype==3:\n",
        "    img = cv2.rotate(img,cv2.ROTATE_180)\n",
        "  elif rtype==4:\n",
        "    img = cv2.rotate(img,cv2.ROTATE_90_CLOCKWISE)\n",
        "\n",
        "  height = img.shape[0]\n",
        "\n",
        "  if SR==True:\n",
        "    height*=SR_Ratio[1]\n",
        "\n",
        "  ########################### MASK EVERY DIGIT INDIVIDUALLY ############################\n",
        "\n",
        "  # for UID in possible_UIDs:\n",
        "\n",
        "  #   for i in range(8):\n",
        "\n",
        "  #     digit = bounding_boxes[UID[1]+i].split()\n",
        "\n",
        "  #     if SR==False:\n",
        "  #       top_left_corner = (int(digit[1]),height-int(digit[4]))\n",
        "  #       bottom_right_corner = (int(digit[3]),height-int(digit[2]))\n",
        "\n",
        "  #     else:\n",
        "  #       top_left_corner = (int(int(digit[1])/SR_Ratio[0]),int((height-int(digit[4]))/SR_Ratio[1]))\n",
        "  #       bottom_right_corner = (int(int(digit[3])/SR_Ratio[0]),int((height-int(digit[2]))/SR_Ratio[1]))\n",
        "\n",
        "  #     img = cv2.rectangle(img,top_left_corner,bottom_right_corner,(0,0,0),-1)\n",
        "\n",
        "  ######################################################################################\n",
        "\n",
        "  for UID in possible_UIDs:\n",
        "\n",
        "    digit1 = bounding_boxes[UID[1]].split()\n",
        "    digit8 = bounding_boxes[UID[1] + 7].split()\n",
        "\n",
        "    h1 = min(height-int(digit1[4]),height-int(digit8[4]))\n",
        "    h2 = max(height-int(digit1[2]),height-int(digit8[2]))\n",
        "\n",
        "    if SR==False:\n",
        "      top_left_corner = (int(digit1[1]),h1)\n",
        "      bottom_right_corner = (int(digit8[3]),h2)\n",
        "\n",
        "    else:\n",
        "      top_left_corner = (int(int(digit1[1])/SR_Ratio[0]),int((h1)/SR_Ratio[1]))\n",
        "      bottom_right_corner = (int(int(digit8[3])/SR_Ratio[0]),int((h2)/SR_Ratio[1]))\n",
        "\n",
        "    img = cv2.rectangle(img,top_left_corner,bottom_right_corner,(0,0,0),-1)\n",
        "\n",
        "  if rtype==2:\n",
        "    img = cv2.rotate(img,cv2.ROTATE_90_CLOCKWISE)\n",
        "  elif rtype==3:\n",
        "    img = cv2.rotate(img,cv2.ROTATE_180)\n",
        "  elif rtype==4:\n",
        "    img = cv2.rotate(img,cv2.ROTATE_90_COUNTERCLOCKWISE)\n",
        "\n",
        "  file_name = image_path.split('/')[-1].split('.')[0]+\"_masked\"+\".\"+image_path.split('.')[-1]\n",
        "  cv2.imwrite(file_name,img)\n",
        "  return file_name"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rrSxsvgY99VW"
      },
      "source": [
        "# Extract, Verify and Mask UIDs\n",
        "\n",
        "def Extract_and_Mask_UIDs (image_path,SR=False,sr_image_path=None,SR_Ratio=[1,1]):\n",
        "\n",
        "  if SR==False:\n",
        "    img = cv2.imread(image_path)\n",
        "  else:\n",
        "    img = cv2.imread(sr_image_path)\n",
        "\n",
        "  gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n",
        "\n",
        "  rotations = [[gray,1],\n",
        "               [cv2.rotate(gray,cv2.ROTATE_90_COUNTERCLOCKWISE),2],\n",
        "               [cv2.rotate(gray,cv2.ROTATE_180),3],\n",
        "               [cv2.rotate(gray,cv2.ROTATE_90_CLOCKWISE),4],\n",
        "               [cv2.GaussianBlur(gray,(5,5),0),1],\n",
        "               [cv2.GaussianBlur(cv2.rotate(gray,cv2.ROTATE_90_COUNTERCLOCKWISE),(5,5),0),2],\n",
        "               [cv2.GaussianBlur(cv2.rotate(gray,cv2.ROTATE_180),(5,5),0),3],\n",
        "               [cv2.GaussianBlur(cv2.rotate(gray,cv2.ROTATE_90_CLOCKWISE),(5,5),0),4]]\n",
        "\n",
        "  settings = ('-l eng --oem 3 --psm 11')\n",
        "\n",
        "  for rotation in rotations :\n",
        "    \n",
        "    cv2.imwrite('rotated_grayscale.png',rotation[0])\n",
        "    bounding_boxes = ocr.image_to_boxes(Image.open('rotated_grayscale.png'),config=settings).split(\" 0\\n\")\n",
        "\n",
        "    possible_UIDs = Regex_Search(bounding_boxes)\n",
        "\n",
        "    if len(possible_UIDs)==0:\n",
        "      continue\n",
        "    else:\n",
        "\n",
        "      if SR==False:\n",
        "        masked_img = Mask_UIDs (image_path,possible_UIDs,bounding_boxes,rotation[1])\n",
        "      else:\n",
        "        masked_img = Mask_UIDs (image_path,possible_UIDs,bounding_boxes,rotation[1],True,SR_Ratio)\n",
        "\n",
        "      return (masked_img,possible_UIDs)\n",
        "\n",
        "  return (None,None)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LaGcwmHjt196"
      },
      "source": [
        "# Test on an Image/PDF\n",
        "\n",
        "input_path = \"/drive/My Drive/data/14.pdf\"   # Path to the Input Image/PDF\n",
        "\n",
        "if input_path.split('.')[-1]==\"pdf\":\n",
        "    \n",
        "    pages = convert_from_path(input_path, 300)\n",
        "    pages[0].save('pdf2img.jpg', 'JPEG')\n",
        "\n",
        "if input_path.split('.')[-1]==\"pdf\":\n",
        "  masked_img,possible_UIDs = Extract_and_Mask_UIDs('pdf2img.jpg')\n",
        "else:\n",
        "  masked_img,possible_UIDs = Extract_and_Mask_UIDs(input_path)\n",
        "\n",
        "if masked_img!=None and input_path.split('.')[-1]==\"pdf\":\n",
        "    \n",
        "  image = Image.open(masked_img) \n",
        "  pdf_bytes = img2pdf.convert(image.filename) \n",
        "  file = open(input_path.split('/')[-1].split('.')[0]+\"_masked\"+\".pdf\", \"wb\")\n",
        "  masked_img = input_path.split('/')[-1].split('.')[0]+\"_masked\"+\".pdf\" \n",
        "  file.write(pdf_bytes) \n",
        "  image.close() \n",
        "  file.close() \n",
        "\n",
        "if masked_img==None:\n",
        "  print(\"Can't find any UID!\")\n",
        "else:\n",
        "  print(\"Found UIDs : \"+str(possible_UIDs[:,0]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SA4KQmNj4q_s"
      },
      "source": [
        "# If it doesn't work, Try on Super Resolution Version \n",
        "\n",
        "input_path = \"/drive/My Drive/data/1.jpg\"   # Path to the Input Image/PDF\n",
        "\n",
        "# Super Resolution using ESRGAN\n",
        "\n",
        "if input_path.split('.')[-1]==\"pdf\":\n",
        "    \n",
        "    pages = convert_from_path(input_path, 300)\n",
        "    pages[0].save('pdf2img.jpg', 'JPEG')\n",
        "\n",
        "if input_path.split('.')[-1]==\"pdf\":\n",
        "  LR_img = cv2.imread('pdf2img.jpg')\n",
        "else:\n",
        "  LR_img = cv2.imread(input_path)\n",
        "\n",
        "SR_img = SR_Model.predict(LR_img[:,:,::-1])\n",
        "cv2.imwrite(\"SR_img.png\",SR_img[:,:,::-1])\n",
        "\n",
        "SR_Ratio = [int(SR_img.shape[1]/LR_img.shape[1]),int(SR_img.shape[0]/LR_img.shape[0])]\n",
        "\n",
        "if input_path.split('.')[-1]==\"pdf\":\n",
        "  masked_img,possible_UIDs = Extract_and_Mask_UIDs('pdf2img.jpg',True,\"SR_img.png\",SR_Ratio)\n",
        "else:\n",
        "  masked_img,possible_UIDs = Extract_and_Mask_UIDs(input_path,True,\"SR_img.png\",SR_Ratio)\n",
        "\n",
        "if masked_img!=None and input_path.split('.')[-1]==\"pdf\":\n",
        "    \n",
        "  image = Image.open(masked_img) \n",
        "  pdf_bytes = img2pdf.convert(image.filename) \n",
        "  file = open(input_path.split('/')[-1].split('.')[0]+\"_masked\"+\".pdf\", \"wb\") \n",
        "  masked_img = input_path.split('/')[-1].split('.')[0]+\"_masked\"+\".pdf\"\n",
        "  file.write(pdf_bytes) \n",
        "  image.close() \n",
        "  file.close() \n",
        "\n",
        "if masked_img==None:\n",
        "  print(\"Can't find any UID!\")\n",
        "else:\n",
        "  print(\"Found UIDs : \"+str(possible_UIDs[:,0]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DTVsJdfKvEmz"
      },
      "source": [
        "# Show Original and Masked Images (Doesn't work with PDF Files ! Download them instead)\n",
        "\n",
        "print(\"Original :\")\n",
        "cv2_imshow(cv2.imread(input_path))\n",
        "print(\"\\nMasked :\")\n",
        "cv2_imshow(cv2.imread(masked_img))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tx5CiLNpQcIL"
      },
      "source": [
        "# Download Masked Image/PDF (if required)\n",
        "\n",
        "from google.colab import files\n",
        "files.download(masked_img)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}