DIP_Filters.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2af8fb57-9115-4e0f-a27f-2cf2b0d02eeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipywidgets.widgets import Label, FloatProgress, FloatSlider, Button, Dropdown, FileUpload, Image, Layout, HBox, VBox, Box, Output, IntProgress, IntSlider\n",
    "from IPython.display import display, clear_output\n",
    "import numpy as np\n",
    "from numpy import dot, exp, mgrid, pi, ravel, square, uint8, zeros\n",
    "import math\n",
    "import bqplot as bq\n",
    "import time\n",
    "import threading\n",
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c447ec1e-9ec5-4719-8a3b-fb4a78a0996a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6f0b7a47-dc10-4a6d-a918-9ba27765deb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import io\n",
    "from itertools import product\n",
    "import PIL.Image as ImagePIL\n",
    "from array import array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f108f966-0eed-413e-8e2e-a87442c3ba0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def medianFilter(img, progress):\n",
    "    img_noisy1 = img\n",
    "    m, n = img_noisy1.shape[0], img_noisy1.shape[1]\n",
    "    img_new1 = np.zeros([m, n])\n",
    "\n",
    "    for i in range(1, m-1):\n",
    "        progress.value += int((i+1)/100)\n",
    "        for j in range(1, n-1):\n",
    "            temp = [img_noisy1[i-1, j-1],\n",
    "                   img_noisy1[i-1, j],\n",
    "                   img_noisy1[i-1, j + 1],\n",
    "                   img_noisy1[i, j-1],\n",
    "                   img_noisy1[i, j],\n",
    "                   img_noisy1[i, j + 1],\n",
    "                   img_noisy1[i + 1, j-1],\n",
    "                   img_noisy1[i + 1, j],\n",
    "                   img_noisy1[i + 1, j + 1]]\n",
    "\n",
    "            temp = sorted(temp)\n",
    "            img_new1[i, j]= temp[4] # Median => Sorted\n",
    "\n",
    "    img_new1 = img_new1.astype(np.uint8)\n",
    "    cv2.imwrite('medianFilter.jpg', img_new1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c7d7a077-93c7-4402-bb89-4f49855922c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_gaussian_kernel(k_size, sigma):\n",
    "    center = k_size // 2\n",
    "    x, y = mgrid[0 - center : k_size - center, 0 - center : k_size - center]\n",
    "    g = 1 / (2 * pi * sigma) * exp(-(square(x) + square(y)) / (2 * square(sigma)))\n",
    "    return g\n",
    "\n",
    "\n",
    "def gaussianFilter(image, k_size, sigma, progress):\n",
    "    height, width = image.shape[0], image.shape[1]\n",
    "    dst_height = height - k_size + 1\n",
    "    dst_width = width - k_size + 1\n",
    "\n",
    "    image_array = zeros((dst_height * dst_width, k_size * k_size))\n",
    "    row = 0\n",
    "    for i, j in product(range(dst_height), range(dst_width)):\n",
    "        progress.value += int((row+1)/100)\n",
    "        window = ravel(image[i : i + k_size, j : j + k_size])\n",
    "        image_array[row, :] = window\n",
    "        row += 1\n",
    "\n",
    "    gaussian_kernel = gen_gaussian_kernel(k_size, sigma)\n",
    "    filter_array = ravel(gaussian_kernel)\n",
    "\n",
    "    dst = dot(image_array, filter_array).reshape(dst_height, dst_width).astype(uint8)\n",
    "\n",
    "    cv2.imwrite('gaussianFilter.jpg', dst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eb892b3e-1a8d-4355-9056-54ae48a0b2a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def averaging(img, progress):\n",
    "    filtr = (1/16) * np.matrix([[1,2,1],[2,4,2],[1,2,1]], dtype=int)\n",
    "    n_r, n_c, ch = img.shape\n",
    "    g = np.zeros([n_r, n_c])\n",
    "    for r in range(1, n_r-1):\n",
    "        progress.value += int((r+1)/100)\n",
    "        for c in range(1, n_c-1):\n",
    "            h = img[r-1, c-1] * filtr[0, 0] + img[r-1, c] * filtr[0, 1] + img[r-1, c + 1] * filtr[0, 2] + img[r, c-1] * filtr[1, 0] + img[r, c] * filtr[1, 1] + img[r, c + 1] * filtr[1, 2] + img[r + 1, c-1] * filtr[2, 0] + img[r + 1, c] * filtr[2, 1] + img[r + 1, c + 1] * filtr[2, 2]\n",
    "\n",
    "            g[r, c]= h\n",
    "\n",
    "    g = g.astype(np.uint8)\n",
    "    cv2.imwrite('averaging.jpg', g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6e3ccbcc-27bb-4b83-abaa-8600c7bfce0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def unsharpMaskingAndHighboostFiltering(img, k, progress):\n",
    "    img = img.reshape(img.shape[0], img.shape[1], 1)\n",
    "    blur = cv2.GaussianBlur(img, (5,5), 0)\n",
    "    blur = blur.reshape(blur.shape[0], blur.shape[1], 1)\n",
    "    mask = img - blur\n",
    "    final = img + k * mask\n",
    "    progress.value = 100\n",
    "    cv2.imwrite('unsharpMaskingAndHighboostFiltering.jpg', final)\n",
    "# Highboost filtering if k > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a4162327-872c-4abc-8c21-192606d23abd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sobelOperator(test, progress):\n",
    "    image_file = test\n",
    "    input_image = test\n",
    "    [nx, ny, nz] = np.shape(input_image)\n",
    "\n",
    "    r_img, g_img, b_img = input_image[:, :, 0], input_image[:, :, 0], input_image[:, :, 0] # 0,1,2\n",
    "\n",
    "\n",
    "    gamma = 1.400  \n",
    "    r_const, g_const, b_const = 0.2126, 0.7152, 0.0722  \n",
    "    grayscale_image = r_const * r_img ** gamma + g_const * g_img ** gamma + b_const * b_img ** gamma\n",
    "\n",
    "\n",
    "    Gx = np.array([[1.0, 0.0, -1.0], [2.0, 0.0, -2.0], [1.0, 0.0, -1.0]])\n",
    "    Gy = np.array([[1.0, 2.0, 1.0], [0.0, 0.0, 0.0], [-1.0, -2.0, -1.0]])\n",
    "    [rows, columns] = np.shape(grayscale_image)  \n",
    "    sobel_filtered_image = np.zeros(shape=(rows, columns))  \n",
    "\n",
    "\n",
    "    for i in range(rows - 2):\n",
    "        progress.value += int((i+1)/100)\n",
    "        for j in range(columns - 2):\n",
    "            gx = np.sum(np.multiply(Gx, grayscale_image[i:i + 3, j:j + 3]))  \n",
    "            gy = np.sum(np.multiply(Gy, grayscale_image[i:i + 3, j:j + 3]))  \n",
    "            sobel_filtered_image[i + 1, j + 1] = np.sqrt(gx ** 2 + gy ** 2)  \n",
    "\n",
    "    cv2.imwrite('sobelOperator.jpg', sobel_filtered_image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2bd47080-976b-4341-99b9-761d66009167",
   "metadata": {},
   "outputs": [],
   "source": [
    "def saltAndPepperNoise(img, progress):\n",
    "    row, col, ch = img.shape\n",
    "    \n",
    "    number_of_white_pixels = random.randint(100, 1000)\n",
    "    for i in range(number_of_white_pixels):\n",
    "        progress.value += int((i+1)/50)\n",
    "        y=random.randint(1, row - 2)\n",
    "        x=random.randint(1, col - 2)\n",
    "        img[y][x] = 255\n",
    "        img[y + 1][x] = 255\n",
    "        img[y - 1][x] = 255\n",
    "        #img[y + 1][x + 1] = 255\n",
    "        #img[y - 1][x - 1] = 255\n",
    "        img[y][x + 1] = 255\n",
    "        img[y][x - 1] = 255\n",
    "        #img[y + 1][x + 1] = 255\n",
    "        #img[y - 1][x - 1] = 255\n",
    "         \n",
    "            \n",
    "    number_of_black_pixels = random.randint(100, 1000)\n",
    "    for i in range(number_of_black_pixels):\n",
    "        progress.value += int((i+1)/50)\n",
    "        y=random.randint(1, row - 2)\n",
    "        x=random.randint(1, col - 2)\n",
    "        img[y][x] = 0\n",
    "        img[y + 1][x] = 0\n",
    "        img[y - 1][x] = 0\n",
    "        #img[y + 1][x + 1] = 0\n",
    "        #img[y - 1][x - 1] = 0\n",
    "        img[y][x + 1] = 0\n",
    "        img[y][x - 1] = 0\n",
    "        #img[y + 1][x + 1] = 0\n",
    "        #img[y - 1][x - 1] = 0\n",
    "         \n",
    "    cv2.imwrite('saltAndPepperNoise.jpg', img)\n",
    "\n",
    "#img = cv2.imread('pic2.png')\n",
    "#img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "#plt.imshow(img, 'gray')\n",
    "#plt.imshow(saltAndPepperNoise(img))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "41760838-2bd7-4044-a242-8bb8883d8cef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# loc = Mean (“centre”) of the distribution.\n",
    "# scale = Standard deviation (spread or “width”) of the distribution. Must be non-negative.\n",
    "def gaussianNoise(real_image, progress):\n",
    "    gaussian = np.random.normal(loc=0, scale=1, size=real_image.size)\n",
    "    gaussian = gaussian.reshape(real_image.shape[0], real_image.shape[1], real_image.shape[2]).astype('uint8')\n",
    "    noisy_image = cv2.add(real_image, gaussian)\n",
    "    cv2.imwrite('gaussianNoise.jpg', noisy_image)\n",
    "    progress.value = 100\n",
    "\n",
    "#img = cv2.imread('pic2.png', 0)\n",
    "#plt.imshow(img, 'gray')\n",
    "#plt.imshow(gaussianNoise(img), 'gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4a1c5ce5-82e7-4c76-b035-8fd72347f251",
   "metadata": {},
   "outputs": [],
   "source": [
    "def imhist(im):\n",
    "    m, n = im.shape\n",
    "    h = [0.0] * 256\n",
    "    for i in range(m):\n",
    "        for j in range(n):\n",
    "            h[im[i, j]]+=1\n",
    "    return np.array(h)/(m*n)\n",
    "\n",
    "def cumsum(h):\n",
    "    return [sum(h[:i+1]) for i in range(len(h))]\n",
    "\n",
    "def histeq(im, progress):\n",
    "    #calculate Histogram\n",
    "    h = imhist(im)\n",
    "    cdf = np.array(cumsum(h))\n",
    "    sk = np.uint8(255 * cdf)\n",
    "    s1, s2 = im.shape\n",
    "    Y = np.zeros_like(im)\n",
    "\n",
    "    for i in range(0, s1):\n",
    "        progress.value += int((i+1)/100)\n",
    "        for j in range(0, s2):\n",
    "            Y[i, j] = sk[im[i, j]]\n",
    "    H = imhist(Y)\n",
    "\n",
    "    return Y, h, H, sk\n",
    "\n",
    "def histogramEq(test, progress):\n",
    "    test = test.reshape(test.shape[0], test.shape[1], 1)\n",
    "    img = np.uint8(test * 255.0)\n",
    "\n",
    "    img = np.uint8((0.2126 * img[:,:,0]) + np.uint8(0.7152 * img[:,:,0]) + np.uint8(0.0722 * img[:,:,0])) # 0,1,2\n",
    "    new_img, h, new_h, sk = histeq(img, progress)\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    fig.add_subplot(221)\n",
    "    plt.plot(h)\n",
    "    plt.title('Original histogram') # original histogram\n",
    "\n",
    "    fig.add_subplot(222)\n",
    "    plt.plot(new_h)\n",
    "    plt.title('New histogram') #hist of eqlauized image\n",
    "\n",
    "    fig.add_subplot(223)\n",
    "    plt.plot(sk)\n",
    "    plt.title('Transfer function') #transfer function\n",
    "    \n",
    "    cv2.imwrite('histogramEq.jpg', new_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7bed9a28-a54a-4bf5-9ee8-8dbdebbe48ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fourierTransform(real_image, progress):\n",
    "    real_image = cv2.resize(real_image, (128, 128))\n",
    "    M = real_image.shape[0] - 1\n",
    "    N = real_image.shape[1] - 1\n",
    "    dft_image = np.zeros((M, N), complex)\n",
    "    Mu = 1\n",
    "    v = 1\n",
    "    j = 1\n",
    "    for m in range(M):\n",
    "        progress.value += int((m+1)/100)\n",
    "        for n in range(N):\n",
    "            for x in range(M):\n",
    "                for y in range(N):\n",
    "                    exp_power = -j * 2 * math.pi * ((Mu * x)/M + (v * y)/N)\n",
    "                    dft_image[m][n] += real_image[x][y] * np.exp(exp_power)\n",
    "    #return dft_image\n",
    "    cv2.imwrite('fourierTransform.jpg', dft_image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ce361872-b29d-49a7-bd12-5c60584192b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def kernel(x,a):\n",
    "    if(np.abs(x)>=0)&(np.abs(x)<=1):\n",
    "        res=(a+2)*(np.abs(x)**3)-(a+3)*(np.abs(x)**2)+1\n",
    "        return res\n",
    "    if(np.abs(x)>1)&(np.abs(x)<=2):\n",
    "        res=a*(np.abs(x)**3)-(a*5)*(np.abs(x)**2)+((a*8)*np.abs(x))-a*4\n",
    "        return res\n",
    "    return 0\n",
    "\n",
    "def pad(imag,col,r,c):\n",
    "\n",
    "    pad=np.zeros((col+4,r+4,c))\n",
    "    pad[2:col+2,2:r+2,:c]=imag\n",
    "    \n",
    "    pad[2:col+2,0:2,:c]=imag[:,0:1,:c]\n",
    "    pad[2:col+2,r+2:r+4,:]=imag[:,r-1:r,:]\n",
    "    \n",
    "    pad[0:2,2:r+2,:c]=imag[0:1,:,:c]\n",
    "    pad[col+2:col+4,2:r+2,:]=imag[col-1:col,:,:]\n",
    "    \n",
    "    pad[0:2,0:2,:c]=imag[0,0,:c]\n",
    "    pad[0:2,r+2:r+4,:c]=imag[0,r-1,:c]\n",
    "    pad[col+2:col+4,0:2,:c]=imag[col-1,0,:c]\n",
    "    pad[col+2:col+4,r+2:r+4,:c]=imag[col-1,r-1,:c]\n",
    "    \n",
    "    return pad\n",
    "\n",
    "def bicubicInterpolation(img, ratio, a, progress):\n",
    "    img = img.reshape(img.shape[0], img.shape[1], 1)\n",
    "    col, rows, ch =img.shape\n",
    "    img= pad(img,col,rows,ch)\n",
    "    \n",
    "    dcol= math.floor(col*ratio)\n",
    "    drows=math.floor(rows*ratio)\n",
    "\n",
    "    matriximage=np.zeros((dcol,drows,1))\n",
    "    v= 1/ratio\n",
    "    \n",
    "    for c in range(ch):\n",
    "        for column in range(dcol):\n",
    "            progress.value += int((column + 1)/100)\n",
    "            for row in range(drows):\n",
    "\n",
    "                x=row * v + 2\n",
    "                y=column * v + 2\n",
    "                \n",
    "                \n",
    "                x1= 1+x-math.floor(x)\n",
    "                y1=1+y-math.floor(y)\n",
    "                x2=x-math.floor(x)\n",
    "                y2=y-math.floor(y)\n",
    "                x3=math.floor(x)+1-x\n",
    "                y3=math.floor(y)+1-y\n",
    "                x4=math.floor(x)+2-x\n",
    "                y4=math.floor(y)+2-y\n",
    "                \n",
    "                mat_kernelx=np.matrix([[kernel(x1,a),kernel(x2,a),kernel(x3,a),kernel(x4,a)]])\n",
    "                \n",
    "                mat_near=np.matrix([[img[int(y-y1),int(x-x1),c],img[int(y-y2),int(x-x1),c],img[int(y+y3),int(x-x1),c],img[int(y+y4),int(x-x1),c]],\n",
    "                                    [img[int(y-y1),int(x-x2),c],img[int(y-y2),int(x-x2),c],img[int(y+y3),int(x-x2),c],img[int(y+y4),int(x-x2),c]],\n",
    "                                    [img[int(y-y1),int(x+x3),c],img[int(y-y2),int(x+x3),c],img[int(y+y3),int(x+x3),c],img[int(y+y4),int(x+x3),c]],\n",
    "                                    [img[int(y-y1),int(x+x4),c],img[int(y-y2),int(x+x4),c],img[int(y+y3),int(x+x4),c],img[int(y+y4),int(x+x4),c]]])\n",
    "                \n",
    "                \n",
    "                mat_kernely=np.matrix([[kernel(y1,a)],[kernel(y2,a)],[kernel(y3,a)],[kernel(y4,a)]])\n",
    "                \n",
    "                \n",
    "                matriximage[column, row, c] = np.dot(np.dot(mat_kernelx, mat_near), mat_kernely)\n",
    " \n",
    "                \n",
    "    cv2.imwrite('bicubicInterpolation.jpg', matriximage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f00291b5-56dc-4ca0-9b97-8ec39807a91c",
   "metadata": {},
   "outputs": [],
   "source": [
    "options = Dropdown(\n",
    "    options=[('None', 0), ('Median Filter', 1), ('Averaging filter', 2),\n",
    "             ('Gaussian Filter', 3), ('Unsharp Masking and Highboost Filtering', 4), ('Sobel Operators', 5), \n",
    "             ('Impulse Noise (Salt and Pepper)', 6), ('Gaussian Noise', 7), ('Histogram Eq.', 8),\n",
    "             ('Fourier Transform', 9), ('Interpolation (Bicubic)', 10)],\n",
    "    value=0,\n",
    "    description='Select Filter:',\n",
    "    layout=Layout(width='450px'))\n",
    "outDropdown = Output()\n",
    "\n",
    "slider = IntSlider(\n",
    "    value=1,\n",
    "    min=1,\n",
    "    max=10,\n",
    "    step=1,\n",
    "    description='K:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='d',\n",
    "    layout=Layout(visibility='hidden', width='475px'))\n",
    "outSlider = Output()\n",
    "\n",
    "progressBar = IntProgress(\n",
    "    value=0,\n",
    "    min=0,\n",
    "    max=100,\n",
    "    description='Loading:',\n",
    "    bar_style='success', # 'success', 'info', 'warning', 'danger' or ''\n",
    "    style={'bar_color': '#1cf28c'},\n",
    "    orientation='horizontal',\n",
    "    layout=Layout(visibility='hidden', flex='1 1 0%', width='520px'))\n",
    "\n",
    "btns = [\n",
    "    #Button(description='Apply Filter', disabled=False, icon='plus', layout=Layout(flex='1 1 0%', width='120px'), button_style='primary'),\n",
    "    #Button(description='Remove Filter', disabled=False, icon='remove', layout=Layout(flex='1 1 0%', width='120px'), button_style='warning'),\n",
    " ]\n",
    "\n",
    "resetBtn = Button(description='Reset', disabled=False, icon='trash', layout=Layout(flex='1 1 0%', width='150px'), button_style='danger')\n",
    "outResetBtn = Output()\n",
    "btns_box_layout = Layout(display='flex', flex_flow='row', align_items='stretch', width='30%')\n",
    "\n",
    "btns_box = Box(children=btns, layout=btns_box_layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d3342d42-f517-45f5-b441-d3288ccdece6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def work(progress, slider):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e3d42a64-5001-4bc5-a0fd-2f7bf7547ca4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_click_resetBtn(change):\n",
    "    with outResetBtn:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "685d9dc8-456b-4b92-8487-fb237e42a468",
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_slider_change(change):\n",
    "    with outSlider:\n",
    "        v = change['new']\n",
    "        progressBar.value = 0\n",
    "        unsharpMaskingAndHighboostFiltering(deepcopy(selected_img), v, progressBar)\n",
    "        file = open(\"unsharpMaskingAndHighboostFiltering.jpg\", \"rb\")\n",
    "        image = file.read()\n",
    "        image_after.value = image\n",
    "        slider.layout.visibility = 'visible'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "13126c99-6983-4abe-bca2-235826231ca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_dropdown_change(change):\n",
    "    with outDropdown:\n",
    "        v = change['new']\n",
    "        progressBar.layout.visibility = 'visible'\n",
    "        if v == 0:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            file = open(\"No-filter.png\", \"rb\")\n",
    "            image = file.read()\n",
    "            image_after.value = image\n",
    "        if v == 1:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            medianFilter(deepcopy(selected_img), progressBar)\n",
    "            file = open(\"medianFilter.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"medianFilter.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "        if v == 2:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            averaging(deepcopy(selected_img), progressBar)\n",
    "            file = open(\"averaging.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"averaging.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "        if v == 3:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            gaussianFilter(deepcopy(selected_img), 5, 0.8, progressBar)\n",
    "            file = open(\"gaussianFilter.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"gaussianFilter.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "        if v == 4:\n",
    "            progressBar.value = 0\n",
    "            unsharpMaskingAndHighboostFiltering(deepcopy(selected_img), 1, progressBar)\n",
    "            file = open(\"unsharpMaskingAndHighboostFiltering.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"unsharpMaskingAndHighboostFiltering.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "            slider.layout.visibility = 'visible'\n",
    "        if v == 5:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            sobelOperator(deepcopy(selected_img), progressBar)\n",
    "            file = open(\"sobelOperator.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"sobelOperator.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "        if v == 6:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            saltAndPepperNoise(deepcopy(selected_img), progressBar)\n",
    "            file = open(\"saltAndPepperNoise.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"saltAndPepperNoise.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "        if v == 7:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            gaussianNoise(deepcopy(selected_img), progressBar)\n",
    "            file = open(\"gaussianNoise.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"gaussianNoise.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "        if v == 8:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            histogramEq(deepcopy(selected_img), progressBar)\n",
    "            file = open(\"histogramEq.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"histogramEq.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "        if v == 9:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            fourierTransform(deepcopy(selected_img), progressBar)\n",
    "            file = open(\"fourierTransform.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"fourierTransform.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image\n",
    "        if v == 10:\n",
    "            slider.layout.visibility = 'hidden'\n",
    "            progressBar.value = 0\n",
    "            bicubicInterpolation(deepcopy(selected_img), 2, -0.5, progressBar)\n",
    "            file = open(\"bicubicInterpolation.jpg\", \"rb\")\n",
    "            image = file.read()\n",
    "            new_image = cv2.imread(\"bicubicInterpolation.jpg\")\n",
    "            print(\"After: \" , new_image.shape[0], \" x \", new_image.shape[1], end=\"\\r\")\n",
    "            image_after.value = image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9065419a-b217-48c6-8505-7f3303031582",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e318129ce3b4db1878b3a52036ca8e7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FileUpload(value={}, accept='image/*', description='Upload')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fac03204e1194437b63d410fe6d7daa1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ImgUpload = FileUpload(accept='image/*', multiple=False)\n",
    "outUpload = Output()\n",
    "\n",
    "display(ImgUpload, outUpload)\n",
    "\n",
    "def on_upload_change(change):\n",
    "    with outUpload:\n",
    "        uploaded_file = ImgUpload.value[list(ImgUpload.value.keys())[0]]['content']\n",
    "\n",
    "        global selected_img\n",
    "        selected_img = cv2.imread(str(list(ImgUpload.value.keys())[0]), 0)\n",
    "        selected_img = selected_img.reshape(selected_img.shape[0], selected_img.shape[1], 1)\n",
    "        \n",
    "        image_before = Image(value=uploaded_file, width=256, height=256)\n",
    "\n",
    "        file = open(\"No-filter.png\", \"rb\")\n",
    "        image = file.read()\n",
    "        \n",
    "        global image_after\n",
    "        image_after = Image(value=image, width=256, height=256)\n",
    "        print(\"Before: \" , selected_img.shape[0], \" x \", selected_img.shape[1])\n",
    "        display(options, HBox([image_before, image_after]), slider, progressBar, outDropdown, outSlider, outResetBtn)\n",
    "        \n",
    "        thread.start()\n",
    "        \n",
    "        \n",
    "thread = threading.Thread(target=work, args=(progressBar, slider,))\n",
    "ImgUpload.observe(on_upload_change, 'value')\n",
    "options.observe(on_dropdown_change, 'value')\n",
    "slider.observe(on_slider_change, 'value')\n",
    "resetBtn.on_click(on_click_resetBtn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "169321e1-125c-4b9a-b529-310c69db71ca",
   "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}