APO_Lab2_Histogram_manipulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nplQ-yuXIbzl"
   },
   "source": [
    "# APO Lab2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "c9v3DebgjLgI"
   },
   "outputs": [],
   "source": [
    "#from google.colab.patches import cv2_imshow\n",
    "import cv2\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython.display import display, Math, Latex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JXAve7azp2Qy"
   },
   "source": [
    "# Histogram manipulation\n",
    "\n",
    "**Cel**: poprawa jakości obrazu\n",
    "\n",
    "Przykład:\n",
    "\n",
    "![alt text](https://github.com/knave88/APO/raw/main/rozciag_przyklad.png)\n",
    "\n",
    "Histogram to jeden z graficznych sposobów przedstawiania rozkładu empirycznego cechy. Składa się z szeregu prostokątów umieszczonych na osi współrzędnych - czyli jest wykresem słupkowym.\n",
    "W przypadku obrazów w skali szarości, gdzie kolory pikseli są opisane za pomocą jednej liczby (najczęściej w zakresie [0,255]), histogram pokazuje ile występuje elementów (pikseli) każdego z odcieni szarości. \n",
    "\n",
    "Obrazy o zawężonym histogramie często są trudne do interpretacji empirycznej bez wcześniejszej obróbki. Do tego typu obrazów stosuje się najczęściej normalizację lub equalizację histogramu w celu poprawy jego jakości (jak widać na rysunku powyżej).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 546
    },
    "id": "OfYoPimSjPaX",
    "outputId": "d074054b-ba48-40a3-edcc-07d0c011e690"
   },
   "outputs": [],
   "source": [
    "# load image with narrow histogram and show it (OpenCV)\n",
    "img = cv2.imread('lena_low.bmp', cv2.IMREAD_GRAYSCALE)\n",
    "\n",
    "#cv2_imshow(img)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))\n",
    "\n",
    "print('Image shape: '+str(img.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cTmhr2_9ge4t"
   },
   "outputs": [],
   "source": [
    "# calculte histogram (no lib)\n",
    "\n",
    "# init histogram array\n",
    "my_hist =np.zeros(256)\n",
    "# loop through image\n",
    "for h in range(img.shape[0]):\n",
    "  for w in range(img.shape[1]):\n",
    "    #get pixel value\n",
    "    current_pixel = img[h,w]\n",
    "    #print(current_pixel)\n",
    "    my_hist[current_pixel] += 1 # increase the value of histogram vecor correspondig to current pixel value\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "GyBkEB2ZgmEa",
    "outputId": "6e32cd24-15b4-4b21-ae7c-8d8ed7c7c756"
   },
   "outputs": [],
   "source": [
    "# plot histogram\n",
    "plt.bar(np.arange(256),my_hist, width=1); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LnC7M5MNplgS"
   },
   "source": [
    "## Stretching\n",
    "\n",
    "Wyrównanie histogramu dąży do ujednolicenia rozkładu pikseli we wszystkich dostępnych poziomach jasności, przez liniowe rościągnięcie histogramu.\n",
    "\n",
    "Wzór:\n",
    "\n",
    "![alt text](https://github.com/knave88/APO/raw/main/stretch.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TbgScyBspl8J"
   },
   "outputs": [],
   "source": [
    "# define scaling range\n",
    "im_min = np.min(img)\n",
    "im_max = np.max(img)\n",
    "\n",
    "new_max = 255\n",
    "new_min = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "C8HnsFTRpmB7"
   },
   "outputs": [],
   "source": [
    "# calculate contrast stretching\n",
    "img_stretch =np.zeros_like(img)\n",
    "for h in range(img.shape[0]):\n",
    "  for w in range(img.shape[1]):\n",
    "    current_pixel = img[h,w]\n",
    "    #print(current_pixel)\n",
    "    img_stretch[h,w] = ((current_pixel-im_min)*new_max)/(im_max-im_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "Xc1hNE4FsxiQ",
    "outputId": "3355d908-a192-4379-89a0-aace521d8811"
   },
   "outputs": [],
   "source": [
    "# show resulting image\n",
    "\n",
    "#cv2_imshow(img_stretch)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_stretch, cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "46ss33aRuEeA",
    "outputId": "1da34f57-18c2-4336-af34-5c1d633b0045"
   },
   "outputs": [],
   "source": [
    "# show histogram of resulting image\n",
    "plt.hist(img_stretch.ravel(),256,[0,256]); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6B8e1sj56_iK"
   },
   "outputs": [],
   "source": [
    "# OpenCV equivalent for comparison\n",
    "\n",
    "# normalize float versions\n",
    "norm_img1 = cv2.normalize(img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\n",
    "# scale to uint8\n",
    "img_stretch_cv = (255*norm_img1).astype(np.uint8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 793
    },
    "id": "TQfW2TsL7-Ta",
    "outputId": "8643c03a-4d70-4719-8e05-a9c87e25483d"
   },
   "outputs": [],
   "source": [
    "# show comaprison\n",
    "fig = plt.figure()\n",
    "fig.set_figwidth(15)\n",
    "\n",
    "fig.add_subplot(2,2,1)\n",
    "plt.imshow(cv2.cvtColor(img_stretch, cv2.COLOR_BGR2RGB))\n",
    "fig.add_subplot(2,2,2)\n",
    "plt.imshow(cv2.cvtColor(img_stretch_cv, cv2.COLOR_BGR2RGB))\n",
    "\n",
    "\n",
    "fig.add_subplot(2,2,3)\n",
    "plt.title('no lib')\n",
    "plt.hist(img_stretch.ravel(),256,[0,256])\n",
    "fig.add_subplot(2,2,4)\n",
    "plt.title('openCV')\n",
    "plt.hist(img_stretch_cv.ravel(),256,[0,256])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cWIM4aIvpmNV"
   },
   "source": [
    "## Equalization\n",
    "\n",
    "Equlizacja histogramu: dąży do wyrównania występowania wszystkich jasności w obrazie w oparciu o rozciąganie histogramu kumulatywnego; uwydatnia szczegóły w obrazie\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 281
    },
    "id": "rTeA-caz3zFe",
    "outputId": "7afa2e50-bfb5-49ca-a8d3-caf3905e1bf1"
   },
   "outputs": [],
   "source": [
    "hist,bins = np.histogram(img.flatten(),256,[0,256])\n",
    "cdf = hist.cumsum()\n",
    "cdf_normalized = cdf * float(hist.max()) / cdf.max()\n",
    "\n",
    "plt.plot(cdf_normalized, color = 'b')\n",
    "plt.hist(img.flatten(),256,[0,256], color = 'r')\n",
    "plt.xlim([0,256])\n",
    "plt.legend(('cumulative','histogram'), loc = 'upper left')\n",
    "plt.title('Porównanie histogramu i jego wersji kumulatywnej')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 41
    },
    "id": "zGGCYcEgpmf9",
    "outputId": "53aa2c94-47db-4b3c-a687-200f7903042a"
   },
   "outputs": [],
   "source": [
    "# formula to calculate cumulation sum\n",
    "display(Math(r's_k = \\sum_{j=0}^{k} {\\frac{n_j}{N}}'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MyGbrwOKpmcz"
   },
   "outputs": [],
   "source": [
    "# create our cumulative sum function\n",
    "def cumsum(a):\n",
    "    a = iter(a)\n",
    "    b = [next(a)]\n",
    "    for i in a:\n",
    "        b.append(b[-1] + i)\n",
    "    return np.array(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 282
    },
    "id": "PqJnvtKpp4jF",
    "outputId": "420e9a12-95f2-4093-9a29-36f4541810b9"
   },
   "outputs": [],
   "source": [
    "# calculte cumsum for histogram \n",
    "cs = cumsum(my_hist)\n",
    "\n",
    "#find the maximum and the minimum histogram value (excluding 0)\n",
    "cs_m = np.ma.masked_equal(cs,0) # For masked array, all operations are performed on non-masked elements.\n",
    "cs_min = cs_m.min()\n",
    "cs_max = cs_m.max()\n",
    "\n",
    "#cs_min = cs.min()\n",
    "#cs_max = cs.max()\n",
    "\n",
    "# normalize cumsum values to be between 0-255\n",
    "cs = ((cs - cs_min) * 255 )/ (cs_max - cs_min)\n",
    "\n",
    "# cast it back to uint8 since we can't use floating point values in images\n",
    "cs = cs.astype('uint8')\n",
    "# display the result\n",
    "plt.plot(cs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "qEg2UnMhp5AG",
    "outputId": "a338866b-bcfa-4512-b018-8f9e383168de"
   },
   "outputs": [],
   "source": [
    "# get the value from cumulative sum for every index in the image, and set that as img_eq\n",
    "img_eq = cs[img]\n",
    "\n",
    "# show resulting image \n",
    "#cv2_imshow(img_eq)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_eq, cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "dvrdvyPK3RZd",
    "outputId": "d1a3b2f5-ea18-4ae5-cc27-b4c3c25ee539"
   },
   "outputs": [],
   "source": [
    "# show histogram\n",
    "plt.hist(img_eq.ravel(),256,[0,256]); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "JncBCbvs4clw",
    "outputId": "deed4d18-55bf-4b87-a5ae-f208a54122e3"
   },
   "outputs": [],
   "source": [
    "# OpenCV equivalent for comparison\n",
    "img_eq_cv = cv2.equalizeHist(img)\n",
    "\n",
    "#cv2_imshow(img_eq_cv)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_eq_cv, cv2.COLOR_BGR2RGB))\n",
    "\n",
    "#plt.hist(img_eq_cv.ravel(),256,[0,256]); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 793
    },
    "id": "BCYe_3h0qKKE",
    "outputId": "75d1aa1d-7ef2-4999-d428-3cb6dd7fe335"
   },
   "outputs": [],
   "source": [
    "# show comaprison\n",
    "fig = plt.figure()\n",
    "fig.set_figwidth(15)\n",
    "\n",
    "fig.add_subplot(2,2,1)\n",
    "plt.imshow(cv2.cvtColor(img_eq, cv2.COLOR_BGR2RGB))\n",
    "fig.add_subplot(2,2,2)\n",
    "plt.imshow(cv2.cvtColor(img_eq_cv, cv2.COLOR_BGR2RGB))\n",
    "\n",
    "fig.add_subplot(2,2,3)\n",
    "plt.title('no lib')\n",
    "plt.hist(img_eq.ravel(),256,[0,256])\n",
    "fig.add_subplot(2,2,4)\n",
    "plt.title('openCV')\n",
    "plt.hist(img_eq_cv.ravel(),256,[0,256])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xREevjed98gj"
   },
   "source": [
    "Podsumowując, do zaimplementowania modyfikacji histogramu nie jest konieczne pobieranie od użytkownika dodatkowych informacji. Niezbędne jest wyliczenie histogramu oraz histogramu kumulatywnego w przypadu equalizacji. Zadanie to można w prosty sposób rozwiązać stosując pętle lub tablicę LUT. \n",
    "\n",
    "W efekcie otrzymujemy nowy obraz. Należy również pamiętać o odświeżeniu histogramu który najczęsciej ulega dużym zmianom przy tej operacji."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J2ZsvAfqJ9M2"
   },
   "source": [
    "# Point operations\n",
    "\n",
    "Przykładowe operacje punktowe jednoargumentowe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "Ln6h_FOnKIK8",
    "outputId": "c6572251-b394-4133-8fd4-5ba4b5a73596"
   },
   "outputs": [],
   "source": [
    "# load image and show it (OpenCV)\n",
    "img_gray = cv2.imread('lena_gray.bmp', cv2.IMREAD_GRAYSCALE)\n",
    "\n",
    "#cv2_imshow(img_gray)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_gray, cv2.COLOR_BGR2RGB))\n",
    "\n",
    "#print('Image shape: '+str(img.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XxrGIUfCKJgE"
   },
   "source": [
    "## Negation\n",
    "\n",
    "Negacja czy zaprzeczenie obrazu, w najprostszy sposób można obliczyć odejmując wartości obrazu od maksymalnej wartości jasności zakresu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "2NSwE_WvKK5c",
    "outputId": "9f11bcdd-16ea-4cff-9f98-c792076ebb98"
   },
   "outputs": [],
   "source": [
    "img_inv = (255-img_gray)\n",
    "\n",
    "#cv2_imshow(img_inv)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_inv, cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "deEgdyOGKoYV",
    "outputId": "cc2e6a0b-3b0a-4ab8-e66d-a01b5600589e"
   },
   "outputs": [],
   "source": [
    "img_inv_cv = cv2.bitwise_not(img_gray)\n",
    "\n",
    "#cv2_imshow(img_inv_cv)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_inv_cv, cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9f14mg-9LevS"
   },
   "source": [
    "Pisząc program należy pamiętać o tym, że obraz nie zawsze musi być w zakresie wartości [0,255]. \n",
    "\n",
    "Warto zwrócić uwagę na typ zmiennej."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "u1a0pcObK7mZ",
    "outputId": "2fa09720-cfe7-4015-8a77-5a526b448b56"
   },
   "outputs": [],
   "source": [
    "# type of image used so far\n",
    "print(img_gray.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 273
    },
    "id": "YTMihFWnLBxT",
    "outputId": "0e0c53fc-0b7c-4b29-b3d2-5028f8c1c964"
   },
   "outputs": [],
   "source": [
    "# load image in different type\n",
    "img2 = cv2.imread('camera16.tif', cv2.IMREAD_UNCHANGED).astype('float16')\n",
    "\n",
    "#cv2_imshow(img2)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(np.uint8(img2), cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oUEAlY1aQccR",
    "outputId": "83a328de-f9e7-459c-9e33-7d41a5d0072e"
   },
   "outputs": [],
   "source": [
    "# why is it disturbed? let's look at the values.\n",
    "img2[0:8,0:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 290
    },
    "id": "9YGxsTvxQBbQ",
    "outputId": "4ead8892-6ccc-4a80-a59a-9df9683816e6"
   },
   "outputs": [],
   "source": [
    "# scale the imege for display\n",
    "print(img2.dtype)\n",
    "\n",
    "#cv2_imshow(img2/255)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(np.uint8(img2/255), cv2.COLOR_BGR2RGB)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 358
    },
    "id": "FlhpeVY6LJtc",
    "outputId": "5f5cfee4-5c67-413b-d69f-a71d66e29193"
   },
   "outputs": [],
   "source": [
    "# image negaton as performed previously -> results in all black image because the max value for float 16 is much higher than 255\n",
    "img_inv2A = (np.float16(255)-img2)\n",
    "\n",
    "#cv2_imshow(img_inv2A/255)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(np.uint8(img_inv2A/255), cv2.COLOR_BGR2RGB))\n",
    "\n",
    "img_inv2A[0:5,0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 358
    },
    "id": "8Vxau6QpQKHH",
    "outputId": "e4c27edf-4218-4c4a-88b0-6d3032079265"
   },
   "outputs": [],
   "source": [
    "#image in float16 negation\n",
    "img_inv2B = (np.float16(np.finfo(img2.dtype).max)-img2) #MAX VLAUE np.float16: 65500\n",
    "\n",
    "#cv2_imshow(img_inv2B/255)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(np.uint8(img_inv2B/255), cv2.COLOR_BGR2RGB))\n",
    "\n",
    "img_inv2B[0:5,0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LdUrBHbbBaI4"
   },
   "source": [
    "Do wykonania negacji nie są potrzebne dodatkowe parametry, ale warto zwrócić uwagę na typ zmiennej przetwarzanego obrazu.\n",
    "W wyniku tej operacji otrzymujemy obraz o tym samym rozmiarze."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H7u35FEkYGbq"
   },
   "source": [
    "## Thresholding / Progowanie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5KZ1H6iAIeix"
   },
   "source": [
    "\n",
    "Algorytm progowania realizuje prostą zależność gdzie wartości powyżej ustalonego progu przyjmują wartośc 1 (lub 255) a wartości poniżej wartość 0. \n",
    "\n",
    "![alt text](https://github.com/knave88/APO/raw/main/progowanie.png)\n",
    "\n",
    "W efekcie otrzymujemy binarny obraz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "Ua7bWYnrYK62",
    "outputId": "24da54cc-041a-4f8b-d078-fc68467e156e"
   },
   "outputs": [],
   "source": [
    "# manual setting of thresh value\n",
    "myThresh = 127\n",
    "\n",
    "# init output image \n",
    "img_th = np.zeros_like(img_gray)\n",
    "# loop through image\n",
    "for h in range(img_gray.shape[0]):\n",
    "  for w in range(img_gray.shape[1]):\n",
    "    current_pixel = img_gray[h,w]\n",
    "    #print(current_pixel)\n",
    "    if (current_pixel>myThresh): img_th[h,w]=1 # thresholding condition\n",
    "\n",
    "# display output\n",
    "#cv2_imshow(img_th*255)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_th*255, cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "TanGLU-RmSvG",
    "outputId": "cf5183d0-1049-476d-df96-ab4a1b467a68"
   },
   "outputs": [],
   "source": [
    "# ręczne ustawienie progu \n",
    "myThresh = 127\n",
    "# progowanie z powyższyą wartością progu\n",
    "ret,img_th_binary = cv2.threshold(img_gray,myThresh,255,cv2.THRESH_BINARY)\n",
    "\n",
    "#cv2_imshow(img_th_binary)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_th_binary, cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g6a-n_NBgZ-R"
   },
   "source": [
    "W programie zaliczenowym należy dać możliwość użytkownikowi interaktywnego doboru progu (najlepiej z aktywnym podglądem, czyli odświeżaniem obrazu po zmianie wartości progu). Przyład implementacji poniżej z zastosowaniem suwaka (slider) do przyjęcia wartości progu od użytkowanika."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "import ipywidgets as widgets\n",
    "\n",
    "def fun_thresh(slider_threshold_value):\n",
    "    print(\"Wybrana wastość progu: \" + str(slider_threshold_value))\n",
    "    \n",
    "    # progowanie z powyższyą wartością progu\n",
    "    ret,img_th_binary2 = cv2.threshold(img_gray,slider_threshold_value,255,cv2.THRESH_BINARY)\n",
    "    \n",
    "    #cv2_imshow(img_th_binary2)\n",
    "    #plt.figure(figsize=(10,10))\n",
    "    plt.imshow(cv2.cvtColor(img_th_binary2, cv2.COLOR_BGR2RGB))\n",
    "    \n",
    "    return slider_threshold_value\n",
    "\n",
    "#interact(fun_thresh, slider_threshold_value=58); # widgets.IntSlider(min=-10, max=30, step=1, value=10)\n",
    "interact(fun_thresh, slider_threshold_value=widgets.IntSlider(min=0, max=255, step=1, value=127));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jKTgxQxta4St"
   },
   "source": [
    "## Posterize\n",
    "\n",
    "Redukcja poziomów szarości przez posteryzację. Polega na równomiernym rozłożeniu zakresów jasności które są ujednolicane do wspólnej wartości. Na przykład dla 2 poziomów posteryzacja odpowiada binaryzacji z progiem 127. \n",
    "\n",
    "Realizacja tej metody przez UOP przyjmuje postać wykresu schodkowego (jak na rysunku poniżej).\n",
    "\n",
    "![alt text](https://github.com/knave88/APO/raw/main/posterize.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jSLDlneya5s9",
    "outputId": "55963442-7dbb-47d8-b28a-6cddf71d0493"
   },
   "outputs": [],
   "source": [
    "myPosterizeBinsNum = 8\n",
    "\n",
    "\n",
    "print('my number of Bins: '+str(myPosterizeBinsNum)) \n",
    "print('my Bin length: '+str(np.round(255/myPosterizeBinsNum))) \n",
    "print('my Posterization Bins: '+str(np.arange(0,255,np.round(255/myPosterizeBinsNum))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "4wLxcQCjWJLe",
    "outputId": "4c50c544-4c8a-4955-d92d-f613e1401ede"
   },
   "outputs": [],
   "source": [
    "# calc size of binning\n",
    "myBins = np.arange(0,255,np.round(255/myPosterizeBinsNum))\n",
    "\n",
    "#init output image\n",
    "img_pstrz = np.zeros_like(img_gray)\n",
    "# loop through image\n",
    "for h in range(img_gray.shape[0]):\n",
    "  for w in range(img_gray.shape[1]):\n",
    "    current_pixel = img_gray[h,w]\n",
    "\n",
    "    # loop through bins\n",
    "    for bin in range(myPosterizeBinsNum):\n",
    "      #print(myBins[bin])\n",
    "      if (current_pixel>myBins[bin]): img_pstrz[h,w]=myBins[bin] # if inside bin assign value\n",
    "\n",
    "    if (current_pixel>myBins[-1]): img_pstrz[h,w]=255 # last bin -> fill with max value\n",
    "\n",
    "# display output image\n",
    "#cv2_imshow(img_pstrz)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_pstrz, cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8668_ASXbzv8"
   },
   "source": [
    "## Posterize with LUT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Zouq4gmZb0i8",
    "outputId": "90b9be97-ac2c-4a60-c67d-3f13e1bd9821"
   },
   "outputs": [],
   "source": [
    "# init LUT\n",
    "bin_length = np.round(255/myPosterizeBinsNum).astype(int)\n",
    "lut_pstrz = []\n",
    "\n",
    "# popualte LUT\n",
    "for bin in range(myPosterizeBinsNum):\n",
    "  temp = np.ones(bin_length,)*myBins[bin] #temp vector\n",
    "  lut_pstrz = np.hstack((lut_pstrz, temp)) #concatenate\n",
    "lut_pstrz = np.hstack((lut_pstrz, np.ones(bin_length,)*255)) #last bin \n",
    "\n",
    "lut_pstrz.shape # check LUT size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vexEQNR-cMc6",
    "outputId": "d47b68ba-9214-4ca3-d432-99114acf9ab9"
   },
   "outputs": [],
   "source": [
    "# show LUT\n",
    "lut_pstrz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 529
    },
    "id": "wM94mebFbO2Z",
    "outputId": "a1eaa64d-fef2-4640-b076-60a10d491ad2"
   },
   "outputs": [],
   "source": [
    "# apply LUT\n",
    "img_pstrz2 = lut_pstrz[img_gray].astype('uint8')\n",
    "\n",
    "#cv2_imshow(img_pstrz2)\n",
    "#plt.figure(figsize=(10,10))\n",
    "plt.imshow(cv2.cvtColor(img_pstrz2, cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5GIWaZx1B5J1"
   },
   "source": [
    "Podsumowując, do zaimplementowania operacji punktowych często jest konieczne pobieranie od użytkownika dodatkowych wartości parametrów. Można to rozwiązać jako pole do wpisywania wartości lub suwak ograniczający możliwość wyboru wartości. Operacje punktowe mają swoje odniesienie w UOP a co za tym idzie można w prosty sposób rozwiązać stosując tablicę LUT. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tdl20y6MCiWU"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "APO_Lab2_Histogram_manipulation.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "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"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}