"<h2> 01. <i>Wprowadzenie do widzenia komputerowego</i> [laboratoria]</h2> \n",
"<h3>Andrzej Wójtowicz (2021)</h3>\n",
"</div>\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "7c64b51d",
"metadata": {
"id": "7c64b51d"
},
"source": [
"# Biblioteka OpenCV\n",
"\n",
"Podczas zajęć będziemy poruszali zagadnienia związane z [widzeniem komputerowym](https://en.wikipedia.org/wiki/Computer_vision) (ang. *computer vision*, CV). Tę tematykę możemy traktować jako rozwinięcie, czy też bardziej zaawansowaną formę [prztwarzania obrazów](https://en.wikipedia.org/wiki/Digital_image_processing) (ang. *image processing*, IP), gdzie tym razem będziemy starali się wyciągnąć pewną bardziej zaawansowaną wiedzę płynącą z obrazów statycznych lub wideo (cf. dyskusja na [Artificial Intelligence Stack Exchange](https://ai.stackexchange.com/a/13588)). Przedmiot ma formę laboratoryjną, zatem główną dyskusję dotyczącą zakresu obu dziedzin zostawimy w ramach dodatkowej literatury uzupełniającej.\n",
"\n",
"Standardem dla algorytmów z dziedzin IP/CV jest biblioteka [OpenCV](https://opencv.org/), która implementuje wiele z tych algorytmów oraz jest aktywnie rozwijana przez społeczność. Sama biblioteka posiada interfejsy do wielu języków programowania, natomiast my skupimy się na języku [Python](https://www.python.org/), który będzie dla nas idealny na potrzeby intensywnego prototypowania. Dokumentację online będzie głównie prowadziła do języka C++, ponieważ nie ma dedykowanej online dla Pythona, ale argumenty funkcji i metod są analogiczne.\n",
"\n",
"Początkowe zajęcia będą głównie dotyczyły zagadnień IP, tak aby zapoznać się z biblioteką OpenCV, a dalsze zajęcia będą już związane z CV.\n",
"\n",
"## Instalacja\n",
"\n",
"Materiały do zajęć Jupyter Notebook są tworzone na serwerze JupyterHub z kernelem Python 3. Pominiemy tutaj tworzenie wirtualnego środowiska, jednak należy mieć na uwadze, że poniższe polecenia mogą być też przydatne podczas próby uruchomienia notebooków lub programów na własnym komputerze.\n",
"\n",
"Poniższe polecenie wyświetla używaną wersję Pythona:"
"Niezbędne moduły zainstalujemy poprzez menadżer `pip`. Sama biblioteka OpenCV, abstrahując od np. paczek debianowych, posiada [4 możliwe opcje instalacji](https://pypi.org/project/opencv-contrib-python/). My zainstalujemy pełną wersję tej biblioteki, a dodatkowo doinstalujemy pakiety związane m.in. wyświetlaniem grafiki oraz uczeniem maszynowym."
"Sama biblioteka posiada też własne moduły związane z wyświetlaniem grafiki (moduł *HighGUI*) oraz z uczeniem maszynowym (moduł *ml*), jednak my raczej nie będziemy z nich korzystać podczas zajęć (aczkolwiek mogą być przydatne podczas realizacji projektu).\n",
"\n",
"Wszystkie moduły, algorytmy i zmienne są dostępne z poziomu modułu `cv2`:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "8eca2db5",
"metadata": {
"executionInfo": {
"elapsed": 406,
"status": "ok",
"timestamp": 1666007623321,
"user": {
"displayName": "Cezary Gałązkiewicz",
"userId": "01409497901784152256"
},
"user_tz": -120
},
"id": "8eca2db5"
},
"outputs": [],
"source": [
"import cv2 as cv"
]
},
{
"cell_type": "markdown",
"id": "82701dba",
"metadata": {
"id": "82701dba"
},
"source": [
"Poniższym poleceniem możemy również sprawdzić wersję zainstalowanej biblioteki:"
"Obraz możemy traktować jako standardową tablicę [NumPy](https://www.numpy.org/) zawierającą dane dotyczące danych pikseli. Im większa liczba pikseli w obrazie, tym większa jest jego rozdzielczość. Intuicyjnie można przyjąć, że piksele są niewielkimi blokami informacji ułożonymi w postaci siatki dwuwymiarowej, a głębokość piksela odnosi się do informacji o kolorze. Aby obraz mógł być przetworzony przez komputer, to taki obraz musi zostać przekonwertowany na postać binarną. Kolor obrazu można obliczyć w następujący sposób:\n",
"\n",
"Liczba kolorów (odcieni) = 2<sup>*bpp*</sup>, gdzie *bpp* oznacza bity na piksel.\n",
"\n",
"Większa liczba bitów na piksel daje więcej możliwych kolorów na obrazach.\n",
"\n",
"| Bity na piksel | Liczba kolorów |\n",
"| :------------: | :------------: |\n",
"| 1 | 2<sup>1</sup> = 2 |\n",
"| 2 | 2<sup>2</sup> = 4 |\n",
"| 3 | 2<sup>3</sup> = 8 |\n",
"| 4 | 2<sup>4</sup> = 16 |\n",
"| 8 | 2<sup>8</sup> = 256 |\n",
"| 16 | 2<sup>16</sup> = 65536 |\n",
"\n",
"Spójrzmy na trzy typowe reprezentacje obrazów.\n",
"\n",
"### Obraz czarno-biały\n",
"\n",
"Obraz binarny składa się z 1 bita na piksel, a więc może mieć tylko dwa możliwe kolory, tj. czarny lub biały. Kolor czarny jest reprezentowany przez wartość 0, a 1 oznacza biel (czasem w użyciu są reprezentacje, które mają odwrotne wartości czerni i bieli).\n",
"\n",
"\n",
"\n",
"### Obraz w skali odcieni szarości\n",
"\n",
"Obraz w skali szarości składa się z 8 bitów na piksel. Oznacza to, że może mieć 256 różnych odcieni, przy czym 0 pikseli będzie reprezentować kolor czarny, a 255 oznacza biel.\n",
"\n",
"\n",
"\n",
"### Obraz kolorowy\n",
"\n",
"Kolorowe obrazy w standardowej formie są reprezentowane jako połączenie barwy czerwonej, niebieskiej i zielonej - wszystkie inne kolory można uzyskać, mieszając te podstawowe kolory we właściwych proporcjach.\n",
"\n",
"\n",
"\n",
"Kolorowy obraz składa się również z 8 bitów na piksel, z tym że na taki obraz składają się 3 kanały (czerwony, zielony i niebieski). W rezultacie 256 różnych natężeń danego koloru podstawowego można przedstawić za pomocą 0 oznaczającego najmniej intensywny i 255 najbardziej intensywny. Dla poniższego obrazu pawiana:\n",
"\n",
"\n",
"\n",
"podstawowe parametry dotyczące wymiarów prezentują się następująco:\n",
"\n",
"```plaintext\n",
"Shape\n",
"(288, 289, 3)\n",
"288: Pixel height (wysokość w pikselach)\n",
"289: Pixel width (szerokość w pikselach)\n",
"3: color channel (liczba kanałów)\n",
"```\n",
"\n",
"Taki obraz możemy reprezentować w postaci trójwymiarowej tablicy:\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "650cae81",
"metadata": {
"id": "650cae81"
},
"source": [
"## Wczytywanie obrazów\n",
"\n",
"Przy użyciu funkcji [`cv.imread()`](https://docs.opencv.org/4.5.3/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56) możemy odczytać obraz. Pierwszy argument to lokalizacja pliku. Obraz powinien znajdować się w katalogu roboczym lub powinna zostać podana ścieżka bezwzględna do pliku.\n",
"\n",
"Drugi argument (opcjonalny) jest flagą oznaczającą w jaki sposób obraz powinien zostać wczytany:\n",
"\n",
"* [`cv.IMREAD_COLOR`](https://docs.opencv.org/4.5.3/d4/da8/group__imgcodecs.html#gga61d9b0126a3e57d9277ac48327799c80af660544735200cbe942eea09232eb822) - wczytuje kolorowy obraz z pominięciem przezroczystości; flaga domyślna,\n",
"* [`cv.IMREAD_GRAYSCALE`](https://docs.opencv.org/4.5.3/d4/da8/group__imgcodecs.html#gga61d9b0126a3e57d9277ac48327799c80ae29981cfc153d3b0cef5c0daeedd2125) : wczytuje obraz w skali odcieni szarości,\n",
"* [`cv.IMREAD_UNCHANGED`](https://docs.opencv.org/4.5.3/d4/da8/group__imgcodecs.html#gga61d9b0126a3e57d9277ac48327799c80aeddd67043ed0df14f9d9a4e66d2b0708) : wczytuje obraz razem z kanałem alfa (przezroczystość).\n",
"\n",
"Zamiast trzech powyższych flag można alternatywnie przekazać odpowiednio 1, 0 lub -1."
"Jak widać, poszczególne piksele na kanałach są 8-bitowymi liczbami całkowitymi bez znaku."
]
},
{
"cell_type": "markdown",
"id": "185a63ad",
"metadata": {
"id": "185a63ad"
},
"source": [
"## Wyświetlanie obrazów przy pomocy Matplotlib\n",
"\n",
"W notebooku Jupyter najwygodniej wyświetla się obrazy przy pomocy biblioteki [Matplotlib](https://matplotlib.org/), a dokładniej modułu `pyplot`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c4516873",
"metadata": {
"id": "c4516873"
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import matplotlib\n",
"%matplotlib inline"
]
},
{
"cell_type": "markdown",
"id": "7e320379",
"metadata": {
"id": "7e320379"
},
"source": [
"Przed wyświetleniem obrazu musimy dokonać drobnej konwersji obrazu. OpenCV domyślnie wczytuje obraz w formacie BGR, natomiast Matplotlib pracuje na obrazie w formacie RGB. Do konwersji użyjemy funkcji [`cv.cvtColor()`](https://docs.opencv.org/4.5.3/d8/d01/group__imgproc__color__conversions.html#ga397ae87e1288a81d2363b61574eb8cab), której pierwszym argumentem jest konwertowany obraz, a drugim sposób konwersji (w tym wypadku definiowany przez stałą [`cv.COLOR_BGR2RGB`](https://docs.opencv.org/4.5.3/d8/d01/group__imgproc__color__conversions.html#gga4e0972be5de079fed4e3a10e24ef5ef0ad3db9ff253b87d02efe4887b2f5d77ee)). *Nota bene*, czasami lepiej jest operować w przestrzeni barw [HSV](https://pl.wikipedia.org/wiki/HSV_(grafika)) niż RGB."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bd083db2",
"metadata": {
"id": "bd083db2"
},
"outputs": [],
"source": [
"image2 = cv.cvtColor(image, cv.COLOR_BGR2RGB)"
]
},
{
"cell_type": "markdown",
"id": "f8b4ae77",
"metadata": {
"id": "f8b4ae77"
},
"source": [
"Po przekonwertowaniu obrazu możemy wyświetlić go przy pomocy `pyplot`. Użyjemy do tego funkcji [`matplotlib.pyplot.imshow()`](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.imshow):"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e39ea012",
"metadata": {
"id": "e39ea012"
},
"outputs": [],
"source": [
"plt.imshow(image2)"
]
},
{
"cell_type": "markdown",
"id": "fc1c34db",
"metadata": {
"id": "fc1c34db"
},
"source": [
"Zwróćmy uwagę, że piksel o współrzędnych `(0, 0)` znajduje się w lewym górnym rogu.\n",
"\n",
"Można też obejść się bez konwersji i po prostu odwrócić w locie kanały w tablicy `numpy`:"
"Wczytaliśmy obraz w skali odcieni szarości. Podczas wyświetlania obrazu możemy ustawić mapę kolorów (parametr `cmap`). Dodatkowo, jeśli na końcu polecenia damy średnik (`;`), to w wynikowej komórce notebooka nie będzie się wyświetlał zwracany typ.\n",
"\n",
"Czasami warto również wyświetlić pasek z informacją o tym jaka wartość odpowiada za dany odcień:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "066b4778",
"metadata": {
"id": "066b4778"
},
"outputs": [],
"source": [
"plt.imshow(x_small, cmap = 'gray');\n",
"plt.colorbar();"
]
},
{
"cell_type": "markdown",
"id": "c561f1ea",
"metadata": {
"id": "c561f1ea"
},
"source": [
"## Proste operacje\n",
"\n",
"Możemy sprawdzić, że obraz jest w istocie tablicą NumPy o wartościach w zakresie od 0 do 255:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fd384995",
"metadata": {
"id": "fd384995"
},
"outputs": [],
"source": [
"print(x_small)"
]
},
{
"cell_type": "markdown",
"id": "794d3cb6",
"metadata": {
"id": "794d3cb6"
},
"source": [
"Wracając do samej biblioteki Matplotlib, możemy również np. sterować rozmiarem wyświetlanego obrazu oraz nadać mu tytuł:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5998b09d",
"metadata": {
"id": "5998b09d"
},
"outputs": [],
"source": [
"plt.figure(figsize = [6, 6])\n",
"plt.imshow(x_small, cmap = 'gray')\n",
"plt.title('Small X', fontsize = 20);"
]
},
{
"cell_type": "markdown",
"id": "059710ee",
"metadata": {
"id": "059710ee"
},
"source": [
"Niektóre parametry Matlplotlib (np. `figsize`) możemy ustawić na domyślne przy pomocy [`matplotlib.rcParams`](https://matplotlib.org/stable/tutorials/introductory/customizing.html#matplotlib-rcparams).\n",
"\n",
"Podczas wczytywania obrazów zawierających przezroczystość należy zwrócić uwagę na sposób wczytywania obrazu:"
"Możemy również podzielić obraz na poszczególne kanały i ew. ponownie je połączyć, odpowiednio przy pomocy funkcji [`cv.split()`](https://docs.opencv.org/4.5.3/d2/de8/group__core__array.html#ga0547c7fed86152d7e9d0096029c8518a) i [`cv.merge()`](https://docs.opencv.org/4.5.3/d2/de8/group__core__array.html#ga7d7b4d6c6ee504b30a20b1680029c7b4):"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "60ab993b",
"metadata": {
"id": "60ab993b"
},
"outputs": [],
"source": [
"b, g, r = cv.split(image)\n",
"plt.imshow(b, cmap = 'gray')\n",
"plt.title('Blue channel', fontsize = 20);"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f8418716",
"metadata": {
"id": "f8418716"
},
"outputs": [],
"source": [
"restored_image = cv.merge((r,g,b))\n",
"plt.imshow(restored_image);"
]
},
{
"cell_type": "markdown",
"id": "9ba6f17e",
"metadata": {
"id": "9ba6f17e"
},
"source": [
"Dostęp do poszczególnych pikseli odbywa się tak jak w macierzy, czyli podając wiersz i kolumnę. Poniżej możemy zobaczyć zmianę piksela na współrzędnych `(1, 1)`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7a018550",
"metadata": {
"id": "7a018550"
},
"outputs": [],
"source": [
"plt.imshow(x_small, cmap = 'gray');"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3aebbb19",
"metadata": {
"id": "3aebbb19"
},
"outputs": [],
"source": [
"x_small[1, 1] = 255\n",
"plt.imshow(x_small, cmap = 'gray');"
]
},
{
"cell_type": "markdown",
"id": "14278fd3",
"metadata": {
"id": "14278fd3"
},
"source": [
"Przycinanie odbywa się przez znany w Pythonie tzw. *slicing*, czyli wycinki:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "52b49c59",
"metadata": {
"id": "52b49c59"
},
"outputs": [],
"source": [
"plt.imshow(x_small[3:8, 2:], cmap = 'gray');"
]
},
{
"cell_type": "markdown",
"id": "e191d0e8",
"metadata": {
"id": "e191d0e8"
},
"source": [
"Możemy również ustawić kolor dla kilku kanałów jednocześnie dla zadanego regionu. Wykonamy to na kopii obrazu:"
"Przeskalowanie obrazu odbywa się przez [`cv.resize()`](https://docs.opencv.org/4.5.3/da/d54/group__imgproc__transform.html#ga47a974309e9102f5f08231edc7e7529d), w której albo podajemy dokładne docelowe wymiary, albo podajemy współczynniki skalowania na osiach *x* i *y*; możemy też uwzględnić odpowiednią metodę interpolacji. Matplotlib nie wyświetli nam wprost powiększonych obrazków, ale będziemy mogli zauważyć zmianę poprzez np. poprzez zmianę zakresów skali osi *x* i *y*:"
"Obrót obrazu dokonywany jest przez funkcję [`cv.flip()`](https://docs.opencv.org/4.5.3/d2/de8/group__core__array.html#gaca7be533e3dac7feb70fc60635adf441), w której podajemy według której osi ma nastąpić obrót (`0`: *x*, `1`: *y*, `-1`: obie)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fd673085",
"metadata": {
"id": "fd673085"
},
"outputs": [],
"source": [
"image_flipped = cv.flip(image, 0)\n",
"plt.imshow(image_flipped[..., ::-1]);"
]
},
{
"cell_type": "markdown",
"id": "e4c0f0d8",
"metadata": {
"id": "e4c0f0d8"
},
"source": [
"Może pojawić się potrzeba utworzenia nowych obrazów, więc najczęściej używa się do tego biblioteki NumPy:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fc86f294",
"metadata": {
"id": "fc86f294"
},
"outputs": [],
"source": [
"import numpy as np"
]
},
{
"cell_type": "markdown",
"id": "bc67f439",
"metadata": {
"id": "bc67f439"
},
"source": [
"Poniższe wywołania pokazują kilka wariantów. Możemy utworzyć pustą trójwymiarową macierz wypełnioną zerami przy pomocy [`numpy.zeros()`](https://numpy.org/doc/stable/reference/generated/numpy.zeros.html):"
"Jeżeli chcemy ustawić jakąś początkową wartość, to możemy przeskalować tablicę jedynek uzyskaną z [`numpy.ones()`](https://numpy.org/doc/stable/reference/generated/numpy.ones.html):"
"Jeżeli nowy obraz powinien mieć takie same wymiary jak inny obraz, to możemy do tej operacji użyć [`numpy.ones_like()`](https://numpy.org/doc/stable/reference/generated/numpy.ones_like.html):"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0f99dda7",
"metadata": {
"id": "0f99dda7"
},
"outputs": [],
"source": [
"empty_from_other = 255*np.ones_like(image)\n",
"plt.imshow(empty_from_other);"
]
},
{
"cell_type": "markdown",
"id": "ac02a038",
"metadata": {
"id": "ac02a038"
},
"source": [
"Czasami może być przydatne utworzenie maski zawierającej informację o tym czy np. dany piksel zawiera wartość w danym zakresie. Przy pomocy [`cv.inRange()`](https://docs.opencv.org/4.5.3/d2/de8/group__core__array.html#ga48af0ab51e36436c5d04340e036ce981) możemy sprawdzić zakresy dla trzech kanałów; przy okazji możemy zobaczyć jak zgrupować kilka obrazów jednocześnie (por. [`matplotlib.pyplot.subplot()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.subplot.html)):"
"Standardowo operujemy w zakresie liczb całkowitych `[0; 255]`, przez co jeśli w wyniku jakiejś operacji mielibyśmy wykroczyć poza zakres, to skończy się to albo operacją modulo albo np. uzyskaniem wartości ujemnych, co ostatecznie przełoży się na błędny wynik.\n",
"\n",
"Załóżmy, że chcemy podbić kontrast o 50%. Przemnożenie obrazu o wartość 1.5 zwróci nam tablicę o wartościach liczb rzeczywistych:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d48cf055",
"metadata": {
"id": "d48cf055"
},
"outputs": [],
"source": [
"new_image = image * 1.5\n",
"print(new_image.dtype)"
]
},
{
"cell_type": "markdown",
"id": "b2dbeacc",
"metadata": {
"id": "b2dbeacc"
},
"source": [
"W takim wypadku możemy naiwnie spróbować przekonwertować to ponownie do liczb całkowitych, ale wartości powyżej 255 zostaną obliczone według operacji modulo, przez co wynik będzie niezadowalający:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "411dabb9",
"metadata": {
"id": "411dabb9"
},
"outputs": [],
"source": [
"new_image = np.uint8(new_image)\n",
"plt.imshow(new_image[..., ::-1]);"
]
},
{
"cell_type": "markdown",
"id": "1fea50c7",
"metadata": {
"id": "1fea50c7"
},
"source": [
"Rozwiązaniem jest przycięcie wartości przy użyciu [`numpy.clip()`](https://numpy.org/doc/stable/reference/generated/numpy.clip.html) do zakresu `[0; 255]` jeśli operujemy na liczbach całkowitych, z ew. znormalizowaniem wartości do zakresu `[0; 1]` jeśli chcemy pracować na liczbach rzeczywistych:"
"Jeśli zwiększymy jasność i potencjalnie wyjdziemy poza zakres `[0; 255]`, to ponownie wartości zostaną przekręcone:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ce823b52",
"metadata": {
"id": "ce823b52"
},
"outputs": [],
"source": [
"new_image = image + 50\n",
"plt.imshow(new_image[..., ::-1]);"
]
},
{
"cell_type": "markdown",
"id": "4be595c9",
"metadata": {
"id": "4be595c9"
},
"source": [
"Z drugiej strony należy mieć też na uwadze pewne subtelne konwersje, które mogą odbywać się niejawnie. Poniżej mamy operację, która powoduje użycie danych typu `int16`, przez co następuje niejawna konwersja i przycięcie (jest o tym informacja w ostrzeżeniu):"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c93528a2",
"metadata": {
"id": "c93528a2"
},
"outputs": [],
"source": [
"new_image = image + (-50)\n",
"plt.imshow(new_image[..., ::-1]);"
]
},
{
"cell_type": "markdown",
"id": "6b3a8f53",
"metadata": {
"id": "6b3a8f53"
},
"source": [
"Rozwiązaniem powyższych problemów może być w przypadku zmiany jasności użycie funkcji [`cv.add()`](https://docs.opencv.org/4.5.3/d2/de8/group__core__array.html#ga10ac1bfb180e2cfda1701d06c24fdbd6) i [`cv.substract()`](https://docs.opencv.org/4.5.3/d2/de8/group__core__array.html#gaa0f00d98b4b5edeaeb7b8333b2de353b), a w przypadku zmiany kontrastu użycie [`cv.multiply()`](https://docs.opencv.org/4.5.3/d2/de8/group__core__array.html#ga979d898a58d7f61c53003e162e7ad89f), konwersja do typu np. `float64` i powrót do `uint8` z przycięciem wartości."
"Funkcja [`cv.imwrite()`](https://docs.opencv.org/4.5.3/d4/da8/group__imgcodecs.html#gabbc7ef1aa2edfaa87772f1202d67e0ce) zapisuje obraz do pliku. Pierwszy argument to nazwa pliku, drugi argument to obraz, który chcemy zapisać. Np. poniższe polecenie spowodowałoby zapisanie obrazu w formacie PNG w katalogu roboczym:\n",
"\n",
"```python\n",
"cv.imwrite('pawian.png', image)\n",
"```\n",
"\n",
"## Anotowanie\n",
"\n",
"Sprawdźmy w jaki sposób do pustego obrazu dodać kilka obiektów geometrycznych. Użyjemy do tego funkcji [`cv.line()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga7078a9fae8c7e7d13d24dac2520ae4a2), [`cv.circle()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#gaf10604b069374903dbd0f0488cb43670) , [`cv.rectangle()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga07d2f74cadcf8e305e810ce8eed13bc9), [`cv.ellipse()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga28b2267d35786f5f890ca167236cbc69), [`cv.polylines()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#gaa3c25f9fb764b6bef791bf034f6e26f5) i [`cv.putText()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga5126f47f883d730f633d74f07456c576). Funkcje te będą nadpisywały wejściowy obraz.\n",
"\n",
"W powyższych funkcjach pojawiają się wspólne argumenty:\n",
"\n",
"* `img` - obraz, na którym będziemy umieszczać obiekty,\n",
"* `color` - kolor obiektu podany w formacie jako krotka (*tuple*), np. `(255, 0, 0)`; w przypadku obrazów w skali odcieni szarości wystarczy podać wartość skalarną,\n",
"* `thickness` - grubość linii, okręgu, itp.; w przypadku wartości `-1` w przypadku zamkniętych figur jak okrąg, obiekt zostanie wypełniony wewnątrz wskazanym kolorem; domyślna wartość to `1`,\n",
"* `lineType` : rodzaj linii, np. 8-sąsiedztwo, antyaliasing, itp.; domyślnie jest 8-sąsiedztwo, natomiast wartość [`cv.LINE_AA`](https://docs.opencv.org/4.5.3/d0/de1/group__core.html#ggaf076ef45de481ac96e0ab3dc2c29a777a85fdabe5335c9e6656563dfd7c94fb4f) włącza antyaliasing.\n",
"\n",
"Na początku zaimportujemy bibliotekę NumPy i przy pomocy funkcji [`numpy.zeros()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html) utworzymy pusty 3-warstwowy czarny obraz o rozmiarze 512x512."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "efd40bcf",
"metadata": {
"id": "efd40bcf"
},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"img = np.zeros((512,512,3), np.uint8)\n",
"\n",
"plt.imshow(img)"
]
},
{
"cell_type": "markdown",
"id": "2b23ae8a",
"metadata": {
"id": "2b23ae8a"
},
"source": [
"W dalszej części operowali na obrazie w formacie RGB.\n",
"\n",
"### Linie\n",
"\n",
"Aby narysować linię, musimy podać początkowe i końcowe współrzędne linii. Przy pomocy [`cv.line()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga7078a9fae8c7e7d13d24dac2520ae4a2) narysujemy na obrazie czerwoną linię od lewego górnego rogu do prawego dolnego rogu o grubości 5 pikseli."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "eecb08e6",
"metadata": {
"id": "eecb08e6"
},
"outputs": [],
"source": [
"cv.line(img, (0,0), (511,511), (255,0,0), 5)\n",
"\n",
"plt.imshow(img)"
]
},
{
"cell_type": "markdown",
"id": "bb1a0101",
"metadata": {
"id": "bb1a0101"
},
"source": [
"### Prostokąty\n",
"\n",
"Aby narysować prostokąt, potrzebujemy lewego górnego rogu i prawego dolnego rogu prostokąta. Tym razem przy pomocy [`cv.rectangle()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga07d2f74cadcf8e305e810ce8eed13bc9) narysujemy zielony prostokąt w prawym górnym rogu obrazu."
"Aby narysować okrąg, potrzebujemy jego współrzędnych środka i promienia. Przy pomocy [`cv.circle()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#gaf10604b069374903dbd0f0488cb43670) narysujemy okrąg wewnątrz prostokąta narysowanego powyżej."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "48207862",
"metadata": {
"id": "48207862"
},
"outputs": [],
"source": [
"cv.circle(img, (447,63), 63, (0,0,255), -1)\n",
"\n",
"plt.imshow(img)"
]
},
{
"cell_type": "markdown",
"id": "60678ca6",
"metadata": {
"id": "60678ca6"
},
"source": [
"### Elipsy\n",
"\n",
"Aby narysować elipsę, musimy przekazać kilka argumentów. Jednym argumentem jest położenie środka `(x, y)`. Następnym argumentem jest długość dwóch osi (długość głównej osi i mniejsza długość osi). Kolejny parametr to kąt obrotu elipsy w kierunku przeciwnym do ruchu wskazówek zegara. Kolejne dwa argumenty oznaczają początek i koniec łuku elipsy mierzonego zgodnie z ruchem wskazówek zegara od głównej osi. tj. podanie wartości `0` i `360` daje pełną elipsę. Aby uzyskać więcej informacji, sprawdź dokumentację [`cv.ellipse()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga28b2267d35786f5f890ca167236cbc69). Poniższy kod rysuje pół elipsy na środku obrazu."
"Aby narysować wielokąt, najpierw potrzebujemy współrzędnych wierzchołków. Ustawmy te punkty w tablicy o wymiarach `liczba_wierszy x 1 x 2`, gdzie `liczba_wierszy` to liczba wierzchołków i powinna być typu `int32`. Tutaj narysujemy mały wielokąt z czterema wierzchołkami w kolorze jasnoniebieskim."
"Wielokąt może wydawać się przerywany, ale jeśli powiększylibyśmy wynikowy obraz, to byśmy zobaczyli, że jest on zamknięty.\n",
"\n",
"Jeśli trzecim argumentem [`cv.polylines()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#gaa3c25f9fb764b6bef791bf034f6e26f5) jest `False`, otrzymamy niedomknięty poligon.\n",
"\n",
"Funkcja `cv.polylines()` może być używana do rysowania wielu linii. Wystarczy utworzyć listę wszystkich linii, które chcemy narysować i przekazać je do funkcji. Wszystkie linie zostaną narysowane osobno. Jest to znacznie szybszy sposób na narysowanie grupy linii niż wywołanie osobno [`cv.line()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga7078a9fae8c7e7d13d24dac2520ae4a2) dla każdej linii.\n",
"\n",
"### Tekst\n",
"\n",
"Aby umieścić tekst na obrazie, musimy określić następujące rzeczy:\n",
"\n",
"* dane tekstowe, które chcemy napisać,\n",
"* współrzędne miejsca, w którym chcemy umieścić tekst (np. lewy dolny róg, w którym zacznie się tekst),\n",
"* typ czcionki (sprawdź dokumentację [`cv.putText()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga5126f47f883d730f633d74f07456c576) dla obsługiwanych czcionek),\n",
"* rozmiar czcionki,\n",
"* pozostałe rzeczy takie jak kolor, grubość, typ linii, itp.; dla uzyskania lepszego wynikowego wyglądu zaleca się `lineType = `[`cv.LINE_AA`](https://docs.opencv.org/4.5.3/d0/de1/group__core.html#ggaf076ef45de481ac96e0ab3dc2c29a777a85fdabe5335c9e6656563dfd7c94fb4f).\n",
"\n",
"Na naszym obrazie umieścimy tekst w kolorze białym."
"Czasami potrzebujemy jednak dokładnych informacji o wynikowym tekście, tak aby np. odpowiednio go umiejscowić lub umieścić pod nim kontrastowe tło. Do uzyskania tych informacji pomocne są funkcje [`cv.getTextSize()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga3d2abfcb995fd2db908c8288199dba82) i [`cv.getFontScaleFromHeight()`](https://docs.opencv.org/4.5.3/d6/d6e/group__imgproc__draw.html#ga442ff925c1a957794a1309e0ed3ba2c3)."
]
},
{
"cell_type": "markdown",
"id": "eec58cd3",
"metadata": {
"id": "eec58cd3"
},
"source": [
"## Wyświetlanie obrazów poza Jupyterem\n",
"\n",
"### HighGUI\n",
"\n",
"W OpenCV obraz standardowo wyświetla się przy pomocy modułu HighGUI. Przy użyciu funkcji [`cv.imshow()`](https://docs.opencv.org/4.5.3/d7/dfc/group__highgui.html#ga453d42fe4cb60e5723281a89973ee563) możemy wyświetlić obraz w oknie. Okno automatycznie dopasowuje się do rozmiaru obrazu.\n",
"\n",
"Pierwszy argument to nazwa okna. Drugi argument to nasz obraz. Możemy utworzyć dowolną liczbę okien, ale z różnymi nazwami okien.\n",
"\n",
"```python\n",
"cv.imshow('image', image)\n",
"cv.waitKey(0)\n",
"```\n",
"\n",
"Pod Windowsem wyświetli nam się wskazany przez nas obraz, natomiast pod Linuxem mechanizm HighGUI przy wyświetlaniu obrazu udostępnia trochę więcej opcji i informacji o wyświetlanym obrazie.\n",
"\n",
"\n",
"\n",
"Zwróćmy uwagę, że obraz pojawia się dopiero po poleceniu `cv.waitKey(0)` oraz będzie oczekiwał na wciśnięcie klawisza.\n",
"\n",
"[`cv.waitKey()`](https://docs.opencv.org/4.5.3/d7/dfc/group__highgui.html#ga5628525ad33f52eab17feebcfba38bd7) jest funkcją związaną z klawiaturą. Jej argumentem jest czas w milisekundach. Funkcja czeka przez określony czas na każde zdarzenie klawiatury. Jeśli w tym czasie zostanie naciśnięty dowolny klawisz, program przejdzie do dalszych operacji. Jeśli jako argument zostanie przekazane 0, to funkcja czeka bez końca na uderzenie klawisza klawiatury. Można również ustawić wykrywanie konkretnych klawiszy, takich jak naciśnięcie klawisza `<A>`, itp. Poza przetwarzaniem zdarzeń klawiatury, ta funkcja przetwarza również wiele innych zdarzeń GUI, więc **musisz** użyć jej przy wyświetleniu obrazu.\n",
"\n",
"Klikając na obraz i wciskając `<Enter>`, konsola zwróci informację liczbową o wciśniętym klawiszu, a ponadto obsługa programu wróci z powrotem do konsoli. Wydając poniższe polecenie usuniemy wszystkie okna:\n",
"\n",
"```python\n",
"cv.destroyAllWindows()\n",
"```\n",
"\n",
"[`cv.destroyAllWindows()`](https://docs.opencv.org/4.5.3/d7/dfc/group__highgui.html#ga6b7fc1c1a8960438156912027b38f481) usuwa wszystkie utworzone przez nas okna, a jeśli chcemy usunąć konkretne okno, należy użyć funkcji [`cv.destroyWindow()`](https://docs.opencv.org/4.5.3/d7/dfc/group__highgui.html#ga851ccdd6961022d1d5b4c4f255dbab34), w której jako argument podajemy dokładną nazwę okna.\n",
"\n",
"Istnieje specjalny przypadek, w którym możemy utworzyć okno i później załadować do niego obraz. W takim przypadku określamy czy rozmiar okna jest zmienny, czy nie. Robi się to za pomocą funkcji [`cv.namedWindow()`](https://docs.opencv.org/4.5.3/d7/dfc/group__highgui.html#ga5afdf8410934fd099df85c75b2e0888b). Domyślna flaga to [`cv.WINDOW_AUTOSIZE`](https://docs.opencv.org/4.5.3/d7/dfc/group__highgui.html#ggabf7d2c5625bc59ac130287f925557ac3acf621ace7a54954cbac01df27e47228f), ale jeśli określimy flagę jako [`cv.WINDOW_NORMAL`](https://docs.opencv.org/4.5.3/d7/dfc/group__highgui.html#ggabf7d2c5625bc59ac130287f925557ac3a29e45c5af696f73ce5e153601e5ca0f1), to możemy zmienić rozmiar okna. Będzie to pomocne, gdy obraz jest zbyt duży:\n",
"\n",
"```python\n",
"cv.namedWindow('image', cv.WINDOW_NORMAL)\n",
"cv.imshow('image', image)\n",
"cv.waitKey(0)\n",
"cv.destroyAllWindows()\n",
"```\n",
"\n",
"Interfejs HighGUI czasami pomaga w debugowaniu, ale trzeba mieć też świadomość, że nie jest on specjalnie rozbudowany i zasadniczo nie służy do budowania zaawansowanych interfejsów graficznych. HighGUI obsługuje sygnały idące nie tylko z klawiatury, ale również myszy, a ponadto pozawala na umieszczenie np. sliderów. Krótkie przykłady znajdują się w samouczkach opisujących [`cv.setMouseCallback()`](https://docs.opencv.org/4.5.3/db/d5b/tutorial_py_mouse_handling.html) oraz [`cv.getTrackbarPos()` i `cv.createTrackbar()`](https://docs.opencv.org/4.5.3/d9/dc8/tutorial_py_trackbar.html).\n",
"\n",
"### Matplotlib\n",
"\n",
"Po przekonwertowaniu obrazu do formatu RGB wyświetlamy go przy pomocy `pyplot`. Używamy przy tym funkcji [`matplotlib.pyplot.imshow()`](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.imshow) oraz [`matplotlib.pyplot.show()`](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.show):\n",
"\n",
"```python\n",
"plt.imshow(image2)\n",
"plt.show()\n",
"```\n",
"\n",
"Funkcja [`matplotlib.pyplot.show()`](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.show) posiada opcjonalny argument `block` (domyślna wartość `True`), która kontroluje czy funkcja jest blokująca:\n",
"\n",
"```python\n",
"plt.imshow(image2)\n",
"plt.show(False)\n",
"```\n",
"\n",
"lub krócej:\n",
"\n",
"```python\n",
"plt.imshow(image2)\n",
"plt.show(0)\n",
"```\n",
"\n",
"**Uwaga**: jeżeli w skrypcie ustawimy argument `block` na `False`, to po uruchomieniu skryptu najprawdopodobniej nie zobaczymy wynikowego obrazu/diagramu, ponieważ skrypt zacznie wykonywać dalsze polecenia i np. zakończy działanie programu. Ustawienie argumentu `block` na `False` najlepiej sprawdza się podczas pracy/eksperymentowania w konsoli interpretera Pythona.\n",
"\n",
"## Moduły\n",
"\n",
"[Lista modułów OpenCV](https://docs.opencv.org/4.5.3/) jest dość długa i zawiera pakiety algorytmów m.in. dla przetwarzania obrazów, uczenia maszynowego, głębokich sieci neuronowych, fotografii obliczeniowej, dedykowane rozwiązania dla CUDA, przepływ optyczny, operacje dla obrazów w logice rozmytej, przetwarzania RGB-D i wiele, wiele innych. Z poziomu Pythona dostęp do poszczególnych algorytmów odbywa się bezpośrednio przez moduł `cv2` (u nas alias `cv`). Część klas i funkcji ma przedrostek oznaczający moduł, np. `cv.bgsegm_BackgroundSubtractorCNT(...)` oznacza klasę [BackgroundSubtractorCNT](https://docs.opencv.org/4.5.3/de/dca/classcv_1_1bgsegm_1_1BackgroundSubtractorCNT.html) z modułu [bgsegm](https://docs.opencv.org/4.5.3/df/d5d/namespacecv_1_1bgsegm.html) zawierającym udoskonalone metody segmentacji pomiędzy tłem a pierwszym planem.\n",
"\n",
"## Ćwiczenie 1\n",
"\n",
"Wczytaj plik [`img/soyjaks.jpg`](https://knowyourmeme.com/memes/two-soyjaks-pointing) i spróbuj odtworzyć poniższy obrazek."
"Przygotuj środowisko pracy instalując wygodne dla Ciebie IDE, np. [PyCharm](https://www.jetbrains.com/pycharm/) (są darmowe studenckie licencje), [Visual Studio](https://visualstudio.microsoft.com) z dodatkiem [Python Tools](https://microsoft.github.io/PTVS/) lub [Visual Studio Code](https://code.visualstudio.com/). Sprawdź czy możesz zaimportować OpenCV, ew. stwórz wirtualne środowisko i doinstaluj niezbędne paczki."
]
},
{
"cell_type": "markdown",
"id": "4a713f31",
"metadata": {
"id": "4a713f31"
},
"source": [
"----\n",
"\n",
"Źródło:\n",
"\n",
"* OpenCV, [Getting Started with Images](https://docs.opencv.org/4.5.3/dc/d2e/tutorial_py_image_display.html).\n",
"* OpenCV, [Drawing Functions in OpenCV](https://docs.opencv.org/4.5.3/dc/da5/tutorial_py_drawing_functions.html).\n",
"* P. Pandey, [Face Detection with Python using OpenCV](https://www.datacamp.com/community/tutorials/face-detection-python-opencv)."
]
}
],
"metadata": {
"author": "Andrzej Wójtowicz",
"colab": {
"collapsed_sections": [
"185a63ad",
"c561f1ea",
"54e22dd0",
"2b23ae8a",
"bb1a0101",
"cdcb4b70",
"60678ca6",
"1219997d",
"cdba71d3",
"f0b793fc"
],
"provenance": []
},
"email": "andre@amu.edu.pl",
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"lang": "pl",
"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.10"
},
"subtitle": "01. Wprowadzenie do widzenia komputerowego [laboratoria]",
