Lab3_Edge Detection.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/DL4CV-NPTEL/Deep-Learning-For-Computer-Vision/blob/main/notebooks/Week_2/Week_2_Lecture_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pz56u-MDozTW"
      },
      "source": [
        "## SOBEL FILTERS"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AGjlELyVozTY"
      },
      "source": [
        "The Sobel operator performs a 2-D spatial gradient measurement on an image and so emphasizes regions of high spatial frequency that correspond to edges. Typically it is used to find the approximate absolute gradient magnitude at each point in an input grayscale image."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hwgQPgbHozTb"
      },
      "source": [
        "### Implementation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "rfSkU7IsozTd"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import cv2\n",
        "import argparse\n",
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DReLPQ4FozTp"
      },
      "source": [
        "### STEP 1 : Converting an image from color to grayscale"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 194
        },
        "id": "G7Cgu1O4ozTr",
        "outputId": "637ab0bf-8fd3-448f-a95b-5632ed82faa5"
      },
      "outputs": [],
      "source": [
        "# array representation of image\n",
        "input_image = plt.imread('https://stsci-opo.org/STScI-01G8GZR18A6CBS9TGJS8JE9CM4.png') \n",
        "# nx: height, ny: width, nz: colors (RGB)\n",
        "[nx, ny, nz] = np.shape(input_image)  \n",
        "\n",
        "# Extracting each RGB components\n",
        "r_img, g_img, b_img = input_image[:, :, 0], input_image[:, :, 1], input_image[:, :, 2]\n",
        "\n",
        "# Here we are converting the color image to grayscale image by using weights and parameters\n",
        "gamma = 1.400 \n",
        "# weights for the RGB components respectively\n",
        "r_const, g_const, b_const = 0.2126, 0.7152, 0.0722 \n",
        "# conversion \n",
        "grayscale_image = r_const * r_img ** gamma + g_const * g_img ** gamma + b_const * b_img ** gamma\n",
        "\n",
        "# This command will display the grayscale image alongside the original image\n",
        "figure1 = plt.figure(1)\n",
        "ax1, ax2 = figure1.add_subplot(121), figure1.add_subplot(122)\n",
        "ax1.imshow(input_image)\n",
        "ax2.imshow(grayscale_image, cmap=plt.get_cmap('gray'))\n",
        "figure1.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bCzaYZvHozTu"
      },
      "source": [
        "### STEP2 - Applying the Sobel operator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X007KGQJozTw"
      },
      "source": [
        "Gx is vertical kernel and Gy is the horizontal kernel.\n",
        "\n",
        "\\begin{equation}\n",
        "Gx = \\begin{bmatrix} 1.0 & 0.0 & -1.0 \\\\ 2.0 & 0.0 & -2.0 \\\\ 1.0 & 0.0 & -1.0 \\end{bmatrix} \n",
        "Gy = \\begin{bmatrix} 1.0 & 2.0 & 1.0 \\\\ 0.0 & 0.0 & 0.0 \\\\ -1.0 & -2.0 & -1.0 \\end{bmatrix}\n",
        "\\end{equation}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 194
        },
        "id": "wnz-UvM9ozTy",
        "outputId": "7d42133f-f93d-46ad-d4e8-41d8120823ff"
      },
      "outputs": [],
      "source": [
        "# Here we define the matrices associated with the Sobel filter\n",
        "Gx = np.array([[1.0, 0.0, -1.0], [2.0, 0.0, -2.0], [1.0, 0.0, -1.0]])\n",
        "Gy = np.array([[1.0, 2.0, 1.0], [0.0, 0.0, 0.0], [-1.0, -2.0, -1.0]])\n",
        "\n",
        "# shape of the input grayscale image\n",
        "rows, columns = np.shape(grayscale_image) \n",
        "# initialize the output images to zeros!\n",
        "sobel_filtered_image = np.zeros(shape=(rows, columns))\n",
        "\n",
        "# Convolution operation\n",
        "for i in range(rows - 2):\n",
        "    for j in range(columns - 2):\n",
        "        gx = np.sum(np.multiply(Gx, grayscale_image[i:i + 3, j:j + 3]))\n",
        "        gy = np.sum(np.multiply(Gy, grayscale_image[i:i + 3, j:j + 3])) \n",
        "        sobel_filtered_image[i + 1, j + 1] = np.sqrt(gx ** 2 + gy ** 2)\n",
        "\n",
        "\n",
        "# Display the original image and the Sobel filtered image\n",
        "figure2 = plt.figure(2)\n",
        "ax1, ax2 = figure2.add_subplot(121), figure2.add_subplot(122)\n",
        "ax1.imshow(input_image)\n",
        "ax2.imshow(sobel_filtered_image, cmap=plt.get_cmap('gray'))\n",
        "figure2.show()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UtUFhyAxozT1"
      },
      "source": [
        "### References :"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c2LMhiXpozT2"
      },
      "source": [
        "\n",
        "https://en.wikipedia.org/wiki/Sobel_operator\n",
        "\n",
        "https://medium.com/@enzoftware/how-to-build-amazing-images-filters-with-python-median-filter-sobel-filter-%EF%B8%8F-%EF%B8%8F-22aeb8e2f540\n",
        "\n",
        "https://homepages.inf.ed.ac.uk/rbf/HIPR2/sobel.htm\n",
        "\n",
        "https://www.geeksforgeeks.org/python-grayscaling-of-images-using-opencv\n",
        "\n",
        "https://docs.opencv.org/3.4/d2/d2c/tutorial_sobel_derivatives.html\n",
        "\n",
        "https://learnopencv.com/edge-detection-using-opencv/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mYW4Odd5ozT3"
      },
      "source": [
        "## CANNY EDGE DETECTOR"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_JZa3XN6ozT5"
      },
      "source": [
        "The Canny edge detector is an edge detection operator that uses a multi-stage algorithm to detect a wide range of edges in images. It was developed by John F. Canny in 1986. Canny also produced a computational theory of edge detection explaining why the technique works."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PSzB_h0AozT6"
      },
      "source": [
        "Algorithm :\n",
        "\n",
        "1. Filter image with derivative of Gaussian \n",
        "2. Find magnitude and orientation of gradient \n",
        "3. Non-maximum supression\n",
        "4. Linking and thresholding(hysteresis):\n",
        "    - Define two thresholds : low and high \n",
        "    - Use the high threshold to start edge curves and the low threshold to continue them.\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0GRSltzYozT8"
      },
      "source": [
        "### STEP 1 : apply gaussian filter to reduce the noise from the image"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KDAF26nRozT9"
      },
      "source": [
        "We can apply gaussian blur to smooth the image. We can do this by convolving the image with Gaussian Kernel. We can have different kenel sizes, sizes depends on the expected blurring effect. Smallest kernel means less visible blur. In our example let's use 5x5 kernel."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NtwM7aAXozT-"
      },
      "outputs": [],
      "source": [
        "from scipy import ndimage\n",
        "from scipy.ndimage.filters import convolve\n",
        "from scipy import misc\n",
        "import numpy as np\n",
        "from matplotlib.pyplot import imshow"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vk-MVNB_ozT_"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "\n",
        "def gaussian_kernel(size, sigma=1):\n",
        "    size = int(size) // 2\n",
        "    x, y = np.mgrid[-size:size+1, -size:size+1]\n",
        "    normal = 1 / (2.0 * np.pi * sigma**2)\n",
        "    g =  np.exp(-((x**2 + y**2) / (2.0*sigma**2))) * normal\n",
        "    return g"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "78EoVD8nozUB"
      },
      "outputs": [],
      "source": [
        "img = plt.imread('https://stsci-opo.org/STScI-01G8GZR18A6CBS9TGJS8JE9CM4.png')\n",
        "img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "alMsn9KlozUC",
        "outputId": "edaacf26-4ecc-405b-e49a-486f993dcc84"
      },
      "outputs": [],
      "source": [
        "img"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "kTXIKgzvozUE",
        "outputId": "974582a2-44e9-45b8-ced4-8128bd651e36"
      },
      "outputs": [],
      "source": [
        "imshow(img, cmap=\"gray\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9CNt6E6sozUF"
      },
      "outputs": [],
      "source": [
        "smooth_img = convolve(img, gaussian_kernel(5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "LY-BVslYozUG",
        "outputId": "d18761c4-4e42-4d88-a706-3135ed2d052c"
      },
      "outputs": [],
      "source": [
        "imshow(smooth_img, cmap='gray')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0aAFcc0SozUH"
      },
      "source": [
        "### STEP 2 : Find the edge intenity and direction by calculating the gradient of the image using edge detection operators"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2GPv__FaozUI"
      },
      "source": [
        "For simplicity let's use the convolve method from scipy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xmpCT7uGozUJ"
      },
      "outputs": [],
      "source": [
        "from scipy import ndimage\n",
        "\n",
        "def sobel_filters(img):\n",
        "    Kx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], np.float32)\n",
        "    Ky = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], np.float32)\n",
        "    \n",
        "    Ix = ndimage.filters.convolve(img, Kx)\n",
        "    Iy = ndimage.filters.convolve(img, Ky)\n",
        "    \n",
        "    G = np.hypot(Ix, Iy)\n",
        "    G = G / G.max() * 255\n",
        "    theta = np.arctan2(Iy, Ix)\n",
        "    \n",
        "    return (G, theta)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CWRmzOR8ozUK"
      },
      "outputs": [],
      "source": [
        "gradientMat, thetaMat = sobel_filters(smooth_img)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UnNT--_EozUL"
      },
      "outputs": [],
      "source": [
        "gradientMat = gradientMat.astype('uint8')\n",
        "thetaMat = thetaMat.astype('uint8')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "7_VeA8PjozUM",
        "outputId": "3ff0d2c2-0228-481d-ff23-d6d76909589b"
      },
      "outputs": [],
      "source": [
        "imshow(gradientMat, cmap='gray')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "zw2qu4rbozUN",
        "outputId": "106f746b-33e5-40b9-e7d3-b4c2b71f9e7e"
      },
      "outputs": [],
      "source": [
        "imshow(thetaMat, cmap='gray')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4F-HyTX1ozUP"
      },
      "source": [
        "### STEP 3 : Non-Maximum Suppression"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hspy11XiozUQ"
      },
      "outputs": [],
      "source": [
        "def non_max_suppression(img, D):\n",
        "    M, N = img.shape\n",
        "    Z = np.zeros((M,N), dtype=np.int32)\n",
        "    angle = D * 180. / np.pi\n",
        "    angle[angle < 0] += 180\n",
        "\n",
        "    \n",
        "    for i in range(1,M-1):\n",
        "        for j in range(1,N-1):\n",
        "            try:\n",
        "                q = 255\n",
        "                r = 255\n",
        "                \n",
        "               #angle 0\n",
        "                if (0 <= angle[i,j] < 22.5) or (157.5 <= angle[i,j] <= 180):\n",
        "                    q = img[i, j+1]\n",
        "                    r = img[i, j-1]\n",
        "                #angle 45\n",
        "                elif (22.5 <= angle[i,j] < 67.5):\n",
        "                    q = img[i+1, j-1]\n",
        "                    r = img[i-1, j+1]\n",
        "                #angle 90\n",
        "                elif (67.5 <= angle[i,j] < 112.5):\n",
        "                    q = img[i+1, j]\n",
        "                    r = img[i-1, j]\n",
        "                #angle 135\n",
        "                elif (112.5 <= angle[i,j] < 157.5):\n",
        "                    q = img[i-1, j-1]\n",
        "                    r = img[i+1, j+1]\n",
        "\n",
        "                if (img[i,j] >= q) and (img[i,j] >= r):\n",
        "                    Z[i,j] = img[i,j]\n",
        "                else:\n",
        "                    Z[i,j] = 0\n",
        "\n",
        "            except IndexError as e:\n",
        "                pass\n",
        "    \n",
        "    return Z"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vT5I0wMIozUR"
      },
      "outputs": [],
      "source": [
        "nonMaxImg = non_max_suppression(gradientMat, thetaMat)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "Mp8jtXWDozUS",
        "outputId": "0b8b8c17-218d-4db3-c8e5-5cf7c85dbfee"
      },
      "outputs": [],
      "source": [
        "imshow(nonMaxImg, cmap='gray')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rxrzr1NAozUT"
      },
      "source": [
        "### STEP 4 : Linking and Thresholding"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qXgWbko4ozUU"
      },
      "outputs": [],
      "source": [
        "def threshold(img, lowThresholdRatio=0.05, highThresholdRatio=0.09):\n",
        "    \n",
        "    highThreshold = img.max() * highThresholdRatio;\n",
        "    lowThreshold = highThreshold * lowThresholdRatio;\n",
        "    \n",
        "    M, N = img.shape\n",
        "    res = np.zeros((M,N), dtype=np.int32)\n",
        "    \n",
        "    weak = np.int32(25)\n",
        "    strong = np.int32(255)\n",
        "    \n",
        "    strong_i, strong_j = np.where(img >= highThreshold)\n",
        "    zeros_i, zeros_j = np.where(img < lowThreshold)\n",
        "    \n",
        "    weak_i, weak_j = np.where((img <= highThreshold) & (img >= lowThreshold))\n",
        "    \n",
        "    res[strong_i, strong_j] = strong\n",
        "    res[weak_i, weak_j] = weak\n",
        "    \n",
        "    return res"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_JrM0H-rozUV"
      },
      "outputs": [],
      "source": [
        "thresholdImg = threshold(nonMaxImg)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "hE8Xo7ErozUW",
        "outputId": "dd0c8d45-5b88-4b89-e2f9-a4d95e13c280"
      },
      "outputs": [],
      "source": [
        "imshow(thresholdImg, cmap='gray')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AdiJl4R0ozUX"
      },
      "outputs": [],
      "source": [
        "def hysteresis(img):\n",
        "\n",
        "    M, N = img.shape\n",
        "    weak = 75 # weak pixel\n",
        "    strong = 355 #stron pixel\n",
        "\n",
        "    for i in range(1, M-1):\n",
        "        for j in range(1, N-1):\n",
        "            if (img[i,j] == weak):\n",
        "                try:\n",
        "                    if ((img[i+1, j-1] == strong) or (img[i+1, j] == strong) or (img[i+1, j+1] == strong)\n",
        "                        or (img[i, j-1] == strong) or (img[i, j+1] == strong)\n",
        "                        or (img[i-1, j-1] == strong) or (img[i-1, j] == strong) or (img[i-1, j+1] == strong)):\n",
        "                        img[i, j] = strong\n",
        "                    else:\n",
        "                        img[i, j] = 0\n",
        "                except IndexError as e:\n",
        "                    pass\n",
        "\n",
        "    return img"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M0X9oSzcozUY"
      },
      "outputs": [],
      "source": [
        "final_img = hysteresis(thresholdImg)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "nOTQp7AOozUZ",
        "outputId": "93a4bcfa-99bd-497c-cd59-9bbcbba42130"
      },
      "outputs": [],
      "source": [
        "imshow(final_img, cmap='gray')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ocq8hfpRozUa"
      },
      "source": [
        "### References : \n",
        "https://docs.opencv.org/4.x/da/d22/tutorial_py_canny.html\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "include_colab_link": true,
      "name": "Week_2_Lecture_1.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.9.5 ('mark1')",
      "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.10.9"
    },
    "vscode": {
      "interpreter": {
        "hash": "16455a106b8771c157630b897ff80da58ba8212423648b00bfc29fe4828ee60f"
      }
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "0c84a4f853bf4e8a9eecd882016c7601": {
          "model_module": "@jupyter-widgets/output",
          "model_module_version": "1.0.0",
          "model_name": "OutputModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/output",
            "_model_module_version": "1.0.0",
            "_model_name": "OutputModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/output",
            "_view_module_version": "1.0.0",
            "_view_name": "OutputView",
            "layout": "IPY_MODEL_8ee03c9b377d4065b23cf885298fcfbc",
            "msg_id": "",
            "outputs": [
              {
                "name": "stdout",
                "output_type": "stream",
                "text": [
                  "Video available at https://youtube.com/watch?v=9r8ph2pb9aw\n"
                ]
              },
              {
                "data": {
                  "image/jpeg": "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\n",
                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://www.youtube.com/embed/9r8ph2pb9aw?fs=1&rel=0\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                  "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7f5022d75350>"
                },
                "metadata": {},
                "output_type": "display_data"
              }
            ]
          }
        },
        "8ee03c9b377d4065b23cf885298fcfbc": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}