BoundingBox.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Remove the overlap issue of two bounding box "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import glob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#dir = '/media/nikhil/Data/Experiments/Handwritten text Extraction/handwriting Extraction Codes/Arabic-Handwriting-Recognition-Using-Matlab-master/Tests/folder/'\n",
    "\n",
    "#dir = '/media/nikhil/Data/Experiments/Handwritten text Extraction/handwriting Extraction Codes/Data/sample cheque data/'\n",
    "\n",
    "#base dir to take the input image. change it to location of input folder\n",
    "base_dir = '/media/nikhil/Data/Experiments/Handwritten text Extraction/handwriting Extraction Codes/pythoncodeBoundingBox/sampleWordImage/'\n",
    "final_dir = '/media/nikhil/Data/Experiments/Handwritten text Extraction/handwriting Extraction Codes/pythoncodeBoundingBox/sampleWordImageBB/'\n",
    "i = 27"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mergeContour(intervals):\n",
    "    merged = []\n",
    "    \n",
    "    mergedIntervalIndex = []\n",
    "    for i, higher in enumerate(intervals):\n",
    "        if not merged:\n",
    "            merged.append(higher)\n",
    "            mergedIntervalIndex.append([i])\n",
    "        else:\n",
    "            lower = merged[-1]\n",
    "            # test for intersection between lower and higher:\n",
    "            # we know via sorting that lower[0] <= higher[0]\n",
    "            if higher[0] <= lower[1] and higher[1]<=lower[1]:\n",
    "                upper_bound = max(lower[1], higher[1])\n",
    "                merged[-1] = (lower[0], upper_bound)\n",
    "                mergedIntervalIndex[-1].append(i)\n",
    "                # replace by merged interval\n",
    "            else:\n",
    "                merged.append(higher)\n",
    "                mergedIntervalIndex.append([i])\n",
    "    \n",
    "    #print (merged_interval_index)\n",
    "    return mergedIntervalIndex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0], [1], [2, 3], [4]]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#l = [(5, 7), (11, 116), (3, 4), (10, 12), (6, 12)]\n",
    "l = [(3, 4), (5, 7), (6, 12), (10, 12), (11, 116) ]\n",
    "mergeContour(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def addBorder(img, bordersize):\n",
    "    return cv2.copyMakeBorder(img, top=bordersize, bottom=bordersize,\n",
    "                              left=bordersize, right=bordersize,\n",
    "                              borderType= cv2.BORDER_CONSTANT, \n",
    "                              value=[255,255,255] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def segmentImage(baseImage, imFloodfillInv, mask, name):\n",
    "    \n",
    "    _, thresh = cv2.threshold(imFloodfillInv, 127, 255, 0)\n",
    "    _, contours, _ = cv2.findContours(thresh, cv2.RETR_TREE,\n",
    "                                      cv2.CHAIN_APPROX_SIMPLE)\n",
    "    \n",
    "    contoursWithRect = []\n",
    "    countourBoundary = []\n",
    "    for contour in contours:\n",
    "        x, y, w, h = cv2.boundingRect(contour)\n",
    "        contoursWithRect.append(((x, x+w), (y, y+h), contour))\n",
    "        \n",
    "    \n",
    "    #sort according to occurance of contours\n",
    "    #The format of each element is : ((x, x+w), (y, y+h), contour)\n",
    "    contoursWithRect = sorted(contoursWithRect, key = lambda x : x[0][0])\n",
    "    \n",
    "    #contains Bounding Interval of countours\n",
    "    #The format of each element is : (x, x+w)\n",
    "    countourBoundary = [x[0] for x in contoursWithRect]\n",
    "    \n",
    "    #contours in sorted order \n",
    "    contours = [x[-1] for x in contoursWithRect]\n",
    "    \n",
    "    #Contains list of merged countours\n",
    "    mergeContourBoundary = mergeContour(countourBoundary)\n",
    "    \n",
    "    #add border to base Image to make it size of contours generated\n",
    "    bordersize=1\n",
    "    baseImageWithBorder = addBorder(baseImage, bordersize)\n",
    "    \n",
    "    baseImageWithBorderInv = 255 - baseImageWithBorder\n",
    "    \n",
    "    \n",
    "    for interval in mergeContourBoundary:\n",
    "        color = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)\n",
    "        cont = [contours[i] for i in interval]\n",
    "        imgContour = cv2.drawContours(color, \n",
    "                                       cont, -1, (255,255,255), -1,8)\n",
    "       \n",
    "        res = cv2.bitwise_and(baseImageWithBorderInv,\n",
    "                              imgContour)\n",
    "        #change dir location to segmented image folder                      \n",
    "        cv2.imwrite(\"sampleWordImageBB/contour/\"+name.split('.')[0]+\n",
    "                    '_'+str(interval)+'.png',res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def boundingBox(img, imFloodfillInv, name):\n",
    "    connectivity = 8\n",
    "    #output = cv2.connectedComponentsWithStats(im_floodfill_inv, connectivity)\n",
    "    labelnum, _, contours, _ = cv2.connectedComponentsWithStats(\n",
    "        imFloodfillInv, connectivity)\n",
    "    \n",
    "    label_range = range(1, labelnum)\n",
    "    contours = sorted(contours, key = lambda x : x[0])\n",
    "    bb_img = img.copy()\n",
    "      \n",
    "    for label in xrange(1,labelnum):\n",
    "        x,y,w,h,size = contours[label]\n",
    "        bb_img = cv2.rectangle(bb_img, (x,y), (x+w,y+h), (0,0,255), 1)\n",
    "        \n",
    "    \n",
    "    #change it to BB image folder\n",
    "    cv2.imwrite(\"sampleWordImageBB/BB/\"+name,bb_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def arabicTextProcessing(path):\n",
    "    name = path.split('/')[-1]\n",
    "    base_image = cv2.imread(path)\n",
    "    gray_image = cv2.cvtColor(base_image, cv2.COLOR_BGR2GRAY)\n",
    "    gray_image = gray_image.astype('uint8')\n",
    "    Iedge = cv2.Canny(gray_image, 100, 200)\n",
    "    \n",
    "    #print(image.shape, gray_image.shape)\n",
    "    #dilation : small size of kernel- can segment between much closer objects and accurately\n",
    "    #according to experiment and trying several values for kernel:\n",
    "    #large value of first emlement of kernel such as (15, 3) helps in dilate image\n",
    "    #vertically. Large value of first element of kernel is useful for\n",
    "    #creating bounding box for text so that we can include the dots\n",
    "    #present in text in one Bounding Box. \n",
    "    #small values of both elements of kernel such as (3, 3)helps in segmenting and\n",
    "    #creating bounding box for number \n",
    "    kernel = np.ones((20,3), np.uint8)\n",
    "    img_dilation = cv2.dilate(Iedge, kernel, iterations=1)\n",
    "    #cv2.imwrite(\"sampleWordImageBB/\"+name.split('.')[0]+\"dilate.png\",img_dilation)\n",
    "    \n",
    "    \n",
    "    # Mask used to flood filling.\n",
    "    # Notice the size needs to be 2 pixels than the image.\n",
    "    th, im_th = cv2.threshold(img_dilation, 220, 255, \n",
    "                              cv2.THRESH_BINARY_INV);\n",
    "    #print(im_th.shape)\n",
    "    #cv2.imwrite(\"sampleWordImageBB/\"+name.split('.')[0]+\"dilate.png\",im_th)\n",
    "    #im_th = img_dilation\n",
    "    \n",
    "    # Copy the thresholded image.\n",
    "    im_floodfill = im_th.copy()\n",
    "    \n",
    "    h, w = im_th.shape[:2]\n",
    "    mask = np.zeros((h+2, w+2), np.uint8)\n",
    "    mask1 = np.zeros((h+10, w+10), np.uint8)\n",
    "    # Floodfill from point (0, 0)\n",
    "    cv2.floodFill(im_floodfill, mask, (0,0), 255)\n",
    "    \n",
    "    # Invert floodfilled image\n",
    "    im_floodfill_inv = cv2.bitwise_not(im_floodfill)\n",
    "    \n",
    "    \n",
    "    \n",
    "    #cv2.imwrite(\"sampleWordImageBB/dilate/\"+name,im_floodfill_inv)\n",
    "    \n",
    "    segmentImage(base_image, im_floodfill_inv, mask, name)\n",
    "    \n",
    "    \n",
    "    boundingBox(base_image, im_floodfill_inv, name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#name = 'word_test3.png'\n",
    "name = \"1233763914833.png\"\n",
    "arabicTextProcessing(base_dir+name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "file_list = glob.glob(base_dir+'*')\n",
    "for fil in file_list:\n",
    "    arabicTextProcessing(fil)\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python (tfone)",
   "language": "python",
   "name": "tfone"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}