You said: "### Zadanie A: Wyczytaj obrazy 'lena.png', 'boats.png' i 'happy-face.png'. Napisz funkcję wyświetlającą dwa obrazy w skali szarości obok siebie (wykorzystaj fragmenty kodu z wcześniejszych zajęć)." "#load images, check dimensions and data type boats = "boats.png" lena = "lena.png" face = "happy_face.png" #displayImages function def displayImages(Image1, Image2, Title1="img1", Title2="img2") : #display images return displayImages(boats, lena)" ChatGPT said: ChatGPT Aby zrealizować zadanie, należy wykonać następujące kroki: Wczytać obrazy. Przekształcić obrazy na skalę szarości. Wyświetlić obrazy obok siebie. Poniżej znajduje się kod realizujący to zadanie. Zakłada on, że używamy bibliotek matplotlib do wyświetlania obrazów oraz PIL (Python Imaging Library) do wczytywania i przetwarzania obrazów. import matplotlib.pyplot as plt from PIL import Image import numpy as np # Wczytywanie obrazów boats = Image.open("boats.png") lena = Image.open("lena.png") face = Image.open("happy-face.png") # Funkcja wyświetlająca dwa obrazy w skali szarości obok siebie def displayImages(Image1, Image2, Title1="img1", Title2="img2"): # Konwersja obrazów na skalę szarości gray_image1 = Image1.convert("L") gray_image2 = Image2.convert("L") # Ustawienie rozmiaru obrazów na ten sam (jeśli są różne) gray_image2 = gray_image2.resize(gray_image1.size) # Konwersja obrazów do numpy array img1_array = np.array(gray_image1) img2_array = np.array(gray_image2) # Wyświetlanie obrazów obok siebie plt.figure(figsize=(10, 5)) # Obraz 1 plt.subplot(1, 2, 1) plt.imshow(img1_array, cmap='gray') plt.title(Title1) plt.axis('off') # Wyłączanie osi # Obraz 2 plt.subplot(1, 2, 2) plt.imshow(img2_array, cmap='gray') plt.title(Title2) plt.axis('off') # Wyłączanie osi # Pokazanie obrazów plt.show() # Wywołanie funkcji dla obrazów "boats" i "lena" displayImages(boats, lena, "Boats", "Lena") Wyjaśnienie kodu: Wczytywanie obrazów: Obrazy są wczytywane przy użyciu PIL.Image.open(). Konwersja do skali szarości: Funkcja .convert("L") zamienia obraz na odcienie szarości. Dopasowanie rozmiarów: Jeśli obrazy mają różne rozmiary, przeskalowujemy obraz drugi do rozmiaru pierwszego. Wyświetlanie obrazów: Używamy matplotlib do wyświetlania obrazów obok siebie w jednym oknie, bez osi, z tytułami. Dodatkowe uwagi: Jeśli obrazy są w innych formatach, kod nadal będzie działał, o ile biblioteka PIL obsługuje dany format. Jeśli napotkasz problem z rozmiarem obrazów, upewnij się, że oba obrazy mają ten sam rozmiar przed ich wyświetleniem. You said: "### Zadanie B: Filtr medianowy: * Dokonaj filtracji obrazu filtrem medianowym z maskami rozmiaru 3x3, 1x5, 5x1 i 5x5 używając funkcji scipy.ndimage.median_filter (parametry $input$, $size$, $output$). * Wykorzystując funkcję z zadania A wyświetl obrazy przed i po filtrcji. * Powtórz operacje dla obrazów testowych 'noised2.png', 'noised3.png' i 'noised4.png'. #### Komentarz: Warto zwrócic uwagę, że wynik filtracji na krawędziach obrazu zależy od tego jak zdefinujemy co ma się stać w przypadku, gdy maska filtru wychodzi za obszar obrazu. Można doczytać w dokumentacji, że przeważnie jest dodatkowy (opcjonalny) parametr funkcji 'mode', np.: * w scipy.ndimage.median_filter - mode{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}, optional https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.median_filter.html#scipy.ndimage.median_filter * scipy.ndimage.grey_erosion https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.grey_erosion.html#scipy.ndimage.grey_erosion" "#apply median filter #display results #check if separable filter is correct" ChatGPT said: ChatGPT W zadaniu B będziemy wykorzystywać filtrację medianową na obrazach, aby wygładzić szum w obrazach za pomocą różnych masek rozmiarów 3x3, 1x5, 5x1 i 5x5. Skorzystamy z funkcji scipy.ndimage.median_filter do przetwarzania obrazów. Poniżej znajduje się przykładowy kod, który spełnia wymagania zadania: Filtracja obrazów z zastosowaniem różnych masek. Wyświetlanie wyników przed i po filtracji. Zastosowanie do różnych obrazów z szumem. Kroki: Wczytanie obrazów. Filtracja medianowa: Użycie scipy.ndimage.median_filter z różnymi maskami. Wyświetlenie wyników przed i po filtracji. Kod: import matplotlib.pyplot as plt import numpy as np from PIL import Image import scipy.ndimage as ndimage # Wczytywanie obrazów testowych z szumem noised2 = Image.open("noised2.png") noised3 = Image.open("noised3.png") noised4 = Image.open("noised4.png") # Funkcja do wyświetlania obrazów przed i po filtracji def displayImages(Image1, Image2, Title1="img1", Title2="img2"): # Konwersja obrazów na skalę szarości gray_image1 = Image1.convert("L") gray_image2 = Image2.convert("L") # Konwersja obrazów do numpy array img1_array = np.array(gray_image1) img2_array = np.array(gray_image2) # Wyświetlanie obrazów obok siebie plt.figure(figsize=(10, 5)) # Obraz 1 plt.subplot(1, 2, 1) plt.imshow(img1_array, cmap='gray') plt.title(Title1) plt.axis('off') # Wyłączanie osi # Obraz 2 plt.subplot(1, 2, 2) plt.imshow(img2_array, cmap='gray') plt.title(Title2) plt.axis('off') # Wyłączanie osi # Pokazanie obrazów plt.show() # Filtracja medianowa z różnymi maskami def apply_median_filter(image, mask_size): return ndimage.median_filter(image, size=mask_size) # Test dla obrazów z szumem: 'noised2.png', 'noised3.png', 'noised4.png' for noised_image, name in [(noised2, "Noised2"), (noised3, "Noised3"), (noised4, "Noised4")]: print(f"Processing {name}") # Konwersja do skali szarości i do tablicy numpy img_array = np.array(noised_image.convert("L")) # Wyświetlanie oryginalnego obrazu displayImages(noised_image, noised_image, f'{name} Original', f'{name} Original') # Filtracja medianowa z różnymi maskami i wyświetlanie wyników for mask_size in [(3, 3), (1, 5), (5, 1), (5, 5)]: filtered_image = apply_median_filter(img_array, mask_size) # Wyświetlanie obrazów przed i po filtracji filtered_pil_image = Image.fromarray(filtered_image) displayImages(noised_image, filtered_pil_image, f'{name} Original', f'{name} Filtered {mask_size}') Wyjaśnienie kodu: Wczytanie obrazów: Używamy PIL.Image.open() do wczytania obrazów z plików. Filtracja medianowa: Funkcja apply_median_filter() przyjmuje obraz i maskę filtracyjną (w postaci krotki, np. (3, 3)), a następnie stosuje funkcję scipy.ndimage.median_filter(), która wykonuje filtrację medianową na obrazie. Wyświetlanie przed i po filtracji: Funkcja displayImages() jest używana do wyświetlania obrazów przed i po zastosowaniu filtru. Obrazy są wyświetlane obok siebie w jednym oknie za pomocą matplotlib.pyplot. Wielokrotne użycie dla różnych masek: Dla każdego obrazu z szumem stosujemy różne maski filtracyjne (3x3, 1x5, 5x1, 5x5). Zmienność w trybie: Zmienność w funkcji median_filter może wystąpić na krawędziach obrazów. Parametr mode pozwala określić sposób radzenia sobie z tymi obszarami. Możesz wybrać tryb reflect, constant, nearest, mirror lub wrap w zależności od tego, jak chcesz obsłużyć krawędzie (tutaj używamy domyślnego trybu). Uwagi: Warto eksperymentować z trybem mode w funkcji median_filter, aby zobaczyć, jak to wpływa na wynik, zwłaszcza w obszarach krawędziowych. Funkcja apply_median_filter() może być dowolnie modyfikowana, aby dostosować sposób obsługi obrazu. You said: "### Zadanie C: Filtr ograniczający (erosion): Zdefiniowano dwa elementy strukturujące (wartości niezerowe w masce wskazują, które punkty obrazu brane są pod uwagę do przeprowadzenia operacji): * SquareMask - kwadratowy o rozmiarze 5x5, * CircleMask - kołowy o rozmiarze 5x5. Wykorzystaj podane kształty elementów strukturujących do przeprowadzenia filtracji ograniczającej - scipy.ndimage.grey_erosion (parametry $input$, $output$, $footprint$). Wykorzystaj funkcję z zadania A do wyświetlenia odpowiednich obrazów. Oceń wpływ: * filtracji ograniczającej na wygląd obrazu, * kształtu elementu strukturującego na wynik. * Powtórz operacje dla obrazów testowych 'noised2.png', 'noised3.png' i 'noised4.png'. Podpowiedź: scipy.ndimage.grey_erosion https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.grey_erosion.html#scipy.ndimage.grey_erosion " "#structuring element - defined in 1st block # SquareMask3x3, CircleMask3x3, SquareMask5x5, CircleMask5x5 #apply erosion filter #display results " ChatGPT said: ChatGPT Zadanie C dotyczy przeprowadzenia filtracji ograniczającej (erosji) na obrazach z wykorzystaniem dwóch typów elementów strukturujących: kwadratowego (SquareMask) i kołowego (CircleMask) o rozmiarze 5x5. W tym zadaniu użyjemy funkcji scipy.ndimage.grey_erosion do przeprowadzenia operacji erozji na obrazach z szumem. Ostatecznie wyświetlimy wyniki przed i po filtracji oraz ocenimy wpływ filtracji na obraz oraz kształt elementu strukturującego. Kroki do wykonania: Zdefiniowanie elementów strukturujących: Kwadratowy element strukturalny 5x5 i kołowy element strukturalny 5x5. Zastosowanie erozji: Użycie funkcji scipy.ndimage.grey_erosion() z odpowiednimi elementami strukturującymi. Wyświetlanie wyników: Użycie funkcji displayImages do wyświetlania wyników przed i po filtracji. Kod: import matplotlib.pyplot as plt import numpy as np from PIL import Image import scipy.ndimage as ndimage # Wczytywanie obrazów testowych z szumem noised2 = Image.open("noised2.png") noised3 = Image.open("noised3.png") noised4 = Image.open("noised4.png") # Zdefiniowanie elementów strukturujących SquareMask5x5 = np.ones((5, 5)) # Kwadrat 5x5 CircleMask5x5 = np.zeros((5, 5)) # Koło 5x5 # Tworzenie kołowego elementu strukturalnego o rozmiarze 5x5 # Koło w masce o rozmiarze 5x5, 1 w obszarze koła, 0 poza nim for i in range(5): for j in range(5): if (i - 2) ** 2 + (j - 2) ** 2 <= 4: # Wzór na okrąg o promieniu 2 CircleMask5x5[i, j] = 1 # Funkcja do wyświetlania obrazów przed i po filtracji def displayImages(Image1, Image2, Title1="img1", Title2="img2"): # Konwersja obrazów na skalę szarości gray_image1 = Image1.convert("L") gray_image2 = Image2.convert("L") # Konwersja obrazów do numpy array img1_array = np.array(gray_image1) img2_array = np.array(gray_image2) # Wyświetlanie obrazów obok siebie plt.figure(figsize=(10, 5)) # Obraz 1 plt.subplot(1, 2, 1) plt.imshow(img1_array, cmap='gray') plt.title(Title1) plt.axis('off') # Wyłączanie osi # Obraz 2 plt.subplot(1, 2, 2) plt.imshow(img2_array, cmap='gray') plt.title(Title2) plt.axis('off') # Wyłączanie osi # Pokazanie obrazów plt.show() # Filtracja ograniczająca z różnymi elementami strukturującymi def apply_erosion_filter(image, structuring_element): return ndimage.grey_erosion(image, footprint=structuring_element) # Test dla obrazów z szumem: 'noised2.png', 'noised3.png', 'noised4.png' for noised_image, name in [(noised2, "Noised2"), (noised3, "Noised3"), (noised4, "Noised4")]: print(f"Processing {name}") # Konwersja do skali szarości i do tablicy numpy img_array = np.array(noised_image.convert("L")) # Wyświetlanie oryginalnego obrazu displayImages(noised_image, noised_image, f'{name} Original', f'{name} Original') # Filtracja ograniczająca z kwadratowym elementem strukturującym 5x5 erosion_result_square = apply_erosion_filter(img_array, SquareMask5x5) erosion_image_square = Image.fromarray(erosion_result_square) displayImages(noised_image, erosion_image_square, f'{name} Original', f'{name} Erosion Square 5x5') # Filtracja ograniczająca z kołowym elementem strukturującym 5x5 erosion_result_circle = apply_erosion_filter(img_array, CircleMask5x5) erosion_image_circle = Image.fromarray(erosion_result_circle) displayImages(noised_image, erosion_image_circle, f'{name} Original', f'{name} Erosion Circle 5x5') Wyjaśnienie kodu: Elementy strukturujące: Kwadratowa maska 5x5: Jest to po prostu macierz 5x5 wypełniona jedynkami. Każdy piksel w obrębie tego elementu strukturalnego zostanie uwzględniony w operacji erozji. Kołowa maska 5x5: Tworzymy maskę, w której 1 znajduje się w obszarze koła o promieniu 2 w obrębie 5x5, a pozostałe miejsca są zerami. Do tego celu używamy wzoru na okrąg w przestrzeni dyskretnej. Filtracja ograniczająca (erosja): Używamy funkcji scipy.ndimage.grey_erosion(), która wykonuje operację erozji obrazu na podstawie przekazanego elementu strukturalnego (SquareMask5x5 lub CircleMask5x5). Erozja polega na "skurczeniu" jasnych obszarów obrazu, z zachowaniem tylko tych pikseli, które są w pełni zgodne z elementem strukturalnym (tzn. muszą być w pełni "pokryte" przez element). Wyświetlanie wyników: Wyniki przed i po filtracji są wyświetlane obok siebie z wykorzystaniem funkcji displayImages(), aby porównać wpływ operacji na obraz. Podsumowanie: Filtracja ograniczająca (erosja) zmienia obraz, zmniejszając jasne obszary i eliminując szczegóły, które nie pasują do struktury elementu. W szczególności, jeśli użyjemy maski kwadratowej, możemy uzyskać bardziej "ostre" krawędzie, podczas gdy maska kołowa może zaokrąglić krawędzie. Kształt elementu strukturującego wpływa na to, które obszary obrazu są "skurczone" — element kwadratowy powoduje bardziej prostokątne zmiany, natomiast element kołowy działa bardziej zaokrąglająco. Dalsze uwagi: Warto eksperymentować z różnymi elementami strukturującymi oraz z różnymi obrazami, aby lepiej zobaczyć wpływ tej operacji na różne typy obrazów (np. obrazy z szumem vs. obrazy bez szumu). You said: "### Zadanie D: Filtr rozszerzający (dilation): Wykorzystaj wcześniej podane kształty elementów strukturujących do przeprowadzenia filtracji rozszerzającej - scipy.ndimage.grey_dilation (parametry $input$, $output$, $footprint$). Wykorzystaj funkcję z zadania A do wyświetlenia odpowiednich obrazów. Oceń wpływ: * filtracji ograniczającej na wygląd obrazu, * kształtu elementu strukturującego na wynik. * Powtórz operacje dla obrazów testowych 'noised2.png', 'noised3.png' i 'noised4.png'. Podpowiedź: scipy.ndimage.grey_dilation https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.grey_dilation.html#scipy.ndimage.grey_dilation" "#structuring element - defined in 1st block # SquareMask3x3, CircleMask3x3, SquareMask5x5, CircleMask5x5 #apply dilation filter #display results " ChatGPT said: ChatGPT Zadanie D dotyczy przeprowadzenia filtracji rozszerzającej (dilacji) na obrazach przy użyciu wcześniej zdefiniowanych elementów strukturujących (kwadratowego i kołowego) o rozmiarze 5x5. Operacja dilacji rozszerza jasne obszary obrazu, "rozciągając" je na sąsiednie piksele. Będziemy wykorzystywać funkcję scipy.ndimage.grey_dilation do przeprowadzenia tej filtracji. Kroki do wykonania: Zdefiniowanie elementów strukturujących: Kwadratowy i kołowy element strukturalny o rozmiarze 5x5. Zastosowanie dilacji: Użycie funkcji scipy.ndimage.grey_dilation() z odpowiednimi elementami strukturującymi. Wyświetlenie wyników: Użycie funkcji displayImages do wyświetlania wyników przed i po filtracji. Kod: import matplotlib.pyplot as plt import numpy as np from PIL import Image import scipy.ndimage as ndimage # Wczytywanie obrazów testowych z szumem noised2 = Image.open("noised2.png") noised3 = Image.open("noised3.png") noised4 = Image.open("noised4.png") # Zdefiniowanie elementów strukturujących SquareMask5x5 = np.ones((5, 5)) # Kwadrat 5x5 CircleMask5x5 = np.zeros((5, 5)) # Koło 5x5 # Tworzenie kołowego elementu strukturalnego o rozmiarze 5x5 # Koło w masce o rozmiarze 5x5, 1 w obszarze koła, 0 poza nim for i in range(5): for j in range(5): if (i - 2) ** 2 + (j - 2) ** 2 <= 4: # Wzór na okrąg o promieniu 2 CircleMask5x5[i, j] = 1 # Funkcja do wyświetlania obrazów przed i po filtracji def displayImages(Image1, Image2, Title1="img1", Title2="img2"): # Konwersja obrazów na skalę szarości gray_image1 = Image1.convert("L") gray_image2 = Image2.convert("L") # Konwersja obrazów do numpy array img1_array = np.array(gray_image1) img2_array = np.array(gray_image2) # Wyświetlanie obrazów obok siebie plt.figure(figsize=(10, 5)) # Obraz 1 plt.subplot(1, 2, 1) plt.imshow(img1_array, cmap='gray') plt.title(Title1) plt.axis('off') # Wyłączanie osi # Obraz 2 plt.subplot(1, 2, 2) plt.imshow(img2_array, cmap='gray') plt.title(Title2) plt.axis('off') # Wyłączanie osi # Pokazanie obrazów plt.show() # Filtracja rozszerzająca z różnymi elementami strukturującymi def apply_dilation_filter(image, structuring_element): return ndimage.grey_dilation(image, footprint=structuring_element) # Test dla obrazów z szumem: 'noised2.png', 'noised3.png', 'noised4.png' for noised_image, name in [(noised2, "Noised2"), (noised3, "Noised3"), (noised4, "Noised4")]: print(f"Processing {name}") # Konwersja do skali szarości i do tablicy numpy img_array = np.array(noised_image.convert("L")) # Wyświetlanie oryginalnego obrazu displayImages(noised_image, noised_image, f'{name} Original', f'{name} Original') # Filtracja rozszerzająca z kwadratowym elementem strukturującym 5x5 dilation_result_square = apply_dilation_filter(img_array, SquareMask5x5) dilation_image_square = Image.fromarray(dilation_result_square) displayImages(noised_image, dilation_image_square, f'{name} Original', f'{name} Dilation Square 5x5') # Filtracja rozszerzająca z kołowym elementem strukturującym 5x5 dilation_result_circle = apply_dilation_filter(img_array, CircleMask5x5) dilation_image_circle = Image.fromarray(dilation_result_circle) displayImages(noised_image, dilation_image_circle, f'{name} Original', f'{name} Dilation Circle 5x5') Wyjaśnienie kodu: Elementy strukturujące: Kwadratowa maska 5x5: Jest to macierz 5x5 wypełniona jedynkami, co oznacza, że podczas operacji rozszerzającej bierze się pod uwagę wszystkie sąsiednie piksele w obrębie kwadratu. Kołowa maska 5x5: Tworzymy maskę o rozmiarze 5x5, w której piksele o wartości 1 znajdują się w obrębie koła o promieniu 2 (w przestrzeni dyskretnej), a pozostałe są zerami. Filtracja rozszerzająca (dilacja): Używamy funkcji scipy.ndimage.grey_dilation(), która wykonuje operację dilacji na obrazie przy użyciu przekazanego elementu strukturalnego. Działanie dilacji polega na "rozciąganiu" jasnych obszarów obrazu, przez co ciemniejsze obszary zostają powiększone. Wynikiem dilacji jest obraz, w którym każdy piksel jest ustawiany na największą wartość spośród pikseli, które są objęte elementem strukturalnym. Wyświetlanie wyników: Przed i po zastosowaniu dilacji wyświetlamy obrazy obok siebie, aby porównać wpływ operacji na obraz. Używamy funkcji displayImages() do prezentacji wyników. Podsumowanie: Filtracja rozszerzająca (dilacja) powoduje, że jasne obszary obrazu stają się bardziej rozciągnięte, a ciemniejsze obszary mogą zostać "wypełnione". Obszary, które były wcześniej małe lub cienkie, mogą stać się większe i bardziej widoczne. Kształt elementu strukturującego wpływa na wynik dilacji. Element kwadratowy prowadzi do rozciągania wzdłuż prostokątnych krawędzi, podczas gdy element kołowy powoduje bardziej zaokrąglone rozszerzenie. Uwagi: Warto eksperymentować z różnymi rozmiarami elementów strukturujących oraz różnymi obrazami, aby zobaczyć, jak dilacja wpływa na różne typy obrazów (np. obrazy z szumem vs. obrazy o wysokiej rozdzielczości). You said: "### Zadanie E: Filtr otwierający (opening): Wykorzystaj wcześniej podane kształty elementów strukturujących do przeprowadzenia filtracji otwarcia - scipy.ndimage.grey_opening (parametry $input$, $output$, $footprint$). Wykorzystaj funkcję z zadania A do wyświetlenia odpowiednich obrazów. Oceń wpływ: * filtracji otwierającej na wygląd obrazu, * kształtu elementu strukturującego na wynik. * Powtórz operacje dla obrazów testowych 'noised2.png', 'noised3.png' i 'noised4.png'. Podpowiedź: scipy.ndimage.grey_opening https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.grey_opening.html#scipy.ndimage.grey_opening" "#structuring element - defined in 1st block # SquareMask3x3, CircleMask3x3, SquareMask5x5, CircleMask5x5 #apply opening filter #display results " ChatGPT said: ChatGPT Zadanie E dotyczy przeprowadzenia filtracji otwierającej (opening) na obrazach z wykorzystaniem wcześniej zdefiniowanych elementów strukturujących (kwadratowego i kołowego) o rozmiarze 5x5. Filtracja otwierająca jest kombinacją dwóch operacji: erozji, a następnie dilacji. Celem jest usunięcie małych jasnych obiektów (np. szumu) z obrazu, przy zachowaniu kształtów większych obiektów. Kroki do wykonania: Zdefiniowanie elementów strukturujących: Kwadratowy i kołowy element strukturalny o rozmiarze 5x5. Zastosowanie filtru otwierającego: Użycie funkcji scipy.ndimage.grey_opening() z odpowiednimi elementami strukturującymi. Wyświetlanie wyników: Użycie funkcji displayImages do wyświetlania wyników przed i po filtracji. Kod: import matplotlib.pyplot as plt import numpy as np from PIL import Image import scipy.ndimage as ndimage # Wczytywanie obrazów testowych z szumem noised2 = Image.open("noised2.png") noised3 = Image.open("noised3.png") noised4 = Image.open("noised4.png") # Zdefiniowanie elementów strukturujących SquareMask5x5 = np.ones((5, 5)) # Kwadrat 5x5 CircleMask5x5 = np.zeros((5, 5)) # Koło 5x5 # Tworzenie kołowego elementu strukturalnego o rozmiarze 5x5 # Koło w masce o rozmiarze 5x5, 1 w obszarze koła, 0 poza nim for i in range(5): for j in range(5): if (i - 2) ** 2 + (j - 2) ** 2 <= 4: # Wzór na okrąg o promieniu 2 CircleMask5x5[i, j] = 1 # Funkcja do wyświetlania obrazów przed i po filtracji def displayImages(Image1, Image2, Title1="img1", Title2="img2"): # Konwersja obrazów na skalę szarości gray_image1 = Image1.convert("L") gray_image2 = Image2.convert("L") # Konwersja obrazów do numpy array img1_array = np.array(gray_image1) img2_array = np.array(gray_image2) # Wyświetlanie obrazów obok siebie plt.figure(figsize=(10, 5)) # Obraz 1 plt.subplot(1, 2, 1) plt.imshow(img1_array, cmap='gray') plt.title(Title1) plt.axis('off') # Wyłączanie osi # Obraz 2 plt.subplot(1, 2, 2) plt.imshow(img2_array, cmap='gray') plt.title(Title2) plt.axis('off') # Wyłączanie osi # Pokazanie obrazów plt.show() # Filtracja otwierająca z różnymi elementami strukturującymi def apply_opening_filter(image, structuring_element): return ndimage.grey_opening(image, footprint=structuring_element) # Test dla obrazów z szumem: 'noised2.png', 'noised3.png', 'noised4.png' for noised_image, name in [(noised2, "Noised2"), (noised3, "Noised3"), (noised4, "Noised4")]: print(f"Processing {name}") # Konwersja do skali szarości i do tablicy numpy img_array = np.array(noised_image.convert("L")) # Wyświetlanie oryginalnego obrazu displayImages(noised_image, noised_image, f'{name} Original', f'{name} Original') # Filtracja otwierająca z kwadratowym elementem strukturującym 5x5 opening_result_square = apply_opening_filter(img_array, SquareMask5x5) opening_image_square = Image.fromarray(opening_result_square) displayImages(noised_image, opening_image_square, f'{name} Original', f'{name} Opening Square 5x5') # Filtracja otwierająca z kołowym elementem strukturującym 5x5 opening_result_circle = apply_opening_filter(img_array, CircleMask5x5) opening_image_circle = Image.fromarray(opening_result_circle) displayImages(noised_image, opening_image_circle, f'{name} Original', f'{name} Opening Circle 5x5') Wyjaśnienie kodu: Elementy strukturujące: Kwadratowa maska 5x5: Jest to macierz 5x5 wypełniona jedynkami. Oznacza to, że podczas operacji otwierającej wszystkie piksele w obrębie kwadratu są uwzględniane w operacji erozji i dilacji. Kołowa maska 5x5: To maska, w której 1 znajduje się w obszarze koła o promieniu 2, a pozostałe miejsca są zerami. Taki element strukturalny może usunąć małe, nieregularne zbiory pikseli. Filtracja otwierająca (opening): Filtr otwierający to operacja składająca się z dwóch etapów: Erozja: Usuń małe jasne obszary. Dilacja: Przywróć pierwotny kształt większych obiektów, ale nie zmieniając tych, które zostały usunięte podczas erozji. Funkcja scipy.ndimage.grey_opening() wykonuje oba kroki: najpierw erozję z określonym elementem strukturującym, a następnie dilację. Wyświetlanie wyników: Obrazy przed i po zastosowaniu filtru otwierającego wyświetlane są obok siebie za pomocą funkcji displayImages(). Podsumowanie: Filtracja otwierająca (opening) jest szczególnie użyteczna w usuwaniu małych jasnych obiektów, takich jak szum, z obrazu. Działa to poprzez usunięcie drobnych szczegółów podczas erozji i przywrócenie kształtu większych obiektów podczas dilacji. Kształt elementu strukturującego wpływa na wynik operacji. Element kwadratowy prowadzi do "prostszych" zmian w obrazie (wzdłuż prostokątnych krawędzi), podczas gdy element kołowy może prowadzić do bardziej zaokrąglonych efektów. Dalsze uwagi: Eksperymentowanie z różnymi rozmiarami elementów strukturujących oraz różnymi typami obrazów pozwoli zobaczyć, jak różne obrazy reagują na filtrację otwierającą (np. obrazy z szumem vs. obrazy o wysokiej jakości). You said: "### Zadanie F: Filtr zamykający (closing): Wykorzystaj wcześniej podane kształty elementów strukturujących do przeprowadzenia filtracji zamknięcia - scipy.ndimage.grey_closing (parametry $input$, $output$, $footprint$). Wykorzystaj funkcję z zadania A do wyświetlenia odpowiednich obrazów. Oceń wpływ: * filtracji otwierającej na wygląd obrazu, * kształtu elementu strukturującego na wynik. * Powtórz operacje dla obrazów testowych 'noised2.png', 'noised3.png' i 'noised4.png'. Podpowiedź: scipy.ndimage.grey_closing https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.grey_closing.html#scipy.ndimage.grey_closing" "#structuring element - defined in 1st block # SquareMask3x3, CircleMask3x3, SquareMask5x5, CircleMask5x5 #apply closing filter #display results " ChatGPT said: ChatGPT Zadanie F dotyczy przeprowadzenia filtracji zamknięcia (closing) na obrazach z wykorzystaniem wcześniej zdefiniowanych elementów strukturujących (kwadratowego i kołowego) o rozmiarze 5x5. Filtracja zamknięcia to operacja odwrotna do filtracji otwierającej — najpierw wykonujemy dilację, a następnie erozję. Celem jest usunięcie małych ciemnych obiektów (np. szumów) i "wypełnienie" małych dziur w większych obiektach obrazu. Kroki do wykonania: Zdefiniowanie elementów strukturujących: Kwadratowy i kołowy element strukturalny o rozmiarze 5x5. Zastosowanie filtru zamykającego: Użycie funkcji scipy.ndimage.grey_closing() z odpowiednimi elementami strukturującymi. Wyświetlanie wyników: Użycie funkcji displayImages do wyświetlania wyników przed i po filtracji. Kod: import matplotlib.pyplot as plt import numpy as np from PIL import Image import scipy.ndimage as ndimage # Wczytywanie obrazów testowych z szumem noised2 = Image.open("noised2.png") noised3 = Image.open("noised3.png") noised4 = Image.open("noised4.png") # Zdefiniowanie elementów strukturujących SquareMask5x5 = np.ones((5, 5)) # Kwadrat 5x5 CircleMask5x5 = np.zeros((5, 5)) # Koło 5x5 # Tworzenie kołowego elementu strukturalnego o rozmiarze 5x5 # Koło w masce o rozmiarze 5x5, 1 w obszarze koła, 0 poza nim for i in range(5): for j in range(5): if (i - 2) ** 2 + (j - 2) ** 2 <= 4: # Wzór na okrąg o promieniu 2 CircleMask5x5[i, j] = 1 # Funkcja do wyświetlania obrazów przed i po filtracji def displayImages(Image1, Image2, Title1="img1", Title2="img2"): # Konwersja obrazów na skalę szarości gray_image1 = Image1.convert("L") gray_image2 = Image2.convert("L") # Konwersja obrazów do numpy array img1_array = np.array(gray_image1) img2_array = np.array(gray_image2) # Wyświetlanie obrazów obok siebie plt.figure(figsize=(10, 5)) # Obraz 1 plt.subplot(1, 2, 1) plt.imshow(img1_array, cmap='gray') plt.title(Title1) plt.axis('off') # Wyłączanie osi # Obraz 2 plt.subplot(1, 2, 2) plt.imshow(img2_array, cmap='gray') plt.title(Title2) plt.axis('off') # Wyłączanie osi # Pokazanie obrazów plt.show() # Filtracja zamykająca z różnymi elementami strukturującymi def apply_closing_filter(image, structuring_element): return ndimage.grey_closing(image, footprint=structuring_element) # Test dla obrazów z szumem: 'noised2.png', 'noised3.png', 'noised4.png' for noised_image, name in [(noised2, "Noised2"), (noised3, "Noised3"), (noised4, "Noised4")]: print(f"Processing {name}") # Konwersja do skali szarości i do tablicy numpy img_array = np.array(noised_image.convert("L")) # Wyświetlanie oryginalnego obrazu displayImages(noised_image, noised_image, f'{name} Original', f'{name} Original') # Filtracja zamykająca z kwadratowym elementem strukturującym 5x5 closing_result_square = apply_closing_filter(img_array, SquareMask5x5) closing_image_square = Image.fromarray(closing_result_square) displayImages(noised_image, closing_image_square, f'{name} Original', f'{name} Closing Square 5x5') # Filtracja zamykająca z kołowym elementem strukturującym 5x5 closing_result_circle = apply_closing_filter(img_array, CircleMask5x5) closing_image_circle = Image.fromarray(closing_result_circle) displayImages(noised_image, closing_image_circle, f'{name} Original', f'{name} Closing Circle 5x5') Wyjaśnienie kodu: Elementy strukturujące: Kwadratowa maska 5x5: Jest to macierz 5x5 wypełniona jedynkami. Oznacza to, że podczas operacji zamknięcia wszystkie piksele w obrębie kwadratu są uwzględniane w operacji dilacji i erozji. Kołowa maska 5x5: Tworzymy maskę o rozmiarze 5x5, w której piksele o wartości 1 znajdują się w obrębie koła o promieniu 2, a pozostałe miejsca są zerami. Taki element strukturalny może wypełnić małe dziury w obrazie. Filtracja zamykająca (closing): Dilacja: Najpierw wykonujemy dilację, która "rozciąga" ciemne obszary obrazu. Erozja: Następnie stosujemy erozję, która przywraca obszar obrazu, ale usuwając małe, ciemne obiekty. Funkcja scipy.ndimage.grey_closing() wykonuje oba kroki (dilację i erozję) w tej kolejności. Wyświetlanie wyników: Obrazy przed i po zastosowaniu filtru zamykającego wyświetlane są obok siebie za pomocą funkcji displayImages(), co pozwala na łatwe porównanie wyników filtracji. Podsumowanie: Filtracja zamykająca (closing) jest przydatna do wypełniania małych dziur w obiektach ciemnych na obrazie oraz do eliminowania małych, ciemnych obiektów, takich jak szumy, które mogą zostać usunięte w procesie erozji. Kształt elementu strukturującego wpływa na efekt operacji. Element kwadratowy ma tendencję do wypełniania prostokątnych kształtów, podczas gdy element kołowy powoduje bardziej naturalne, zaokrąglone wypełnienie. Uwagi: Eksperymentowanie z różnymi rozmiarami elementów strukturujących oraz różnymi typami obrazów pozwoli zobaczyć, jak różne obrazy reagują na filtrację zamykającą (np. obrazy z szumem vs. obrazy o wysokiej jakości). ChatGPT can make mistakes. Check important info.