{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "054e06d6",
   "metadata": {},
   "source": [
    "# CHAPTER 2:TWO DIMENSIONAL CONVOLUTION AND CORRELATION\n",
    "After completing this chapter, the reader should be able to \n",
    "•\tPerform linear convolution between two matrices in spatial domain\n",
    "•\tPerform linear convolution in transform domain\n",
    "•\tUnderstand the properties of application of convolution\n",
    "•\tPerform correlation in spatial and transform domain\n",
    "•\tUnderstand the relationship between convolution and correlation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0a4f155",
   "metadata": {},
   "source": [
    "## Experiment 2.1: Computation of 2D Convolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49f99049",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Two dimensional convolution\n",
    "import numpy as np\n",
    "from scipy import signal\n",
    "x=np.array([[1,2],[3,4]])\n",
    "h=np.array([[5,6],[7,8]])\n",
    "y=signal.convolve2d(x,h)\n",
    "print('x:',x),print('h:',h)\n",
    "print('y:',y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47c23a16",
   "metadata": {},
   "source": [
    "## Experiment 2.2: Implementation of Identity system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1258b1a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Identity operation\n",
    "import cv2\n",
    "import numpy as np\n",
    "from scipy import signal\n",
    "import matplotlib.pyplot as plt\n",
    "x=cv2.imread('cameraman.tif',0)\n",
    "kernel=np.zeros([3,3])\n",
    "kernel[1,1]=1\n",
    "y=signal.convolve2d(x,kernel,'same')\n",
    "fig = plt.figure(figsize=(8,8))\n",
    "plt.subplot(1,3,1),plt.imshow(x,cmap='gray')\n",
    "plt.title('x[m,n]'),plt.axis('off')\n",
    "plt.subplot(1,3,2),plt.imshow(kernel,cmap='gray')\n",
    "plt.title('h[m,n]=$\\delta[m,n]$'),plt.yticks([0,1,2])\n",
    "plt.subplot(1,3,3),plt.imshow(y,cmap='gray')\n",
    "plt.title('y[m,n]'),plt.axis('off')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ebe75d9",
   "metadata": {},
   "source": [
    "## Experiment 2.3: Implementation of Spatial shift operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e218ae35",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Spaital shift operation\n",
    "import cv2\n",
    "import numpy as np\n",
    "from scipy import signal\n",
    "import matplotlib.pyplot as plt\n",
    "#Step 1: Defining the input signal x[m,n]\n",
    "x=cv2.imread('cameraman.tif',0)\n",
    "#Step 2: Defining the spatial shift kernels\n",
    "kernel_1=np.zeros([20,20])\n",
    "kernel_1[10,19]=1\n",
    "kernel_2=np.zeros([20,20])\n",
    "kernel_2[19,10]=1\n",
    "kernel_3=np.zeros([20,20])\n",
    "kernel_3[19,19]=1\n",
    "#Step 3: Obtaining the output\n",
    "y1=signal.convolve2d(x,kernel_1,'same')\n",
    "y2=signal.convolve2d(x,kernel_2,'same')\n",
    "y3=signal.convolve2d(x,kernel_3,'same')\n",
    "# Step 4: Displaying the result\n",
    "fig = plt.figure(figsize=(12,12))\n",
    "plt.subplot(3,3,1),plt.imshow(x,cmap='gray'),plt.title('x[m,n]'),plt.axis('off')\n",
    "plt.subplot(3,3,2),plt.imshow(kernel_1,cmap='gray')\n",
    "plt.title('h[m,n]=$\\delta[m,n-9]$'),plt.subplot(3,3,3),plt.imshow(y1,cmap='gray')\n",
    "plt.title('$y_1[m,n]$'),plt.axis('off'),plt.subplot(3,3,4),plt.imshow(x,cmap='gray')\n",
    "plt.title('x[m,n]'),plt.axis('off'),plt.subplot(3,3,5),plt.imshow(kernel_2,cmap='gray')\n",
    "plt.title('h[m,n]=$\\delta[m-9,n]$'),plt.subplot(3,3,6),plt.imshow(y2,cmap='gray')\n",
    "plt.title('$y_2[m,n]$'),plt.axis('off'),plt.subplot(3,3,7),plt.imshow(x,cmap='gray')\n",
    "plt.title('x[m,n]'),plt.axis('off'),plt.subplot(3,3,8),plt.imshow(kernel_3,cmap='gray')\n",
    "plt.title('h[m,n]=$\\delta[m-9,n-9]$'),plt.subplot(3,3,9),plt.imshow(y3,cmap='gray')\n",
    "plt.title('$y_3[m,n]$'),plt.axis('off')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d4305f0",
   "metadata": {},
   "source": [
    "## Experiment 2.4: Gaussian smoothing using 2D convolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b19662c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Gaussian smoothing\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "from scipy import signal\n",
    "#Step 1: Defining the input signal x[m,n]\n",
    "img_in=cv2.imread('cameraman.tif',0)\n",
    "#Step 2: Generation of 2D Gaussian kernel\n",
    "x=np.linspace(-10,10,20)\n",
    "y=np.linspace(-10,10,20)\n",
    "X,Y=np.meshgrid(x,y)\n",
    "D0=3\n",
    "kernel=(1/(2*np.pi*D0))*np.exp(-(X**2+Y**2)/(2*D0**2))\n",
    "#Step 3: Obtaining the output image\n",
    "img_out=signal.convolve2d(img_in,kernel,'same')\n",
    "#Step 4: Displaying the result\n",
    "plt.subplot(1,3,1),plt.imshow(img_in,cmap='gray'),plt.title('Input image'),plt.axis('off')\n",
    "plt.subplot(1,3,2),plt.imshow(kernel,cmap='gray'),plt.title('Gaussian kernel')\n",
    "plt.subplot(1,3,3),plt.imshow(img_out,cmap='gray'),plt.title('Output image'),plt.axis('off')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ae727d6",
   "metadata": {},
   "source": [
    "## Experiment 2.5: Implementation of Image Sharpening operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dfcc21f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Image sharpening\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "from scipy import signal\n",
    "#Step 1: Defining the input signal x[m,n]\n",
    "img_in=cv2.imread('testimage_edge.jpg',0)\n",
    "#Step 2: Defining the kernel\n",
    "kernel=np.array([[0,1,0],[1,-5,1],[0,1,0]])\n",
    "#Step 3: Obtaining the output image\n",
    "img_out=signal.convolve2d(img_in,kernel,'same')\n",
    "#Step 4: Displaying the result\n",
    "fig = plt.figure(figsize=(8,8)),plt.subplot(1,3,1),plt.imshow(img_in,cmap='gray')\n",
    "plt.title('Input image'),plt.axis('off'),plt.subplot(1,3,2),\n",
    "plt.imshow(kernel,cmap='gray'),plt.title('Kernel'),plt.subplot(1,3,3),\n",
    "plt.imshow(img_out,cmap='gray'),plt.title('Output image'),plt.axis('off')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb33fc50",
   "metadata": {},
   "source": [
    "## Experiment 2.6: Directional edge detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7a0cc55",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Directional filtering\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import signal\n",
    "import cv2\n",
    "#Step 1: Reading the input image\n",
    "img=cv2.imread('X.png',0)\n",
    "#Step 2: Generating directional kernel\n",
    "k1=np.array([[0,0,0],[-0.5,1,-0.5],[0,0,0]]) #Horizontal direction\n",
    "k2=np.array([[0,-0.5,0],[0,1,0],[0,-0.5,0]]) #Vertical direction\n",
    "k3=np.array([[-0.5,0,0],[0,1,0],[0,0,-0.5]]) #Diagonal direction\n",
    "k4=np.array([[0,0,-0.5],[0,1,0],[-0.5,0,0]]) #Diagonal direction\n",
    "#Step 3: Performing convolution\n",
    "img1=signal.convolve2d(img,k1,'same')\n",
    "img2=signal.convolve2d(img,k2,'same')\n",
    "img3=signal.convolve2d(img,k3,'same')\n",
    "img4=signal.convolve2d(img,k4,'same')\n",
    "#Step 4: Displaying the results\n",
    "fig = plt.figure(figsize=(9,9)),plt.subplot(3,3,1),plt.imshow(img,cmap='gray'),\n",
    "plt.title('Input image'),plt.xticks([]),plt.yticks([])\n",
    "plt.subplot(3,3,2),plt.imshow(k1,cmap='gray'),plt.title('Horizontal Kernel')\n",
    "plt.subplot(3,3,3),plt.imshow(img1,cmap='gray')\n",
    "plt.title('Horizontal edge detection'),plt.axis('off')\n",
    "plt.subplot(3,3,4),plt.imshow(k2,cmap='gray'),plt.title('Vertical Kernel')\n",
    "plt.subplot(3,3,5),plt.imshow(img2,cmap='gray')\n",
    "plt.title('Vertical edge detection'),plt.axis('off')\n",
    "plt.subplot(3,3,6),plt.imshow(k3,cmap='gray'),plt.title('Diagonal Kernel')\n",
    "plt.subplot(3,3,7),plt.imshow(img3,cmap='gray'),plt.axis('off')\n",
    "plt.title('Diagonal edge detection')\n",
    "plt.subplot(3,3,8),plt.imshow(k4,cmap='gray'),plt.title('Vertical Kernel')\n",
    "plt.subplot(3,3,9),plt.imshow(img4,cmap='gray'),plt.axis('off')\n",
    "plt.title('Diagonal edge detection')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fa0ef41",
   "metadata": {},
   "source": [
    "## Experiment 2.7: Linear convolution between two step signals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbfd77cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Linear convolution of two step signals\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import signal\n",
    "#Step 1: Generation of input images\n",
    "img1=np.ones([16,16])\n",
    "img1[0:16,0:8]=0\n",
    "img2=img1\n",
    "#Step 2: Perform linear convolution\n",
    "img_out=signal.convolve2d(img1,img2,'same')\n",
    "#Step 3: Displaying the result\n",
    "plt.subplot(1,3,1),plt.imshow(img1,cmap='gray')\n",
    "plt.title('Image-1'),plt.xticks([]),plt.yticks([])\n",
    "plt.subplot(1,3,2),plt.imshow(img2,cmap='gray')\n",
    "plt.title('Image-2'),plt.xticks([]),plt.yticks([])\n",
    "plt.subplot(1,3,3),plt.imshow(img_out,cmap='gray')\n",
    "plt.title('Linear convolution result'),plt.xticks([]),\n",
    "plt.yticks([])\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7120791c",
   "metadata": {},
   "source": [
    "## Experiment 2.8: Convolution of two Gaussian functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cfaaf2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Linear convolution of two Gaussian functions\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import signal\n",
    "#Step 1: Generation of input images\n",
    "x=np.linspace(-128,128,256)\n",
    "y=x\n",
    "X,Y=np.meshgrid(x,y)\n",
    "D=np.sqrt(X**2+Y**2)\n",
    "sigma1,sigma2=10,20\n",
    "img1=(1/(2*np.pi*sigma1))*np.exp((-D**2)/(2*sigma1**2))\n",
    "img2=(1/(2*np.pi*sigma2))*np.exp((-D**2)/(2*sigma2**2))\n",
    "#Step 2: Perform linear convolution\n",
    "img_out=signal.convolve2d(img1,img2)\n",
    "#Step 3: Displaying the result\n",
    "plt.subplot(2,3,1),plt.imshow(img1,cmap='gray'),plt.title('Image-1'),plt.axis('off')\n",
    "plt.subplot(2,3,2),plt.imshow(img2,cmap='gray'),plt.title('Image-2'),plt.axis('off')\n",
    "plt.subplot(2,3,3),plt.imshow(img_out,cmap='gray')\n",
    "plt.title('Linear convolution result'),plt.axis('off'),plt.subplot(2,3,4), plt.plot(img1[128,:]),plt.title('Profile of Image-1'),plt.subplot(2,3,5), plt.plot(img2[128,:]),plt.title('Profile of Image-2'),plt.subplot(2,3,6), plt.plot(img_out[256,:]),plt.title('Profile of output image')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a66b0684",
   "metadata": {},
   "source": [
    "## Experiment 2.9: Computation of linear convolution using transform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4df6ad2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computation of linear convolution in transform\n",
    "import numpy as np\n",
    "from scipy import signal\n",
    "#Step 1: Defining the input matrices\n",
    "x=np.array([[1,2],[3,4]])\n",
    "h=np.array([[5,6],[7,8]])\n",
    "print('x:',x),print('h:',h)\n",
    "#Step 2: Linear convolution in spatial domain\n",
    "y=signal.convolve2d(x,h)\n",
    "#Step 3: Zero padding of the input matrices\n",
    "x1=np.pad(x, [(0, 1), (0, 1)], mode='constant')\n",
    "h1=np.pad(h, [(0, 1), (0, 1)], mode='constant')\n",
    "print('x after padding:',x1),print('h after padding:',h1)\n",
    "#Step 4: Taking Forward transform\n",
    "X1=np.fft.fft2(x1)\n",
    "H1=np.fft.fft2(h1)\n",
    "#Step 5: Multiplication of the spectrum\n",
    "Y1=np.multiply(X1,H1)\n",
    "#Step 6: Taking Inverse Fourier transform\n",
    "y1=np.fft.ifft2(Y1)\n",
    "#Step 7: Comparing the result\n",
    "print('Result of linear convolution in spatial domain:',y)\n",
    "print(\"Result of linear convolution in transform domain:\",np.abs(y1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "562bc35d",
   "metadata": {},
   "source": [
    "## Experiment 2.10: Computation of 2D autocorrelation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11089e84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computation of 2D Correlation \n",
    "import numpy as np\n",
    "from scipy import signal\n",
    "x=np.array([[1,2],[3,4]])\n",
    "y=signal.correlate2d(x,x)\n",
    "print('Autocorrelation result:',y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "263580a1",
   "metadata": {},
   "source": [
    "## Experiment 2.11: Computation of 2D autocorrelation in Transform domain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31653499",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Correlation through transform domain\n",
    "import numpy as np\n",
    "from scipy import signal\n",
    "#Step 1: Defining the input matrices\n",
    "x=np.array([[1,2],[3,4]])\n",
    "h=x\n",
    "#Step 2: Flipping the matrix 'h'\n",
    "h1=h[:,::-1] #Equivalent to fliplr\n",
    "h2=h1[::-1,]#Equivalent to flip ud\n",
    "#Step 2: Linear correlation in spatial domain\n",
    "y=signal.correlate2d(x,h)\n",
    "#Step 3: Zero padding of the input matrices\n",
    "x1=np.pad(x, [(0, 1), (0, 1)], mode='constant')\n",
    "h1=np.pad(h2, [(0, 1), (0, 1)], mode='constant')\n",
    "#Step 4: Taking Forward transform\n",
    "X1=np.fft.fft2(x1)\n",
    "H1=np.fft.fft2(h1)\n",
    "#Step 5: Multiplication of the spectrum\n",
    "Y1=np.multiply(X1,H1)\n",
    "#Step 6: Taking Inverse Fourier transform\n",
    "y1=np.fft.ifft2(Y1)\n",
    "#Step 7: Comparing the result\n",
    "print('Result of correlation in Spatial domain:',y)\n",
    "print('Result of correlation in Transform domain:',np.abs(y1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8624c380",
   "metadata": {},
   "source": [
    "## Experiment 2.12: Relationship between convolution and correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f776881f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Relation between correlation and Convolution\n",
    "import numpy as np\n",
    "from scipy import signal\n",
    "#Step 1: Defining the input matrices\n",
    "x=np.array([[1,2],[3,4]])\n",
    "h=x\n",
    "#Step 2: Fold the second signal\n",
    "h1=h[:,::-1] #Equivalent to fliplr\n",
    "h2=h1[::-1,:]#Equivalent to flip ud\n",
    "#Step 2: Linear convolution \n",
    "y=signal.convolve2d(x,h2)\n",
    "#Step 3: Printing the result\n",
    "print('Input x:',x),print('Input h:', h),\n",
    "print('Flipped h:', h2)\n",
    "print('Correlation using Convolution:', y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c077ca9",
   "metadata": {},
   "source": [
    "## Experiment 2.13: Comparison between autocorrelation and cross-correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1483e61c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Autocorrelation and Cross-correlation\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import signal\n",
    "#Step 1: Generation of test image\n",
    "#Test image 1\n",
    "x=np.zeros([32,32])\n",
    "for i in range(0,32):\n",
    "    for j in range(0,32):\n",
    "        if(i<j):\n",
    "            x[i,j]=255\n",
    "#Test image 2\n",
    "y=np.zeros([32,32])\n",
    "for i in range(0,32):\n",
    "    for j in range(0,32):\n",
    "        if(i>j):\n",
    "            y[i,j]=255\n",
    "rxx=signal.correlate2d(x,x);#Step 2: Performing the autocorrelation\n",
    "rxy=signal.correlate2d(x,y);#Step 3: Performing the cross correlation\n",
    "fig = plt.figure(figsize=(6,6));#Sep 4: Displaying the result\n",
    "plt.subplot(2,2,1),plt.imshow(x,cmap='gray')\n",
    "plt.title('Test Image-1'),plt.xticks([]),plt.yticks([]) \n",
    "plt.subplot(2,2,2),plt.imshow(y,cmap='gray')\n",
    "plt.title('Test Image-2'),plt.xticks([]),plt.yticks([])\n",
    "plt.subplot(2,2,3),plt.imshow(rxx,cmap='gray')\n",
    "plt.title('Result of Aucocorrelation'),plt.axis('off')\n",
    "plt.subplot(2,2,4),plt.imshow(rxy,cmap='gray')\n",
    "plt.title('Result of Cross correlation (Rxy)'),plt.axis('off')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94478ed4",
   "metadata": {},
   "source": [
    "## Experiment 2.14: Template Matching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20a929b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Template matching\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "#Step 1: Reading the input image and template\n",
    "img = cv2.imread('A-Z.png',0)\n",
    "template = cv2.imread('template.png',0)\n",
    "#Displaying the input and template\n",
    "plt.figure(1),plt.subplot(2,1,1),plt.imshow(img,cmap='gray')\n",
    "plt.title('Test image'),plt.xticks([]),plt.yticks([])\n",
    "plt.subplot(2,1,2),plt.imshow(template,cmap='gray')\n",
    "plt.title('Template image'),plt.xticks([]),plt.yticks([])\n",
    "#Step 2: Perform template matching\n",
    "img_copy = img.copy()\n",
    "res = cv2.matchTemplate(img, template,cv2.TM_CCORR_NORMED)\n",
    "#Step 3: Bounding box for matched character\n",
    "min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)\n",
    "top_left = max_loc\n",
    "h,w=template.shape\n",
    "bottom_right = (top_left[0] + w, top_left[1] + h)\n",
    "cv2.rectangle(img, top_left, bottom_right, 0, 2)\n",
    "plt.figure(2),plt.imshow(img, cmap=\"gray\"),plt.xticks([]),plt.yticks([])\n",
    "plt.title('Image after template matching'),\n",
    "plt.tight_layout()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
