8.1. Wczytywanie obrazu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image = cv2.imread("images/plane.jpg", cv2.IMREAD_GRAYSCALE)





# Wyświetlenie obrazu.
plt.imshow(image, cmap="gray"), plt.axis("off")
plt.show()





# Wyświetlenie typu danych.
type(image)

numpy.ndarray





# Wyświetlenie danych obrazu.
image

array([[140, 136, 146, ..., 132, 139, 134],
       [144, 136, 149, ..., 142, 124, 126],
       [152, 139, 144, ..., 121, 127, 134],
       ...,
       [156, 146, 144, ..., 157, 154, 151],
       [146, 150, 147, ..., 156, 158, 157],
       [143, 138, 147, ..., 156, 157, 157]], dtype=uint8)





# Wyświetlenie rozdzielczości obrazu.
image.shape

(2270, 3600)





# Wyświetlenie wartości pierwszego piksela.
image[0,0]

140





# Wczytanie obrazu w kolorze.
image_bgr = cv2.imread("images/plane.jpg", cv2.IMREAD_COLOR)

# Wyświetlenie wartości piksela.
image_bgr[0,0]

array([195, 144, 111], dtype=uint8)





# Konwersja na przestrzeń barw RGB.
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)

# Wyświetlenie obrazu.
plt.imshow(image_rgb), plt.axis("off")
plt.show()





8.2. Zapisywanie obrazu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image = cv2.imread("images/plane.jpg", cv2.IMREAD_GRAYSCALE)

# Zapisanie obrazu.
cv2.imwrite("images/plane_new.jpg", image)

True





8.3. Zmiana wielkości obrazu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Zmiana wielkości obrazu na 50×50 pikseli.
image_50x50 = cv2.resize(image, (50, 50))

# Wyświetlenie obrazu.
plt.imshow(image_50x50, cmap="gray"), plt.axis("off")
plt.show()





8.4. Kadrowanie obrazu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Pobranie połowy kolumn i wszystkich wierszy.
image_cropped = image[:,:128]

# Wyświetlenie obrazu.
plt.imshow(image_cropped, cmap="gray"), plt.axis("off")
plt.show()





8.5. Rozmywanie obrazu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Rozmycie obrazu.
image_blurry = cv2.blur(image, (5,5))

# Wyświetlenie obrazu.
plt.imshow(image_blurry, cmap="gray"), plt.axis("off")
plt.show()





# Rozmycie obrazu.
image_very_blurry = cv2.blur(image, (100,100))

# Wyświetlenie obrazu.
plt.imshow(image_very_blurry, cmap="gray"), plt.xticks([]), plt.yticks([])
plt.show()





# Utworzenie jądra.
kernel = np.ones((5,5)) / 25.0

# Wyświetlenie jądra.
kernel

array([[ 0.04,  0.04,  0.04,  0.04,  0.04],
       [ 0.04,  0.04,  0.04,  0.04,  0.04],
       [ 0.04,  0.04,  0.04,  0.04,  0.04],
       [ 0.04,  0.04,  0.04,  0.04,  0.04],
       [ 0.04,  0.04,  0.04,  0.04,  0.04]])





# Zastosowanie jądra.
image_kernel = cv2.filter2D(image, -1, kernel)

# Wyświetlenie obrazu.
plt.imshow(image_kernel, cmap="gray"), plt.xticks([]), plt.yticks([])
plt.show()





8.6. Wyostrzanie obrazu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Utworzenie jądra.
kernel = np.array([[0, -1, 0],
                   [-1, 5,-1],
                   [0, -1, 0]])

# Wyostrzenie obrazu.
image_sharp = cv2.filter2D(image, -1, kernel)

# Wyświetlenie obrazu.
plt.imshow(image_sharp, cmap="gray"), plt.axis("off")
plt.show()





8.7. Zwiększanie kontrastu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu.
image = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Poprawienie obrazu.
image_enhanced = cv2.equalizeHist(image)

# Wyświetlenie obrazu.
plt.imshow(image_enhanced, cmap="gray"), plt.axis("off")
plt.show()





# Wczytanie obrazu.
image_bgr = cv2.imread("images/plane.jpg")

# Konwersja na przestrzeń barw YUV.
image_yuv = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2YUV)

# Przeprowadzenie wyrównania histogramu.
image_yuv[:, :, 0] = cv2.equalizeHist(image_yuv[:, :, 0])

# Konwersja na przestrzeń barw RGB.
image_rgb = cv2.cvtColor(image_yuv, cv2.COLOR_YUV2RGB)

# Wyświetlenie obrazu.
plt.imshow(image_rgb), plt.axis("off")
plt.show()





8.8. Izolowanie kolorów

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu.
image_bgr = cv2.imread('images/plane_256x256.jpg')

# Konwersja przestrzeni barw BGR na HSV.
image_hsv = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2HSV)

# Zdefiniowanie zakresu koloru niebieskiego w HSV.
lower_blue = np.array([50,100,50])
upper_blue = np.array([130,255,255])

# Utworzenie maski.
mask = cv2.inRange(image_hsv, lower_blue, upper_blue)

# Nałożenie maski na obraz.
image_bgr_masked = cv2.bitwise_and(image_bgr, image_bgr, mask=mask)

# Konwersja przestrzeni barw BGR na RGB.
image_rgb = cv2.cvtColor(image_bgr_masked, cv2.COLOR_BGR2RGB)

# Wyświetlenie obrazu.
plt.imshow(image_rgb), plt.axis("off")
plt.show()





# Wyświetlenie obrazu.
plt.imshow(mask, cmap='gray'), plt.axis("off")
plt.show()





8.9. Progowanie obrazu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image_grey = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Zastosowanie progowania adaptacyjnego.
max_output_value = 255
neighborhood_size = 99
subtract_from_mean = 10
image_binarized = cv2.adaptiveThreshold(image_grey,
                                        max_output_value,
                                        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                        cv2.THRESH_BINARY,
                                        neighborhood_size,
                                        subtract_from_mean)

# Wyświetlenie obrazu.
plt.imshow(image_binarized, cmap="gray"), plt.axis("off")
plt.show()





# Zastosowanie argumentu cv2.ADAPTIVE_THRESH_MEAN_C.
image_mean_threshold = cv2.adaptiveThreshold(image_grey,
                                             max_output_value,
                                             cv2.ADAPTIVE_THRESH_MEAN_C,
                                             cv2.THRESH_BINARY,
                                             neighborhood_size,
                                             subtract_from_mean)

# Wyświetlenie obrazu.
plt.imshow(image_mean_threshold, cmap="gray"), plt.axis("off")
plt.show()





8.10. Usuwanie tła obrazu

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu i jego konwersja na RGB.
image_bgr = cv2.imread('images/plane_256x256.jpg')
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)

# Wartości prostokątnego zaznaczenia: początkowy punkt na osi x, początkowy punkt na osi y, długość, wysokość.
rectangle = (0, 56, 256, 150)

# Utworzenie maski początkowej.
mask = np.zeros(image_rgb.shape[:2], np.uint8)

# Utworzenie tablic początkowych używanych przez algorytm GrabCut.
bgdModel = np.zeros((1, 65), np.float64)
fgdModel = np.zeros((1, 65), np.float64)

# Wykonanie algorytmu GrabCut.
cv2.grabCut(image_rgb, # Obraz.
            mask, # Maska.
            rectangle, # Prostokąt.
            bgdModel, # Tablica tymczasowa dla tła.
            fgdModel, # Tablica tymczasowa dla pierwszego planu.
            5, # Liczba iteracji.
            cv2.GC_INIT_WITH_RECT) # Użycie argumentu GC_INIT_WITH_RECT.

# Utworzenie maski, w której piksele tła mają przypisaną wartość 0, natomiast piksele pozostałych elementów — wartość 1.
mask_2 = np.where((mask==2) | (mask==0), 0, 1).astype('uint8')

# Nałożenie maski na obraz i odjęcie tła.
image_rgb_nobg = image_rgb * mask_2[:, :, np.newaxis]

# Wyświetlenie obrazu.
plt.imshow(image_rgb_nobg), plt.axis("off")
plt.show()





# Nałożenie maski.
plt.imshow(mask, cmap='gray'), plt.axis("off")
plt.show()





# Nałożenie maski.
plt.imshow(mask_2, cmap='gray'), plt.axis("off")
plt.show()





8.11. Wykrywanie krawędzi

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image_gray = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Obliczenie mediany intensywności.
median_intensity = np.median(image_gray)

# Zdefiniowanie wartości progowych o jedno odchylenie standardowe więcej i jedno mniej niż mediana intensywności piksela.
lower_threshold = int(max(0, (1.0 - 0.33) * median_intensity))
upper_threshold = int(min(255, (1.0 + 0.33) * median_intensity))

# Zastosowanie techniki wykrywania krawędzi Canny.
image_canny = cv2.Canny(image_gray, lower_threshold, upper_threshold)

# Wyświetlenie obrazu.
plt.imshow(image_canny, cmap="gray"), plt.axis("off")
plt.show()





8.12. Wykrywanie narożników w obrazie

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image_bgr = cv2.imread("images/plane_256x256.jpg")
image_gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
image_gray = np.float32(image_gray)

# Zdefiniowanie parametrów wykrywacza narożników.
block_size = 2
aperture = 29
free_parameter = 0.04

# Wykrywanie narożników.
detector_responses = cv2.cornerHarris(image_gray,
                                      block_size,
                                      aperture,
                                      free_parameter)

# Oznaczenie dużych narożników.
detector_responses = cv2.dilate(detector_responses, None)

# Zachowane będą tylko dane większe niż podana wartość progowa i zostaną oznaczone kolorem białym.
threshold = 0.02
image_bgr[detector_responses >
          threshold *
          detector_responses.max()] = [255,255,255]

# Konwersja na obraz czarno-biały.
image_gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Wyświetlenie obrazu.
plt.imshow(image_gray, cmap="gray"), plt.axis("off")
plt.show()





# Wyświetlenie potencjalnych narożników.
plt.imshow(detector_responses, cmap='gray'), plt.axis("off")
plt.show()





# Wczytanie obrazów.
image_bgr = cv2.imread('images/plane_256x256.jpg')
image_gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Liczba narożników do wykrycia.
corners_to_detect = 10
minimum_quality_score = 0.05
minimum_distance = 25

# Wykrycie narożników.
corners = cv2.goodFeaturesToTrack(image_gray,
                                  corners_to_detect,
                                  minimum_quality_score,
                                  minimum_distance)
corners = np.int16(corners)

# Narysowanie białego koła w miejscu każdego wykrytego narożnika.
for corner in corners:
    x, y = corner[0]
    cv2.circle(image_bgr, (x,y), 10, (255,255,255), -1)

# Konwersja na obraz czarno-biały.
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Wyświetlenie obrazu.
plt.imshow(image_rgb, cmap='gray'), plt.axis("off")
plt.show()





8.13. Tworzenie cech w uczeniu maszynowym

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Wczytanie obrazu jako czarno-białego.
image = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Zmiana wielkości obrazu na 10×10 pikseli.
image_10x10 = cv2.resize(image, (10, 10))

# Konwersja danych obrazu na wektor jednowymiarowy.
image_10x10.flatten()

array([133, 130, 130, 129, 130, 129, 129, 128, 128, 127, 135, 131, 131,
       131, 130, 130, 129, 128, 128, 128, 134, 132, 131, 131, 130, 129,
       129, 128, 130, 133, 132, 158, 130, 133, 130,  46,  97,  26, 132,
       143, 141,  36,  54,  91,   9,   9,  49, 144, 179,  41, 142,  95,
        32,  36,  29,  43, 113, 141, 179, 187, 141, 124,  26,  25, 132,
       135, 151, 175, 174, 184, 143, 151,  38, 133, 134, 139, 174, 177,
       169, 174, 155, 141, 135, 137, 137, 152, 169, 168, 168, 179, 152,
       139, 136, 135, 137, 143, 159, 166, 171, 175], dtype=uint8)





plt.imshow(image_10x10, cmap="gray"), plt.axis("off")
plt.show()





image_10x10.shape
(10, 10)





image_10x10.flatten().shape
(100,)





# Wczytanie obrazu w kolorze.
image_color = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_COLOR)

# Zmiana wielkości obrazu na 10×10 pikseli.
image_color_10x10 = cv2.resize(image_color, (10, 10))

# Konwersja danych obrazu na wektor jednowymiarowy i wyświetlenie jego wielkości.
image_color_10x10.flatten().shape
(300,)





# Wczytanie obrazu jako czarno-białego.
image_256x256_gray = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_GRAYSCALE)

# Konwersja danych obrazu na wektor jednowymiarowy i wyświetlenie jego wielkości.
image_256x256_gray.flatten().shape
(65536,)





# Wczytanie obrazu w kolorze.
image_256x256_color = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_COLOR)

# Konwersja danych obrazu na wektor jednowymiarowy i wyświetlenie jego wielkości.
image_256x256_color.flatten().shape

(196608,)





8.14. Użycie histogramu koloru jako cechy

# Wczytanie bibliotek.
import cv2
import numpy as np
from matplotlib import pyplot as plt

np.random.seed(0)

# Wczytanie obrazu.
image_bgr = cv2.imread("images/plane_256x256.jpg", cv2.IMREAD_COLOR)

# Konwersja na przestrzeń barw RGB.
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)

# Utworzenie listy dla wartości cech.
features = []

# Wygenerowanie histogramu dla każdego kanału koloru.
colors = ("r","g","b")

# Dla każdego kanału: wygenerowanie histogramu i dodanie go do listy wartości cech.
for i, channel in enumerate(colors):
    histogram = cv2.calcHist([image_rgb], # Obraz.
                        [i], # Indeks kanału.
                        None, # Brak maski.
                        [256], # Wielkość histogramu.
                        [0,256]) # Zakres wartości.
    features.extend(histogram)

# Utworzenie wektora dla wartości cech obserwacji.
observation = np.array(features).flatten()

# Wyświetlenie wartości obserwacji dla pierwszych pięciu cech.
observation[0:5]

array([ 1008.,   217.,   184.,   165.,   116.], dtype=float32)





# Wyświetlenie wartości kanałów RGB.
image_rgb[0,0]

array([107, 163, 212], dtype=uint8)





# Wczytanie biblioteki pandas.
import pandas as pd

# Utworzenie pewnych danych.
data = pd.Series([1, 1, 2, 2, 3, 3, 3, 4, 5])

# Wyświetlenie histogramu.
data.hist(grid=False)
plt.show()





# Wygenerowanie histogramu dla każdego kanału koloru.
colors = ("r","g","b")

# Dla każdego kanału: wygenerowanie histogramu i przygotowanie wykresu.
for i, channel in enumerate(colors):
    histogram = cv2.calcHist([image_rgb], # Obraz.
                        [i], # Indeks kanału.
                        None, # Brak maski.
                        [256], # Wielkość histogramu.
                        [0,256]) # Zakres wartości.
    plt.plot(histogram, color = channel)
    plt.xlim([0,256])

# Wyświetlenie wykresu.
plt.show()





8.15. Użycie wytrenowanych embeddingów jako cech

# Wczytanie bibliotek.
import cv2
import numpy as np
import torch
from torchvision import transforms
import torchvision.models as models

# Wczytanie obrazu.
image_bgr = cv2.imread("images/plane.jpg", cv2.IMREAD_COLOR)

# Konwersja na typ danych PyTorch.
convert_tensor = transforms.ToTensor()
pytorch_image = convert_tensor(np.array(image_rgb))

# Wczytanie wytrenowanego modelu.
model = models.resnet18(pretrained=True)

# Wskazanie konkretnej warstwy modelu, która ma zostać użyta.
layer = model._modules.get('avgpool')

# Wybór trybu modelu.
model.eval()

# Użycie embeddingu razem z opcją no_grad.
with torch.no_grad():
    embedding = model(pytorch_image.unsqueeze(0))

print(embedding.shape)

torch.Size([1, 1000])





# Wczytanie bibliotek.
import cv2
import tensorflow as tf
import tensorflow_hub as hub

# Wczytanie obrazu.
image_bgr = cv2.imread("images/plane.jpg", cv2.IMREAD_COLOR)
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)

# Konwersja na typ danych TensorFlow.
tf_image = tf.image.convert_image_dtype([image_rgb], tf.float32)

# Utworzenie modelu i pobranie embeddingów za pomocą modelu początkowego V1.
embedding_model = hub.KerasLayer(
    "https://tfhub.dev/google/imagenet/inception_v1/feature_vector/5"
)
embeddings = embedding_model(tf_image)

# Wyświetlenie kształtu embeddingu.
print(embeddings.shape)

(1, 1024)





8.16. Wykrywanie obiektów za pomocą OpenCV

# Wczytanie bibliotek.
import cv2
from matplotlib import pyplot as plt

# W trakcie pierwszego uruchomienia trzeba wydać następujące polecenia:
# mkdir models && cd models
# wget https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_default.xml
face_cascade = cv2.CascadeClassifier()
face_cascade.load(
    cv2.samples.findFile(
        "models/haarcascade_frontalface_default.xml"
    )
)

# Wczytanie obrazu.
image_bgr = cv2.imread("images/kyle_pic.jpg", cv2.IMREAD_COLOR)
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)

# Wykrywanie twarzy i narysowanie prostokąta.
faces = face_cascade.detectMultiScale(image_rgb)
for (x,y,w,h) in faces:
    cv2.rectangle(image_rgb, (x, y),
                      (x + h, y + w),
                      (0, 255, 0), 5)

# Wyświetlenie obrazu.
plt.subplot(1, 1, 1)
plt.imshow(image_rgb)
plt.show()





8.17. Klasyfikowanie obrazów za pomocą PyTorch

# Wczytanie bibliotek.
import cv2
import json
import numpy as np
import torch
from torchvision import transforms
from torchvision.models import resnet18
import urllib.request

# Pobranie klas imagenet.
with urllib.request.urlopen(
    "https://raw.githubusercontent.com/raghakot/keras-vis/master/resources/"
    ):
    imagenet_class_index = json.load(url)

# Utworzenie egzemplarza wytrenowanego modelu.
model = resnet18(pretrained=True)

# Wczytanie obrazu.
image_bgr = cv2.imread("images/plane.jpg", cv2.IMREAD_COLOR)
image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)

# Konwersja na typ danych PyTorch.
convert_tensor = transforms.ToTensor()
pytorch_image = convert_tensor(np.array(image_rgb))

# Wybór trybu modelu.
model.eval()

# Utworzenie prognozy.
prediction = model(pytorch_image.unsqueeze(0))

# Pobranie indeksu największego prognozowanego prawdopodobieństwa.
_, index = torch.max(prediction, 1)

# Konwersja na wartość procentową.
percentage = torch.nn.functional.softmax(prediction, dim=1)[0] * 100

# Wyświetlenie nazwy elementu o podanym indeksie i wartości procentowej.
print(imagenet_class_index[str(index.tolist()[0])][1],
    percentage[index.tolist()[0]].item())

airship 6.0569939613342285
