Analysis&Evaluation_Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import h5py\n",
    "import math\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from random import *\n",
    "import imageio as io\n",
    "import numpy.ma as ma\n",
    "from skimage import measure\n",
    "from skimage import filters\n",
    "from skimage import restoration\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.feature_extraction import image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Directories of Test Set\n",
    "TEST_LABEL_DIR = 'gcp/dataset/test_label_patches.npy'\n",
    "TEST_NOISY_DIR = 'gcp/dataset/test_data_patches.npy'\n",
    "\n",
    "#Directories of Denoised Output of each architecture\n",
    "WGANVGG_DIR = 'Results/wganvgg/output_all_wganvgg.npy'\n",
    "WGANMSE_DIR = 'Results/wganmse/output_all_wganmse.npy'\n",
    "CNNVGG_DIR = 'Results/cnnvgg/output_all_cnnvgg.npy'\n",
    "CNNMSE_DIR = 'Results/cnnmse/output_all_cnnmse.npy'\n",
    "GAN_DIR = 'Results/resunetwgan/output_all_resunetwgan.npy'\n",
    "\n",
    "MAX_PIX = 69900 #is the maximum pixel value in original images of the whole dataset (Used for Denormalization)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save numpy array as npy file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def saveOutput(data, fileName):\n",
    "    np.save(fileName + '.npy', data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Standard Denoising Filters (Baseline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gaussian Filter\n",
    "\n",
    "* sigma : scalar or sequence of scalars, optional Standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gaussianFilter(imgs, sig = 2):\n",
    "    denoisedImgs = np.zeros(imgs.shape, dtype=np.float32)\n",
    "    for i in range(0, len(imgs)):\n",
    "        denoisedImgs[i] = filters.gaussian(imgs[i], sigma = sig)\n",
    "    \n",
    "    return denoisedImgs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Median Filter\n",
    "* selem: filter shape and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def medianFilter(imgs, kernel_size = 3):\n",
    "    denoisedImgs = np.zeros(imgs.shape, dtype=np.float32)\n",
    "    for i in range(0, len(imgs)):\n",
    "        denoisedImgs[i] = filters.median(imgs[i, :, :, 0], np.ones((kernel_size, kernel_size)))[:, :, np.newaxis]\n",
    "    \n",
    "    return denoisedImgs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TV Filter: Perform total-variation denoising on n-dimensional images\n",
    "* Total variation denoising is remarkably effective at simultaneously preserving edges whilst smoothing away noise in flat regions, even at low signal-to-noise ratios.\n",
    "* It is based on the principle that signals with excessive and possibly spurious detail have high total variation, that is, the integral of the absolute gradient of the signal is high. According to this principle, reducing the total variation of the signal subject to it being a close match to the original signal, removes unwanted detail whilst preserving important details such as edges.\n",
    "* weight : Denoising weight. The greater weight, the more denoising (at the expense of fidelity to input)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tvFilter(imgs, wt = 0.1):\n",
    "    denoisedImgs = np.zeros(imgs.shape, dtype=np.float32)\n",
    "    for i in range(0, len(imgs)):\n",
    "        denoisedImgs[i] = restoration.denoise_tv_chambolle(imgs[i], weight=wt)\n",
    "    \n",
    "    return denoisedImgs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def meanFilter(imgs, kernel_size = 3):\n",
    "    denoisedImgs = np.zeros(imgs.shape, dtype=np.float32)\n",
    "    kernel = np.ones((kernel_size, kernel_size), np.float32) / (kernel_size * kernel_size)\n",
    "    for i in range(0, len(imgs)):\n",
    "        denoisedImgs[i] = cv2.filter2D(imgs[i,:,:,0], -1, kernel)[:, :, np.newaxis]\n",
    "    return denoisedImgs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_npydata(path = 'Results/wganvgg/output_all_wganvgg.npy'):\n",
    "    return np.load(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_label = read_npydata(TEST_LABEL_DIR)[:,:,:,np.newaxis]\n",
    "test_noisy = read_npydata(TEST_NOISY_DIR)[:,:,:,np.newaxis]\n",
    "test_label.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking if poisson noise added is correct\n",
    "\n",
    "lambda = original/factor <br>\n",
    "check that stddev( (lambda-noisy)/sqrt(lambda)  ) ~= 1 <br>\n",
    "This is the quantitative test that poisson noise is correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_poisson(img_noisy, img_lbl, factor = 100):\n",
    "    img2 = img_noisy * MAX_PIX / factor #65144 is maximum pixel value in whole original dataset\n",
    "    img1 = img_lbl * MAX_PIX_NOISY #699 is maximum pixel value in noisy dataset\n",
    "    \n",
    "    lambd = img1 / factor\n",
    "    return np.std((lambd - img2) / np.sqrt(lambd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read NNs denoised output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wganvggDenoised = read_npydata(path = WGANVGG_DIR)\n",
    "cnnvggDenoised = read_npydata(path = CNNVGG_DIR)\n",
    "cnnmseDenoised = read_npydata(path = CNNMSE_DIR)\n",
    "wganmseDenoised = read_npydata(path = WGANMSE_DIR)\n",
    "ganDenoised = np.float32(read_npydata(path = GAN_DIR))[:,:,:,np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Peak Signal to Noise Ratio (PSNR)\n",
    "Equivalent to average per pixel loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def psnr(img1, img2, PIXEL_MAX = 1):\n",
    "    mse = np.mean( (img1 - img2) ** 2 )\n",
    "    mse = max(mse, 1e-8)\n",
    "    return 20 * math.log10(PIXEL_MAX / math.sqrt(mse))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Structural Similarity (SSIM):\n",
    "\n",
    "* SSIM attempts to model the perceived change in the structural information of the image, whereas MSE is actually estimating the perceived errors.\n",
    "* The SSIM value can vary between -1 and 1, where 1 indicates perfect similarity.\n",
    "<img src = \"https://www.pyimagesearch.com/wp-content/uploads/2014/06/compare_ssim.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ssimQ(img1, img2):\n",
    "    return measure.compare_ssim(img1, img2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PSNR and SSIM Calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quant_analysis(denoised, lbls):\n",
    "    psnrs = []\n",
    "    ssims = []\n",
    "    for img, lbl in zip(denoised, lbls):\n",
    "        psnrs.append(psnr(img * 255, lbl * 255, PIXEL_MAX = 255))\n",
    "        ssims.append(ssimQ(img[:,:,0] * 255, lbl[:,:,0] * 255))\n",
    "    return psnrs, np.mean(psnrs), np.std(psnrs), ssims, np.mean(ssims), np.std(ssims)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuning Gaussian Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Gaussian Filter Tuning Kernel Size\n",
    "sigms = [3, 2, 1, 0.5, 0.1]\n",
    "maxiSSIM = 0\n",
    "maxiSig = 0.1\n",
    "for sig in sigms:\n",
    "    print('Current Sigma:', sig)\n",
    "    gaussianDenoised = gaussianFilter(test_noisy, sig = sig)\n",
    "    _, _, _, _, tmpSSIM, _ = quant_analysis(gaussianDenoised, test_label)\n",
    "    if tmpSSIM > maxiSSIM:\n",
    "        maxiSSIM = tmpSSIM\n",
    "        maxiSig = sig\n",
    "        \n",
    "print('Best Sigma: ', maxiSig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gaussianDenoised = gaussianFilter(test_noisy, sig = maxiSig)\n",
    "#saveOutput(gaussianDenoised, 'gaussianDenoised')\n",
    "gaussianDenoised.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuning TV Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TV Filter\n",
    "wts = [0.05, 0.1, 0.2]\n",
    "maxiSSIM = 0\n",
    "maxiWt = 0.1\n",
    "for wt in wts:\n",
    "    print('Current Wt:', wt)\n",
    "    tvDenoised = tvFilter(test_noisy, wt = wt)\n",
    "    _, _, _, _, tmpSSIM, _ = quant_analysis(tvDenoised, test_label)\n",
    "    if tmpSSIM > maxiSSIM:\n",
    "        maxiSSIM = tmpSSIM\n",
    "        maxiWt = wt\n",
    "        \n",
    "print('Best Weight:', maxiWt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tvDenoised = tvFilter(test_noisy, wt = maxiWt)\n",
    "#saveOutput(tvDenoised, 'tvDenoised')\n",
    "tvDenoised.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuning Median Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Median Filter\n",
    "szs = [3, 5, 7]\n",
    "maxiSSIM = 0\n",
    "maxiSz = 0.1\n",
    "for sz in szs:\n",
    "    print('Current Kernel Size = ', sz)\n",
    "    medianDenoised = np.float32(medianFilter(test_noisy, kernel_size = sz)) / 255\n",
    "    _, _, _, _, tmpSSIM, _ = quant_analysis(medianDenoised, test_label)\n",
    "    if tmpSSIM > maxiSSIM:\n",
    "        maxiSSIM = tmpSSIM\n",
    "        maxiSz = sz\n",
    "    #print('Max: ', np.max(medianDenoised), np.min(medianDenoised))\n",
    "\n",
    "print('Best Kernel Size:', maxiSz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "medianDenoised = np.float32(medianFilter(test_noisy, kernel_size = maxiSz)) / 255\n",
    "#saveOutput(medianDenoised, 'medianDenoised')\n",
    "medianDenoised.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuning Mean Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Mean Filter\n",
    "szs = [3, 5, 7]\n",
    "maxiSSIM = 0\n",
    "maxiSz = 0.1\n",
    "for sz in szs:\n",
    "    print('Current Kernel Size = ', sz)\n",
    "    meanDenoised = meanFilter(test_noisy, kernel_size = sz)\n",
    "    _, _, _, _, tmpSSIM, _ = quant_analysis(meanDenoised, test_label)\n",
    "    if tmpSSIM > maxiSSIM:\n",
    "        maxiSSIM = tmpSSIM\n",
    "        maxiSz = sz\n",
    "    \n",
    "print('Best Kernel Size: ', maxiSz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meanDenoised = meanFilter(test_noisy, kernel_size = maxiSz)\n",
    "#saveOutput(meanDenoised, 'meanDenoised')\n",
    "meanDenoised.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis of Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collect Images back from patches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#81 is the number of patches for a single image\n",
    "#1080, 1080 is the size of the original image\n",
    "def collect_back(patches, original_size = (81, 1080, 1080, 1)):\n",
    "    return image.reconstruct_from_patches_2d(patches, original_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dataframe for quanititative analysis of each method\n",
    "cols = ['noisy', 'gaussian', 'median', 'mean', 'tv', 'cnnvgg', 'cnnmse', 'wganvgg', 'wganmse', 'ResUNet', 'label']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ssimCompare = pd.DataFrame(columns = cols)\n",
    "psnrCompare = pd.DataFrame(columns = cols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute SSIM and PSNR for each output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "denoised = {'noisy': test_noisy, 'gaussian': gaussianDenoised, 'label': test_label, \\\n",
    "            'median': medianDenoised, 'mean':meanDenoised, 'tv':tvDenoised, \\\n",
    "            'cnnvgg': cnnvggDenoised, 'cnnmse':cnnmseDenoised, \\\n",
    "            'wganvgg':wganvggDenoised, 'wganmse':wganmseDenoised, 'ResUNet':ganDenoised}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for col in cols:\n",
    "    if col == 'label':\n",
    "        continue\n",
    "    print('Output Type:', col)\n",
    "    tmp = np.float32(denoised[col])\n",
    "    print(tmp.shape, tmp.dtype)\n",
    "    print(test_label.shape, test_label.dtype)\n",
    "    PSNR, PSNRMean, PSNRSTD, SSIM, SSIMMean, SSIMSTD = quant_analysis(tmp, test_label)\n",
    "    ssimCompare[col] = SSIM\n",
    "    psnrCompare[col] = PSNR\n",
    "    \n",
    "    print('PSNR MEAN = ', PSNRMean, ' +- STD = ', PSNRSTD)\n",
    "    print('SSIM MEAN = ', SSIMMean, ' +- STD = ', SSIMSTD)\n",
    "    print('------------------------------------------------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Box Plots for PSNR and SSIM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##PSNR\n",
    "psnrCompare.loc[:, psnrCompare.columns != 'label'].plot.box(figsize=(18,12), showmeans=True)\n",
    "plt.title ('PSNR of each method', fontsize=20)\n",
    "plt.xticks(rotation='vertical', fontsize=20)\n",
    "plt.xlabel('Method', fontsize=20)\n",
    "plt.ylabel('PSNR', fontsize=20)\n",
    "plt.savefig('rankPSNR.png', dpi = 300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##SSIM\n",
    "ssimCompare.loc[:, ssimCompare.columns != 'label'].plot.box(figsize=(18,12), showmeans=True)\n",
    "plt.title ('SSIM of each method', fontsize=20)\n",
    "plt.xticks(rotation='vertical', fontsize=20)\n",
    "plt.xlabel('Method', fontsize=20)\n",
    "plt.ylabel('SSIM Value', fontsize=20)\n",
    "plt.savefig('rankSSIM.png', dpi = 300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting Some Samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_imgs(cols, denoised, ind):\n",
    "    fig = plt.figure(1, figsize = (20, 20))\n",
    "    axs = []\n",
    "    for col in range(len(cols)):\n",
    "        ax = fig.add_subplot(4, 3, col+1)\n",
    "        ax.title.set_text(cols[col])\n",
    "        plt.subplot(4, 3, col + 1)\n",
    "        imgs = denoised[cols[col]]\n",
    "        plt.imshow(np.uint8(imgs[ind,:,:,0] * 255), cmap = 'gray')\n",
    "    plt.savefig('example' + str(ind) + '.png', dpi = 100)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 22\n",
    "plot_imgs(cols, denoised, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "==========================================================================\n",
    "# Analysis using Sine Wave Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Read Sine Images Test Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Directories of Test Set\n",
    "TEST_LABEL_DIR = 'gcp/dataset/test_label_patches.npy'\n",
    "TEST_NOISY_DIR = 'gcp/dataset/test_data_patches.npy'\n",
    "#Directories of Denoised Output of each architecture\n",
    "WGANVGG_DIR = 'Results/wganvgg/output_all_wganvgg.npy'\n",
    "WGANMSE_DIR = 'Results/wganmse/output_all_wganmse.npy'\n",
    "CNNVGG_DIR = 'Results/cnnvgg/output_all_cnnvgg.npy'\n",
    "CNNMSE_DIR = 'Results/cnnmse/output_all_cnnmse.npy'\n",
    "GAN_DIR = 'Results/resunetwgan/output_all_resunetwgan.npy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_label_sin = read_npydata(TEST_LABEL_DIR)[:,:,:,np.newaxis]\n",
    "test_noisy_sin = read_npydata(TEST_NOISY_DIR)[:,:,:,np.newaxis]\n",
    "wganvggSinDenoised = read_npydata(path = WGANVGG_DIR)\n",
    "cnnvggSinDenoised = read_npydata(path = CNNVGG_DIR)\n",
    "cnnmseSinDenoised = read_npydata(path = CNNMSE_DIR)\n",
    "wganmseSinDenoised = read_npydata(path = WGANMSE_DIR)\n",
    "ganSinDenoised = np.float32(read_npydata(path = GAN_DIR))[:,:,:,np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gaussianDenoisedSine = gaussianFilter(test_noisy_sin, sig = 2)\n",
    "gaussianDenoisedSine.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tvDenoisedSine = tvFilter(test_noisy_sin, wt = 0.05)\n",
    "tvDenoisedSine.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "medianDenoisedSine = np.float32(medianFilter(test_noisy_sin, kernel_size = 5)) / 255\n",
    "medianDenoisedSine.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meanDenoisedSine = meanFilter(test_noisy_sin, kernel_size = 7)\n",
    "meanDenoisedSine.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Map Filter for Peaks / Troughs of Sine Wave\n",
    "def createMap(peak, wl):\n",
    "    size = 120\n",
    "    rge = 0.9\n",
    "    slope = 1\n",
    "    a = np.zeros((size,size))\n",
    "    #wl = 20 #wavelength of wave\n",
    "    #slope =.2 # slope of wave\n",
    "    for i in range(0,size):\n",
    "        for j in range(0,size):\n",
    "            val = -i-slope*j\n",
    "            if(peak ==0):\n",
    "                if(-rge < (val+(wl/4))%wl < rge):\n",
    "                    a[i,j] = True\n",
    "                else:\n",
    "                    a[i,j] = False\n",
    "            else:\n",
    "                if((-rge < (val+(wl*3/4))% wl< rge)):\n",
    "                    a[i,j] = True\n",
    "                else:\n",
    "                    a[i,j] = False\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "denoised2 = {'noisy': test_noisy_sin, 'gaussian': gaussianDenoisedSine, 'label': test_label_sin[:,:,:,np.newaxis], \\\n",
    "            'median': medianDenoisedSine, 'mean':meanDenoisedSine, 'tv':tvDenoisedSine, \\\n",
    "            'cnnvgg': cnnvggSinDenoised, 'cnnmse':cnnmseSinDenoised, \\\n",
    "            'wganvgg':wganvggSinDenoised, 'wganmse':wganmseSinDenoised, 'ResUNet':ganSinDenoised[:,:,:,np.newaxis]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List of Wavelengths\n",
    "wls = [3, 5, 9, 14, 20, 30, 50]\n",
    "# Position of test images will be used in plotting\n",
    "pos1 = [0,1,2,3,4,5,6, 14,15,16,17,18,19,20, 21,22,23,24,25,26,27, 28,29,30,31,32,33,34]\n",
    "pos = [0,1,2,3,4,5,6, 14,15,16,17,18,19,20, 21,22,23,24,25,26,27, 28,29,30,31,32,33,34]\n",
    "#List of Amplitudes\n",
    "amps = [0.2, 1, 2, 5, 0.2, 1, 2, 5]\n",
    "for p in pos1:\n",
    "    pos.append(wl + 70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "succs = []\n",
    "for i in range(len(pos)):\n",
    "    lambd = wls[i % 7]\n",
    "    p = pos[i]\n",
    "    #lambd = 50\n",
    "    mapP = createMap(1, lambd)\n",
    "    mapT = createMap(0, lambd)\n",
    "    xticks = []\n",
    "    succ = {}\n",
    "    for col in cols:\n",
    "        #print('Type: ', col)\n",
    "        xticks.append(col)\n",
    "        imgs = denoised2[col]\n",
    "        img = imgs[p,:,:,0]\n",
    "        # SNR Calculation\n",
    "        peaks = []\n",
    "        troughs = []\n",
    "        for ii in range(120):\n",
    "            for jj in range(120):\n",
    "                if mapP[ii,jj] == True:\n",
    "                    peaks.append(img[ii,jj])\n",
    "                if mapT[ii,jj] == True:\n",
    "                    troughs.append(img[ii,jj])\n",
    "        Signal =  max(np.mean(peaks) - np.mean(troughs), 0)\n",
    "        Noise = 0.5 * ( np.std(troughs) + np.std(peaks) )\n",
    "        S2N = Signal / Noise\n",
    "        succ[col] = S2N\n",
    "        print('Col:', col, ' ---> Signal To Noise Ratio:', S2N, succ[col])\n",
    "    succs.append(succ)\n",
    "    if i > 50:\n",
    "        baselvl = 500\n",
    "    else:\n",
    "        baselvl = 150\n",
    "    print(' Wavelength:', lambd, ' --> Base level:', baselvl, ' --> i:', i)\n",
    "    if i % 7 == 6:\n",
    "        print('PLOTTING', int(i/7))\n",
    "        plotSINE(succs, amps[int(i/7)], baselvl)\n",
    "        succs = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotSINE(succs, amp, baselevel):\n",
    "    x = np.array(range(0, 14, 2), dtype = float)\n",
    "    xticks = ['3', '5', '9', '14', '20', '30', '50']\n",
    "    start_pos = -0.2\n",
    "\n",
    "    fig = plt.figure(2, figsize = (20, 14))\n",
    "    ax = plt.subplot(111)\n",
    "    colors_main = ['r', 'b', 'g', 'y', 'k', 'm', 'crimson', 'c', 'sandybrown', 'chartreuse']\n",
    "    cols3 = ['noisy', 'gaussian', 'median', 'mean', 'tv', 'cnnvgg', 'cnnmse', 'wganvgg', 'wganmse', 'ResUNet']\n",
    "    for t, counter in zip(cols3, range(10)):\n",
    "        vals = [succs[0][t], succs[1][t], succs[2][t], succs[3][t], succs[4][t], succs[5][t], succs[6][t]]\n",
    "        ax.bar(x + start_pos, vals, width=0.15, color=colors_main[counter], align='center')\n",
    "        start_pos += 0.15\n",
    "\n",
    "    ax.legend((cols3), fontsize = 24, loc=1, bbox_to_anchor=(0.8, 0.5, 0.5, 0.5))\n",
    "    plt.title('SNR for different architectures at different Wavelength (Amplitude = ' + str(amp) + ', base-level = ' + str(baselevel) + ')', fontsize = 24)\n",
    "    plt.xticks([0,2,4,6,8,10,12], (xticks), fontsize = 26)\n",
    "    plt.xlabel('wavelength', fontsize = 28)\n",
    "    plt.ylabel('SNR', fontsize = 28)\n",
    "    plt.grid()\n",
    "    #plt.savefig('amp' + str(amp) + '_' + str(baselevel) + '.png', dpi = 100)\n",
    "    plt.figure()\n",
    "    plt.show()"
   ]
  }
 ],
 "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
}