Theory on Convolutions and Kernels.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolution and Kernels "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.signal import gaussian\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def convoluplot(signal, kernel):\n",
    "    fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True)\n",
    "    ax1.stem(signal)\n",
    "    ax1.set_title('Signal')\n",
    "    ax2.stem(kernel)\n",
    "    ax2.set_title('kernel')\n",
    "    filtered = np.convolve(signal, kernel, \"same\")\n",
    "    ax3.stem(filtered)\n",
    "    ax3.set_title(\"Convolution\")\n",
    "    plt.show()\n",
    "\n",
    "# different signals and kernels for readers to try\n",
    "#signal = np.zeros(10)\n",
    "#signal[0:5] = 1\n",
    "#kernel = np.zeros(10)\n",
    "#kernel[0:2] = 1\n",
    "#convoluplot(signal, kernel)\n",
    "\n",
    "signal = np.array([0, 0, 1, 1, 1, 0, 0, 0])\n",
    "kernel = np.array([1, 1, 0, 0, 0])\n",
    "convoluplot(signal, kernel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2D Images and Predefined Kernels for Edge Detection using Convolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from PIL import Image\n",
    "from scipy import misc\n",
    "from skimage import data\n",
    "from skimage.color import rgb2gray\n",
    "import matplotlib.pyplot as plt\n",
    "from skimage import io, color\n",
    "import scipy.signal\n",
    "from skimage import exposure\n",
    "\n",
    "original_image = io.imread('./figs/House.png')\n",
    "grey_image = io.imread('./figs/House.png', as_grey=True)\n",
    "\n",
    "edge_kernel_horizontal = np.array([[-1, -1, -1],\n",
    "                                   [0, 0, 0],\n",
    "                                   [1, 1, 1]])\n",
    "horizontal_edge_detection = scipy.signal.convolve2d(\n",
    "    grey_image, edge_kernel_horizontal, 'valid')\n",
    "horizontal_edges_equalized = exposure.equalize_adapthist(\n",
    "    horizontal_edge_detection /\n",
    "    np.max(\n",
    "        np.abs(horizontal_edge_detection)),\n",
    "    clip_limit=0.03)\n",
    "\n",
    "edge_kernel_vertical = np.array([[-1, 0, 1],\n",
    "                                 [-1, 0, 1],\n",
    "                                 [-1, 0, 1]])\n",
    "vertical_edge_detection = scipy.signal.convolve2d(\n",
    "    grey_image, edge_kernel_vertical, 'valid')\n",
    "vertical_edges_equalized = exposure.equalize_adapthist(\n",
    "    vertical_edge_detection /\n",
    "    np.max(\n",
    "        np.abs(vertical_edge_detection)),\n",
    "    clip_limit=0.03)\n",
    "\n",
    "edge_kernel_outline = np.array([[-1, -1, -1],\n",
    "                                [-1, 8, -1],\n",
    "                                [-1, -1, -1]])\n",
    "outline_edge_detection = scipy.signal.convolve2d(\n",
    "    grey_image, edge_kernel_outline, 'valid')\n",
    "outline_edges_equalized = exposure.equalize_adapthist(\n",
    "    outline_edge_detection /\n",
    "    np.max(\n",
    "        np.abs(outline_edge_detection)),\n",
    "    clip_limit=0.03)\n",
    "\n",
    "\n",
    "f, ax_array = plt.subplots(2, 2)\n",
    "f.set_figheight(10)\n",
    "f.set_figwidth(15)\n",
    "ax_array[0, 0].imshow(original_image)\n",
    "ax_array[0, 0].set_title('Original Image')\n",
    "ax_array[0, 0].axis('off')\n",
    "ax_array[0, 1].imshow(horizontal_edges_equalized, cmap=plt.cm.gray)\n",
    "ax_array[0, 1].set_title('Horizontal Edge')\n",
    "ax_array[0, 1].axis('off')\n",
    "ax_array[1, 0].imshow(vertical_edges_equalized, cmap=plt.cm.gray)\n",
    "ax_array[1, 0].set_title('Vertical Edge')\n",
    "ax_array[1, 0].axis('off')\n",
    "ax_array[1, 1].imshow(outline_edges_equalized, cmap=plt.cm.gray)\n",
    "ax_array[1, 1].set_title('Outline Edge')\n",
    "ax_array[1, 1].axis('off')\n",
    "plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}