intro_gabor.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "#%matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "from ipywidgets import FloatSlider, IntSlider\n",
    "from ipywidgets import interactive\n",
    "from utils_noise import colorize, normalize, normalize_var\n",
    "from utils_noise import plot_colored, plot_spectral\n",
    "from utils_noise import gaborK, gaborN_rand, gaborN_uni"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gabor Kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Gabor kernel is the convolution of a Gaussian and Harmonic kernel. This results in symmetric gaussian lobes in its power spectrum.\n",
    "1. **sigma** - Variance of the Gaussian.\n",
    "2. **theta** - Orientation or angle of the kernel.\n",
    "3. **lambd** - Wavelength of the sinusoidal factor in the Harmonic kernel. In the spectral domain, this changes the distance between the lobes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "ksize = 199 # fixed kernel size\n",
    "\n",
    "# Interactive slider\n",
    "def PlotGaborK(sigma, theta, lambd, xy_ratio, sides):\n",
    "    img = gaborK(ksize = ksize, sigma = sigma, theta = theta, lambd = lambd, xy_ratio = xy_ratio, sides = sides)\n",
    "    plot_spectral(img, title = 'Gabor Kernel')\n",
    "    \n",
    "# Parameter sliders\n",
    "s_sigma = FloatSlider(min = 2, max = 20, value = 8, step = 0.5, continuous_update = False, description = 'Kernel Var:')\n",
    "s_theta = FloatSlider(min = 0, max = np.pi, value = np.pi / 4, step = np.pi / 20, continuous_update = False, description = 'Orientation:')\n",
    "s_lambd = FloatSlider(min = 0.25, max = 20, value = 10, step = 0.25, continuous_update = False, description = 'Bandwidth:')\n",
    "s_xyratio = FloatSlider(min = 0.1, max = 10, value = 1, step = 0.1, continuous_update = False, description = 'XY Ratio:')\n",
    "s_sides = IntSlider(min = 1, max = 12, value = 1, step = 1, continuous_update = False, description = 'Sides:')\n",
    "\n",
    "interactive(PlotGaborK,\n",
    "                 sigma = s_sigma,\n",
    "                 theta = s_theta,\n",
    "                 lambd = s_lambd,\n",
    "                 xy_ratio = s_xyratio,\n",
    "                 sides = s_sides)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gabor Noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Gabor noise is the convolution of a sparse white noise and Gabor kernel, making it a type of \"Sparse Convolution Noise\". Informally, this can be thought of as *splatting* an image with Gabor kernels. Sparse white noise typically has a flat power spectrum, hence the spectral properties of the Gabor noise is equivalent to its Gabor kernel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Spread"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The kernels here share the same properties, but are randomly distributed across the image.\n",
    "1. **grid** - Size of the grid the image is divided into.\n",
    "2. **num_kern** - Number of kernels added to each grid.\n",
    "3. **kszie** - Size of each kernel. When kernel size is reduced to one, the resulting image will just be the sparse white noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "size = 224 # fixed image size\n",
    "grid = 14 # fixed grid size\n",
    "# num_kern is the number of kernels per grid\n",
    "\n",
    "def PlotGaborAni(num_kern, ksize, sigma, theta, lambd, sides):\n",
    "    img = gaborN_rand(size = size, grid = grid, num_kern = num_kern, ksize = ksize, sigma = sigma, theta = theta, lambd = lambd, sides = sides)\n",
    "    img = normalize_var(img)\n",
    "    plot_colored(img, title = 'Gabor Noise - Random')\n",
    "    \n",
    "# Parameter sliders\n",
    "s_num_kern = IntSlider(min = 1, max = 200, value = 23, step = 1, continuous_update = False, description = 'No. Kernels:')\n",
    "s_ksize = IntSlider(min = 1, max = 40, value = 23, step = 1, continuous_update = False, description = 'Kernel Size:')\n",
    "s_sigma = FloatSlider(min = 0, max = 20, value = 8, step = 0.25, continuous_update = False, description = 'Kernel Var:')\n",
    "s_theta = FloatSlider(min = 0, max = np.pi, value = np.pi / 4, step = np.pi / 24, continuous_update = False, description = 'Orientation:')\n",
    "s_lambd = FloatSlider(min = 1, max = 20, value = 8, step = 0.25, continuous_update = False, description = 'Bandwidth:')\n",
    "s_sides = IntSlider(min = 1, max = 12, value = 1, step = 1, continuous_update = False, description = 'Sides:')\n",
    "\n",
    "interactive(PlotGaborAni,\n",
    "                 num_kern = s_num_kern,\n",
    "                 ksize = s_ksize,\n",
    "                 sigma = s_sigma,\n",
    "                 theta = s_theta,\n",
    "                 lambd = s_lambd,\n",
    "                 sides = s_sides)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uniform Spread, Random Orientations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The kernels here share the same properties except orientation. They are uniformly istributed across the image for more predictable control. Most of the parameters are fixed with the exception of **lambd** which controls the thickness of the kernels. The intention is to have individual orientations for each kernel uniformly spaced along the grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "'''\n",
    "size              size of image\n",
    "grid              best if odd and a factor of size\n",
    "ksize            slightly larger than grid_size so that kernels merge or look more cohesive\n",
    "sigma           large enough so that adjacent kernels merge\n",
    "'''\n",
    "size = 299\n",
    "grid = 13\n",
    "ksize = grid + 4\n",
    "sigma = grid // 3\n",
    "xy_ratio = 1\n",
    "\n",
    "# Random orientations for kernels\n",
    "no_filters = (299 // 13)**2\n",
    "np.random.seed(0)\n",
    "thetas = np.random.uniform(low = 0, high = np.pi, size = no_filters)\n",
    "\n",
    "# Interactive slider\n",
    "def PlotGaborAni(lambd):\n",
    "    img = gaborN_uni(size = size, grid = grid, ksize = ksize, sigma = sigma, lambd = lambd, thetas = thetas, xy_ratio = xy_ratio)\n",
    "    img = normalize_var(img)\n",
    "    plot_colored(img, title = 'Gabor Noise - Uniform')\n",
    "    \n",
    "s_lambd = FloatSlider(min = 0.25, max = grid, value = 7, step = 0.25, continuous_update = False, description = 'Bandwidth:')\n",
    "interactive(PlotGaborAni, lambd = s_lambd)"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}