fourier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy import ndimage, fft, stats\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib.pyplot import imread"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "PLOT_RESULTS = True\n",
    "RADIUS = 30\n",
    "STD = 5\n",
    "DPI=120"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Fourier transformation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- load the input image\n",
    "img = imread('inputs/tuebingen.jpg')[:, :, 1] / 255.  \n",
    "img_size = img.shape[0]\n",
    "\n",
    "\n",
    "# TODO\n",
    "FT_img_log = ...\n",
    "\n",
    "\n",
    "# ----- plot input image together with fourier transformation\n",
    "if PLOT_RESULTS:   #plot_results:\n",
    "    plt.figure(figsize=(12, 12),dpi=DPI)\n",
    "    plt.subplot(121)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow(img, cmap = 'gray')\n",
    "    plt.title('Input image')\n",
    "\n",
    "    plt.subplot(122)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow(FT_img_log, cmap='gray')\n",
    "    plt.title('Fourier transformation')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 High-pass filter in spectral space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "def highpass_filter(img_size, radius):\n",
    "    ''' Returns a highpass filter.\n",
    "    input:\n",
    "        img_size: length of the filter\n",
    "        redius: radius of the circular aperture\n",
    "    output:\n",
    "        highpass: a filter of size(img_size, img_size) with values zero and one\n",
    "    '''\n",
    "    highpass = np.zeros((img_size, img_size))\n",
    "    highpass = ...\n",
    "    return highpass\n",
    "\n",
    "# TODO\n",
    "#   step 2: apply filter (with radius 30) to the spectrum\n",
    "highpass = highpass_filter(img_size, radius=RADIUS) \n",
    "img_highpass = ...\n",
    "\n",
    "\n",
    "# TODO\n",
    "#   step 3: transform the spectrum back to image space                     \n",
    "img_filtered = ...\n",
    "\n",
    "if PLOT_RESULTS:   #plot_results:\n",
    "    plt.figure(figsize=(12, 12),dpi=DPI)\n",
    "    plt.subplot(121)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow(np.abs(img_highpass)**0.15, cmap = 'gray')   # Potenz dient der Kontrastanpassung\n",
    "    plt.title('Highpass filter applied in fourier space')\n",
    "\n",
    "    plt.subplot(122)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow((img_filtered), cmap=plt.cm.gray)\n",
    "    plt.title('Backtransformation of the highpass filtered image')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Gaussian filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.1 Construct a Gaussian filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "def g_kern(kernlen=5, std=1):\n",
    "    ''' Returns a 2D Gaussian kernel with standard devitation sig\n",
    "    input:\n",
    "        kernlen: length of the filter\n",
    "        std: standard deviation of the gaussian in pixels\n",
    "    output:\n",
    "        g_kern_2d: a gaussian kernel of size (kernlen, kernlen) with sum 1\n",
    "    '''\n",
    "    g_kern_2d = ...\n",
    "    return g_kern_2d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.2 Apply Gaussian filter in image space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "#   step 2: create such a gaussian filter with standard deviation 3 and filtersize 25 and\n",
    "#           convolve the image with this filter \n",
    "gaussfilter_img = ...\n",
    "img_conv = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.3 Transform the Gaussian filter to fourier space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "#   step 3: transform the gaussian kernel to fourier space\n",
    "gaussfilter_f = ...\n",
    "gaussfilter_f_shift = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.4 Apply this filter in fourier space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_gauss = ...\n",
    "img_gauss_f = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.5. Visuallise and compare two filtering methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#   step 5: compare the results\n",
    "difference = np.mean(np.abs(img_gauss_f - img_conv))       \n",
    "print('difference: ' + str(difference))\n",
    "\n",
    "if PLOT_RESULTS:\n",
    "    # compare the two images\n",
    "    plt.figure(figsize=(12, 12),dpi=DPI)\n",
    "\n",
    "    plt.subplot(221)        # plt.subplot(122)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow((gaussfilter_img), cmap=plt.cm.gray)\n",
    "    plt.title('Gaussian (image space)')\n",
    "\n",
    "    plt.subplot(222)        # plt.subplot(121)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow(np.abs(gaussfilter_f_shift), cmap=plt.cm.gray)\n",
    "    plt.title('Gaussian (fourier space)')\n",
    "\n",
    "    plt.subplot(223)        # plt.subplot(122)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow((img_conv), cmap=plt.cm.gray)      # img_conv\n",
    "    plt.title('Gaussian filter applied in image space')\n",
    "\n",
    "    plt.subplot(224)        # plt.subplot(121)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow((img_gauss_f), cmap=plt.cm.gray)\n",
    "    plt.title('Gaussian filter applied in fourier space')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.6 Splitted convolutional filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "def g_kern1d(kernlen=5, std=1):\n",
    "    '''\n",
    "    Returns a 1D Gaussian kernel with standard devitation sig \n",
    "    input:\n",
    "        kernlen: length of the filter std: standard deviation of the gaussian in  pixels \n",
    "    output: \n",
    "        g_kern_1d: a gaussian kernel of size (kernlen, 1)\n",
    "    '''\n",
    "    g_kern_1d = ... \n",
    "    return g_kern_1d\n",
    "\n",
    "gaussfilter_img_1D = ...\n",
    "img_conv_sep_final = ...\n",
    "\n",
    "# ----- plot results\n",
    "if PLOT_RESULTS:   #plot_results:\n",
    "    plt.figure(figsize=(12, 12),dpi=DPI)\n",
    "    plt.subplot(121)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow((img_conv), cmap=plt.cm.gray)      \n",
    "    plt.title('Gaussian filter (2D) applied in image space')\n",
    "    plt.subplot(122)\n",
    "    plt.xticks([]), plt.yticks([])\n",
    "    plt.imshow(img_conv_sep_final, cmap='gray')\n",
    "    plt.title('Gaussian filter (separated) applied in image space')\n",
    "    plt.show()"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}