POB_Lab9_OpMorf.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "POB_Lab9_OpMorf.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JXAve7azp2Qy"
      },
      "source": [
        "# POB Lab 9 Operacje morfologiczne"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c9v3DebgjLgI"
      },
      "source": [
        "#from google.colab.patches import cv2_imshow\n",
        "import cv2\n",
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "#!wget https://github.com/knave88/APO/raw/main/A1.bmp -O A1.bmp\n",
        "#!wget https://github.com/knave88/APO/raw/main/A1_result.bmp -O A1_result.bmp\n",
        "#!wget https://github.com/knave88/APO/raw/main/testing.bmp -O testing.bmp"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bhiwTnFcLXMl"
      },
      "source": [
        "# Wstęp"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OfYoPimSjPaX"
      },
      "source": [
        "# Wczytanie obrazu pierwotnego\n",
        "img = cv2.imread('A1_result.bmp', cv2.IMREAD_GRAYSCALE)\n",
        "#cv2_imshow(img)\n",
        "plt.figure(figsize=(12,12))\n",
        "plt.imshow(img, cmap=plt.get_cmap('gray'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jdLdc8zjuL6L"
      },
      "source": [
        "## Elementy struturalne\n",
        "Właściwości filtrów morfologicznych określane są przez tzw. element strukturalny, wykorzystywany jako ruchome okno. Określony jest względem wybranego piksela, tzw. punktu centralnego lub początkowego. Dla ułatwienia przyjmuje się standardowo za punkt początkowy środkowy piksel okna. Z tego też względu rozmiar elementu struktualnego powinien być liczbą nieparzystą."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PYMk10n4uMi5"
      },
      "source": [
        "# element strukturalny o kształcie kwadratu 5x5\n",
        "cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2m4GSZy2ujdk"
      },
      "source": [
        "# element strukturalny o kształcie prostokąta 2x3\n",
        "cv2.getStructuringElement(cv2.MORPH_RECT,(2,3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hWZdl7lDuphs"
      },
      "source": [
        "# element strukturalny o kształcie elipsy 3x3 (bardzo zgrubne przybliżenie, takie same jak romb)\n",
        "cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oXAMnE2BvDSM"
      },
      "source": [
        "# element strukturalny o kształcie elipsy 5x5 (już wyraźnie widać kształt eliptyczny)\n",
        "cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d9aXgY1fwPG5"
      },
      "source": [
        "# element strukturalny o kształcie krzyża 5x5 \n",
        "cv2.getStructuringElement(cv2.MORPH_CROSS,(5,5))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6hiD_fG7zfWY"
      },
      "source": [
        "Element strukturalny o kształcie rombu nie jest zaimplementowany w OpenCV, natomiast dość łatwo można to zrobic samemu. Poniżej implementacja definująca romb o zadanym promieniu (licząc z pominięciem punktu centralnego)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VdHorixWzc1X"
      },
      "source": [
        "def diamond(r):\n",
        "    return np.uint8(np.add.outer(*[np.r_[:r,r:-1:-1]]*2)>=r)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qkhjxQZSzsRH"
      },
      "source": [
        "diamond(2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vJLGjYRj0qD6"
      },
      "source": [
        "diamond(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U9Hrr3F7OCBI"
      },
      "source": [
        "## Operacje morfologiczne"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MyLze_e9LPM5"
      },
      "source": [
        "## a) erozja\n",
        "\n",
        "Erozja jest jednym z podstawowych przekształceń morfologicznych. Erozja, czyli zwężanie, jest zastosowaniem różnicy Minkowskiego do obrazu. Jej działanie polega na obcinaniu brzegów obiektu na obrazie. Jeżeli choć jeden piksel z sąsiedztwa objętego przez kernel ma wartość równą zero, punkt centralny również otrzymuje wartość zero. W przeciwnym wypadku jego wartość nie ulega zmianie."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TanGLU-RmSvG"
      },
      "source": [
        "# ustawienie elementu strukturalnego (kernel) \n",
        "kernel = np.ones((5,5),np.uint8)\n",
        "# wykonanie erozji morfologicznej przy użyciu zdefiniowanego elementu strukturalnego \n",
        "img_erode = cv2.erode(img, kernel, iterations = 2, borderType = cv2.BORDER_REPLICATE)\n",
        "# w tym przypadku wykonujemy dwie iteracje czyli powtarzamy wykonanie tej operacji, dla bardziej wyrażnego rezultatu\n",
        "# podobnie jak wprzypadku operacji sąsiedztwa z Lab3 mozemy podać argument borderType określjący przetwarzanie pikseli na krawędziach obrazu"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oI-YaQP6wz9L"
      },
      "source": [
        "# porównanie obrazu oryginalnego i po operacji morfologicznej\n",
        "frame = cv2.hconcat((img, img_erode))\n",
        "#cv2_imshow(frame)\n",
        "plt.figure(figsize=(15,15))\n",
        "plt.imshow(frame, cmap=plt.get_cmap('gray'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kh4hGtqI0lHh"
      },
      "source": [
        "Jak widać operacja erozji powoduje zmniejszenie obiektów. Ponieważ zastosowane dwie iteracje operacji erozji z dość dużym elementem strukturalnym to zmniejszenie obiektów jest bardzo zauważalne. Ponadto, część małych obiektów zniknęła całkowicie. W zależności od zastosowania może to być efekt pozytywny lub nie."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CbKaaK_aLjDY"
      },
      "source": [
        "## b) dylacja\n",
        "\n",
        "Dylatacja, czyli rozszerzanie, jest zastosowaniem sumy Minkowskiego do obrazu.  Jeżeli choć jeden piksel z sąsiedztwa objętego przez kernel ma wartość równą jeden, punkt centralny również otrzymuje wartość jeden. W przeciwnym wypadku przypisywane jest mu zero. \n",
        "\n",
        "Dylatacja służy do zamykania małych otworów oraz zatok we wnętrzu figury. Obiekty zwiększają swoją objętość i jeśli dwa lub więcej obiektów położonych jest blisko siebie, zrastają się w większe obiekty."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sKmwB_xrGi7R"
      },
      "source": [
        "# wykonanie erozji morfologicznej przy użyciu zdefiniowanego elementu strukturalnego \n",
        "img_dilate = cv2.dilate(img, kernel, iterations = 2, borderType = cv2.BORDER_REPLICATE)\n",
        "\n",
        "frame = cv2.hconcat((img, img_dilate))\n",
        "#cv2_imshow(frame)\n",
        "plt.figure(figsize=(15,15))\n",
        "plt.imshow(frame, cmap=plt.get_cmap('gray'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_QVTKwQs4MNc"
      },
      "source": [
        "Jak widać operacja dylacji powoduje powiększenie obiektów. Należy zwrócić uwagę na kształt krawędzi obiektów który jest zależny od kształtu elementu strukturalnego. Im element strukturalny ma ostre krawędze tym bardziej \"kanciaste\" będą obiekty. Im bardziej element strukturalny przypomina koło tym bardziej obłe będą krawędzie obiektów."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I6W6QgZenwVp"
      },
      "source": [
        "## c) otwarcie mofologiczne\n",
        "\n",
        "Otwarcie morfologiczne jest równoważne nałożeniu operacji dylatacji na wynik erozji obrazu pierwotnego. Dzięki zastosowaniu dwóch podstawowych operacji w parze możliwe jest pozbycie się niedogodności związanej ze zmianą rozmiaru obiektów. \n",
        "\n",
        "Operacja otwarcia zachowuje rozmiary obiektów obrazu przy ich jednoczesnym wygładzeniu – usunięciu wszystkich „wystających” elementów. Często używana do usuwania małych obiektów (artefaktów/\"śmieci\") z obrazu."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m7ZMr-sx_nlk"
      },
      "source": [
        "# wykonanie operacji otwarcia morfologicznego przy użyciu zdefiniowanego elementu strukturalnego \n",
        "img_open = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel, borderType = cv2.BORDER_REPLICATE)\n",
        "\n",
        "frame = cv2.hconcat((img, img_open))\n",
        "#cv2_imshow(frame)\n",
        "plt.figure(figsize=(15,15))\n",
        "plt.imshow(frame, cmap=plt.get_cmap('gray'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pWdzj77hn8Br"
      },
      "source": [
        "## d) zamknięcie morfologiczne\n",
        "\n",
        "Operacja zamknięcia (czasem zwana domknięciem) morfologicznego jest równoważna nałożeniu operacji erozji na wynik dylatacji obrazu pierwotnego. Domknięcie usuwa z obrazu „dziury” oraz wklęsłości mniejsze od elementu strukturalnego. Uwaga, obietky mogą się połączyć."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JQWlVdGL_oHx"
      },
      "source": [
        "# wykonanie operacji zamknięcia morfologicznego przy użyciu zdefiniowanego elementu strukturalnego \n",
        "img_close = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel, borderType = cv2.BORDER_REPLICATE)\n",
        "\n",
        "frame = cv2.hconcat((img, img_close))\n",
        "#cv2_imshow(frame)\n",
        "plt.figure(figsize=(15,15))\n",
        "plt.imshow(frame, cmap=plt.get_cmap('gray'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y9iTIsVJCzxy"
      },
      "source": [
        "# Zadanie 1\n",
        "\n",
        "Dla wskazanego obrazu wykonać operację erozja i dylacja z podanymi elementami strukturalnymi o zadanym rozmiarze:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "_2qH9GidS5OD"
      },
      "source": [
        "# wczytanie obrazu do zadania 1\n",
        "img1 = cv2.imread('digits1_half.bmp', cv2.IMREAD_GRAYSCALE)\n",
        "#cv2_imshow(img)\n",
        "plt.figure(figsize=(15,15))\n",
        "plt.imshow(img1, cmap=plt.get_cmap('gray'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L-JKcsfSCwnQ"
      },
      "source": [
        "# widget do konstrukcji elementu strukturalnego\n",
        "\n",
        "from ipywidgets import widgets, GridspecLayout, BoundedIntText, Layout, ToggleButton\n",
        "from IPython.display import display\n",
        "\n",
        "grid_size = 7\n",
        "\n",
        "def create_expanded_input():\n",
        "    return widgets.ToggleButton(value=False, description='Click me',disabled=False, button_style='', icon='check', style={'button_width' : '100px'})\n",
        "\n",
        "grid = GridspecLayout(grid_size, grid_size)\n",
        "\n",
        "for i in range(grid_size):\n",
        "    for j in range(grid_size):\n",
        "        grid[i, j] = create_expanded_input();\n",
        "\n",
        "print(\"Budowa elementu strukturalnego - klikajac odpowiednie przyciski zmieniamy wartość\")\n",
        "display(grid)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jhEX4zFiQ6ST"
      },
      "source": [
        "# zczytanie kerenela z widget'a\n",
        "kernel = np.zeros((grid_size,grid_size))\n",
        "for i in range(grid_size):\n",
        "    for j in range(grid_size):\n",
        "        kernel[i, j] = int(grid[i, j].value)\n",
        "\n",
        "kernel = kernel.astype(np.uint8)\n",
        "\n",
        "\n",
        "# utworzenie widget listy rozwijanej op morf\n",
        "my_op = widgets.Dropdown(\n",
        "    options=[('Erode', 1), ('Dilate', 2), ('Open', 3), ('Close', 4)],\n",
        "    value=1,\n",
        "    description='Morph op:',\n",
        ")\n",
        "\n",
        "# utworzenie widget przyscisk\n",
        "button = widgets.Button(\n",
        "    description='Click me',\n",
        "    disabled=False,\n",
        "    button_style='', # 'success', 'info', 'warning', 'danger' or ''\n",
        "    tooltip='Click me',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "# funkcja uruchamiana po przysicnieciu guzika\n",
        "def my_foo(self):\n",
        "  print(\"Kernel:\")\n",
        "  print(kernel)\n",
        "  print(\"\\n\")\n",
        "\n",
        "  if (my_op.value==1):\n",
        "    img_out = cv2.erode(img1, kernel, iterations = 1, borderType = cv2.BORDER_REPLICATE)\n",
        "    print(\"Operation: Erosion\")\n",
        "  elif (my_op.value==2):\n",
        "    img_out = cv2.dilate(img1, kernel, iterations = 1, borderType = cv2.BORDER_REPLICATE)\n",
        "    print(\"Operation: Dilation\")\n",
        "  elif (my_op.value==3):\n",
        "    img_out = cv2.morphologyEx(img1, cv2.MORPH_OPEN, kernel, borderType = cv2.BORDER_REPLICATE)\n",
        "    print(\"Operation: Open\")\n",
        "  elif (my_op.value==4):\n",
        "    img_out = cv2.morphologyEx(img1, cv2.MORPH_CLOSE, kernel, borderType = cv2.BORDER_REPLICATE)\n",
        "    print(\"Operation: Close\")\n",
        "  else:\n",
        "    img_out = cv2.dilate(img1, kernel, iterations = 1, borderType = cv2.BORDER_REPLICATE)\n",
        "\n",
        "  frame = cv2.hconcat((img1, img_out))\n",
        "  #cv2_imshow(frame)\n",
        "  plt.figure(figsize=(15,15))\n",
        "  plt.imshow(frame, cmap=plt.get_cmap('gray'))\n",
        "  return frame\n",
        "\n",
        "\n",
        "# przypisanie funkcji do guzika\n",
        "button.on_click(my_foo)\n",
        "# zdefiniowanie widgetów obok siebie\n",
        "grid2 = GridspecLayout(1, 2)\n",
        "grid2[0,0] = my_op\n",
        "grid2[0,1] = button"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NkqQt9eUQ3A6"
      },
      "source": [
        "# widget do wykonania operacji morfologicznych\n",
        "display(grid2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DbO_CBjvNWi3"
      },
      "source": [
        "\n",
        "#img_out = cv2.erode(img, kernel, iterations = 1, borderType = cv2.BORDER_REPLICATE)\n",
        "#img_out = cv2.dilate(img, kernel, iterations = 1, borderType = cv2.BORDER_REPLICATE)\n",
        "#img_out = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel, borderType = cv2.BORDER_REPLICATE)\n",
        "#img_out = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel, borderType = cv2.BORDER_REPLICATE)\n",
        "\n",
        "#frame = cv2.hconcat((img, img_out))\n",
        "#cv2_imshow(frame)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qg8FawxFb88I"
      },
      "source": [
        "# Ad. Zadanie 4 Szkieletyzacja (ścienianie) obiektów "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eoz4P7igfiCs"
      },
      "source": [
        "Szkielet figury, to zbiór wszystkich punktów równoodległych od co najmniej dwóch brzegów. Szkielet odzwierciedla podstawowe własności topologiczne figury, a jego dalsza analiza może zostać wykorzystana do wielu celów.\n",
        "\n",
        "Szkieletyzacja jest operacją wyznaczania liniowej reprezentacji (szkieletów) figur na analizowanym obrazie. Można ją wyznaczać między innymi przy użyciu operacji morfologicznych. Poniżej przedstawiona jest bardzo uproszczona implementacja.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "ALGORYTM:\n",
        "1.   Utworzenie pustego obrazu do przechowania szkieletu (*skel*).\n",
        "2.   Wykonanie operacji otwarcia morfologicznego na obrazie oryginalnym, uzyskując *im_open*. \n",
        "3.   Odjęcie im_open od obrazu oryginalnego, uzyskując *im_temp*.\n",
        "4.   Wykonanie operacji erozji na oryginalnym obrazie oraz poprawienie szkieletu przez obliczenie części wspólnej *im_temp* oraz aktualnego szkieletu.\n",
        "5.   Powtórzenie kroków 2-4 aż obraz oryginalny będzie pusty (kompletnie zerodowany).\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C8XtWwBmauQX"
      },
      "source": [
        "# Krok 1\n",
        "size = np.size(img)\n",
        "skel = np.zeros(img.shape, np.uint8)\n",
        "im_copy = img.copy()\n",
        "\n",
        "# utoworzenie kernela\n",
        "element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xyf5mCPEdrp1"
      },
      "source": [
        "# Pętla obejmująca kroki 2-4\n",
        "while True:\n",
        "    #Krok 2: Otwarcie morfologiczne\n",
        "    im_open = cv2.morphologyEx(im_copy, cv2.MORPH_OPEN, element)\n",
        "    #Krok 3: Odjęcie powyższego wyniku od obrazu oryginalnego\n",
        "    im_temp = cv2.subtract(im_copy, im_open)\n",
        "    #Krok 4: \n",
        "    #erozja morfologiczna\n",
        "    im_eroded = cv2.erode(im_copy, element)\n",
        "    # aktualizacja szkieletu\n",
        "    skel = cv2.bitwise_or(skel,im_temp)\n",
        "    # aktualizacja obrazu przetwarzanego\n",
        "    im_copy = im_eroded.copy()\n",
        "    #plt.figure(figsize=(10,10))\n",
        "    #plt.imshow(im_copy, cmap=plt.get_cmap('gray'))                             # Odkomentuj (te i poprzednia linie) jeśli chcesz zobaczyć kolejne kroki - uwaga wiele obrazów\n",
        "\n",
        "    #Krok 5: Przetwij pętlę jeśli nie ma już obiektów w obrazie\n",
        "    if cv2.countNonZero(im_copy)==0:\n",
        "        break\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9XiOODrdb9yj"
      },
      "source": [
        "# wizualne porównanie wyników\n",
        "frame = cv2.hconcat((img, skel))\n",
        "#cv2_imshow(frame)\n",
        "plt.figure(figsize=(15,15))\n",
        "plt.imshow(frame, cmap=plt.get_cmap('gray'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pWqC3hBJU2sb"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}