module_2-lec4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Tesseract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# In the previous example, we were using a clear, unambiguous image for conversion. Sometimes there will \n",
    "# be noise in images you want to OCR, making it difficult to extract the text. Luckily, there are \n",
    "# techniques we can use to increase the efficacy of OCR with pytesseract and Pillow.\n",
    "#\n",
    "# Let's use a different image this time, with the same text as before but with added noise in the picture. \n",
    "# We can view this image using the following code. \n",
    "from PIL import Image\n",
    "img = Image.open(\"readonly/Noisy_OCR.PNG\")\n",
    "display(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# As you can see, this image had shapes of different opacities behind the text, which can confuse  \n",
    "# the tesseract engine. Let's see if OCR will work on this noisy image\n",
    "import pytesseract\n",
    "text = pytesseract.image_to_string(Image.open(\"readonly/Noisy_OCR.PNG\"))\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# This is a bit surprising given how nicely tesseract worked previously! Let's experiment on the image \n",
    "# using techniqes that will allow for more effective image analysis. First up, lets change the size of\n",
    "# the image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# First we will import PIL\n",
    "import PIL \n",
    "# Then set the base width of our image\n",
    "basewidth = 600 \n",
    "# Now lets open it\n",
    "img = Image.open(\"readonly/Noisy_OCR.PNG\")\n",
    "# We want to get the correct aspect ratio, so we can do this by taking the base width and dividing\n",
    "# it by the actual width of the image\n",
    "wpercent = (basewidth / float(img.size[0]))\n",
    "# With that ratio we can just get the appropriate height of the image.\n",
    "hsize = int((float(img.size[1]) * float(wpercent)))\n",
    "# Finally, lets resize the image. antialiasing is a specific way of resizing lines to try and make them \n",
    "# appear smooth\n",
    "img = img.resize((basewidth, hsize), PIL.Image.ANTIALIAS)\n",
    "# Now lets save this to a file\n",
    "img.save('resized_nois.png') # save the image as a jpg\n",
    "# And finally, lets display it\n",
    "display(img)\n",
    "# and run OCR\n",
    "text = pytesseract.image_to_string(Image.open('resized_nois.png')) \n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# hrm, no improvement for resizing the image. Let's convert the image to greyscale. Converting images \n",
    "# can be done in many different ways. If we poke around in the PILLOW documentation we find that one of\n",
    "# the easiest ways to do this is to use the convert() function and pass in the string 'L'\n",
    "img = Image.open('readonly/Noisy_OCR.PNG')\n",
    "img = img.convert('L')\n",
    "# Now lets save that image\n",
    "img.save('greyscale_noise.jpg')\n",
    "# And run OCR on the greyscale image\n",
    "text = pytesseract.image_to_string(Image.open('greyscale_noise.jpg')) \n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Wow, that worked really well! If we look at the help documentation using the help function\n",
    "# as in help(img.convert) we see that the conversion mechanism is the ITU-R 601-2 luma transform.\n",
    "# There's more information about this out there, but this method essentially takes a three channel image,\n",
    "# where there is information for the amount of red, green, and blue (R, G, and B), and reduces it\n",
    "# to a single channel to represent luminosity. This method actually comes from how standard\n",
    "# definition television sets encoded color onto black and while images. If you get really interested\n",
    "# in image manipulation and recognition, learning about color spaces and how we represent color, both\n",
    "# computationally and through human perception, is really an interesting field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Even though we have now the complete text of the image, there are a few other techniques\n",
    "# we could use to help improve OCR detection in the event that the above two don't help.\n",
    "# The next approach I would use is called binarization, which means to separate into two\n",
    "# distinct parts - in this case, black and white. Binarization is enacted through a process \n",
    "# called thresholding. If a pixel value is greater than a threshold value, it will be converted\n",
    "# to a black pixel; if it is lower than the threshold it will be converted to a white pixel. \n",
    "# This process eliminates noise in the OCR process allowing greater image recognition accuracy. \n",
    "# With Pillow, this process is straightforward.\n",
    "# Lets open the noisy impage and convert it using binarization\n",
    "img = Image.open('readonly/Noisy_OCR.PNG').convert('1')\n",
    "# Now lets save and display that image\n",
    "img.save('black_white_noise.jpg')\n",
    "display(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# So, that was a bit magical, and really required a fine reading of the docs to figure out\n",
    "# that the number \"1\" is a string parameter to the convert function actually does the binarization.\n",
    "# But you actually have all of the skills you need to write this functionality yourself.\n",
    "# Lets walk through an example. First, lets define a function called binarize, which takes in\n",
    "# an image and a threshold value:\n",
    "def binarize(image_to_transform, threshold):\n",
    "    # now, lets convert that image to a single greyscale image using convert()\n",
    "    output_image=image_to_transform.convert(\"L\")\n",
    "    # the threshold value is usually provided as a number between 0 and 255, which\n",
    "    # is the number of bits in a byte.\n",
    "    # the algorithm for the binarization is pretty simple, go through every pixel in the\n",
    "    # image and, if it's greater than the threshold, turn it all the way up (255), and\n",
    "    # if it's lower than the threshold, turn it all the way down (0).\n",
    "    # so lets write this in code. First, we need to iterate over all of the pixels in the\n",
    "    # image we want to work with\n",
    "    for x in range(output_image.width):\n",
    "        for y in range(output_image.height):\n",
    "            # for the given pixel at w,h, lets check its value against the threshold\n",
    "            if output_image.getpixel((x,y))< threshold: #note that the first parameter is actually a tuple object\n",
    "                # lets set this to zero\n",
    "                output_image.putpixel( (x,y), 0 )\n",
    "            else:\n",
    "                # otherwise lets set this to 255\n",
    "                output_image.putpixel( (x,y), 255 )\n",
    "    #now we just return the new image\n",
    "    return output_image\n",
    "\n",
    "# lets test this function over a range of different thresholds. Remember that you can use\n",
    "# the range() function to generate a list of numbers at different step sizes. range() is called\n",
    "# with a start, a stop, and a step size. So lets try range(0, 257, 64), which should generate 5\n",
    "# images of different threshold values\n",
    "for thresh in range(0,257,64):\n",
    "    print(\"Trying with threshold \" + str(thresh))\n",
    "    # Lets display the binarized image inline\n",
    "    display(binarize(Image.open('readonly/Noisy_OCR.PNG'), thresh))\n",
    "    # And lets use tesseract on it. It's inefficient to binarize it twice but this is just for\n",
    "    # a demo\n",
    "    print(pytesseract.image_to_string(binarize(Image.open('readonly/Noisy_OCR.PNG'), thresh)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We can see from this that a threshold of 0 essentially turns everything white,\n",
    "# that the text becomes more bold as we move towards a higher threshold, and that\n",
    "# the shapes, which have a filled in grey color, become more evident at higher\n",
    "# thresholds. In the next lecture we'll look a bit more at some of the challenges\n",
    "# you can expect when doing OCR on real data"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Module 2.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}