gurdeepsingh_openCV_blurring_and_sharpening.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Convolution and Blurring "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import cv2  # importing the opencv module \n",
    "import numpy as np "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now reading the image that we have \n",
    "img=cv2.imread(\"obama.jpg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 33  16  13]\n",
      "  [ 33  16  13]\n",
      "  [ 32  16  13]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " [[ 32  18  14]\n",
      "  [ 32  18  14]\n",
      "  [ 32  18  14]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " [[ 31  20  16]\n",
      "  [ 34  21  18]\n",
      "  [ 35  22  20]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " ...\n",
      "\n",
      " [[156 154 181]\n",
      "  [163 162 183]\n",
      "  [169 168 185]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " [[155 155 180]\n",
      "  [165 163 184]\n",
      "  [170 169 186]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " [[155 155 180]\n",
      "  [162 162 183]\n",
      "  [170 169 187]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]]\n"
     ]
    }
   ],
   "source": [
    "print(img)  # Now we can see that by using opencv.imread function we can read the images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now let us view the image by using imshow function \n",
    "\n",
    "cv2.imshow(\"img\",img)    # This will display the image \n",
    "cv2.waitKey()            # This function will hold the screen/display like we use getch() in c/c++ language \n",
    "cv2.destroyAllWindows()  # This function is very important to use because this function will close/shut down all the display screen \n",
    "                         # we cam also say that cv2.destroyAllWindows will act like closing all opened files "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# the snapshot of the above output \n",
    "![img](/extras/snapshot1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Now lets do Convolution on our image "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Convolution is a mathematical operation performed on two functions producing a third function which is typically a modified version of one of the original function \n",
    "\n",
    "output_image(modified image) = original_image x kernel_function\n",
    "\n",
    "Where kernel_function is a matrix of our choice which have shape of any (2x3 or 5x5 or 7x7 and so on )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now for performing convolution operation we have to change our 3d image to 2d image ie from colored image to black n white \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "img=cv2.imread(\"obama.jpg\",0)   # by putting 0 in imread function we can see black n white output of our colored image "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(337, 337)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.shape    # lets us see shape of img and we find that ys its actually 2d "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv2.imshow(\"img\",img)\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This is the snapshot of above code's output \n",
    "![image.png](/extras/snapshot2.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets do convolution \n",
    "# Here the img is our original image and kernel is kernel function and the ouput image will be modified version of original image "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Creating our 3 x 3 kernel/filter\n",
    "kernel_3x3 = np.ones((3, 3), np.float32) / 9   # we divide out kernel matrix with 9 so that we can normalized our kernel ( scaled)\n",
    "\n",
    "# We use the cv2.fitler2D to convolve the kernal with an image \n",
    "blurred = cv2.filter2D(img, -1, kernel_3x3)\n",
    "cv2.imshow('3x3 Kernel Blurring', blurred)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "# Creating our 7 x 7 kernel\n",
    "kernel_7x7 = np.ones((7, 7), np.float32) / 49   # normalized by dividing the kernel with 49 so that there elements summed up to 1 \n",
    "\n",
    "# We use the cv2.fitler2D to convolve the kernal with an image \n",
    "blurred2 = cv2.filter2D(img, -1, kernel_7x7)\n",
    "cv2.imshow('7x7 Kernel Blurring', blurred2)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "# Creating our 11 x 11 kernel\n",
    "kernel_11x11=np.ones((11,11),np.float32)/121    # normalized by dividing kernel by 121 \n",
    "\n",
    "\n",
    "# We use the cv2.fitler2D to convolve the kernal with an image \n",
    "blurred3= cv2.filter2D(img, -1, kernel_11x11)\n",
    "cv2.imshow('11x11 Kernel Blurring', blurred3)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Snapshot of above cell's output\n",
    "![image.png](/extras/snapshot3.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Blurring by using cv2 functions and the convolution concept "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now above we make our kernel/filter and then do convolution by using filter2d function. And there are various kernels that are designed for some specific purpose like blurring, sharpening, detecting edges and so on \n",
    "\n",
    "Now we use the inbuilt cv2 function that has built in kernel and will automatically perform convolution. Such functions are :\n",
    "blur(), GaussianBlur(), medianBlur(), bilateralFilter(). Lets use all and see the result "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Averaging done by convolving the image with a normalized box filter(ie kernel that designed for this bluring purpose)\n",
    "# This takes the pixels under the box(kernel) and replaces the central element\n",
    "# Box(kernel) size needs to odd and positive \n",
    "blur = cv2.blur(img, (3,3))\n",
    "cv2.imshow('Averaging', blur)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "# Instead of box filter, gaussian kernel\n",
    "Gaussian = cv2.GaussianBlur(img, (7,7), 0)\n",
    "cv2.imshow('Gaussian Blurring', Gaussian)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "# Takes median of all the pixels under kernel area and central \n",
    "# element is replaced with this median value\n",
    "median = cv2.medianBlur(img, 5)\n",
    "cv2.imshow('Median Blurring', median)\n",
    "cv2.waitKey(0)\n",
    "\n",
    "# Bilateral is very effective in noise removal while keeping edges sharp\n",
    "bilateral = cv2.bilateralFilter(img, 9, 75, 75)\n",
    "cv2.imshow('Bilateral Blurring', bilateral)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Snapshot of above ouput \n",
    "![image.png](/extras/snapshot4.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Sharpening"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### By altering our kernels we can implement sharpening, which has the effects of in strengthening or emphasizing edges in an image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Create our shapening kernel, we don't normalize since the \n",
    "# the values in the matrix sum to 1\n",
    "kernel_sharpening = np.array([[-1,-1,-1], \n",
    "                              [-1,9,-1], \n",
    "                              [-1,-1,-1]])\n",
    "\n",
    "# applying different kernels to the input image\n",
    "sharpened = cv2.filter2D(img, -1, kernel_sharpening)\n",
    "\n",
    "cv2.imshow('Image Sharpening', sharpened)\n",
    "\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Snapshot of output \n",
    "![image.png](/extras/snapshot5.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Thanks \n",
    "# for any query u can dm me on linkedin : https://www.linkedin.com/in/gurdeep-singh-bhatia-319441171/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}