praca dyplomowa magisterska - serwer...
TRANSCRIPT
POLITECHNIKA WARSZAWSKA
Wydział Elektroniki i Technik Informacyjnych
Instytut Radioelektroniki
Rok akademicki 2010/2011
PRACA DYPLOMOWA – MAGISTERSKA
Adam Strupczewski
AUTOMATYCZNE SORTOWANIE OBRAZÓW
Kierownik pracy:
dr inż. Grzegorz Galiński
Ocena ...........................................
...........................................
Podpis Przewodniczącego
Komisji Egzaminu Dyplomowego
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 2
Adam Strupczewski
Specjalność: Radiokomunikacja i Techniki Multimedialne
Data urodzenia: 14.05.1987
Data rozpoczęcia studiów: 01.10.2005
ŻYCIORYS
Urodziłem się 14 maja 1987 roku w Warszawie. Swoje dzieciństwo spędziłem w Warszawie i
Wiedniu, gdzie mieszkałem w latach 1994-1999. Uczęszczałem tam do Vienna International School
- międzynarodowej szkoły z wykładowym angielskim. Równolegle uczyłem się w weekendy w
polskiej szkole, gdzie w roku szkolnym 1997/1998 przerobiłem materiał z dwóch kolejnych klas
nauczania, zdając egzaminy komisyjne z obydwu poziomów ze znakomitymi wynikami. Naukę w
gimnazjum kontynuowałem już w Warszawie. W 2002 roku poszedłem do renomowanego liceum
im. Władysława IV, w której to szkole odniosłem liczne sukcesy w konkursach matematycznych i
fizycznych. Naukę zdecydowałem się kontynuować na Politechnice Warszawskiej, na wydziale
Elektroniki i Technik Informacyjnych. W trakcie moich studiów wziąłem udział w programie
Erasmus i przez rok studiowałem na Coventry University w Anglii. Udało mi się w trakcie tego roku
napisać pracę inżynierską na angielskim uniwersytecie i uzyskać w 2009 roku tytuł Bachelor of
Science in Informatics. W lecie 2010 roku odbyłem 3-miesięczny staż w Międzynarodowej Agencji
Energii Atomowej (IAEA) w Wiedniu, w zakresie systemów I&C. W styczniu 2011 roku rozpocząłem
pracę na pełen etat jako programista w firmie Samsung Electronics.
........................................
podpis
EGZAMIN DYPLOMOWY
Złożył egzamin dyplomowy w dniu ................................
z wynikiem .....................................................................
Ogólny wynik studiów ...................................................
Dodatkowe uwagi i wnioski Komisji ..............................
........................................................................................
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 3
Streszczenie
Praca dotyczy automatycznego sortowania obrazów cyfrowych na podstawie ich wizualnego
podobieństwa. Zawartość cyfrowych obrazów można opisać za pomocą cech liczbowych – na
przykład deskryptorów standardu MPEG-7. Następnie można tak opisane obrazy posortować
szeregując owe deskryptory / cechy. Tym samym, dokonywane jest automatyczne sortowanie,
które nie wymaga na żadnym etapie ingerencji człowieka. Jest ono potencjalnie bardzo pożyteczne
wobec ogromu treści multimedialnych we współczesnym świecie.
Niniejsza praca ma na celu zbadanie różnych możliwości automatycznego sortowania
obrazów (danych wielowymiarowych), określenie jego jakości i porównanie wyników z oceną
subiektywną. W pracy opisane są po kolei deskryptory użyte do opisu zawartości obrazów, użyte
algorytmy sortujące oraz wyniki sortowania z wybranymi deskryptorami i algorytmami. Na koniec
uzyskane wyniki są porównane ze sobą i zebrane są wnioski.
W ramach pracy została stworzona aplikacja demonstracyjna, która w przejrzysty sposób
obrazuje takie automatyczne sortowanie. Plik wykonywalny aplikacji, jej kody źródłowe oraz
krótka instrukcja obsługi znajdują się na płycie załączonej do niniejszej pracy.
Automatic Image Sorting
Summary
The thesis concentrates on automatic, content-based image sorting. The content of a digital image
can be described by a set of numbers – for instance by so called descriptors of the MPEG-7
standard. Images described in this fashion can be sorted simply by organizing the sets of numbers
associated with them. Thus automatic image sorting not requiring any human action is performed.
This approach is potentially very useful, as the amount of digital media grows ever more quickly in
the contemporary world.
This report aims at investigating different variations of such sorting, determining its
accuracy and comparing its results with subjective assessment. The report describes the
descriptors used for image content description, the algorithms used for descriptor sorting as well
as the results of sorting when using chosen descriptors and sorting algorithms. Finally, the
obtained results are compared with each other and conclusions are stated.
As part of the thesis, the author created a demonstrational application which visualizes
such automatic image sorting in a clear and accessible way. The application executable, the source
code and a short manual are on the CD attached to this report.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 4
Spis treści
1. Wstęp .................................................................................................................................... 6
1.1. Wprowadzenie .......................................................................................................................... 6
1.2. Cele pracy .................................................................................................................................. 7
1.3. Struktura pracy.......................................................................................................................... 8
2. Idea automatycznego sortowania obrazów ............................................................................ 9
2.1. Sortowanie jednowymiarowe ................................................................................................... 9
2.2. Sortowanie wielowymiarowe ................................................................................................. 10
3. Deskryptory MPEG-7 ............................................................................................................ 12
3.1. Klasyfikacja deskryptorów MPEG-7 ........................................................................................ 12
3.2. Deskryptory użyte do badań ................................................................................................... 13
3.2.1. Color Layout ..................................................................................................................... 13
3.2.2. Scalable Color ................................................................................................................... 15
3.2.3. Color Structure ................................................................................................................. 19
3.2.4. Color Temperature Browsing ........................................................................................... 22
4. Algorytmy sortujące dane wielowymiarowe ......................................................................... 25
4.1. Zaimplementowane algorytmy ............................................................................................... 25
4.1.1. Mapy samoorganizujące się (SOM) .................................................................................. 25
4.1.2. Rozkład na składowe główne (ang. Principal Component Analysis) ................................ 29
4.1.3. Algorytm FastMap ............................................................................................................ 32
4.1.4. Porównanie PCA i FastMap .............................................................................................. 34
4.1.5. Algorytm Mutual-Rank Similarity-Space .......................................................................... 36
4.1.6. Zmodyfikowany PCA ......................................................................................................... 37
4.2. Inne Algorytmy ........................................................................................................................ 38
4.2.1. N-Land .............................................................................................................................. 38
4.2.2. Metoda K-średnich ........................................................................................................... 39
5. Zrealizowana aplikacja ......................................................................................................... 42
5.1. Wybór narzędzi ....................................................................................................................... 42
5.1.1. Wybór języka programowania ......................................................................................... 42
5.1.2. Wybór bibliotek ................................................................................................................ 43
5.2. Ogólna architektura i logika programu ................................................................................... 44
5.2.1. Funkcjonalność ................................................................................................................. 44
5.2.2. Logika i przegląd klas ........................................................................................................ 46
5.3. Interfejs Graficzny (GUI).......................................................................................................... 47
5.4. Szczególne problemy napotkane w trakcie implementacji .................................................... 51
5.4.1. Pamięć zajmowana przez ładowane obrazy .................................................................... 51
5.4.2. Szybkość ładowania obrazów ........................................................................................... 52
5.4.3. Szybkość i jakość sortowania ........................................................................................... 52
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 5
5.5. Elementy zrealizowane w ramach pracy inżynierskiej na Coventry University ...................... 53
5.5.1. Słowa kluczowe ................................................................................................................ 53
5.5.2. Operacje na obrazach ....................................................................................................... 54
6. Testy i ich rezultaty .............................................................................................................. 55
6.1. Porównanie deskryptorów...................................................................................................... 55
6.1.1. Czas ekstrakcji deskryptorów ........................................................................................... 55
6.1.2. Wizualne różnice w wyniku sortowania ........................................................................... 56
6.2. Ogólne porównanie algorytmów ............................................................................................ 61
6.2.1. SOM .................................................................................................................................. 61
6.2.2. FastMap ............................................................................................................................ 63
6.2.3. PCA dla deskryptorów ...................................................................................................... 64
6.2.4. PCA dla macierzy odległości ............................................................................................. 65
6.2.5. Mutual-Rank Similarity-Space .......................................................................................... 66
6.3. Szybkościowe porównanie algorytmów ................................................................................. 69
6.3.1. Analiza teoretyczna złożoności obliczeniowej ................................................................. 69
6.3.2. Wyniki empiryczne ........................................................................................................... 70
6.4. Jakościowe porównanie algorytmów ..................................................................................... 72
6.4.1. Przygotowanie testu ......................................................................................................... 72
4.6.2. Wyniki testu...................................................................................................................... 75
7. Wnioski końcowe ................................................................................................................. 78
7.1. Uzyskane wyniki ...................................................................................................................... 78
7.2. Dalsze prace ............................................................................................................................ 78
Literatura ................................................................................................................................ 80
Załącznik A – Porównanie bibliotek do tworzenia GUI .............................................................. 83
Załącznik B – Tabela oceny podobieństwa 50 obrazów ............................................................. 84
Załącznik C – Analiza podobnych programów ........................................................................... 85
C-1. Ogólny przegląd oprogramowania sortującego obrazy ......................................................... 85
C-2. Program Caliph & Emir ........................................................................................................... 87
C-3. System PicSOM ....................................................................................................................... 89
C-4. Program ImageSorter ............................................................................................................. 90
Załącznik D – Opis zawartości płyty CD ..................................................................................... 91
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 6
1. Wstęp
1.1. Wprowadzenie
Ilość informacji elektronicznych we współczesnym świecie zwiększa się wciąż szybciej i szybciej.
Obecnie roczny przyrost informacji szacuje się na niemal milion terabajtów, z czego ponad połowa
to cyfrowe obrazy [Skarbek 2009]. Wobec takiego ogromu danych staje się oczywiste, jak bardzo
zyskuje na znaczeniu skuteczne sortowanie i organizacja tych danych.
W przypadku cyfrowych obrazów istnieje od dawna wiele klasycznych metod sortowania,
takich jak sortowanie według nazw, rozmiarów czy dat stworzenia pliku. Jednakże, przy pracy z
bardzo dużymi zbiorami obrazów, takie metody mogą okazać się niewystarczające. Można sobie
łatwo wyobrazić, że użytkownik chce znaleźć obraz o określonej zawartości – np. przedstawiający
autobus. Wówczas klasyczne sortowanie nie da zadowalających rezultatów, nawet jeśli wszystkie
obrazy będą miały adekwatne tytuły – co dziś jest coraz większą rzadkością wobec ogromu danych
multimedialnych.
Aby rozwiązać ten problem, powstały systemy wyszukiwania na podstawie zawartości
(ang. Content Based Image Retrieval, CBIR). Polegają one na tym, że użytkownik może wskazać
obrazek wzorcowy i system wyszuka obrazy podobne do wskazanego. Jest to stosunkowo nowa
koncepcja wyszukiwania i nie jest jeszcze w pełni rozwinięta, jednak już teraz widać jak bardzo
dużą rolę może pełnić w niedalekiej przyszłości.
Co się jednak stanie, gdy użytkownik nie będzie miał pod ręką obrazu wzorcowego, lub też
nie będzie wiedział jak zdefiniować cel swoich poszukiwań? Jeśli w tej sytuacji będzie chciał szybko
znaleźć obrazy o podobnej treści wybierając je z dużego zbioru, system CBIR będzie bezużyteczny.
Istnieje jednak kolejna, nowa koncepcja systemu, który umożliwi szybkie wyszukiwanie właśnie w
takim przypadku. Jest to koncepcja automatycznego sortowania na podstawie zawartości.
Ten rozwijany w ciągu ostatnich lat pomysł zakłada automatyczne rozpoznawanie
zawartości obrazu i sortowanie na tej podstawie. Automatyczność jest tu rozumiana jako proces
nie wymagający ingerencji człowieka – za wszystko odpowiedzialny jest tylko i wyłącznie
komputer. Dzięki takiemu systemowi, nawet w przypadku braku jakichkolwiek obrazów
wzorcowych, użytkownik może szybko znaleźć obrazy o zadanym charakterze [Barthel 2008].
Z tego względu, że ludzie mają coraz mniej czasu na ‘ręczne’ klasyfikowanie zawartości
multimediów, automatyczna ekstrakcja wizualnych cech i ich porządkowanie nabierają coraz
więcej znaczenia. Pomysł automatycznego sortowania jest z tego względu warty zbadania i
rozwijania, gdyż potencjalnie ma wiele do zaoferowania.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 7
1.2. Cele pracy
Aby zrealizować skutecznie jakikolwiek projekt, jego cele muszą być możliwie jasno określone od
samego początku. Tak też było w przypadku niniejszej pracy. Założone elementy – w ich
ostatecznej formie – są wypunktowane poniżej. Należy jednak zaznaczyć, że zadania stawiane
przed pracą były w miarę upływu czasu nieco modyfikowane, tak by na bieżąco uwzględniać
osiągane wyniki i kierować dalszą pracę w możliwie najpożyteczniejszym kierunku. Ostatecznie
główne cele pracy magisterskiej można określić jako:
1. Zapoznanie się z opisem obrazów cyfrowych za pomocą deskryptorów standardu
MPEG-7, ze szczególnym uwzględnieniem deskryptorów koloru. Ponadto wybór
deskryptorów, które zostaną użyte w dalszej pracy.
2. Zapoznanie się z algorytmami używanymi do sortowania danych wielowymiarowych, w
szczególności z mapami samoorganizującymi się (ang. Self Organizing Maps, SOM) oraz
wybór algorytmów, które zostaną użyte w dalszej pracy.
3. Stworzenie aplikacji, która umożliwi sortowanie obrazów cyfrowych różnymi metodami.
W szczególności, stworzona aplikacja powinna umożliwiać:
i. Użycie różnych deskryptorów do opisu obrazów cyfrowych
ii. Użycie różnych algorytmów do sortowania danych wielowymiarowych –
deskryptorów opisujących obrazy cyfrowe
iii. Zobrazowanie wyników wybranego sortowania w graficznym interfejsie
4. Przetestowanie różnych wariantów sortowania: deskryptorów i algorytmów
sortujących. Zbadanie przydatności automatycznego sortowania w różnych wariantach.
5. Porównanie szybkości i jakości różnych wariantów automatycznego sortowania;
odniesienie wyników do oceny subiektywnej; próba określenia właściwego kierunku w
przyszłych pracach dotyczących automatycznego sortowania.
6. Zestawienie wszystkich zgromadzonych wyników w jasny i przejrzysty sposób, próba ich
oceny i wyciągnięcie wniosków końcowych.
Poza głównymi celami można wyodrębnić jeszcze rozmaite cele poboczne, które siłą rzeczy
musiały zostać zrealizowane w toku pisania pracy. Są to między innymi:
analiza istniejącego oprogramowania, które nawiązuje do idei automatycznego sortowania
obrazów ;
analiza języków programowania i bibliotek w celu wybrania najodpowiedniejszej
kombinacji do napisania aplikacji demonstracyjnej.
Powyższe i inne cele poboczne nie są jednak zbyt istotne z punktu widzenia ogółu pracy, dlatego za
wyjątkiem analizy podobnego oprogramowania, która została przeprowadzona w załączniku C, nie
będą szczegółowo omówione.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 8
1.3. Struktura pracy
Praca składa się z siedmiu rozdziałów. Są one uporządkowane w taki sposób, by czytelnik mógł
łatwo zrozumieć zagadnienia automatycznego sortowania oraz badania i testy mające ocenić różne
jego warianty. Najpierw omawiane są zagadnienia teoretyczne, a następnie to, co zostało
wykonane w ramach niniejszej pracy.
Rozdział drugi przedstawia ogólną koncepcję sortowania jedno- i wielowymiarowego.
Wprowadza pojęcie automatycznego sortowania obrazów jako przykład sortowania danych
wielowymiarowych. Mówi o tym, co jest potrzebne by takie sortowanie realizować i jak ono
wygląda od strony funkcjonalnej.
Rozdział trzeci opisuje deskryptory standardu MPEG-7. Na wstępie różne deskryptory są
klasyfikowane, a następnie wybrane deskryptory są omawiane dość szczegółowo. Opisany jest
zarówno sposób ich ekstrakcji, forma ich przechowywania, jak i sposób porównywania ich ze sobą.
Szczegółowo opisane zostały cztery deskryptory koloru użyte do badań automatycznego
sortowania: Color Layout, Scalable Color, Color Temperature oraz Color Structure.
Rozdział czwarty zawiera przegląd algorytmów użytych do sortowania danych
wielowymiarowych. Koncentruje się na ich opisie teoretycznym ze wskazaniem różnic między nimi.
Na koniec wspomniane zostają także dwa dość popularne algorytmy, które nie zostały użyte w
niniejszej pracy, z wyjaśnieniem tej decyzji.
Rozdział piąty opisuje stworzoną aplikację do automatycznego sortowania obrazów.
Rozpoczyna od omówienia etapu planowania i wyboru narzędzi do jej tworzenia, a następnie
opisuje pokrótce architekturę, funkcjonalność oraz GUI programu. Wreszcie wspomniane są
pewne szczególne problemy napotkane w trakcie implementacji, a na koniec opisane są elementy
zrealizowane w ramach pracy inżynierskiej na uniwersytecie w Coventry.
Rozdział szósty porównuje ze sobą różne metody realizacji automatycznego sortowania.
Zestawia wyniki uzyskane przy użyciu różnych deskryptorów i różnych algorytmów. Opisuje także
wyniki wszystkich przeprowadzonych testów : szybkościowych i jakościowych. Na koniec
porównuje różne algorytmy pod kątem subiektywnego postrzegania podobieństwa obrazów.
Rozdział siódmy zawiera wnioski na temat wszystkich wykonanych eksperymentów i
testów. Podsumowuje uzyskane wyniki i mówi o możliwym zakresie dalszych prac związanych z
zagadnieniem automatycznego sortowania obrazów.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 9
2. Idea automatycznego sortowania obrazów
Jest dość zrozumiałe, że obrazów ‘jako takich’ nie da się posortować. Aby mówić o sortowaniu
czegokolwiek, musi być jakiś sposób na porównanie dwóch rzeczy ze sobą. W zależności od tego, w
jakiej przestrzeni docelowej sortowane są obiekty, możemy porównywać np. które są ‘większe’ lub
które są ‘bliżej siebie’ – czyli bardziej podobne.
2.1. Sortowanie jednowymiarowe
Klasyczne sortowanie w jednym wymiarze opiera się na porównaniach ‘mniejszy-większy’. Dane są
sortowane np. alfabetycznie czy według rozmiarów. Jest to najprostszy wariant sortowania i choć z
pewnością działa najszybciej (w czasie O(nlogn) przy zastosowaniu algorytmu quicksort), to jego
użyteczność do sortowania multimediów jest ograniczona. Już sam fakt, że dane opisujące obrazy
(rozmiary, nazwy z reguły będące tylko numerami) są jednowymiarowe, świadczy o tym, że dane
te w małym stopniu oddają to, co dany obrazek faktycznie reprezentuje.
Niemniej, niemal wszystkie przypadki sortowania, z którymi człowiek spotyka się na co
dzień, są właśnie jednowymiarowe. Tak są z reguły uporządkowane chociażby dane w folderach na
komputerze:
Rys. 2.1-1 Drzewo katalogów posortowane alfabetycznie
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 10
2.2. Sortowanie wielowymiarowe
Aby ułatwić opis treści multimedialnych w sposób automatyczny, grupa MPEG stworzyła
standard opisu zawartości multimediów (ang. Multimedia Content Description Interface), znany
jako MPEG-7 [MPEG 2008]. W ramach tego powszechnie uznanego międzynarodowego standardu
opracowane zostały wygodne narzędzia do opisu zawartości obrazów cyfrowych – tak zwane
deskryptory. Deskryptory to nic innego jak zestawy liczb, które opisują wybraną cechę – np. kolory,
krawędzie czy kształty. Są to tablice liczb, które w pewien sposób oddają to, co występuje w
obrazie. Standard MPEG-7 precyzyjnie definiuje postać deskryptorów. Grupa MPEG podaje też
przykłady jak te deskryptory liczyć oraz jak można je ze sobą porównywać.
Można zauważyć, że stosując deskryptory do opisu obrazów dostaje się obiekty, które
mogą już być ze sobą porównane – o ile obrazy same w sobie trudno porównywać, to liczby można
porównywać bez problemu. Nasuwa się zatem wniosek, że deskryptory są pierwszym składnikiem
niezbędnym do automatycznego sortowania obrazów na podstawie treści.
Niestety deskryptory same w sobie nie wystarczą. Dzieje się tak dlatego, że nie ma żadnego
‘oczywistego’ sposobu by je sortować. Każdy deskryptor to pewna tablica liczb. Jak stwierdzić,
która z dwóch tablic jest większa? Nie da się tego rozwiązać w prosty sposób. Dlatego też, aby móc
automatycznie sortować obrazy na podstawie treści, potrzebne są również algorytmy sortujące
dane wielowymiarowe. Są one drugim niezbędnym składnikiem, jak to zobrazowano na schemacie
poniżej.
Rys. 2.2-1 Idea automatycznego sortowania na podstawie podobieństwa
Numeryczny opis cech
obrazów
Algorytm sortujący
dane wielowymiarowe
Automatyczne
sortowanie obrazów
Obrazy cyfrowe
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 11
Algorytmy sortujące dane wielowymiarowe występują w różnych postaciach. Zasadniczo działają w
taki sposób, że jako dane wejściowe otrzymują zbiór obiektów N-wymiarowych, a jako dane
wyjściowe podają zbiór tych samych obiektów, jednak opisanych wektorami M wymiarowymi,
gdzie M ≤ N.
W przypadku sortowania obrazów docelowa przestrzeń, w jakiej chcemy oglądać wyniki,
nie powinna być jednowymiarowa. Aby sensownie przedstawić zbiory podobnych obrazów blisko
siebie, należy je umiejscowić w 2 lub 3 wymiarach. W niniejszej pracy została wybrana opcja
dwuwymiarowa. Wszystkie algorytmy sortujące wykonują więc operację przekształcenia
deskryptorów opisujących obrazy – wektorów N-wymiarowych – na współrzędne [x,y] opisujące
obrazy – wektory 2-wymiarowe. Należy jednak zaznaczyć, że przekształcenie charakteryzuje się
tym, iż obrazy znajdujące się blisko w pierwotnej N-wymiarowej przestrzeni powinny być blisko
także w nowej dwuwymiarowej przestrzeni. Obrazuje to poniższy rysunek.
Rys. 2.2-2 Sortowanie danych wielowymiarowych na płaszczyźnie
Zbiór obiektów opisanych wektorami
cech [a1, a2…an]
Zbiór obiektów opisanych
współrzędnymi [x,y]
Proces Sortowania
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 12
3. Deskryptory MPEG-7
Deskryptory standardu MPEG-7 wydają się idealnym narzędziem do automatycznego określenia
czym charakteryzuje się dany obraz. Dlatego ich rola w automatycznym sortowaniu jest kluczowa i
zostaną omówione nieco szerzej.
3.1. Klasyfikacja deskryptorów MPEG-7
Zasadniczo standard MPEG-7 definiuje trzy grupy deskryptorów do opisu treści obrazu
[MPEG 2008]:
deskryptory koloru
deskryptory tekstury
deskryptory kształtu
Deskryptory każdej z tych grup mogą być użyte do opisu treści obrazów i ich późniejszego
sortowania. Jednakże przy tworzeniu aplikacji demonstracyjnej konieczne było zawężenie tego
zbioru do kilku deskryptorów ze względu na ograniczenia czasowe. Skoncentrowanie się na
deskryptorach koloru, jako że dobrze nadają się one do opisu całości obrazu, podczas gdy inne
deskryptory raczej do poszczególnych obiektów występujących w obrazie.
W standardzie z 2003 roku zdefiniowano pięć deskryptorów koloru:
Dominant Color
Color Layout
Scalable Color
Color Structure
GOF / GOP Color
Ostatni dotyczy obrazów w sekwencjach wideo bądź grup obrazów, więc w sytuacji sortowania
pojedynczych obrazów nie będzie pomocny. Z pozostałych czterech pierwszy deskryptor – koloru
dominującego – określa kolory, które dominują w obrazie. W związku z tym nie jest on klasycznym
wektorem, i jego użycie w wielu strukturach jak np. SOM jest niemożliwe. Dlatego, w dalszych
badaniach zdecydowano się użyć pierwszych trzech deskryptorów z tej grupy.
Dlatego zdecydowano w ramach niniejszej pracy zaimplementować jedynie pozostałe trzy
deskryptory: Color Layout, Scalable Color i Color Structure. Ponadto, do tej trójki deskryptorów
koloru dołożono jeszcze czwarty, opracowany na Wydziale EiTI Politechniki Warszawskiej – Color
Temperature Browsing. Te cztery deskryptory zostaną teraz omówione nieco bardziej szczegółowo
na podstawie [Galiński 2008, Modi 2009, MPEG 2002, MPEG 2003 oraz MPEG 2008].
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 13
3.2. Deskryptory użyte do badań
3.2.1. Color Layout
Deskryptor Color Layout (CLD) przechowuje informację o tym, jakie kolory występują w obrazie i
jakie jest ich wzajemne rozmieszczenie. Może składać się z różnej liczby współczynników w
zależności od wyboru użytkownika. Liczony jest stosunkowo szybko i stąd dobrze nadaje się do
zastosowania w automatycznym sortowaniu obrazów.
Proces jego ekstrakcji składa się z kilku kroków. Schematycznie został on przedstawiony na
rysunku 3.2.1-1.
Rys. 3.2.1-1 Ekstrakcja deskryptora Color Layout
Obraz wejściowy najpierw poddawany jest skalowaniu do miniatury 8x8 pikseli. Każdy z
wyjściowych 64 pikseli otrzymuje kolor będący średnią kolorów pikseli, z których powstał. Zostało
to schematycznie zobrazowane na rysunku 3.2.1-2.
Obraz wejściowy
Deskryptor
Color Layout
Utworzenie miniatury
8x8
Transformacja kolorów
do przestrzeni YCbCr
Dyskretna Transformata
Kosinusowa (DCT)
Kwantyzacja
współczynników
Skanowanie Zigzag
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 14
Rys. 3.2.1-2 Tworzenie miniatur 8x8 (miniatury uzyskano używając programu Caliph [Lux 2007])
Następnie kolory każdego piksela są transformowane z przestrzeni RGB do przestrzeni YCbCr, co
później umożliwia odseparowanie współczynników luminancji i chrominancji. Kolejnym krokiem
jest transformata DCT wykonywana oddzielnie dla każdego z trzech składników w nowej
przestrzeni. Otrzymuje się stąd trzy macierze 8x8 transformowanych współczynników YCbCr.
Współczynniki te są kwantowane, a następnie umieszczone w liniowych tablicach poprzez
skanowanie zigzag pokazane poniżej.
Rys. 3.2.1-3 Skanowanie zigzag
Takie uporządkowanie współczynników zapewnia, że będą one posortowane z malejącą ważnością
– zaczynając od tych reprezentujących najniższe częstotliwości w obrazie. Więcej informacji można
znaleźć w [Wikipedia 2008b].
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 15
Gdy wszystkie współczynniki są już umieszczone w trzech tablicach we właściwym
porządku, wybiera się kilka początkowych współczynników z każdej tablicy by utworzyć deskryptor
Color Layout. Zaleca się, by użyć do tego celu pierwszych 6 współczynników luminancji Y oraz po 3
współczynniki chrominancji Cb i Cr, co daje deskryptor złożony z 12 współczynników [MPEG 2002].
Niemniej ostateczna decyzja ile współczynników użyć leży w gestii projektanta systemu.
Ostatnią istotną rzeczą, o której należy wspomnieć, jest proces liczenia odległości między
deskryptorami CLD. Grupa MPEG definiuje ją jako ważoną sumę odległości Euklidesowych
pomiędzy każdym ze składników Y, Cb i Cr. Jeśli więc istnieją dwa deskryptory: CLD1 (YCoeff,
CbCoeff, CrCoeff) i CLD2 (YCoeff’, CbCoeff’, CrCoeff’), to odległość między nimi wynosi:
(3.2.1-1) Odległość między dwoma deskryptorami CLD [MPEG 2002]
Symbol λ reprezentuje wagę, z jaką brane są poszczególne współczynniki uwzględniane w
obliczeniach. Grupa MPEG sugeruje używanie następującego przydziału wag:
Tabela 3.2.1-1 Domyślne wartości wag dla CLD [MPEG 2002]
3.2.2. Scalable Color
Deskryptor Scalable Color (SCD) jest swoistym histogramem kolorów. Przechowuje więc
informację o tym jakie kolory w jakich ilościach występują w obrazie, natomiast nie uwzględnia
tego, gdzie w obrazie te kolory występują – tak jak robi to CLD. Dzięki zastosowaniu transformaty
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 16
Haara i ułożeniu współczynników w skalowalnej kolejności możliwa jest jego reprezentacja z różną
dokładnością. W porównaniu z Color Layout proces jego ekstrakcji trwa jednak dłużej.
Proces liczenia tego deskryptora został przedstawiony na schemacie poniżej.
Rys. 3.2.2-1 Ekstrakcja deskryptora Scalable Color
Pierwszym krokiem jest transformacja kolorów z przestrzeni RGB do HSV. Wykonywana jest ona
dlatego, że przestrzeń HSV reprezentuje kolory w sposób ściślej odpowiadający temu, jak
postrzega je ludzkie oko, podczas gdy RGB jest stworzona z myślą o łatwym pokazywaniu kolorów
na wyświetlaczach. Przestrzeń HSV składa się z trzech składników – Hue (odcienia), Saturation
(nasycenia) i Value (wartości). Są one omówione poniżej [Nokia Corporation 2009].
Hue – mieści się w przedziale 0-359 reprezentuje liczbę stopni na kole kolorów tak jak
pokazano poniżej.
Obraz wejściowy
Deskryptor
Scalable Color
Transformacja kolorów do
przestrzeni HSV
Stworzenie 256-komórkowego
histogramu kolorów
Kwantyzacja współczynników
Transformata Haara
Opcjonalna kwantyzacja
Skalowalne uporządkowanie
współczynników
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 17
Rys. 3.2.2-2a Koło kolorów HSV
Saturation – mieści się w przedziale 0-255 i wyraża jak silna jest barwa; im kolor jest
bardziej szary, tym S jest bliższa zeru
Rys. 3.2.2-2b Skala nasycenia HSV
Value – mieści się w przedziale 0-255 i oddaje jasność barwy; im ciemniejszy jest kolor, tym
V jest bliższe zeru
Rys. 3.2.2-2c Skala wartości HSV
Dla potrzeb obliczania deskryptora Scalable Color powyższe skale HSV są kwantowane tak, by w
sumie dostać strukturę o 256 komórkach, która może być ukazana jako cylinder (rys. 3.2.2-3).
Poszczególne składowe są kwantowane następująco:
H – hue do 16 wartości
S – saturation do 4 wartości
V – value do 4 wartości
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 18
Rys. 3.2.2-3 Model Barw HSV [Galiński 2008]
Po takiej kwantyzacji utworzony zostaje 256-komórkowy histogram kolorów w przestrzeni HSV.
Następnie wartości histogramu także są kwantowane. Więcej szczegółów na ten temat znajduje
się w [MPEG 2003].
Kolejnym krokiem jest szereg jednowymiarowych transformat Haara. Transformaty te
przetwarzają pary współczynników. Wykonują sumowanie i odejmowanie dwóch współczynników,
po czym sumę zapisują w miejscu pierwszego współczynnika, a różnicę w miejscu drugiego. Ten
proces jest powtarzany aż do momentu, gdy pozostanie tylko jeden współczynnik będący sumą.
Następnie tak uzyskane współczynniki (1 współczynnik będący sumą wszystkich oraz 255
współczynników różnicowych) są zapisywane w 256-komórkowej tablicy w specjalnym porządku
który zapewnia, że najpierw występują współczynniki zawierające najwięcej informacji. W
rezultacie otrzymuje się 16 podstawowych współczynników i do 240 uzupełniających.
Wszystkie te współczynniki tworzą deskryptor Scalable Color. Jednak, jako że deskryptor
jest skalowalny, to od użytkownika zależy ile współczynników zostanie użytych do jego
reprezentacji. W praktyce można wybrać 16, 32, 64, 128 lub 256 współczynników. Inną często
stosowaną techniką zmniejszenia rozmiaru deskryptora jest odrzucenie mniej znaczących
płaszczyzn bitowych dla wszystkich współczynników. Jednakże w przypadku użycia deskryptora do
sortowania obrazów metoda ta nie wydaje się opłacalna, gdyż opis obrazu powinien być w tej
sytuacji możliwie najdokładniejszy.
Jeżeli chodzi o obliczanie odległości pomiędzy dwoma deskryptorami SCD, to powinno być
ono wykonywane inaczej niż dla deskryptora CLD. Grupa MPEG zaleca używać w tym celu normę
L1. Oznacza to, że odległość pomiędzy deskryptorami jest zwyczajną sumą różnic między
odpowiadającymi współczynnikami. Jeśli więc mamy dwa deskryptory SCD1 i SCD2, to wzór na
odległość przyjmie postać:
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 19
( 1 ,2 )
0
| 1[ ] 2[ ] |
Min NoOfSCD CoeffNoOfSCD Coeff
i
D SCD i SCD i
(3.2.2-1) Odległość pomiędzy dwoma deskryptorami SCD
Jako że dwa różne deskryptory SCD mogą mieć różną liczbę współczynników, przy obliczaniu
odległości należy uwzględnić tylko tyle współczynników, ile ma mniejszy z deskryptorów.
3.2.3. Color Structure
Deskryptor Color Structure (CSD) jest nieco zmodyfikowanym histogramem kolorów. Zawiera on
zarówno informację o tym ile i jakie kolory występują w obrazie (jak zwykły histogram), jak i
informację o tym jak występujące piksele tego samego koloru są rozmieszczone względem siebie –
czy tworzą grupę, czy są rozproszone (rozszerzenie, które czyni go szczególnym).
Informację o wzajemnym rozmieszczeniu występujących w obrazie kolorów otrzymuje się
dzięki zastosowaniu szczególnego sposobu zliczania kolorów pikseli. Nie jest to wykonywane
zwyczajnie piksel po pikselu, lecz po obrazie przesuwany jest pewien element scalający – kratka o
wymiarach np. 3x3. Ta kratka jest przesuwana po obrazie tak, by znaleźć się we wszystkich
możliwych położeniach. Jeśli w danym położeniu jakikolwiek piksel danego koloru znajduje się pod
kratką, to wartość odpowiadającej komórki histogramu jest inkrementowana. Oznacza to, że
niezależnie od tego, ile takich samych pikseli będzie w danym momencie pod kratką, zostaną
wszystkie policzone raz. Z tego względu piksele bardziej ‘rozrzucone’ po całym obrazie dadzą
większą wartość komórki histogramu CSD, niż piksele bardziej skupione.
Można to prześledzić na poniższym przykładzie [MPEG 2002]. Rysunek 3.2.3-1a przedstawia
obraz z 3 zwartymi obszarami zawierającymi kolor bordowy. Z kolei rysunek 3.2.3-1b przedstawia
obraz z rozproszonymi obszarami koloru bordo.
Rys. 3.2.3-1a Obraz ze zwartymi obszarami kolorów [MPEG 2002]
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 20
Rys. 3.2.3-1b Obraz z rozproszonymi obszarami kolorów [MPEG 2002]
Oznaczmy kolor bordo jako kolor kwalifikujący się do m-tej komórki histogramu kolorów. Zwykły
histogram kolorów dla obydwu powyższych obrazów policzyłby 150 bordowych pikseli, i do m-tej
komórki wpisałby wartość 150. Tymczasem, poprzez szczególne zliczanie z wykorzystaniem kratki
3x3, Color Structure obliczy w pierwszym przypadku 300, a w drugim aż 580! Ta duża różnica
dowodzi, że deskryptor ten uwzględnia nie tylko ilość występujących kolorów, ale także
częstotliwość ich występowania w obrazie. Te cechy powodują, że dobrze nadaje się on do
porównywania obrazów i określania ich podobieństwa.
Etapy ekstrakcji tego deskryptora można przedstawić następująco:
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 21
Rys. 3.2.3-2 Ekstrakcja deskryptora Color Structure
Ekstrakcję deskryptora rozpoczyna się od transformacji kolorów z przestrzeni RGB do przestrzeni
HMMD. Przestrzeń ta jest nieco podobna do przestrzeni HSV, jednak składa się z dwóch rożków
zamiast walca w usiłowaniu pogodzenia konfliktu dokładności reprezentacji nasycenie – jasność.
Przy porównywaniu obrazów ze sobą przestrzeń HMMD spisuje się lepiej od przestrzeni HSV
[Savvas 2009].
Rys. 3.2.3-3 Przestrzeń kolorów HMMD [MPEG 2002]
Obraz wejściowy
Deskryptor
Color Structure
Transformacja kolorów do
przestrzeni HMMD
Kwantowanie wartości HMMD
do struktury 256-komórkowej
Akumulacja histogramu
Opcjonalna scalenie
histogramu do mniejszej
liczby komórek
Nieliniowa kwantyzacja
wartości histogramu
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 22
Gdy już wszystkie piksele są wyrażone w nowej przestrzeni kolorów, rozpoczyna się akumulacja
histogramu. Dokonywana jest ona w sposób opisany powyżej – z użyciem elementu scalającego
8x8. Ponadto, by zmniejszyć nakład obliczeniowy oraz uniezależni wynik od rozmiaru obrazu,
stosuje się podpróbkowanie zależne od rozmiaru obrazu wejściowego. Innymi słowy, element
scalający jest przesuwany nie co jeden piksel, ale co kilka pikseli przy każdym przesunięciu.
Następnie dokonywane jest opcjonalne scalenie komórek histogramu jeśli wymagana jest
inna ich liczba niż początkowe 256. Na koniec dokonuje się nieliniowej kwantyzacji wartości
histogramu. Tak otrzymany wektor wartości reprezentuje już gotowy deskryptor Color Structure.
W obliczaniu odległości deskryptorów CSD zalecana jest norma L1. Zakładając, że obraz A
opisany jest deskryptorem hA, a obraz B opisany jest deskryptorem hB, odległość między tak
opisanymi obrazami wyrazi się wzorem:
(3.2.3-1) Odległość pomiędzy dwoma deskryptorami CSD
Gdzie n oznacza komórkę histogramu – deskryptora.
Deskryptor CSD został stworzony z myślą o rozróżnianiu obrazów między sobą i szybkim
wyszukiwaniu obrazu podobnego do obrazu wzorcowego. Jego przydatność w sortowaniu
pozostaje jednak do zbadania. Należy natomiast zaznaczyć, że proces ekstrakcji tego deskryptora
jest kosztowny obliczeniowo, znacznie bardziej niż Color Layout. Więcej informacji o Color
Structure można znaleźć w [MPEG 2002].
3.2.4. Color Temperature Browsing
Deskryptor Color Temperature Browsing (dalej nazywany CTB) jest dość szczególny, gdyż składa się
zasadniczo tylko z jednego współczynnika. Ogólne założenie CTB jest takie, że ma on oddać
postrzeganą temperaturę światła, które oświetla scenę w obrazie. Wartość jedynego
współczynnika powinna przedstawiać właśnie tę temperaturę. Ta temperatura może być rozbita
na kategorię (hot/warm/moderate/cool) oraz podprzedział uściślający tą kategorię. Niemniej,
można obie te wartości określić jako jeden współczynnik. Mimo że deskryptor CTB składa się tylko
z jednego współczynnika, proces ekstrakcji jest dość skomplikowany. Został schematycznie
ukazany poniżej [MPEG 2004].
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 23
Rys. 3.2.4-1 Ekstrakcja deskryptora Color Temperature
Pierwszym krokiem, jaki sie wykonuje aby obliczyć wartość deskryptora Color Temperature, jest
linearyzacja wartości RGB obrazu tak, by pozbyć się korekcji gamma wprowadzanej w celu
wyświetlania obrazu na monitorach. Następnie zlinearyzowane wartości RlGlBl są konwertowane
do przestrzeni CIE 1931 XYZ (Rys. 3.2.4-2), co umożliwi określenie iluminantu za pomocą jedynie
dwóch współczynników: xs i ys. Kolejnym krokiem jest usunięcie pikseli o luminancji mniejszej niż
próg niskiej luminancji Tll.
Po tych wstępnych obróbkach wartości wszystkich pikseli są uśredniane, skąd otrzymuje się
średnie wartości XAYAZA. Na podstawie tych średnich wartości liczony jest próg samo-luminancji
Obraz wejściowy
Deskryptor Color
Temperature
Linearyzacja wartości RGB
Konwersja kolorów do
przestrzeni XYZ
Pominięcie pikseli o
luminancji niższej niż próg
Uśrednienie wartości XYZ dla
wszystkich pozostałych pikseli
Policzenie chromatycznych
współczynników iluminantu
sceny
Opcjonalnie pominięcie pikseli
o luminancji spoza nowo
obliczonego zakresu
Przeliczenie iluminantu sceny
na temperaturę obrazu
Przeskalowanie temperatury
do zakresu 0-255
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 24
(XT, YT, ZT). Jeśli XT, YT, ZT są takie same jak poprzednio wyliczone, to należy przejść do kolejnego
kroku, a jeśli nie to należy usunąć z obrazu piksele o wartościach większych niż próg samo-
luminancji i powrócić do kroku poprzedniego.
Gdy wszystkie piksele spoza zakresu dolnego progu luminancji i iteracyjnie wyliczanego
progu samo-luminancji zostaną odrzucone, to po uśrednieniu wartości XYZ pozostałych pikseli
obliczane są chromatyczne współczynniki iluminantu sceny: xs i ys.
Następnie te chromatyczne współczynniki iluminantu sceny są przeliczane na temperaturę
obrazu T w zakresie 1667 – 25000 K. Ostatnim krokiem jest przeskalowanie tej temperatury do
przedziału 0-255. Jej wartość staje się wówczas liczbą 8 bitową gdzie 2 najstarsze bity reprezentują
jedną z czterech kategorii: gorący, ciepły, umiarkowany, chłodny, a kolejne 6 bitów rozwija każdą z
kategorii. To, jakim wartościom temperatury barwowej (z przedziału 1667-25000) odpowiadają
poszczególne kolory, ukazuje poniższy rysunek.
Rys. 3.2.4-2 Przestrzeń kolorów XY z zaznaczonymi temperaturami barw [NameMedia 2010]
Aby znaleźć wzajemną odległość dwóch deskryptorów CTB, zaleca się odejmowanie temperatur
już sprowadzonych do zakresu [0-255]. Więcej informacji na temat obliczeń podczas ekstrakcji
deskryptora Color Temperature można znaleźć w [MPEG 2004].
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 25
4. Algorytmy sortujące dane wielowymiarowe
Istnieje bardzo wiele algorytmów i różnych pomysłów na sortowanie czy grupowanie danych
wielowymiarowych. Szczególnie w ostatnich latach, w dobie intensywnego rozwoju komputerów i
szybkiego rozrostu baz danych, temat takiego sortowania był w centrum uwagi. Jest zrozumiałe, że
przebadanie wszystkich algorytmów, jakie zostały wymyślone, jest kompletnie nierealne.
Konieczne było wybranie kilku algorytmów najbardziej reprezentatywnych i dających największe
nadzieje na dobre rezultaty.
4.1. Zaimplementowane algorytmy
Decyzja o tym, które algorytmy zaimplementować, była podyktowana kilkoma względami. Po
pierwsze, kierowano się już istniejącymi programami do sortowania [Lux 2007, UAS-Berlin 2008],
próbując uzyskać podobne rezultaty. Po drugie, ważnym celem stawianym przed algorytmami była
łatwość wizualizacji wyników. Wreszcie, dążono do tego by zaimplementowane algorytmy były z
jednej strony zróżnicowane, a z drugiej tworzyły pewną całość, którą będzie można ze sobą
porównywać.
4.1.1. Mapy samoorganizujące się (SOM)
Algorytm samoorganizujące się map (ang. Self Organizing Maps, SOM) jest na pierwszy rzut oka
dość szczególny. Algorytm ten nie bazuje na policzeniu nowych współrzędnych dla danych w nowej
przestrzeni, tak by były one od razu posortowane. Jego działanie jest inne: można powiedzieć, że
iteracyjnie przesuwa i modyfikuje istniejące dane w nowej przestrzeni w taki sposób, by uzyskać
zorganizowaną, posortowaną strukturę. Do organizacji danych używa specjalnie przygotowanej
sieci węzłów, zamiast tak jak zwykłe algorytmy ciągłej przestrzeni.
Ten iteracyjny algorytm został opracowany przez Profesora Tuevo Kohonena na początku
lat osiemdziesiątych [Kohonen 2005a, 2005b; Honkela 1998]. Dziś jest stosowany w dwóch
odmianach: tradycyjnej i w tzw. wersji Batch, która została opracowana z myślą o wydajniejszym
stosowaniu na komputerach. Obie zostały zanalizowane i zaimplementowane w ramach pracy. Ich
opis znajduje się poniżej.
4.1.1.1. Wersja tradycyjna - Incremental SOM
Wersja tradycyjna używa sieci węzłów by zorganizować dane w nowej przestrzeni o dowolnie
wybranej liczbie wymiarów. Jako że do sortowania obrazów wybrano docelową przestrzeń
dwuwymiarową, opis działania tego algorytmu będzie opierał się na takim właśnie założeniu.
Można zamodelować sortowanie z wykorzystaniem algorytmu SOM jako następujące trzy
etapy:
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 26
1. Inicjalizacja mapy węzłów
2. Wyuczenie mapy węzłów
3. Dopasowanie danych wejściowych do wyuczonej mapy węzłów
Pierwszy krok polega na stworzeniu mapy węzłów o takim samym typie jak dane, które są do
posortowania. Jeśliby sortować kolory, to każdy z węzłów reprezentowałby kolor (3 wymiary – R,
G, B) a dwuwymiarowa wizualizacja takiej mapy węzłów mogłaby wyglądać jak na rysunku 4.1.1.1-
1.
Rys. 4.1.1.1-1 Przykład mapy węzłów SOM [Germano 1999]
W przypadku gdy sortowane mają być obrazy opisane deskryptorami, każdy z węzłów powinien
sam być deskryptorem. Ilość węzłów tworzących mapę musi być co najmniej równa liczbie
obiektów, które chcemy posortować (może być większa – wówczas niektóre będą puste). Przed
wyuczeniem mapa węzłów może zawierać dowolne wartości, nawet całkiem losowe. Jednakże
lepsze metody inicjalizacji mapy spowodują, że algorytm szybciej dojdzie do zbieżności.
Gdy już zostanie utworzona początkowa mapa węzłów, kolejnym krokiem jest
wytrenowanie tej mapy za pomocą danych wejściowych. Ten proces jest wykonywany podczas
szeregu iteracji, typowo 5-10 razy tyle ile jest elementów wejściowych do posortowania. Proces
uczenia można przedstawić za pomocą poniższego pseudokodu [Germano 1999]:
Dla t od 0 do 1
Losowo wybierz element wejściowy
Znajdź najlepsze dopasowanie (ang. Best Matching Unit, BMU) w mapie węzłów
Przeskaluj sąsiadów znalezionego BMU
Zwiększ t o pewną małą wartość
Koniec Pętli
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 27
Każda iteracja składa się z kilku kroków. Pierwszy krok jest dość prosty – polega na zwykłym
wybraniu losowego elementu ze zbioru danych wejściowych, które są sortowane. W przypadku
sortowania obrazów poprzez ich deskryptory wybrany powinien zostać jeden z deskryptorów.
Następną czynnością jest znalezienie najlepszego dopasowania (BMU) w istniejącej mapie węzłów.
Oznacza to znalezienie takiego węzła na mapie, który będzie najbliższy wybranemu wcześniej
elementowi wejściowemu. W przypadku sortowania deskryptorów Color Layout zostanie do tego
celu użyty wzór 3.2.1-1.
Kolejnym krokiem jest ustalenie sąsiadów najlepszego dopasowania. Aby algorytm SOM był
zbieżny, ilość tych sąsiadów musi zmniejszać się wraz z czasem (gdy t rośnie). Typowym
rozwiązaniem jest ustalenie początkowego promienia sąsiedztwa R i zmniejszanie go
monotonicznie do 0 wraz ze zwiększaniem t do 1.
Wreszcie, najważniejszym krokiem jest przeskalowanie sąsiadów BMU – ‘upodobnienie’ ich
do aktualnie rozważanego elementu wejściowego. To ‘upodobnienie’ powinno być wykonywane z
różnymi wagami. Po pierwsze, węzły leżące bliżej BMU powinny zostać bardziej upodobnione do
BMU niż węzły leżące od niego daleko. Można do tego celu używać różnych funkcji, jednak
najpopularniejsza jest funkcja Gaussa. Po drugie, ilość jaką węzły mogą się nauczyć powinna się
zmniejszać wraz z czasem (wzrostem t). Ta zależność jest z reguły implementowana jako liniowa.
Obie wymienione wagi używane są do obliczenia złożonej wagi W, która jest używana do uczenia
każdego sąsiada BMU w procesie uczenia. Przykładowy wzór ukazujący jak obliczać wartość W przy
zastosowaniu Gaussowskiej funkcji sąsiedztwa jest ukazany poniżej [Kohonen 2005]:
Rys. 4.1.1.1-2 Funkcja Gaussa
[Germano 1999]
20
2
| |
2 ( )( ) ( )
ir r
t
iW r t e
(4.1.1.1-1)
gdzie
0 ( ) 1t jest współczynnikiem uczenia zmniejszanym z czasem
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 28
2
ir jest wektorową lokalizacją uczonego węzła w wyświetlanej sieci
2
0r jest wektorową lokalizacją BMU w wyświetlanej sieci
0 ( )t R jest szerokością funkcji sąsiedztwa, zmniejszaną z czasem
Po tym jak W zostanie obliczone, węzły sąsiadujące (a wśród nich także i samo BMU) są
aktualizowane wg poniższego prawa (Wzór 4.1.1.1-2):
Nowa_Wartość = (1-W) * Stara_Wartość + W * Wartość_Węzła_Wejściowego
Po pewnej liczbie takich iteracji wykreuje się mapa o węzłach, których wartości będą zbliżone do
wartości danych wejściowych. Utworzona mapa będzie jednak posiadać szczególną cechę: węzły
blisko siebie będą do siebie bardzo podobne.
Ostatnim procesem niezbędnym by posortować dane wejściowe, jest dopasowanie tych
danych do utworzonej mapy węzłów. Jeśli proces uczenia mapy został wykonany prawidłowo, to
powinno być możliwe dobre dopasowanie każdego obrazu wejściowego do pewnego węzła na
mapie. Następnie wystarczy przypisać współrzędne węzłów tak skojarzonym obrazom i obrazy
będą posortowane.
Więcej informacji o algorytmie SOM można znaleźć w [Kohonen 2005a, 2005b; Douglas
1999; FAQS.ORG 2008].
4.1.1.2. Wersja zmodyfikowana - Batch-SOM
Główną wadą algorytmu Incremental SOM jest to, że działa on wolno dla dużych zbiorów danych.
Dlatego też stworzono inną wersję, znaną jako Batch-SOM. Ma ona działać szybciej na
komputerach, szczególnie w środowisku MATLAB. Spośród trzech głównych kroków koniecznych
by posortować dane wejściowe, pierwszy i ostatni są w tym algorytmie takie same jak w klasycznej
jego odmianie. Różnica tkwi w sposobie uczenia mapy węzłów. W przypadku Batch-SOM uczenie
wykonuje się następująco [Kohonen 2005a]:
1. Dla każdego węzła i na mapie zbierz listę wszystkich elementów wejściowych, których BMU
leży w sąsiedztwie i
2. Dla każdego węzła zastąp istniejącą wartość węzła średnią ważoną z listy elementów
wejściowych
3. Powtórz kroki 1 i 2 kilka razy
W wersji Batch t nie jest zwiększane po każdym znalezieniu BMU i wyuczeniu jego sąsiedztwa, ale
jest zwiększane po tym jak sąsiedztwa wszystkich węzłów na mapie zostaną zaktualizowane raz.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 29
Druga różnica tkwi w sposobie uczenia każdego węzła. Nie jest ono wykonywane kolejno z
zastosowaniem wzoru 4.1.1.1-2. Zamiast tego, każdy węzeł jest aktualizowany raz, zbiorczo,
zgodnie z poniższą zależnością [Kohonen 2005a]:
( )
1
( )
1
( )
( 1)
( )
n
ic j j
j
i n
ic j
j
W t x
m t
W t
(4.1.1.2-1)
gdzie:
n jest liczbą obiektów wejściowych (danych trenujących)
( 1)im t jest nową wartością węzła i
( )c j jest BMU wejściowego wektora jx
( )ic jW jest współczynnikiem wagowym funkcji sąsiedztwa
Zarówno klasyczna wersja algorytmu SOM, jak i wersja Batch SOM zostały zanalizowane i
wypróbowane pod kątem użycia w automatycznym sortowaniu obrazów. Więcej informacji na ten
temat znajduje się w rozdziale 5.
4.1.2. Rozkład na składowe główne (ang. Principal Component Analysis)
Rozkład na składowe podstawowe (PCA) jest jakby ‘najwłaściwszym’ algorytmem do
porządkowania danych wielowymiarowych. Wynika to z faktu, że w pewnym sensie PCA dostarcza
optymalnych wyników. Można by bardzo ogólnie stwierdzić, że algorytm ten transformuje
pierwotne dane do nowej przestrzeni w taki sposób, aby wymiary w nowej przestrzeni zachowały
możliwie jak najwięcej informacji o wymiarach pierwotnych [Wikipedia 2009a].
W przeciwieństwie do algorytmu SOM, który operuje na węzłach, PCA zamienia przestrzeń
N wymiarów wejściowych na nową przestrzeń M ortogonalnych wymiarów (M ≤ N). Wymiary
nowej przestrzeni są przy tym tak zorientowane, by każdy kolejny zawierał możliwie najwięcej
informacji o całym zbiorze obiektów wejściowych. Zatem, jeśli do reprezentacji wybrane zostaną
np. pierwsze dwa wymiary z nowej przestrzeni otrzymanej z PCA, to będą one miały największą
wariancję i będą odpowiadać posortowaniu całego wielowymiarowego zbioru danych na
płaszczyźnie gdy zrzutujemy na te dwa wymiary wszystkie dane wejściowe.
Rozkład na składowe podstawowe – który w zależności od dziedziny zastosowania bywa
również nazywany transformatą Karhunen-Love – jest dość skomplikowaną i złożoną operacją
matematyczną. Przy dużych zbiorach danych trwa on bardzo długo i dlatego poza tradycyjną formą
stosuje się też formy uproszczone, które działają znacznie szybciej. Zdecydowano się
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 30
zaimplementować zarówno tradycyjną, jak i uproszczoną formę celem porównania ich ze sobą.
Opis obydwu algorytmów znajduje się poniżej [O'callaghan, Bober 2006; StatSoft 2009a; Wikipedia
2009a].
4.1.2.1. Wersja pełna PCA
W pełnej wersji algorytm PCA znajduje nowe współrzędne wszystkich obiektów
wejściowych poprzez policzenie wektorów i wartości własnych macierzy kowariancji uformowanej
przez te dane. Można wybrać jedną z dwóch dróg: poprzez macierz kowariancji lub poprzez
przekształcenie SVD. W ramach niniejszej pracy zdecydowano się na pierwszą z tych dróg. Ogólnie
kroki algorytmu w tej postaci można przedstawić następująco [Wikipedia 2009a]:
1. Stworzenie macierzy kolumnowej X o wymiarach MxN. Do tego celu używa się N
wektorów danych wejściowych o wymiarze M.
2. Znalezienie średniej wzdłuż każdego pierwotnego wymiaru i odjęcie jej od danych
wejściowych by otrzymać macierz B – suma wartości w każdej kolumnie macierzy B
ma być równa zero.
3. Znalezienie macierzy kowariancji C z następującej zależności
(4.1.2.1-1)
4. Znalezienie wektorów własnych macierzy kowariancji. Wykonuje się to rozwiązując
równanie macierzowe
(4.1.2.1-2)
Gdzie x – macierz wektorów własnych macierzy C, λ – macierz wartości własnych
macierzy C. Ten krok jest bardzo kosztowny obliczeniowo i przy dużych zbiorach
danych może uniemożliwić stosowanie PCA.
5. Uszeregowanie wektorów własnych według malejących wartości własnych – od
wektora o największej wariancji do wektora o najmniejszej wariancji.
6. Wybranie N pierwszych wektorów jako wymiarów w nowej przestrzeni.
7. Rzutowanie wszystkich wektorów wejściowych na te N nowych wymiarów –
otrzymuje się współrzędne obiektów wejściowych w nowej przestrzeni.
Rozkład PCA można też zobrazować graficznie, by lepiej uzmysłowić sobie na czym on polega.
Załóżmy, że mamy chmurę punktów w przestrzeni 3D. Celem jest znaleźć po kolei nowe wymiary
*1C B B
N
Cx x
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 31
stosując PCA. Algorytm wskaże nowe wymiary jako kolejne kierunki ‘największej zmienności
danych’. Jest to zobrazowane na poniższym rysunku.
Rys. 4.1.2.1-1 Znajdywanie kierunków największej zmienności danych metodą PCA
Jeśli przyjąć, że czerwona chmura reprezentuje punkty, to pierwszy nowy wymiar znaleziony przez
PCA będzie taki, jak niebieska linia – kierunek największego rozciągnięcia danych. Następne nowe
wymiary znalezione przez PCA będą prostopadłe to tej niebieskiej linii i będą wskazywać kolejne
kierunki ‘wypukłości’ rozważanej chmury.
4.1.2.2. Wersja skrócona PCA
Uproszczony wariant rozkładu na składowe podstawowe można stosować wtedy, gdy potrzebne
jest zaledwie kilka najważniejszych tych składowych. Wówczas nie jest konieczne obliczanie
macierzy kowariancji i liczenie wektorów własnych. Można dobre przybliżenie pierwszej składowej
podstawowej uzyskać wykonując poniższy pseudokod [Roweis 1998]:
Zainicjuj p jako losowy wektor długości m
Wykonaj c razy:
Zainicjuj wektor t o długości m zerami
Dla każdego wektora x є X wykonaj:
( )t t x p x
| |
tp
t
Zwróć p
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 32
Jeśli potrzeba jest więcej składowych, to można je znaleźć stosując ten sam algorytm. W tym celu
należy najpierw ‘odjąć’ informacje, które wyraża znaleziony właśnie wymiar od danych
wejściowych. Innymi słowy, należy dokonać rzutowania wszystkich wektorów na znaleziony
wektor p, a następnie wyniki rzutowania kolejno odejmować od wektorów wejściowych. W ten
sposób otrzymana zostanie nowa macierz X. Przy powtórzeniu powyższego algorytmu dla tej
nowej macierzy, zostanie znaleziony kolejny wymiar o największej wariancji, prostopadły do tych
znalezionych dotychczas.
Rzutowanie wektora v na wektor u można zapisać jako
(4.1.2.2-1)
gdzie <v, u> jest iloczynem skalarnym wektorów v oraz u.
Nie ulega kwestii, że uproszczony algorytm PCA działa kilka rzędów wielkości szybciej niż
klasyczna wersja, dając niewiele gorsze rezultaty przy szukaniu tylko pierwszych dwóch wektorów
własnych dużej macierzy. Niemniej, znalezienie wszystkich wektorów własnych dla
wielowymiarowych danych jest tą metodą trudne lub nawet niemożliwe ze względu na
dokładność.
4.1.3. Algorytm FastMap
Algorytm FastMap również ma na celu rzutowanie punktów z przestrzeni N wymiarowej do
przestrzeni M wymiarowej (M≤N), gdzie wymiary w nowej M-wymiarowej przestrzeni są tak
dobrane, by mieć maksymalną wariancję. Algorytm PCA opisany w punkcie 4.1.2. liczy w tym celu
kierunki główne, i dzięki temu znajduje optymalne rozmieszczenie M nowych wymiarów. W
odróżnieniu, algorytm FastMap wyznacza tylko przybliżenie korzystając z uproszczonej metody
ortogonalizacji, ale charakteryzuje się godną podziwu szybkością obliczeń [Faloutsos, Lin 1995].
Kluczem w algorytmie FastMap jest twierdzenie cosinusów. To dzięki niemu można
utworzyć w N wymiarowej przestrzeni wirtualną prostą i na nią zrzutować wszystkie punkty z tej
przestrzeni. Prosta ta jest wybierana w łatwy sposób – przechodzi przez dwa najbardziej odległe
od siebie elementy w pierwotnej, N wymiarowej przestrzeni. Znając współrzędne tych dwóch
najodleglejszych punktów można dla każdego z pozostałych punktów wyznaczyć punkt xi będący
rzutem na tę prostą. Wygląda to jak na poniższym rysunku:
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 33
Rys. 4.1.3-1
Twierdzenie Cosinusów
gdzie:
Oa, Ob – najbardziej odległe punkty wyznaczające wirtualną prostą
Oi – aktualnie rozważany obiekt
E – rzut obiektu Oi na prostą OaOb
xi – współrzędna rzutu E (odległość od Oa)
Z twierdzenia cosinusów wynika:
2 2 2
, , , ,2b i a i a b i a bd d d x d (4.1.3-1)
Skąd
2 2 2
, , ,
,2
a i a b b i
i
a b
d d dx
d
(4.1.3-2)
Widać, że metoda ta zadziała dla przypadku, gdy chcemy rzutować punkty z przestrzeni N
wymiarowej w przestrzeń jednowymiarową. Pytanie tylko, czy można je rzutować tą techniką w
przestrzeń M wymiarową? Odpowiedź jest twierdząca. Należy w tym celu od zbioru punktów w
przestrzeni N wymiarowej odjąć informację o już wykonanym rzutowaniu.
Największą różnicą w koncepcji działania algorytmu FastMap w stosunku do PCA jest
dziedzina wykonywania operacji matematycznych. FastMap jest przeznaczony dla macierzy
przechowującej wzajemne odległości pomiędzy punktami. Nie są więc wcale potrzebne oryginalne
współrzędne punktów. Jeśli nie można z nich skorzystać, to algorytm FastMap jest w tej sytuacji
niezastąpiony. Jeśli jednak pierwotnymi danymi są właśnie współrzędne punktów – jak to jest przy
opisie obrazów deskryptorami – to stworzenie mapy odległości wymaga dodatkowych obliczeń.
Aby rozważyć, jak należy odejmować informację o już wyekstrahowanej współrzędnej z
reszty zbioru, należy założyć, że do dyspozycji jest mapa wszystkich wzajemnych odległości między
punktami (w początkowej N wymiarowej przestrzeni). Niech na skutek wyżej opisanego
rzutowania punkty Oi oraz Oj otrzymają współrzędne xi, xj na pewnej prostej. Jeśli uwzględni się te
nowe współrzędne w starych odległościach, to będzie można ‘usunąć’ ten jeden nowo znaleziony
wymiar z mapy odległości. Należy tylko dla każdej pary punktów Oi, Oj przeprowadzić aktualizację
odległości w mapie wg wzoru:
2 2 2
' ' ', ,i j i j i jD O O D O O x x (4.1.3-3)
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 34
gdzie
D – stara odległość między punktami Oi, Oj
D’ – nowa odległość między punktami Oi, Oj
xi, xj – nowo znalezione współrzędne punktów Oi, Oj
Powtarzając ten krok iteracyjnie otrzymuje się nową mapę odległości, którą można dalej
‘ortogonalizować’ analogicznie jak za pierwszym razem. Można więc ostatecznie uzyskać tyle
wymiarów wyjściowych, ile jest potrzeba (pod warunkiem, że w trakcie tego procesu mapa
odległości nie zamieni się w same zera).
Algorytm FastMap zastosowany w stworzonej przez autora aplikacji bazuje na 2-
wymiarowej przestrzeni docelowej. Przestrzeń wejściowa zależy natomiast od liczby wymiarów
wykorzystywanego deskryptora. Łatwo zauważyć, że jakość wyników sortowania obrazów tym
algorytmem będzie silnie zależeć od zróżnicowania danych wejściowych – jeśli podawana będzie
grupa bardzo podobnych obrazów, oraz dwa krańcowo inne, to te odróżniające się zostaną
wybrane jako ‘krańcowe’ punkty, a wszystkie pozostałe zostaną umieszczone blisko siebie w
docelowej płaszczyźnie. Niemniej, jeśli zbiór do sortowania jest duży, i ‘równomiernie
zróżnicowany’, jak to zwykle bywa w przypadku np. kolekcji zdjęć, to wyniki osiągane przez
algorytm FastMap są całkiem dobre. Należy przy tym zaznaczyć dużą szybkość działania tego
algorytmu.
4.1.4. Porównanie PCA i FastMap
Aby lepiej zobrazować różnicę pomiędzy algorytmem FastMap i PCA, warto rozważyć rysunek,
przedstawiający punkty w przestrzeni 2D. Można przyjąć za cel przeniesienie tych punktów do
nowej, dwu-wymiarowej przestrzeni, jednak tak by każda kolejna współrzędna w nowej
przestrzeni zawierała maksymalnie dużo informacji o wzajemnej odległości między punktami
(miała maksymalną wariancję).
Rys. 4.1.3.1-1
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 35
Algorytm FastMap znajdzie punkty krańcowe, połączy je prostą i zrzutuje na nią wszystkie punkty.
Następnie odejmie informację o tym od istniejącego zbioru punktów, wyznaczy drugą prostą itd.
Pierwsza tak wyznaczona prosta jest zaznaczona poniżej na czerwono.
Rys. 4.1.3.1-2
Algorytm PCA postąpi inaczej. Uwzględniając wszystkie zależności między wszystkimi punktami
wygeneruje ‘optymalny’ układ nowych współrzędnych. Dla rozważanego zbioru punktów będzie to
wyglądało jak poniżej (dla porównania na czerwono punkty, które wybrał i połączył prostą w
pierwszej iteracji FastMap):
Rys. 4.1.3.1-3
W odniesieniu do zbioru obrazów, które są do posortowania, algorytm PCA daje wyniki nieco
lepsze jeśli chodzi o wariancję nowych wymiarów i co ważniejsze, dobre niezależnie od rodzaju
danych wejściowych (jeśli tylko jeden obrazek jest znacząco różny od pozostałych, to jego
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 36
odchylenie zostanie uwzględnione przez PCA tylko z wagą 1/N). Dalsze porównanie obydwu
algorytmów znajdują się w rozdziale 6.
4.1.5. Algorytm Mutual-Rank Similarity-Space
Algorytm wprowadzenia przestrzeni ‘wzajemnych rang’ jest ciekawą propozycją, która może być
zastosowana razem z dowolnym innym algorytmem, który sortuje obiekty na podstawie ‘mapy
odległości’. Wynika to z faktu, że algorytm ten jest propozycją pewnej modyfikacji tych map
odległości.
Niech macierz SF na pozycji SF(i,j) przechowuje odległości między obrazami i oraz j,
obliczonymi na podstawie deskryptorów MPEG-7. Najprzejrzyściej będzie przedstawić algorytm
wzajemnych rang w punktach, na przykładzie sortowania obrazów. Wykonuje on kolejno
następujące operacje [O'callaghan, Bober 2006]:
1. Zamiana macierzy podobieństwa SF na macierz rang RF
Każda kolumna przetwarzana jest osobno, przy czym wartości podobieństwa
zamieniane są na liczby porządkowe. Innymi słowy, dla danego i, wartość SF
określająca największe podobieństwo zamieniana jest na np. N (gdzie N to liczba
obrazów w całym zbiorze), druga największa wartość SF zamieniana jest na N-1,
trzecia na N-2 itd. O ile przed tym krokiem macierz SF była z reguły symetryczna, to
macierz RF nie jest już symetryczna – bo ranga obrazu i względem j nie musi być taka
sama jak ranga obrazu j względem i.
2. Opcjonalnie dalsze przetwarzanie macierzy RF
Można dla dodatkowych korzyści nieco zmodyfikować RF. Na przykład, dla
wielu cech charakterystycznych wartości rang poniżej pewnej progowej wartości
stają się bez znaczenia – obrazy są po prostu ‘różne’. Dlatego może okazać się
korzystne usunięcie niepotrzebnej informacji na temat tych bardzo różnych
obrazów, i przypisanie jednej wartości rangi (np. 50) wszystkim obrazom, które są
poniżej określonego progu.
3. Symetryzacja macierzy RF
Większość algorytmów działających na macierzy wzajemnych odległości
między punktami zakłada, że są one symetryczne. Stąd symetryczna postać macierzy
RF jest pożądana. Można ją uzyskać na kilka sposobów, jeden z nich to dodanie
macierzy RF do jej transpozycji:
MF = RF + RFT (4.1.5-1)
Inna propozycja to wybranie maksimum według następującej zależności:
( , ) max ( , ), ( , )F F FM i j R i j R j i (4.1.5-2)
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 37
4. Połączenie kilku macierzy MF w jedną globalną strukturę
Jeśli używane były różne metody opisu zbioru obrazów (np. różne
deskryptory), to każda z tych metod da inną macierz MF. W tym kroku należy
zamienić te cząstkowe opisy w jeden całościowy opis. Najprościej zrobić to dodając
do siebie macierze MF, opcjonalnie dodając je z różnymi wagami.
i Fi
i
M a M (4.1.5-3)
5. Użycie dowolnego algorytmu przetwarzającego macierz wzajemnych odległości, by
uporządkować dane w nowej przestrzeni współrzędnych
Autorzy patentu zalecają użycie algorytmu Laplacian Eigenmap (PCA), jednak
podkreślają, że istnieje tu duża dowolność i różne podejścia mogą okazać się dobre.
Podsumowując, algorytm tworzenia przestrzeni Mutual-Rank Similarity-Space przetwarza
rzeczywiste odległości między danymi na odległości względne. Powoduje to, że wynik sortowania
staje się silnie uzależniony od rodzaju danych wejściowych, i końcowy rezultat obrazuje przede
wszystkim podobieństwa/różnice między tymi danymi, a nie ich bezwzględne cechy jak to ma
zwykle miejsce. Taka metoda pozwala potencjalnie na uzyskanie lepszej wizualizacji.
4.1.6. Zmodyfikowany PCA
Istnieje jeszcze inna możliwość zastosowania algorytmu PCA do sortowania obrazów. Została ona
zaproponowana przez autorów patentu dotyczącego przestrzeni Mutual-Rank Similarity-Space
(punkt 4.1.5.) i dostarcza całkiem ciekawych rezultatów.
W klasycznej metodzie sortowania poprzez rozkład PCA wykonuje się dwa zasadnicze kroki.
Najpierw znajduje się wektory własne macierzy kowariancji pewnych N-wymiarowych danych.
Następnie na M najważniejszych w ten sposób znalezionych wektorów rzutuje się wszystkie dane
wejściowe, aby dostać współrzędne w nowej M-wymiarowej przestrzeni.
Modyfikacja tego algorytmu polega na tym, że obliczenia nie są przeprowadzane na
oryginalnych danych, lecz na kwadratowej macierzy wzajemnych odległości elementów
wejściowych. Następnie nie jest liczona macierz kowariancji, lecz wektory własne są obliczane
bezpośrednio dla macierzy odległości z następującej zależności:
D A x Dx (4.1.6-1)
Gdzie
A - macierz odległości opisująca układ punktów w przestrzeni N wymiarowej
D – macierz diagonalna, powstała z sumowania wierszy (kolumn) macierzy A
λ – wartości własne macierzy D-A
x – szukane wektory własne
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 38
Rozwiązanie tego równania to N wektorów własnych, które przechowują nowe współrzędne
punktów w nowej przestrzeni. Po obliczeniu tych wektorów nie należy już wykonywać żadnego
rzutowania, lecz poszczególnym obrazom przypisać po dwie współrzędne dwóch głównych
wektorów własnych, i te współrzędne użyć bezpośrednio do reprezentacji.
Autorzy metody opisanej w akapicie 4.1.5. zalecają użycie tej właśnie metody jako
uzupełnienia transformacji do przestrzeni Mutual-Rank Similarity-Space. Należy tu zauważyć, że
można jej używać zarówno do macierzy wzajemnych odległości, jak i do macierzy wzajemnych
rang.
Testy wykazały, iż powyższa metoda daje bardzo dobre wyniki sortowania. Niestety jest
ona bardzo czasochłonna. Nie próbowano rozwiązać równania 4.1.6-1 metodą uproszczoną jak to
opisano w punkcie 4.1.2.2, ze względu na inną postać równania i ograniczenia czasowe. Dalsze
rozważania na temat tej metody znajdują się w rozdziale szóstym.
4.2. Inne Algorytmy
Istnieje wiele algorytmów z rodziny Multidimensional Scaling, które można również wykorzystywać
do automatycznego sortowania obrazów. Ich lista jest długa. Warto natomiast wspomnieć o
dwóch algorytmach, które nie zostały zaimplementowane, gdyż nie do końca pasują do problemu
automatycznego sortowania. Ich krótki opis wraz z uzasadnieniem ich pominięcia znajduje się
poniżej.
4.2.1. N-Land
Koncepcja N-Land bazuje na tzw. rozdzielaniu wymiarów (ang. dimensional stacking). Polega to na
tym, że wymiary danych do zobrazowania dzielone są na pary, a następnie rekurencyjnie
przedstawiane na płaszczyźnie jako x i y.
Można sobie wyobrazić, że pierwsze dwa wymiary spośród N będą współrzędnymi x i y
pewnej prostokątnej siatki. Wszystkie elementy o takiej samej wartości pierwszych dwóch
wymiarów ‘wpadną’ do tej samej komórki owej siatki. Aby można było rozróżnić między nimi, w
obrębie tej komórki tworzy się nową dwuwymiarową siatkę, która wyrazi kolejne dwa wymiary
pierwotnych danych. Taka operacja powtarzana jest rekurencyjnie aż do momentu, w którym
pozostanie tylko jeden nie wykorzystany wymiar danych wejściowych. Wówczas jest on wyrażany
kolorem lub intensywnością [Ward 1999]. Dla danych o parzystej liczbie wymiarów, cała
informacja jest wyrażana poprzez przestrzenne rozmieszczenie punktów o takiej samej barwie.
Najwyraźniej demonstruje to przykład. Zakładając, że należy przedstawić dane 6-
wymiarowe, otrzymuje się następują hierarchię siatek 2D:
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 39
Rys. 4.2.1-1 Rozwijanie wymiarów na płaszczyźnie [Ward 1999]
Z kolei wizualne przedstawienie całego zbioru danych 4-wymiarowych w taki sposób mogłoby
wyglądać następująco:
Rys. 4.2.1-1 Przedstawienie danych 4D metodą N-Land [Ward 1999]
Algorytm N-Land jest ciekawym i oryginalnym sposobem na wizualizację danych
wielowymiarowych. Jednakże w przypadku sortowania obrazów jest całkowicie niepraktyczny. Po
pierwsze rozmieszczenie, które on oferuje, nie zdołałoby ukazać w należyty sposób podobieństwa
między obrazami. Po drugie, przy deskryptorach składających się z kilkudziesięciu współczynników
wyniki algorytmu byłyby całkiem nieczytelne. Wreszcie, przy zakresach współczynników nie w
granicach 0-3 czy 0-6 (jak w powyższych przykładach), ale w zakresach o znacznie większej
rozpiętości, algorytm N-Land okazuje się zbyt prymitywnym narzędziem, by mógł dać jakiekolwiek
sensowne rezultaty. Z tych względów nie zdecydowano się na jego implementację w ramach
pracy.
4.2.2. Metoda K-średnich
Algorytm K-średnich (ang. K-means clustering) jest sposobem bardziej na grupowanie danych w
skupiska niż ich typowe sortowanie. Jednak dobrze nadaje się organizacji niektórych danych
wielowymiarowych, i stąd warto o nim wspomnieć.
W podstawowej wersji algorytm polega na wyborze ustalonej liczby k, która reprezentuje
liczbę skupisk, na jaką chcemy podzielić dane. Następnie należy zainicjować środek każdego
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 40
skupiska – może to być poprzez losowe wybranie k danych wejściowych, lub też trzymając się
określonego równomiernego rozłożenia środków w organizowanej przestrzeni. Następnie
wykonuje się następujące iteracyjne kroki aż do momentu, gdy wszystkie obliczane średnie
centroidy przestaną się przesuwać [Matteuci 2008]:
1. Przyporządkuj wszystkie punkty do najbliższego centroidu tak, aby spełniały zależność
(4.2.2-1):
gdzie:
Si(t) i-te skupisko punktów w chwili t
xj j-ty punkt z danych wejściowych mi środek i-tego centroidu
2. Dla wszystkich centroidów ustaw ich nowy środek jako średnią wszystkich przypisanych
punktów:
(4.2.2-2)
Poniższy rysunek obrazuje działanie tego algorytmu (4 iteracje) dla przypadku, gdy chcemy
podzielić dane wejściowe na dwa skupiska:
Rys. 4.2.2-1 Podział na skupiska wg K-średnich [Matteuci 2008]
Można sobie wyobrazić, że podobnie skutecznie jak pokazano w dwóch wymiarach algorytm ten
zadziała i dla N wymiarów. Tak więc będzie w stanie skutecznie pogrupować żądane obrazy.
Niestety jest z tym jednak kilka poważnych problemów.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 41
Po pierwsze, zakładając że obrazy są podzielone na grupy podobnych zbiorów pozostaje
pytanie jak je wyświetlić. Nie wiadomo jakie współrzędne najlepiej nadać obrazom. Chyba
najsensowniejsze podejście to wyświetlanie całkiem osobno zbiorów obrazów z tego samego
skupiska. Czy taka metoda jest jednak zadowalająca?
Istnieje jeszcze inny, poważniejszy problem. Otóż wejściowe obrazy wcale nie muszą
tworzyć grup o podobnej treści. Każdy może być inny i nie wykazywać większych podobieństw do
pozostałych. Jaki sens będzie miało wówczas pokazywanie skupisk? A nawet jeśliby takie skupiska
istniały, to jak rozpoznać ile ich jest? Liczba k musi być przecież z góry podana (choć istnieją
algorytmy określania liczby k w sensowny sposób, to nie są idealne).
Wszystkie te względy zadecydowały, że implementację algorytmu K-średnich uznano za
nieopłacalną.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 42
5. Zrealizowana aplikacja
Najbardziej pracochłonnym zadaniem do zrealizowania w ramach niniejszej pracy magisterskiej
było napisanie aplikacji, która zaimplementuje różne algorytmy sortowania oraz obliczanie
deskryptorów. To właśnie dzięki tej aplikacji możliwa była obserwacja i porównanie wyników
różnego rodzaju sortowania. Ze względu na wykonywane operacje wybrano dla aplikacji nazwę
Image Organizer.
Jako dość czasochłonne przedsięwzięcie z programistycznego punktu widzenia, tworzenie
aplikacji zostało starannie zaplanowane. W ramach tego planowania wybrano język
programowania, pomocnicze biblioteki które miały zostać użyte oraz ustalono architekturę i logikę
programu. Krótki opis wszystkich tych elementów znajduje się w kolejnych podrozdziałach.
5.1. Wybór narzędzi
Podstawową kwestią przy pisaniu jakiegokolwiek oprogramowania jest wybór środowiska
uruchomieniowego i języka, w jakim program zostanie stworzony. Kolejnym ważnym aspektem są
dodatkowe biblioteki, a szczególności biblioteka do tworzenia GUI, którą bardzo niewygodnie jest
zmieniać po rozpoczęciu pisania kodu.
Rodzaj środowiska uruchomieniowego leżał niemal wyłącznie w gestii autora, gdyż nie było
żadnych z góry narzuconych wymagań. Niemniej przenośność pomiędzy różnymi systemami
operacyjnymi zawsze jest dodatkowym atutem. Jako punkt wyjścia przyjęto, że kod wykonywalny
powinien poprawnie działać na najbardziej popularnym systemie operacyjnym – MS Windows, a
jeśli to możliwe to również na systemie Linux.
5.1.1. Wybór języka programowania
Autor miał pełną swobodę w wyborze języka programowania. Niemniej, pożądane było aby język
pozwalał na tworzenie szybko działającego kodu wykonywalnego, obsługiwał wielowątkowość
oraz nie był ściśle przypisany do jednej platformy systemowej.
Logicznym wyborem był język już dobrze znany przez autora. Do tych należały przede
wszystkim C++, Java oraz Python. Aby podjąć decyzję, przeprowadzona została krótka analiza,
której wynikiem jest poniższa tabela [Prata 2006, Python Software Foundation 2010, Wikipedia
2008a]. Ukazuje ona najważniejsze różnice oraz cechy wspólne tych trzech języków.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 43
Tabela 5.1.1-1 Porównanie C++, Javy i Pythona
C++ Java Python
kompilowany (bardzo szybki) kompilowany (średnio szybki) skryptowy (najwolniejszy)
wykonywany bezpośrednio przez system operacyjny
uruchamiany przez JVM czytany przez interpreter
bardzo wydajny pamięciowo średnio wydajny pamięciowo średnio wydajny pamięciowo
wolny w pisaniu szybszy w pisaniu niż C++ najszybszy w pisaniu
szeroko wspierany przez wbudowane / zewnętrzne biblioteki
obiektowy, wspiera wielowątkowość
przenośny na różne systemy operacyjne
Z porównania wynika, że najwięcej zalet przemawia za językiem C++. Szczególnie istotne są
największa szybkość działania i najlepsza wydajność pamięciowa – gdyż aplikacja do sortowania i
wyświetlania obrazów kładzie nacisk na te aspekty. Jako że autor ponad to miał najwięcej
doświadczenia w tym języku programowania, został on wybrany do stworzenia aplikacji.
5.1.2. Wybór bibliotek
Gdy już został wybrany język C++, konieczne było wybranie biblioteki do tworzenia GUI, jako że
język sam w sobie nie udostępnia żadnych elementów interfejsu graficznego. Ponadto należało
zastanowić się nad innymi narzędziami, które będą potrzebne i są oferowane w postaci gotowego
kodu wykonywalnego lub binarnego.
5.1.2.1. Biblioteka GUI
Istnieje bardzo wiele bibliotek do tworzenia GUI w języku C++. Porównanie najważniejszych
znajduje się w załączniku A i zostało przez autora opracowane w ramach innej pracy pt. Przegląd
narzędzi do wizualizacji danych w 2D i 3D, możliwych do wykorzystania w projekcie AiD,
wykonywanej dla Instytutu Problemów Jądrowych w Świerku.
Przy ostatecznym wyborze biblioteki kierowano sie przede wszystkim obszernością i
jakością dokumentacji dostępnej online, przenośnością biblioteki i bogactwem oferowanych
elementów GUI. Po analizie możliwości zdecydowano się użyć biblioteki Qt (licencja GPL). Bibliotekę tę charakteryzuje bardzo dobra i wciąż aktualizowana dokumentacja online, duża
ilość gotowych przykładów demonstrujących jej użycie, a przede wszystkim przenośność i
elastyczność – można linkować ją zarówno statycznie jak i dynamicznie [Nokia 2008, Nokia
Corporation 2008]. Pisanie kodu z jej wykorzystaniem wydaje się być nawet szybsze i prostsze niż
w Javie, a liczne przykłady dostępne w Internecie dodatkowo ułatwiają to zadanie.
Wybór tej biblioteki był jednak podyktowany nie tylko oferowanym przez nią GUI. W
aplikacji sortującej obrazy konieczne jest użycie dekoderów plików graficznych, a mile widziane są
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 44
gotowe obiekty ułatwiające ładowanie i przechowywanie obrazów. Ponadto, wobec kosztownych
operacji obliczeniowych jakich można się spodziewać przy sortowaniu danych wielowymiarowych,
wielowątkowość wydaje się koniecznością. Wszystkie te elementy są w pełni wspierane przez Qt.
5.1.2.2. Biblioteka matematyczna
Choć Qt oferuje bardzo wiele, to przy sortowaniu wielowymiarowym zachodzi czasem
potrzeba użycia skomplikowanych przekształceń macierzowych. Trudno zaimplementować
samemu np. liczenie wektorów własnych macierzy. Przede wszystkim jednak nie ma to sensu,
skoro gotowe i sprawnie wykonujące to biblioteki są już napisane. Jako że pewne operacje
macierzowe były wymagane do implementacji algorytmu PCA, zdecydowano się poza Qt użyć
jeszcze biblioteki matematycznej.
Do wyboru było kilka możliwości. Większość bibliotek to jednak kod binarny – który
trudniej jest połączyć ze swoim programem, a ponadto nie ma się wglądu do jego wnętrza. Z tego
względu zdecydowano się skorzystać z biblioteki ALGLIB [Bochkanov 2009]. Dołącza się ją w
postaci plików źródłowych i kompiluje razem z programem, co jest niewątpliwą zaletą. Ponadto
biblioteka ta jest darmowa (GPL) oraz oferuje bardzo dużo jeśli chodzi o operacje na macierzach i
wykonywanie na nich przekształceń, więc idealnie nadaje się do wykorzystania w ramach niniejszej
pracy.
Ostateczna wersja aplikacji została skompilowana pod system MS Windows z wykorzystaniem
kompilatora MinGW. Nic nie stoi jednak na przeszkodzie, aby skompilować aplikację pod system
Linux, jako że cały napisany kod wraz z użytymi bibliotekami jest przenośny.
5.2. Ogólna architektura i logika programu
Wymagania stawiane aplikacji zostały już wymienione w podrozdziale 1.2. Pozostała jednak
decyzja o tym, jak aplikacja ma wyglądać od strony funkcjonalnej.
5.2.1. Funkcjonalność
Zdecydowano, że powinna być możliwość załadowania obrazów do pamięci, a następnie ich
posortowania ze wskazaniem który algorytm i który deskryptor ma być użyty. Jako że liczenie
deskryptorów powinno być wykonywane tylko raz dla każdego obrazu, jest to robione w
momencie ładowania obrazów. Poza sortowaniem za bardzo użyteczne uznano możliwość
wybrania podzbioru załadowanych obrazów do sortowania oraz powiększenie regionu
zainteresowania. Ponadto, jako że niniejsza praca była po części realizowana jako praca
inżynierska na Coventry University, wymagano zapewnienia podstawowych operacji na
zaznaczonych obrazach (przeniesienie na dysku, otwarcie itp.), a także możliwości filtrowania za
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 45
pomocą słów kluczowych (o czym więcej w podrozdziale 5.5.) Uproszczony schemat funkcjonalny
zrealizowanej aplikacji znajduje sie poniżej.
5.2.1-1 Ogólny schemat funkcjonalny aplikacji
Pola zaznaczone na czerwono reprezentują opcje dostępne dla użytkownika w każdym momencie.
Poza tymi opcjami to co może zrobić użytkownik zależy od stanu, w jakim znajduje się program.
Zasadniczo są dwa stany.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 46
1. Stan bez żadnych obrazów załadowanych do pamięci programu
W tym stanie wyświetlane jest główne okno programu i nie są pokazywane żadne obrazy.
Aby móc coś więcej zrobić, użytkownik musi najpierw załadować obrazy. Może to zrobić
pojedynczo, lub całymi katalogami klikając na drzewo katalogów widoczne w lewej części
głównego okna programu (Rys. 5.3-1). Zanim obrazy zostaną załadowane należy wybrać
deskryptory jakie będą używane w zakładce opcji, a dodatkowo można wybrać sposób filtrowania
za pomocą słów kluczowych korzystając z panelu w prawej części głównego okna.
2. Stan z obrazami załadowanymi do pamięci programu
Gdy obrazy są załadowane do pamięci programu, to wyświetlane są w głównym panelu
jako miniatury. Można je wszystkie posortować wybierając jedną z dostępnych opcji sortowania
lub też wybrać jakiś podzbiór do kolejnych operacji. Dla zaznaczonych obrazów można edytować
opisujące je słowa kluczowe, przenosić je na dysku, otwierać je, kopiować czy usuwać. Więcej na
ten temat znajduje się w podrozdziale 5.3.
5.2.2. Logika i przegląd klas
Jako że cała aplikacja wraz z GUI i wielowątkowością jest oparta na bibliotece Qt, po
uruchomieniu aplikacji tworzony jest obiekt głównej klasy MainWindow dziedziczącej po
QMainWindow, który to obiekt jest odpowiedzialny za wyświetlanie GUI, obsługę interakcji
użytkownika, uruchamianie innych wątków i ogółem całą komunikację ze wszystkimi innymi
obiektami w programie. Listę klas (każda dla przejrzystości napisana w osobnym pliku) wraz z
krótkim opisem przedstawia poniższa tabela.
Tabela 5.2.2-1 Lista klas stworzonej aplikacji
Nazwa klasy Funkcja
MainWindow Wyświetla główne okno programu, łączy wszystkie elementy GUI i inne obiekty ze sobą, obsługuje większość akcji użytkownika i przekazuje je do odpowiednich obiektów podrzędnych. Ponadto przechowuje załadowane obrazy
ImageScene Scena na której umieszczane są obrazy
ImageView Struktura przez którą oglądane są obrazy (wymagane przez architekturę grafiki 2D w Qt)
ImageItem Reprezentuje załadowany obrazek – przechowuje sam obrazek, opisujące go deskryptory i ew. słowa kluczowe
LoadImagesThread Wątek ładujący obrazy do programu
ResizeImagesThread Wątek skalujący obrazy podczas operacji zbliżania / oddalania
KeywordUtil Narzędzie do manipulacji na słowach kluczowych opisujących obrazy
KeywordDialog Okno dialogowe ukazujące się podczas edycji słów kluczowych
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 47
EigenMapIterThread
EigenMapThread
FastMapThread
SomUtilThread
Wątki wykonujące sortowanie wybranych obrazów – każdy sposób sortowania reprezentowany jest przez osobną klasę i tak też osobny wątek
ColLayoutDescriptor
ColStructureDescriptor
ColTempDescriptor
ScalableColDescriptor
Klasy deskryptorów – przechowują obliczone deskryptory opisujące obrazy
ColLayoutExtrUtil
ColStructureExtrUtil
ColTempExtrUtil
ScalableColExtrUtil
Narzędzia do obliczania deskryptorów i porównywania ich ze sobą, liczą deskryptory na podstawie obrazów oraz wykonują operacje na deskryptorach
Kod źródłowy jest załączony na płycie CD i umożliwia zainteresowanym dokładniejsze
prześledzenie struktury programu.
5.3. Interfejs Graficzny (GUI)
Cały interfejs graficzny jest oparty na elementach biblioteki Qt. Krótki przegląd najlepiej zacząć od
przedstawienia głównego okna po uruchomieniu programu – widok poniżej.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 48
Rys. 5.3-1 Główne okno programu Image Organizer
Można powiedzieć, że główne okno składa się zasadniczo z paska menu oraz sześciu paneli
zaznaczonych czerwonymi elipsami na powyższym rysunku. Ich krótka charakterystyka znajduje się
poniżej.
0. Pasek Menu – zawiera trzy listy. File umożliwia wyjście z programu. About umożliwia
ukazanie informacji o programie. Najciekawszą listą jest lista Options, która po
rozwinięciu wygląda jak na rys. 5.3-2.
Użytkownik może tu ustalić, który deskryptor będzie obliczany przy ładowaniu obrazów,
który algorytm zostanie wykorzystany do automatycznego sortowania oraz kilka innych
opcji takich jak kolor tła czy ładowanie obrazów z podfolderów.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 49
Rys. 5.3-2 Lista Options
1. Pasek narzędzi – umożliwia posortowanie obrazów alfabetycznie po rozmiarze, po dacie
stworzenia oraz według podobieństwa (przedmiot pracy). Ponadto umożliwia usunięcie
wybranych obrazów i pokazanie wszystkich (w sytuacji gdy jakieś są ukryte). Ten pasek
jest uaktywniany po załadowaniu obrazów do aplikacji i wówczas wygląda następująco:
Rys. 5.3-3 Pasek narzędzi
2. Drzewo katalogów – umożliwia wybór obrazów do załadowania poprzez podwójne
kliknięcie na plik obrazu lub kliknięcie na katalog z wciśniętym klawiszem SHIFT.
3. Panel miniatury – wyświetla miniaturę obrazu znajdującego się pod kursorem myszy gdy
mysz przesuwa się nad drzewem katalogów oraz nad obrazami w głównym panelu (4).
4. Główny panel – wyświetla wszystkie lub część załadowanych obrazów. To tutaj są
wyświetlane miniatury obrazów i możliwe jest oglądanie wyników sortowania. Po
załadowaniu i posortowaniu obrazów panel ten może wyglądać następująco:
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 50
Rys. 5.3-4 Panel główny
Warto dodać, że klikając na obrazy z wciśniętym klawiszem SHIFT można je zaznaczać, a
następnie korzystając z menu kontekstowego wykonać wybraną operację taką jak
ukrycie ich w programie czy przeniesienie ich na dysku.
Rys. 5.3-5 Menu kontekstowe
5. Panel słów kluczowych – zrealizowany w celu edycji słów kluczowych i filtrowania
obrazów za pomocą słów kluczowych na potrzeby pracy inżynierskiej na Coventry
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 51
University. Nie będzie szerzej omawiany gdyż nie jest ściśle związany z tematyką
niniejszej pracy.
6. Panel podpowiedzi i informacji – znajduje się w dolnej części ekranu i wyświetla
wskazówki co użytkownik może zrobić w danym momencie. W lewej jego części są też
wyświetlane podstawowe informacje o obrazach z głównego panelu, nad którymi
aktualnie znajduje się kursor myszy.
Rys. 5.3-6 Podstawowe informacje o obrazie z panelu głównego
Reszta stworzonego GUI nie będzie omawiana gdyż nie jest szczególnie istotna z punktu widzenia
tematyki niniejszej pracy.
5.4. Szczególne problemy napotkane w trakcie implementacji
Podczas tworzenia aplikacji napotkano szereg problemów praktycznych, o których warto
wspomnieć, jako że ich rozwiązania nie były oczywiste.
5.4.1. Pamięć zajmowana przez ładowane obrazy
Cyfrowe obrazy są zapisane na dysku w postaci skompresowanej tak, by nie zajmować dużo
miejsca. Jednakże ich załadowanie do pamięci operacyjnej poprzedza proces dekompresji, po
którym okazuje się, że obrazy zajmują niebezpiecznie dużo. Warto policzyć, ile miejsca w pamięci
RAM zajmuje obrazek a wymiarze 2000x3000 pikseli zakładając 32bpp:
3000 2000 32 192000000 24000000 22,9x x bity bity bajty MB
Zatem, aby załadować do pamięci 10000 takich obrazów, potrzeba aż 230 GB pamięci RAM! Łatwo
zdać sobie sprawę, że nawet najnowsze komputery nie posiadają takich zasobów.
Aby rozwiązać tę trudność, zdecydowano się ładować do pamięci programu tylko miniatury
obrazów o rozmiarze 128x128 pikseli. Dzięki temu dysponując pamięcią o wielkości 2GB można
załadować ponad 32000 obrazów.
Ładowanie do pamięci miniatur obrazów powoduje problem przy powiększaniu – miniatura
wygląda dobrze tylko gdy jest mała. Aby ten problem obejść, stworzono klasę ResizeImageThread,
która podczas powiększania wybranego regionu przeładowuje widoczne w powiększeniu obrazy,
wczytując je w wyższej rozdzielczości. Działanie obiektu tej klasy uruchamiane jest w osobnym
wątku, dzięki czemu powiększanie wybranych regionów za pomocą kółka myszy jest płynne, a
obrazy są podmieniane w momencie gdy obiekt ResizeImageThread skończy swoje działanie.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 52
5.4.2. Szybkość ładowania obrazów
Niestety odczytywanie obrazów z dysku, ich dekompresja i ładowanie do pamięci zajmuje dużo
czasu. Ładowanie 1000 obrazów z aparatu fotograficznego zajmuje kilka minut. Takie czasy są nie
do przyjęcia w aplikacji która ma być szybka i użyteczna.
Okazuje się, że ładowanie obrazów do pamięci przebiega znacznie szybciej gdy są ładowane
w niższej rozdzielczości – wówczas krócej trwa dekompresja i krócej trwa ich kopiowanie z dysku
do pamięci RAM. Poprawia to szybkość ładowania kilkakrotnie.
Mimo tego, szukano jeszcze innego sposobu by tą szybkość poprawić. Okazało się, że
dekoder JPEG oferowany przez bibliotekę Qt ma parametr określający jakość dekodowania.
Zmniejszając ten parametr do minimum przy ładowaniu miniatur 128x128 pozwoliło na
dodatkowe dwukrotne skrócenie czasu ładowania przy niezauważalnym pogorszeniu jakości. Przy
powiększaniu wybranych regionów obrazy są ładowane w wyższej rozdzielczości i jakości.
Wykres 5.4.2-1 Czas ładowania obrazów dla Image Organizer (porównanie szybkości wykonano w
architekturze jednowątkowej, stąd czasy są krótsze niż w ostatecznej wersji aplikacji)
5.4.3. Szybkość i jakość sortowania
Zasadniczo tematyka szybkości i jakości sortowania jest szeroko omówiona w rozdziale szóstym.
Niemniej, na wstępie należy zaznaczyć kilka istotnych kwestii jeśli chodzi o poprawę szybkości
sortowania.
Zasadniczo szybkość zależy od tego jak duży jest deskryptor (im większą tablicą jest
deskryptor tym dłużej trwa jego przetwarzanie i co za tym idzie sortowanie) oraz od algorytmu
sortującego. Należy zaznaczyć, że poprawa wydajności jednego z algorytmów ma symboliczne
14,3
4,7
2,5
0
2
4
6
8
10
12
14
16
normalne
obrazki
miniatury
128 x 128
miniatury +
skalowalna jakość
Czas ładowania [s] 1000 obrazków
384x256 na Intel Core 2 Duo 2,4 GHz
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 53
znaczenie w porównaniu z możliwością stosowania algorytmów o całkiem różnej złożoności.
Dlatego położono nacisk na możliwość łączenia różnych metod sortowania ze sobą. I tak też można
posortować wszystkie obrazy najszybszym algorytmem, następnie zaznaczyć podzbiór i
posortować go innym algorytmem. Takie podejście zapewnia elastyczność i możliwość
najefektywniejszego stosowania automatycznego sortowania.
Pozostałe zabiegi stosowane do poprawy szybkości sortowania mają już bezpośrednio
negatywny wpływ na jakość sortowania i są zależne od konkretnego algorytmu. Z reguły polegają
na zmniejszeniu iteracji bądź na pewnych aproksymacjach. Więcej o tym w rozdziale szóstym.
5.5. Elementy zrealizowane w ramach pracy inżynierskiej na
Coventry University
Dwa elementy w aplikacji Image Organizer zostały zrealizowane wyłącznie na potrzeby
pracy inżynierskiej na Coventry University i zostaną tylko krótko przedstawione w tym
podrozdziale, gdyż nie są ściśle związane z tematyką pracy magisterskiej.
5.5.1. Słowa kluczowe
Aplikacja Image Organizer umożliwia odczyt i zapis słów kluczowych w nagłówkach plików
graficznych reprezentujących obrazy. Uznano taką formę obsługi meta danych za najciekawszą w
implementacji, gdyż nie wymaga ona tworzenia osobnej bazy danych a słowa kluczowe są zapisane
bezpośrednio z obrazem, więc łatwo je znaleźć bez przeszukiwania dużej ilości innych informacji.
Obsługiwane są formaty JPG, GIF, PNG oraz BMP. Każdy z tych formatów zawiera w
strukturze pliku pole, w którym można umieścić meta dane. Stworzona aplikacja umożliwia
manipulację tych danych tak, by można było dopisać lub skasować wybrane informacje.
Szczególnie pomocne przy pracy nad tym zagadnieniem okazały się źródła [Augustyniak 2007,
Code Project 2001, Digital Camera Software 2009, Maas 2003, PNG 2008, W3C 2008].
Aby maksymalnie ułatwić użytkownikowi edycję słów kluczowych i wyszukiwanie obrazów
za ich pomocą, wprowadzono także możliwość przypisania obrazu do jednej z góry narzuconych
kategorii, które tworzą hierarchiczną strukturę. Jak demonstruje rysunek 5.5.1-1 do obrazu można
przypisywać dowolnie wybraną kategorię z trzystopniowej hierarchii, oraz dowolne słowa
kluczowe oddzielone przecinkami.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 54
Rys. 5.5.1-1 Opis obrazów za pomocą kategorii i słów kluczowych w Image Organizer
5.5.2. Operacje na obrazach
Aby zapewnić aplikacji wymaganą przy pracy inżynierskiej użyteczność, konieczne było
zapewnienie możliwości wykonywania różnych operacji na już posortowanych obrazach. Zostały w
tym celu umożliwione podstawowe operacje na zaznaczonej grupie obrazów: skopiowanie do
wybranej lokalizacji, przeniesienie do wybranej lokalizacji, usunięcie z dysku oraz otwarcie w
domyślnym edytorze zdjęć cyfrowych.
Poza tym oprócz automatycznego sortowania na podstawie wizualnego podobieństwa
(na podstawie deskryptorów), dodano możliwość sortowania po nazwie, rozmiarze i dacie
stworzenia. Wyboru odpowiedniego rodzaju sortowania użytkownik dokonuje klikając na
odpowiednią ikonkę na pasku narzędzi.
Rys. 5.5.2-1 Różne opcje sortowania reprezentowane przez ikonki na pasku narzędzi
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 55
6. Testy i ich rezultaty
Głównym powodem stworzenia aplikacji Image Organizer była chęć użycia programu do
porównania różnych deskryptorów i różnych metod sortowania obrazów ze sobą. Wszystkie
przeprowadzone porównania i testy są opisane w tym rozdziale.
6.1. Porównanie deskryptorów
Niemożliwe jest jednoczesne porównanie różnych deskryptorów i różnych algorytmów sortowania
ze sobą. Dlatego, jako że główną częścią pracy jest porównywanie algorytmów, najpierw zostaną
krótko scharakteryzowane różnice przy sortowaniu z użyciem różnych deskryptorów.
6.1.1. Czas ekstrakcji deskryptorów
Choć czas ekstrakcji deskryptorów przy ładowaniu obrazów nie jest najważniejszy, to należy ten
czas uwzględnić. Zasadniczo algorytmy liczenia deskryptorów zostały w aplikacji
zaimplementowane na podstawie referencyjnego oprogramowania MPEG-7 eXperimentation
Model (XM) [MPEG 2003]. Na podstawie kodu referencyjnego stworzono własny kod, który miał
dawać analogiczne rezultaty. Jedyną różnicą pomiędzy deskryptorami obliczanymi przez
oprogramowanie MPEG-7 XM a stworzoną aplikacją jest to, że Image Organizer domyślnie liczy
deskryptory dla miniatur obrazów o wymiarach 128x128. Dokładność przy tym sposobie jest
jednak bardzo zbliżona, a znacznie skraca się czas obliczeń.
Aby porównać ze sobą czas ekstrakcji różnych deskryptorów, porównano szybkość
ładowania 1000 obrazów o wymiarach 384x256 pikseli. Należy tylko zaznaczyć, że podane czasy
dotyczą ładowania obrazów – zatem wszystkich operacji włącznie z odczytywanie z dysku i
dekompresją.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 56
Wykres 6.1.2-1 Porównanie szybkości ładowania obrazów przy ekstrakcji różnych deskryptorów
(dla architektury wielowątkowej aplikacji - ostatecznej)
Jak widać czas ekstrakcji deskryptorów bywa bardzo różny. Dla deskryptorów Color Layout i Color
Temperature jest najkrótszy i wynosi ok. 30% czasu ładowania obrazów. Można powiedzieć, że taki
narzut z praktycznego punktu widzenia jest do przyjęcia. Z kolei dla deskryptora Color Structure
czas ten wynosi aż 250% czasu ładowania miniatur obrazów, co jest dużym narzutem i wielkim
minusem tego deskryptora w praktycznym zastosowaniu do sortowania.
6.1.2. Wizualne różnice w wyniku sortowania
Aby porównać wizualne wyniki sortowania z użyciem różnych deskryptorów, należy najpierw
wybrać algorytm sortujący. Zdecydowano się użyć do tego celu algorytmu SOM, jako że
przedstawia on wyniki w wygodnej do porównań formie, bez nakładających się obrazów. Do
testów użyto zbioru 1000 obrazów testowych. Wyniki przedstawiono poniżej.
7,1
8,9 9,210,2
18,3
0
2
4
6
8
10
12
14
16
18
20
Bez liczenia
deskryptorów
Color Layout Color
Temperature
Scalable Color Color
Structure
Czas ładowania [s] 1000 obrazków 384x256 na
Intel Core 2 Duo 2,4 GHz
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 57
Rys. 6.1.2-1 SOM z użyciem CLD dla 1000 obrazów
Sortowanie z użyciem deskryptora Color Layout jest wykonywane najszybciej i daje najmilsze
wizualnie wyniki. Układa ono obrazy przede wszystkim według występujących w nich kolorów tak,
by uzyskać płynny efekt zmiany treści podczas przemieszczania się między posortowanymi
obrazami.
Skuteczność deskryptora prawdopodobnie leży w jego małej liczbie współczynników –
dziewięciu. Choć w tabeli 3.2.1-1 znajduje się 12 niezerowych wag, to testy wykazały że można
pominąć 3 najmniej znaczące współczynniki Y bez zauważalnego pogorszenia jakości sortowania,
zwiększając szybkość sortowania o 25%. Przy tym średnie wartości Y, Cb i Cr (pierwsze
współczynniki z każdej grupy) brane są ze zdecydowanie największymi wagami przy obliczaniu
odległości. Z tego względu deskryptor w dużej mierze opisuje średni kolor obrazu, a w mniejszej
przestrzenne rozmieszenie kolorów.
Choć wizualnie CLD daje najlepsze wyniki, to nie można powiedzieć, że do wszystkich
zastosowań będzie to najlepszy sposób opisu obrazów. Przy wyszukiwaniu określonej tekstury
może on okazać się całkiem bezużyteczny.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 58
Rys. 6.1.2-2 SOM z użyciem SCD dla 1000 obrazów
W stworzonej aplikacji deskryptor Scalable Color jest używany w najbardziej okrojonej wersji - z 16
współczynnikami. W zasadzie SCD odpowiada szczególnemu, przekształconemu transformatą
Haara histogramowi kolorów. W porównaniu z CLD, deskryptor SCD ma tendencję do skupiania
obrazów w grupy o podobnej treści. Poza tym jednak wydaje się dawać gorsze rezultaty – bardziej
nierównomierne i ‘zaszumione’, gdyż obrazy obok siebie nie zawsze płynnie zmieniają
kolorystyczną treść.
Prawdopodobnie gorsze wizualnie wyniki wynikają z tego, że trudniej na dwuwymiarową
płaszczyznę przetransformować 16 wymiarów niż 9. Poza tym, jako że SCD jest przechowywany w
bardzo skompresowanej postaci przy 16 współczynnikach (wybranych z 256), może się łatwo
zdarzyć, że różne obrazy będą miały zbliżone deskryptory. Z drugiej strony większa liczba
współczynników niż dla deskryptora CLD powoduje, że odległości między całkiem różnymi parami
obrazów mogą być bardzo podobne – jednak z różnych przyczyn.
Drugą wadą użycia SCD do automatycznego sortowania jest to, że trwa ono znacznie dłużej
niż z użyciem CLD, gdyż deskryptor SCD ma niemal dwukrotnie więcej współczynników.
Podsumowując, deskryptor SCD wydaje się być mniej efektywny w użyciu do
automatycznego sortowania niż deskryptor CLD.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 59
Rys. 6.1.2-3 SOM z użyciem CTB dla 1000 obrazów
Color Temperature Browsing jest szczególnym deskryptorem, gdyż ma tylko jeden współczynnik –
jest więc jednowymiarowy. Z tego względu używając tylko i wyłącznie tego deskryptora łatwiej by
było posortować obrazy w jednym wymiarze – np. na prostej niż na płaszczyźnie. Niemniej
algorytm SOM umożliwia też sortowanie z użyciem CTB w dwóch wymiarach. W efekcie obrazy
zostają uszeregowane według liniowo zmieniających się wartości tego deskryptora od góry do dołu
ekranu (lub w innych kierunkach, zależnie od inicjalizacji). Na rys. 6.1.2-3 widać obrazy o najniższej
średniej temperaturze barwowej na górze, a te o najwyższej na samym dole.
Jako że Color Temperature Browsing składa się tylko z jednego współczynnika, sortowanie
według niego jest szybkie. Niemniej wyniki są ograniczonej wartości i zdaje się, że przedstawianie
ich ma sens raczej w jednym wymiarze. Nie zmienia to faktu, że deskryptor ten może się
znakomicie nadawać do wstępnego uszeregowania obrazów (jak wskazuje sama jego nazwa) i
wyboru podzbioru do dalszego sortowania używając innego deskryptora i algorytmu.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 60
Rys. 6.1.2-4 SOM z użyciem CSD dla 1000 obrazów
Deskryptor Color Structure daje całkiem ciekawe rezultaty. Ze względu na szczególny sposób
akumulacji histogramu znakomicie nadaje się do porównywania tekstury i struktury kolorystycznej
różnych obrazów. Widać to na powyższym rysunku. Wiele sąsiadujących ze sobą obrazów jest
bardzo podobnych. Do tego stopnia, że analizując niektóre fragmenty posortowanej mapy można
mieć wrażenie, iż sąsiednie obrazy są lepiej dopasowane niż przy użyciu Color Layout.
Niestety deskryptor ten ma jedną poważną wadę. Dobre wyniki daje tylko przy użyciu
pełnego, 256-komórkowego histogramu. Przy próbach scalania komórek, jakościowe rezultaty
sortowania z użyciem tego deskryptora są zdecydowanie niezadowalające. Stąd na powyższym
rysunku użyto jego pełnej, 256-elementowej wersji. Jako że składa się on z 256 współczynników, to
sortowanie z jego użyciem jest bardzo wolne, a ponadto powstają różne problemy przy
mapowaniu aż 256 wymiarów na 2 wymiary. Wydaje się to być powodem miejscowych ‘zaburzeń’
podobieństwa sąsiednich obrazów, obserwowanych na rysunku 6.1.2-4.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 61
6.2. Ogólne porównanie algorytmów
Na podstawie rozważań z podrozdziału 6.1 do porównywania ze sobą algorytmów sortowania (6.2-
6.4) zdecydowano używać deskryptora Color Layout. Decyzja została podjęta ze względu na
najlepsze rezultaty czasowe i jakościowe sortowania z użyciem tego deskryptora.
6.2.1. SOM
W przypadku map samoorganizujących SOM były do wyboru dwa warianty algorytmu: Incremental
SOM i Batch SOM, jak to zostało opisane w rozdziale 4. Porównano obie wersje i okazało się, że
wbrew oczekiwaniom Batch SOM nie działa szybciej gdy implementuje się go w C++. Możliwe, iż w
MATLABIE ma on większą przewagę nad klasycznym algorytmem, niemniej autorowi nie udało się
tego zaobserwować. W teorii oba algorytmy wykonują w przybliżeniu tyle samo operacji i mają
złożoność obliczeniową tego samego rzędu (≈N3). Na dodatek, algorytm Batch SOM dawał
minimalnie gorsze rezultaty wizualne przy sortowaniu, więc ostatecznie zdecydowano się z niego
zrezygnować.
Jeśli chodzi o parametry algorytmu Incremental SOM, to dążąc do kompromisu pomiędzy
czasem sortowania a jakością sortowania, ustalono je eksperymentalnie jako następujące (N –
liczba danych wejściowych, czyli obrazów):
Liczba węzłów uczonej mapy: 1.3 x N (30% pustych miejsc na końcu)
Liczba iteracji uczenia: 10 x N
Początkowy promień uczenia: 0.2 x N
Zmniejszanie promienia uczenia: liniowe
Funkcja wag uczenia sąsiedztwa: gaussowska
Ponadto, celem skrócenia czasu sortowania, zdecydowano się zaimplementować przeskok
niektórych iteracji w środku normalnego procesu uczenia. Standardowo parametr czasu t zmienia
się od 0 do 1 liniowo, i przy każdej zmianie wykonuje się jedną iterację znalezienia BMU i uczenia
sąsiadów. W zmodyfikowanym algorytmie niektóre z tych iteracji są pomijane (ok. 20%). Pozwala
to skrócić czas sortowania o 20% bez widocznego pogorszenia jakości.
W implementacji algorytmu zrezygnowano z losowej inicjalizacji uczonej mapy, gdyż taka
inicjalizacja daje gorsze rezultaty. Zamiast tego zdecydowano się przygotować wcześniej
wytrenowaną dużym zbiorem obrazów mapę, która odpowiednio przeskalowana odpowiada
początkowemu stanowi nowej uczonej mapy.
Poza samym procesem uczenia, w algorytmie SOM bardzo ważny jest element
dopasowania obrazów do już wyuczonej mapy. Dopasowywanie po kolei kolejnych obrazów do
najlepszych węzłów może spowodować, że ostatnie rozważane obrazy nie znajdą się w dobrym
miejscu, bo najlepszy dla nich węzeł będzie już zajęty. Stąd zdecydowano się na nieco bardziej
skomplikowaną metodę. Wygląda ona następująco.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 62
1. Tworzona jest lista dopasowań, która dla każdego węzła na wyuczonej mapie przechowuje
pięć najlepiej pasujących elementów wejściowych.
2. Ta lista wszystkich możliwych dopasowań jest sortowana według rosnącej rozbieżności
dopasowania danych wejściowych do odpowiadających BMU.
3. Brane są kolejne wpisy z tej listy oraz:
a. Jeśli element wejściowy z danego wpisu został już umieszony na mapie, to brany
jest następny wpis z listy.
b. Jeśli węzeł na mapie z danego wpisu jest już zajęty, to brany jest następny wpis z
listy.
c. W przeciwnym razie element wejściowy jest przypisywany do odpowiadającego
węzła z danego wpisu.
4. Jeśli po przejściu całej listy dopasowań pozostają jakieś dane wejściowe jeszcze nie
przypisane do wyuczonej mapy, to zostają one na końcu przypisane po kolei, każda do
najlepiej pasującego węzła. Takich danych nie powinno być jednak dużo.
Według takiego rozumowania najpierw przypisywane są do wyuczonej mapy najlepiej pasujące
wektory wejściowe. To podejście nie jest zbyt kosztowne obliczeniowo, a nieco poprawia jakość
ostatecznego dopasowania danych wejściowych w porównaniu z przydziałem w losowej
kolejności.
Kolejną istotną rzeczą, o której należy wspomnieć przy okazji algorytmu SOM, jest kształt
uczonej mapy. Struktura prostokątna nie sprawdza się najlepiej. Lepszym rozwiązaniem jest użycie
struktury Torusa – takiego prostokąta, którego krawędzie zawijają i łączą się. To znaczy lewa
krawędź przechodzi w prawą, a dolna w górną. Widać to na rys. 6.2.1-1 demonstrującym
sortowanie 1000 obrazów metodą SOM. Na przykład obrazy na prawej krawędzi są podobne do
tych na lewej krawędzi.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 63
Rys. 6.2.1-1 Sortowanie SOM
Jeśli chodzi o szybkość sortowania, to algorytm SOM plasuje się miedzy algorytmem PCA a
algorytmami FastMap i skróconym PCA. Więcej na ten temat znajduje się w podrozdziale 6.3.
6.2.2. FastMap
W przypadku algorytmu FastMap w zasadzie niewiele można wybrać jeśli chodzi o opcjonalne
ustawienia. Cały algorytm został zaimplementowany dokładanie tak jak to opisano w ustępie 4.1.3.
W porównaniu z SOM działa on znacznie szybciej, gdyż nie występuje w nim kosztowny
obliczeniowo proces uczenia mapy węzłów. Ma jednak pewną wadę – posortowane obrazy są
umieszczone w różnych punktach ciągłej płaszczyzny. W wyniku tego nie są rozmieszczone na
prostokątnej siatce i mogą się nakładać na siebie, jeśli obrazom w celu wygodnego ukazania ich
treści zostaną nadane pewne niezerowe wymiary. Rysunek 6.2.2-1 przedstawia wynik sortowania
za pomocą FastMap dla tych samych 1000 obrazów co wcześniej.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 64
Rys. 6.2.2-1 Sortowanie FastMap
Widać wyraźnie obrazy, które zostały wybrane przez algorytm jako najbardziej odległe punkty
wyznaczające wirtualne proste. Są to obrazy przylegające do lewej i prawej oraz dolnej i górnej
krawędzi.
W porównaniu z algorytmem SOM, FastMap daje nieco mniej czytelny rezultat – bo wiele
obrazów nakłada się na siebie. Niemniej sortowanie trwa znacznie (o rząd wielkości) krócej.
6.2.3. PCA dla deskryptorów
Algorytm znajdywania składowych głównych w klasycznym rozumieniu (operując na macierzy
danych wejściowych, a nie macierzy odległości wzajemnych jak to opisano w ustępie 6.2.4.) został
zaimplementowany tylko w uproszczonej wersji. Wynika to z faktu, że testy wykazały, iż dwa
najważniejsze wektory własne znajdywane uproszczoną metodą są niemal identyczne z tymi
znajdowanymi przy pełnych obliczeniach. Tymczasem uproszczona metoda ich szukania (opisana w
punkcie 4.1.2.) jest o wiele szybsza – odnosi się wrażenie, że o parę rzędów wielkości.
Wynik sortowania zbioru tych samych obrazów co wcześniej poprzez rzutowanie ich na
znalezione wektory własne zbioru wygląda następująco:
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 65
Rys. 6.2.3-1 Sortowanie PCA
Wydaje się, że rezultaty sortowania przy stosowaniu PCA są gorsze wizualnie niż przy algorytmie
FastMap. Czy tak jest faktycznie zostało zanalizowane w podrozdziale 6.4. Niemniej, należy się
zastanowić nad istotą działania obydwu algorytmów. FastMap operuje na mapie odległości
obrazów ze zbioru wejściowego. Znajduje w tym zbiorze wzajemnych odległości najgłówniejsze
kierunki, następnie rzutuje na nie wszystkie dane.
Tymczasem PCA liczy kierunki główne oryginalnych danych wejściowych. Jeśli więc każdy
wektor wejściowy byłby całkiem inny, to znalezione kierunki główne mogą nie segregować
obrazów wzdłuż żadnego optycznie ładnego wymiaru - kierunki znalezione przez PCA mogą być w
pewnym sensie 'miedzy' istniejącymi deskryptorami podanymi na wejściu, i stąd wizualnie wydaje
się, że nie ma dobrego rezultatu. Wizualnie postrzegana precyzja sortowania z zastosowaniem PCA
silnie zależy od użytych deskryptorów oraz konkretnych danych, które są sortowane. W toku
eksperymentów zostało zauważone, że niektóre zbiory obrazów są sortowane tym sposobem
bardzo dobrze (nawet lepiej niż z FastMap), a inne zbiory znacznie gorzej.
Na rysunku 6.2.3-1 widać, że od lewej do prawej (pierwszy kierunek główny) obrazy są
posortowane według rosnącej luminancji, a od góry do dołu (drugi kierunek główny) według
koloru: od niebiesko-zielonego do żółtego.
6.2.4. PCA dla macierzy odległości
Metoda liczenia wektorów własnych dla macierzy odległości i zastosowanie najważniejszych
współrzędnych tych wektorów bezpośrednio do reprezentacji nie ma wiele wspólnego z
poprzednią wersją PCA. Działanie tej metody nie jest zbyt intuicyjne. Można jednak sobie
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 66
wyobrazić, że mając macierze wzajemnych odległości obrazów szukane są główne N-wymiarowe
kierunki, w jakich te odległości się zmieniają. Następnie brane są po dwie współrzędne różnych
wymiarów z tych głównych kierunków i użyte bezpośrednio do reprezentacji. Tak znalezione
współrzędne powinny być dla każdego wymiaru nieco inne niż pozostałe, dzięki czemu
uszeregowanie obrazów za ich pomocą daje dobre wizualnie rezultaty. Wynik sortowania tych
samych obrazów co wcześniej przedstawiono poniżej.
Rys. 6.2.4-1 Sortowanie PCA dla macierzy odległości
Niestety równania 4.1.6-1 nie da się tak łatwo rozwiązać uproszczonym sposobem. W związku z
tym konieczne było skorzystanie z biblioteki ALGLIB, co prowadziło do liczenia wszystkich
wektorów własnych bardzo dużej macierzy NxN.
6.2.5. Mutual-Rank Similarity-Space
Algorytm tworzenia przestrzeni Mutual-Rank Similarity-Space nie jest w zasadzie algorytmem do
sortowania danych. Jest metodą transformacji macierzy odległości sortowanego zbioru na macierz
rang wzajemnych. Następnie macierz takich rang może być posortowana dowolnym algorytmem
operującym na macierzy odległości. Algorytm rang wzajemnych jest więc pewnym rozszerzeniem,
które można zastosować w połączeniu z innymi algorytmami. Poniżej przedstawiono wyniki
zastosowania tego rozszerzenia wraz z algorytmem PCA opisanym w punkcie 6.2.4.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 67
Rys. 6.2.5-1 Sortowanie PCA dla macierzy rang
Jak widać, wyniki są bardzo podobne do tych uzyskiwanych dla ‘czystej’ macierzy odległości
(6.2.4.). Jest to dość zrozumiałe. Rangi w pewien sposób odpowiadają odległościom. Mają jednak
tę zaletę, że szeregują dane bardziej równomiernie. Dwa najbardziej podobne obrazy otrzymają
rangę 1, kolejne rangę 2, 3 itd. W przypadku odległości różnice liczbowe mogą być dużo większe.
Największą zaletą przestrzeni Mutual-Rank Similarity-Space jest jednak niewątpliwie
łatwość łączenia różnych miar ze sobą. Gdy opisujemy obrazy dwoma deskryptorami, zakresy
wartości odległości między deskryptorami są bardzo różne. Trudno je sensownie połączyć.
Tymczasem w przypadku dwóch macierzy rang wzajemnych, można je łatwo scalić sumując rangi,
które są znormalizowane. Dlatego stosowanie rozszerzenia wzajemnych rang jest szczególnie
opłacalne przy sortowaniu według kilku deskryptorów na raz.
W stworzonej aplikacji takie sortowanie zostało również umożliwione. Zdecydowano, by
obrazy opisać na raz trzema deskryptorami: Color Layout, Scalable Color i Color Temperature.
Color Structure odrzucono ze względu na zbyt dużą złożoność obliczeniową w przypadku tego
deskryptora (jako że sensowne wizualnie rezultaty sortowania daje tylko w pełnej 256-
współczynnikowej postaci). Macierze rang uzyskane z każdego deskryptora zsumowano (z wagami
odpowiednio 1.5, 1, 1) przed policzeniem ostatecznych współrzędnych obrazów w nowej
przestrzeni. Wagi dobrano empirycznie, porównując uzyskiwane wyniki i kierując się
subiektywnymi odczuciami. Przetestowano dwie opcje: z zastosowaniem FastMap i PCA. Wyniki są
przedstawione poniżej.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 68
Rys. 6.2.5-2 Sortowanie FastMap dla macierzy rang z 3 deskryptorami
Rys. 6.2.5-3 Sortowanie PCA dla macierzy rang z 3 deskryptorami
Trudno porównać jakość wyników bez szczegółowej analizy (która jest przeprowadzana w
podrozdziale 6.4.). W powyżej zademonstrowanym przypadku widać jedynie, że wyniki są
zdecydowanie różne niż przy użyciu tylko jednego deskryptora, i bardziej równomiernie
rozmieszczone. Niemniej nie ulega kwestii, że używanie naraz kilku deskryptorów ma potencjalnie
bardzo duże możliwości i w dalszej przyszłości może doprowadzić do klasyfikacji obrazów nawet
według pojawiających się w nich obiektów, a nie tylko kolorów czy struktur kolorów.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 69
6.3. Szybkościowe porównanie algorytmów
Aby algorytmy sortowania były efektywne i chętnie stosowane, muszą wykazywać się należytą
szybkością. Szczególnie przy sortowaniu bardzo dużych zbiorów obrazów ma to kluczowe
znaczenie. Zdecydowano porównać ze sobą cztery algorytmy: SOM, FastMap i PCA dla danych
oryginalnych oraz PCA dla macierzy odległości. Pozostałe opcje, które oferuje aplikacja Image
Organizer wywodzą się z tych czterech wersji. W punkcie 6.3.1. przeprowadzono rozważania
teoretyczne, a w punkcie 6.3.2. sprawdzono wyniki uzyskiwane w praktyce.
6.3.1. Analiza teoretyczna złożoności obliczeniowej
W dalszej części przyjęte zostały następujące oznaczenia:
N – liczba danych wejściowych (obrazów)
A – pewna ustalona liczba naturalna (mniejsza niż 10)
C – liczba współczynników deskryptora (w zależności od deskryptora od 9 do 256)
SOM
Najkosztowniejszy obliczeniowo jest w tym algorytmie proces uczenia. Z tego względu tylko on
zostanie rozważony.
W czasie uczenia algorytm SOM wykonuje A x N operacji wyszukania najlepszego
dopasowania (BMU). Przy każdym wyszukaniu BMU przeglądanych jest N węzłów. Po znalezieniu
najlepiej pasującego węzła przechodzony jest cały obszar sąsiedztwa, i wykonywana jest
aktualizacja każdego węzła (w sumie zawsze aktualizowanych jest maksymalnie N węzłów –
zależnie od promienia uczenia). Podsumowując, ze względu na ilość danych wejściowych do
posortowania złożoność wynosi O(N3).
Tą złożoność należy przemnożyć przez liczbę operacji porównań i przypisań konkretnych
liczb, co jest funkcją liczby współczynników deskryptora C. Całkowita liczba wykonanych operacji
jest więc O(CN3).
FastMap
Algorytm FastMap zaczyna sortowanie od stworzenia mapy odległości wzajemnych. Ta ma
wymiary N x N, zatem ta operacja ma złożoność N2. Następnie szukane są dwa najodleglejsze
elementy – w najbardziej kosztownym obliczeniowo przypadku to też ma złożoność rzędu N2. Po
tym wszystkie elementy są rzutowane na wirtualną prostą i są obliczane pierwsze współrzędne –
złożoność N. Wreszcie informacja o juz wykonanym rzutowaniu jest odejmowana od juz istniejącej
mapy odległości – złożoność N2. Ostatnie dwa kroki są następnie powtarzane.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 70
Oznaczając liczbę współczynników deskryptora przez C można określić całkowitą złożoność
algorytmu jako O(CN2).
Uproszczone PCA dla deskryptorów
Uproszczony algorytm znajdowania kierunków głównych powinien być najszybszy ze wszystkich.
Przechodzi on wszystkie dane wejściowe A razy, co ma złożoność O(N). Przy każdym przejściu
wykonuje pewne mnożenia i sumowania, które mają złożoność O(C). Wreszcie operacja
rzutowania danych wejściowych na wektory własne i następnie ich aktualizacja mają złożoność
O(CN). Taka sama jest całkowita złożoność algorytmu. Ma on więc złożoność liniową ze względu
na N.
PCA dla macierzy odległości wzajemnych
PCA w tej wersji ma zupełnie inną złożoność. Po pierwsze dlatego, że operuje na ogromnej
macierzy o wymiarach N x N a nie C x N. Po drugie dlatego, że rozwiązanie równania 4.1.6-1 jest
znajdywane poprzez policzenie wszystkich wektorów własnych tej dużej macierzy.
Można powiedzieć, że zasadnicze znaczenie dla czasu trwania sortowania tym algorytmem
ma samo znajdowanie wektorów własnych macierzy N x N. Pozostałe operacje wykonywane
wcześniej i później trwają krócej, więc mogą zostać pominięte. Należy więc odpowiedzieć na
pytanie, jaką złożoność ma szukanie wektorów własnych macierzy.
Według autora biblioteki ALGLIB Sergey’a Bochkanova złożoność rozwiązywania równania
4.1.6-1 wynosi O(N3). Niemniej, choć można ją określić tym samym rzędem wielkości jak przy
algorytmie SOM, to de facto sortowanie z obliczaniem wszystkich wektorów własnych trwa dużo
dłużej.
6.3.2. Wyniki empiryczne
Aby porównać faktyczne osiągnięcia poszczególnych algorytmów w sortowaniu obrazów
zmierzono czasy sortowania dla zbiorów trzech liczności: 200, 1000, 5000. Wyniki są zestawione w
tabeli poniżej.
Należy tylko zaznaczyć, że wobec wielowątkowej architektury programu, dochodzą pewne
narzuty na odświeżanie ekranu i przełączanie wątków – tak więc czasy nie odpowiadają w 100%
samemu wykonywaniu algorytmu. Niemniej, są one dobrym przybliżeniem.
UWAGA. Na posortowanie 5000 obrazów algorytmem PCA dla macierzy odległości zabrakło
pamięci operacyjnej w komputerze używanym do testów.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 71
Tabela 6.3.2-1 Szybkość sortowania różnymi algorytmami w funkcji liczby obrazów [s]
Liczba Obrazów
Algorytm 200 1000 5000
PCA uproszczone dla macierzy wektorów
0,2 0,2 0,5
FastMap 0,2 0,9 10,6
SOM 0,6 2,3 33,0
PCA pełna dla macierzy odległości
0,6 20,0 -
Algorytmy zostały uszeregowane od najszybszego do najwolniejszego. Jak widać, dla małej liczby
obrazów (kilkaset), wszystkie algorytmy spisują się dobrze i sortują dane w ciągu czasu poniżej
sekundy. Algorytmy uproszczonego PCA i FastMap robią to dla 200 obrazów szybciej niż trwa
reakcja człowieka.
Dla większej liczby obrazów jest już nieco gorzej. Dla 5000, o ile algorytm uproszczonego
PCA z rzutowaniem na nowe kierunki sortuje nadal bardzo szybko, to już algorytm FastMap robi to
w około 10s. Ten dość długi czas dla algorytmu o niezbyt dużej złożoności wynika stąd, że przy
tworzeniu macierzy odległości, na której operuje FastMap, uzyskuje się strukturę o bardzo dużych
wymiarach 5000x5000. Stąd operacje jej aktualizacji muszą trwać.
Algorytm SOM dla tej ilości obrazów radzi sobie jeszcze gorzej. Wynika to z długiego czasu
potrzebnego do obliczeń – ponad pół minuty. Można przypuszczać, że czas tego rzędu będzie
stanowił pewną trudność w zastosowaniu takiego sortowania na co dzień.
Algorytm PCA wykonywany w pełnej wersji dla macierzy odległości już nie sprawdza się w
ogóle dla 5000 obrazów. Wynika to z braku pamięci RAM potrzebnej by wykonać odpowiednie
operacje macierzowe na tak dużej strukturze. Można się też domyślać, że nawet gdyby wystarczyło
pamięci operacyjnej, to na wynik należałoby czekać przynajmniej kilka minut.
Podsumowując, wybór algorytmu sortującego musi być podyktowany nie tylko chęcią
uzyskania odpowiednich rezultatów, ale też wielkością zbioru danych wejściowych. Stosowanie
dwóch ostatnich algorytmów z tabeli 6.3.2-1 dla paru tysięcy obrazów jest niepraktyczne lub
nawet niemożliwe.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 72
6.4. Jakościowe porównanie algorytmów
Porównanie jakości sortowania różnych algorytmów stanowi pewien problem. Mianowicie
powstaje pytanie, jak należy tą jakość porównywać? Patrzeć ogólnie na cały wynik sortowania, czy
też w szczegółach analizować poszczególne fragmenty? Jak stwierdzić dobrą, a jak złą jakość?
Można podejść do tego zagadnienia na dwa sposoby. Po pierwsze, można wyrazić
subiektywne odczucie co do tego jak dobrze posortowany jest cały zbiór. Po drugie, można
porównywać ze sobą kolejne pary obrazów stwierdzając stopień podobieństwa i patrząc jak daleko
dwa obrazy są od siebie na posortowanej płaszczyźnie.
Ta pierwsza metoda została już w zasadzie wykorzystana w podrozdziale 6.1. gdzie każdy z
algorytmów był z grubsza porównywany. Pozostaje więc użyć drugiej metody oceny.
6.4.1. Przygotowanie testu
Niestety metoda ta jest bardzo czasochłonna ze względu na konieczność wykonania dużej
ilości manualnych porównań obrazów ze sobą. Aby metoda ta była w ogóle skuteczna, trzeba testy
jakoś usystematyzować.
Zdecydowano posługiwać się zbiorem 50 wzorcowych obrazów. Każdą możliwą parę
obrazów scharakteryzowano jako jedną z trzech sytuacji:
1. silnie podobne
2. trochę podobne
3. niepodobne
Następnie porównano ze sobą mapy będące wynikiem sortowania poszczególnymi algorytmami.
Ich jakość oceniano porównując ze sobą wszystkie możliwe pary obrazów i stwierdzając, jak daleko
od siebie są ustawione obrazy, które należą do aktualnie rozważanej pary. Ustalono, że najlepszy
algorytm ma uzyskać najmniejszą sumę not. Noty zdecydowano się przyznawać następująco:
1. Dla obrazów silnie podobnych:
0 gdy obrazy są oddalone o mniej niż 2 wymiary obrazu
1 gdy obrazy są oddalone między 2 a 3 wymiary obrazu
3 gdy obrazy są oddalone o więcej niż 3 wymiary obrazu
2. Dla obrazów trochę podobnych
2 gdy obrazy są oddalone o mniej niż 1 wymiar obrazu
0 gdy obrazy są oddalone między 1 a 3 wymiary obrazu
2 gdy obrazy są oddalone o więcej niż 3 wymiary obrazu
3. Dla obrazów niepodobnych
3 gdy obrazy są oddalone o mniej niż 2 wymiar obrazu
1 gdy obrazy są oddalone między 2 a 3 wymiary obrazu
0 gdy obrazy są oddalone o więcej niż 3 wymiary obrazu
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 73
Oddalenie obrazów od siebie o n wymiarów obrazu rozumie się jako to, że środki obrazów są
oddalone o n długości przekątnych obrazu. Demonstruje to poniższy rysunek.
Rys. 6.4-1a Obrazy oddalone o 2 wymiary obrazu
W przypadku algorytmu SOM, w którym obrazy umieszczane są w dyskretnych punktach – węzłach
wyuczonej mapy – konieczne było inne mierzenie odległości. Zdecydowano się sumować odległość
w kolumnach i wierszach, a następnie dzielić wynik przez 2. W takim rozumowaniu dla algorytmu
SOM sąsiednie obrazki są oddalone o ½W, a obrazki sąsiadujące po przekątnej o 1W. Ukazano to
poniżej.
Rys. 6.4-1b Oddalenie obrazów dla SOM
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 74
Ustalenie miary przekątnej obrazu do określania jak daleko obrazy są od siebie zamiast stosowania
bezwzględnej miary jest wbrew pozorem lepszym rozwiązaniem. Wynika to z tego, że wymiary
wyświetlanych obrazków są liniowo zależne od liczby obrazów wyświetlanych na ekranie. Wobec
tego, przy większych zbiorach obrazów obrazy pozostające w tej samej bezwzględnej odległości
mogą w rzeczywistości i być ‘dalej’ i okazać się mniej podobne. Stosowanie do obliczeń względnych
wymiarów wyświetlanych obrazów niweluje ten problem.
Manualne porównywanie pojedynczych wyników sortowania zajęłoby zbyt dużo czasu
nawet w przypadku sortowania grupy tylko 50 obrazów. Dlatego zdecydowano się
zautomatyzować testy, zostawiając ocenę jakości posortowanego zbioru algorytmowi w aplikacji.
Algorytm ten opierał się jednak na manualnie stworzonej tabeli 50x50 stwierdzającej subiektywne
podobieństwa między każdą parą z 50 obrazów. Tę tabelę autor stworzył samodzielnie oglądając
obrazy i kierując się swoimi odczuciami odnośnie ich podobieństwa. Znajduje się ona w
załączniku B.
Aby dać pojęcie jak rozumiano podobieństwo obrazów, poniżej przedstawione są trzy pary
obrazów: silnie podobne, trochę podobne, niepodobne.
Rys. 6.4-2 Pary obrazów od góry: silnie podobnych, trochę podobnych, niepodobnych
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 75
4.6.2. Wyniki testu
Wyniki testu są przedstawione na wykresie poniżej.
Wykres 6.4-1 Jakość sortowania 50 wzorcowych obrazów według oceny subiektywnej (z użyciem
deskryptora CLD)
Należy zaznaczyć, że test należy traktować z pewnym dystansem, gdyż mimo że starano się dobrać
grupę 50 obrazów dość reprezentatywnie, to liczba 50 jest dość mała i stąd testy mają tylko
poglądowy charakter. Sama metoda liczenia jakości jest z pewnością również niedoskonała.
Niemniej, nawet przy tak prostym teście można zauważyć pewne ciekawe prawidłowości.
Po pierwsze zauważmy, że zastosowanie przestrzeni Mutual-Rank Similarity-Space do
algorytmów FastMap i PCA poprawiło wyniki w stosunku do sytuacji, gdy wzajemne rangi nie były
użyte. Świadczy to o tym, że użycie wzajemnych rang jest pożyteczne i nie tylko ułatwia
stosowanie kilku deskryptorów na raz, ale też wpływa korzystnie na same wyniki sortowania.
Po drugie należy zauważyć, że PCA na macierzy odległości daje lepsze wyniki niż tradycyjne
PCA i FastMap. Można stąd wnioskować, że mimo wielkiej kosztowności obliczeń algorytm ten jest
wartościowy.
W zasadzie można stwierdzić, że FastMap oraz PCA na macierzy odległości – oba z
zastosowaniem przestrzeni rang wzajemnych – dają podobne wyniki sortowania jeśli chodzi o
9221004
579648 612
868
587650
0
200
400
600
800
1000
1200
Jakość sortowania 50 obrazków wg oceny subiektywnej
(mniejszy wynik lepszy)
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 76
jakość. Nie zmienia wiele to, czy stosowany jest jeden, czy 3 deskryptory. Niemniej trzeba tu
zaznaczyć, że odpowiedni dobór wielu deskryptorów z różnymi wagami może dać nieocenione
efekty przy bardziej skomplikowanym sortowaniu nastawionym np. na rozpoznawanie obiektów.
W niniejszej pracy możliwość łączenia różnych deskryptorów ze sobą nie została dogłębnie
zanalizowana.
Na koniec trzeba też skomentować wynik uzyskany przez algorytm SOM. Jest on
porównywalny z wynikami osiąganymi przez FastMap i PCA, choć jest liczony całkiem inaczej.
Dowodzi to, że uzyskane wyniki numeryczne oceniające jakość sortowania oddają postrzegane
zależności subiektywne – SOM dawał równie dobre wyniki wizualne co inne algorytmy, mimo że
rozmieszczenie obrazów wykonywane jest w tym przypadku zupełnie inaczej.
Ostatnią rzeczą, nad którą warto pomyśleć, jest to jak dobry jest tak naprawdę wynik
sortowania na podstawie zmierzonej miary subiektywnej. Aby odpowiedzieć na to pytanie, należy
się najpierw zastanowić nad liczbą par obrazów, gdy wszystkich jest 50. Tych par jest 49*50/2 =
1225.
Jak to wcześniej opisano, przy złym umieszczeniu na mapie przyznaje się każdej parze ‘karę’
o wielkości od 1 do 3, natomiast 0 gdy obrazy są w takiej odległości, jak to subiektywnie oceniono
za prawidłowe.
Co zatem mówi wynik np. 600? Otóż średnio rzecz biorąc oznacza on ‘karę’ ½ dla każdej
pary obrazów. Wobec widełek 0-3 wynik ½ wydaje się bardzo dobry. Znaczy on, iż średnio co druga
para jest idealnie dopasowana, a co druga tylko trochę odbiega od oceny subiektywnej (‘kara’
wielkości 1).
Przykładowa mapa posortowanych obrazów osiągająca wynik 650 ukazana jest poniżej.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 77
Rys. 6.4-3 Wynik sortowania 50 obrazów metodą PCA odległościowego dla opisu 3 deskryptorami z
zastosowaniem rang wzajemnych
Reasumując, mimo iż testy subiektywne oceniające jakość automatycznego sortowania były
niedokładne, przeprowadzone na niewielkim zbiorze obrazów i obarczone błędem subiektywnego
postrzegania podobieństwa przez autora, okazały się sensowne. Uzyskane wyniki mówią dużo o
porównywanych algorytmach i są dowodem, że przeprowadzone testy subiektywne były
pożyteczne.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 78
7. Wnioski końcowe
Koncepcja automatycznego sortowania jest z pewnością oryginalnym i dość obiecującym
pomysłem. W tej chwili jest pewnego rodzaju prototypem i można dostrzec bardziej jej wielki
potencjał niż konkretne praktyczne zastosowanie.
7.1. Uzyskane wyniki
Uzyskane wyniki dowodzą, że poprzez opis z użyciem deskryptorów i stosowanie różnych
algorytmów do sortowania danych wielowymiarowych można efektywnie sortować duże zbiory
obrazów. Na sprzęcie, który pojawi się w ciągu najbliższych lat, prawdopodobnie nawet dziesiątki
tysięcy na raz.
Niniejsza praca ukazuje, że bardzo skutecznie można sortować obrazy według pewnych
niskopoziomowych, prostych cech takich jak kolory. Sortując zbiory hierarchicznie i stosując
szybsze algorytmy do większej liczby obrazów, a wolniejsze do ich mniejszej liczby można pogodzić
problem szybkości i jakości sortowania.
Pojawia się jednak nieuchronne pytanie jak użyteczne jest takie sortowanie? Można mieć
co do tego wątpliwości. Jednakże, już niniejsza praca wykazuje przykład takiej użyteczności.
Nietrudno wyobrazić sobie użytkownika, który ma zbiór 2000 obrazów z wakacji i potrzebny mu
jest obrazek z zachodem słońca. Korzystając z aplikacji Image Organizer można takie obrazy bez
trudu znaleźć w całym zbiorze bez konieczności przeglądania wszystkich.
Niemniej, prawdziwy potencjał automatycznego sortowania pozostaje do rozwinięcia. Co
może być celem przyszłego rozwoju tej koncepcji opisano w kolejnym podrozdziale.
7.2. Dalsze prace
Niniejsza praca daje dobry przegląd w zakresie algorytmów zdatnych do użycia w procesie
automatycznego sortowania obrazów. Zostały porównane algorytmy o krańcowo różnej złożoności
obliczeniowej, a także o całkiem innej zasadzie działania. Niemniej, różnych wariantów zarówno
omówionych jak i nieomówionych tu algorytmów jest wiele i pozostaje jeszcze rozległa płaszczyzna
do zbadania w tym względzie.
Jeszcze więcej jednak pozostaje do zbadania w kwestii łączenia różnych deskryptorów ze
sobą w celu rozpoznawania obiektów. Pewnym zalążkiem w tym kierunku jest choćby praca
[Spyrou et al. 2005]. W artykule tym opisano badania nad połączeniem trzech deskryptorów: Color
Layout, Scalable Color oraz Edge Histogram w celu rozróżnienia zdjęć przedstawiających miasto i
plażę. Wyniki skuteczności były na poziomie 90%.
Można sobie wyobrazić, że dalszy wysiłek w kierunku klasyfikacji obiektów na zdjęciach
może doprowadzić do tego, że treść będzie w całości rozpoznawana bez konieczności oglądania
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 79
zdjęć przez człowieka. Przy milionach obrazów, które powstają każdego dnia, taki system może być
nieoceniony. Ponadto przy celnym, automatycznym opisie treści obrazów automatyczne
sortowanie nabierze nowego wymiaru. Można sobie wyobrazić, że obrazy będą mogły zostać
posortowane według występujących w nich obiektów. Na przykład obrazy przedstawiające
autobusy będą skupione razem na płaszczyźnie, te obrazy będą przechodzić stopniowo w obrazy
zawierające autobusy i samochody, aż wreszcie przejdą w obrazy zawierające same samochody.
Taki porządek byłby z pewnością ciekawą alternatywą dla użytkownika, który jest zainteresowany
obiektami z określonej grupy.
Inną kwestią jest jeszcze to, czy umieszczenie tak skomplikowanie opisanych obrazów na
płaszczyźnie będzie wystarczające. Być może wygodniejsza byłaby 3- lub nawet 4- wymiarowa
przestrzeń docelowa. Wówczas jednak rodzi się pytanie, jak taką przestrzeń wizualizować w
wygodny dla użytkownika sposób.
Autor żywi przekonanie, że powyżej opisane kwestie będą w najbliższym czasie badane i
rozwijane, jako że temat organizacji multimediów jest we współczesnym świecie wciąż ważniejszy i
ważniejszy. Pozostaje mieć nadzieję, że niniejsza praca choćby w małym stopniu przyczyni się do
rozwoju dziedziny automatycznego sortowania i okaże się pomocna na przyszłość.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 80
Literatura
Augustyniak, M. (2007) Osadzanie deskryptorów MPEG-7 w nagłówkach plików graficznych. Praca inżynierska, Politechnika Warszawska: Wydział Elektroniki i Technik Informacyjnych
Barthel, K.U., Mammani, S., Wyatt, N. (2005) ‘Automatic Image Sorting Using MPEG-7 Descriptors’. Workshop on Immersive
Communication and Broadcast Systems (ICOB), 2005. Second Workshop, 28-29 październik 2005, Berlin, Niemcy. Fraunhofer HHI.
Barthel, K.U. (2008) ‘Improved Image Retrieval Using Automatic Image Sorting and Semi-automatic Generation of Image
Semantics.’ strony 227-230. Image Analysis for Multimedia Interactive Services, 2008. WIAMIS '08. Ninth International Workshop, 7-9 Maj 2008, Klagenfurt. ISBN: 978-0-7695-3344-5
Bochkanov, S. (2009) ALGLIB [online] Dostępny w: < http://www.alglib.net/> [15 listopad 2009] Borgatti (1997) Multidimensional Scaling [online] Dostępny w:
<http://www.analytictech.com/borgatti/mds.htm> [22 wrzesień 2008] Code Project (2001) Extracting IPTC Header Information from JPEG Images [online] Dostępny w:
<http://www.codeproject.com/KB/graphics/iptc.aspx> [12 październik 2008] Digital Camera Software (2009) BMP File Format [online] Dostępny w:
<http://www.digicamsoft.com/bmp/bmp.html> [22 styczeń 2008] Douglas, J. (1999) Self-organizing Maps [online] Dostępny w: <http://www.english.ucsb.edu/grad/student-
pages/jdouglass/coursework/hyperliterature/soms/> [15 wrzesień 2008] Faloutsos C., Lin K. (1995) FastMap: A Fast Algorithm for Indexing, Data-Mining and Visualization of Traditional and
Multimedia Datasets, strony 163-174. International Conference on Management of Data, 1995. 22-25 Maj 1995, San Jose, California.
Dostępny także [online] w: < http://www.sis.pitt.edu/~ktech/IR_Project/Documents/fastmap.pdf> [10 październik 2009]
Galiński, G. (2008) ASM – Algorytmy i Standardy Multimedialne – Materiały pomocnicze do wykładu, Politechnika Warszawska:
Wydział Informatyki i Technik Informacyjnych Germano, T. (1999) Self-organizing Maps [online] Dostępny w:
<http://davis.wpi.edu/~matt/courses/soms/> [15 wrzesień 2008] Google (2009) Picasa Basics: Picasa 3 feature overview [online] Dostępny w:
<http://picasa.google.co.uk/support/bin/answer.py?answer=93773> [16 luty 2009]
Laaksonen J., Koskela, M., Oja, E. (2002) ‘PicSOM – Self-Organizing Image Retrieval with MPEG-7 Content Descriptors, IEEE Transactions on Neural Networks, Tom 13, Nr 4, Lipiec 2002, str. 841-853
Maas, C. (2003) Freeware Hex Editor XVI32 [online] Dostępny w:
< http://www.chmaas.handshake.de/delphi/freeware/xvi32/xvi32.htm> [19 styczeń 2009] Honkela, T. (1998) Self-organizing Maps [online] Dostępny w:
<http://mlab.taik.fi/~timo/som/thesis-som.html> [27 październik 2008] Kohonen, T. (2005a) SOM Toolbox: Intro to SOM by Tuevo Kohonen [online] Dostępny w:
<http://www.cis.hut.fi/projects/somtoolbox/theory/somalgorithm.shtml> [27 październik 2008] Kohonen, T. (2005b) SOM Toolbox: Implementation of the algorithm [online] Dostępny w:
<http://www.cis.hut.fi/projects/somtoolbox/documentation/somalg.shtml> [27 październik 2008] Lischner, R. (2003) C++ in a nutshell. USA: O’Reilly Media Inc.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 81
Lux, M.(2007) SemanticMetadata.net >> Caliph and Emir [online] Dostępny w: <http://www.semanticmetadata.net/features/> [30 październik 2008]
Matteuci M. (2008) Clustering – K-means [online] Dostępny w:
< http://home.dei.polimi.it/matteucc/Clustering/tutorial_html/kmeans.html> [24 listopad 2010]
Modi, V. (2009) Color Descriptors from compressed Images. School of Informatics. The University of Edinburgh, UK. Dostępny także [online] w: <http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/AV0506/s0567178.pdf>
[10 styczeń 2009] MPEG (2002) Multimedia content description interface: Part 8 – Extraction and Use of MPEG-7 Descriptions, ISO/IEC TR 15938-
8:2002 MPEG (2003) Multimedia content description interface: Part 6 – MPEG-7 XM Reference Software, ISO/IEC IS 15938-6:2003
Dostępny także online w: <http://tiger.ire.pw.edu.pl/asm/lab/lab5/MPEG7-XM.zip> [15 wrzesień 2008] MPEG (2004) Multimedia content description interface: Part 8 – Extraction and Use of MPEG-7 Descriptions, ISO/IEC
JTC1/SC29/WG11: First amendment to ISO/IEC TR 15938-8:2002
MPEG (2008) MPEG-7 Overview [online] Dostępny w:
<http://www.chiariglione.org/mpeg/standards/mpeg-7/mpeg-7.htm> [20 wrzesień 2009] NameMedia (2010) Photography community, including forums, reviews, and galleries from Photo.net [online] Dostępny w:
< http://static.photo.net/attachments/bboard/00C/00C0CJ-23143884.jpg> [22 listopad 2010] Nokia (2008) Online Reference Documentation (Qt) [online] Dostępny w:
<http://doc.trolltech.com/> [12 wrzesień 2008] Nokia Corporation (2008) Qt – A cross-platform application and UI framework [online] Dostępny w:
<http://www.qtsoftware.com/> [10 październik 2008] Nokia Corporation (2009) The HSV Color Model [online] Dostępny w:
< http://doc.trolltech.com/4.4/qcolor.html#the-hsv-color-model> [13 styczeń 2009] O'CALLAGHAN, R. J., BOBER, M. (2006) Mutual-Rank Similarity-Space for Navigating, Visualising and Clustering in Image
Databases, International Patent WO/2007/020423 Photo Sorter (2009) About photo sorter platinum [online] Dostępny w:
<http://www.photosorter.us/about_photo_sorter_platinum.html> [16 luty 2009] Portable Network Graphics (2008) PNG Specification: File Structure [online] Dostępny w:
<http://www.mirrorservice.org/sites/www.libpng.org/pub/png/spec/1.2/PNG-Structure.html> [16 październik 2008]
Prata, S. (2006) Język C++. Gliwice, Poland: HELION. Python Software Foundation (2010) Python Documentation [online] Dostępny w:
< http://www.python.org/doc/> [10 październik 2008] Roweis, S. (1998) EM Algorithms for PCA and SPCA. Advances in Neural Information Processing Systems. Ed. Michael I. Jordan,
Michael J. Kearns, and Sara A. Solla The MIT Press, 1998. Savvas, C. (2009) Image Processing and Retrieval Trends: HMMD color space [online] Dostępny w:
< http://savvash.blogspot.com/2009/03/hmmd-color-space.html> [22 listopad 2010] Skarbek, W. (2009) INM – Indeksowanie Multimediów – Skrypt wykładowy, Politechnika Warszawska: Wydział Informatyki i
Technik Informacyjnych Sort Photos (2009) About sort photos [online] Dostępny w:
< http://www.sortphotos.org/about_sort_photos.html>[16 luty 2009]
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 82
SortPics (2009) SortPics: Image Sorter with Duplicate Detector [online] Dostępny w:
<http://www.sortpics.com/> [12 luty 2009] Spyrou, Evaggelos and Le Borgne, Hervé and Mailis, Theofilos and Cooke, Eddie and Avrithis, Yannis and O'Connor, Noel E.
(2005) Fusing MPEG-7 visual descriptors for image classification. W: ICANN 2005 - International Conference on Artificial Neural Networks, 11-15 wrzesień 2005, Warszawa, Polska. ISBN 978-3-540-28755-1. Dostępny także [online] w: <www.acemedia.org/aceMedia/files/document/wp7/2005/icann05-iti.pdf> [20 wrzesień 2008]
StatSoft (2009a) Principal Components and Factor Analysis [online] Dostępny w: <http://www.statsoft.com/textbook/principal-components-factor-analysis/> [11 październik 2009] StatSoft (2009b) Multidimensional Scaling [online] Dostępny w: < http://www.statsoft.com/textbook/multidimensional-scaling/> [11 październik 2009] Surong W., Tien, C. L., Rajan, D. (2003) ‘Efficient image retrieval using MPEG-7 descriptors.’ Referat nr 1824 International
Conference on Image Processing 2003, 14-17 wrzesień 2003, Barcelona, Hiszpania. Torres, L. Institute of Electrical and Electronics Engineers (IEEE)
Szymczyk, T. (2009) Rozpoznawanie obrazów z wykorzystaniem deskryptorów zaimplementowanych w MPEG-7. Instytut
Informatyki, Wydział Elektroniki i Informatyki, Politechnika Lubelska. Dostępny także [online] w: <http://pluton.pol.lublin.pl/lafi/referaty/2004/algorytmy_metody_systemy/2_11.pdf> [10 January 2009]
University of Applied Sciences – Berlin (2008) Zentrum fur Mensch-Maschine-Kommunikation >> ImageSorter V3 (Beta 3) [online] Dostępny w: <http://mmk.f4.fhtw-berlin.de/Projekte/ImageSorter/> [10 październik 2008]
W3C (2008) GIF 89a Specification [online] Dostępny w:
<http://www.w3.org/Graphics/GIF/spec-gif89a.txt> [22 January 2009] Ward, M. (1999) N-Land: a Graphical Tool for Exploring N-dimensional Data [online] Dostępny w:
< http://davis.wpi.edu/~matt/courses/nland/cgi93.html> [22 listopad 2010] Wikipedia (2008a) Comparison of Java and C++ [online] Dostępny w:
<http://en.wikipedia.org/wiki/Comparison_of_Java_and_C%2B%2B> [10 październik 2008] Wikipedia (2008b) Discrete Cosine Transform [online] Dostępny w:
<http://en.wikipedia.org/wiki/Discrete_cosine_transform> [20 wrzesień 2009] Wikipedia (2009a) Principal Components Analysis [online] Dostępny w:
< http://en.wikipedia.org/wiki/Principal_component_analysis> [11 październik 2009] Wikipedia (2009b) Multidimensional Scaling [online] Dostępny w:
< http://en.wikipedia.org/wiki/Multidimensional_scaling> [11 październik 2009] Wikipedia (2009c) HSL and HSV [online] Dostępny w:
<http://en.wikipedia.org/wiki/HSL_color_space#Conversion_from_RGB_to_HSL_or_HSV> [30 listopad 2009] Wikipedia (2010a) k-means clustering [online] Dostępny w:
< http://en.wikipedia.org/wiki/K-means_clustering> [24 listopad 2010] Wikipedia (2010b) Multidimensional Scaling [online] Dostępny w:
<http://en.wikipedia.org/wiki/Multidimensional_scaling> [22 wrzesień 2009]
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 83
Załącznik A – Porównanie bibliotek do tworzenia GUI
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 84
Załącznik B – Tabela oceny podobieństwa 50
obrazów
Obrazy znajdują się na płycie CD. Informacja jest przechowywana w górnej połowie tabeli.
Numeracja obrazów zaczyna się w górnym lewym rogu (1-50).
const static int similarityTab[50][50] = {
/*1*/ 0,2,2,1,1,2,2,1,2,2,1,2,2,1,2,2,2,2,1,2,2,2,2,1,1,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,
0,0,2,1,2,2,2,2,2,2,2,2,2,2,2,1,1,1,2,2,2,1,1,2,2,2,1,2,2,2,1,1,2,2,2,2,1,2,2,1,1,2,2,2,2,2,1,2,1,2,
0,0,0,2,2,2,2,2,2,0,2,2,0,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
0,0,0,0,1,2,2,0,2,2,1,2,2,1,2,2,1,1,1,2,2,2,2,0,1,2,2,0,0,1,2,2,2,1,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,1,
0,0,0,0,0,2,2,1,2,2,1,2,2,1,2,2,2,1,2,2,2,2,2,1,1,2,2,1,1,0,2,2,2,1,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,1,
0,0,0,0,0,0,0,2,2,2,2,0,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,2,1,0,2,1,1,1,2,1,2,2,2,2,0,1,2,2,
0,0,0,0,0,0,0,2,1,2,2,0,2,2,0,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,1,1,0,2,0,0,1,0,1,1,1,1,2,2,2,1,0,1,1,2,
0,0,0,0,0,0,0,0,2,2,1,2,2,2,2,2,1,1,1,2,2,2,2,0,1,2,2,1,0,1,2,2,2,1,2,2,1,2,2,2,1,2,2,2,2,2,2,2,2,1,
0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,1,2,2,2,2,2,2,2,1,2,1,0,2,1,2,2,
0,0,0,0,0,0,0,0,0,0,2,2,0,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,
/*2*/ 0,0,0,0,0,0,0,0,0,0,0,2,1,1,2,2,1,2,2,2,2,2,2,1,1,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,1,
0,0,0,0,0,0,0,0,0,0,0,0,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,2,1,0,1,0,1,1,2,1,2,2,2,2,0,1,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,1,1,1,1,1,2,2,1,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,1,1,1,2,0,1,1,1,1,1,1,1,2,2,2,2,1,1,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2,1,1,1,2,2,1,2,2,2,2,2,2,2,1,2,2,1,2,2,1,1,2,2,2,2,2,2,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,2,2,1,0,0,2,2,1,1,1,2,2,2,1,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2,1,1,2,2,2,2,1,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,1,1,1,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2,2,1,1,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,
/*3*/ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2,2,0,1,2,2,2,1,2,2,2,2,2,1,2,2,1,2,2,2,2,2,2,2,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,1,1,2,2,2,1,0,2,1,2,2,1,2,1,1,2,2,2,2,2,2,2,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,1,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,2,1,1,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,1,0,2,2,2,2,0,2,1,1,1,2,2,2,2,2,2,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,
/*4*/ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2,1,1,1,1,1,1,1,1,2,2,2,2,1,1,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,2,1,2,1,1,1,2,2,2,2,2,2,1,0,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,2,1,1,1,1,2,2,2,2,1,1,0,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,1,1,2,1,2,1,2,1,1,1,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,1,1,2,1,2,2,2,1,0,1,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,1,2,2,2,2,2,2,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,0,2,2,2,2,0,1,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2,2,2,2,2,1,1,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,2,2,2,1,1,1,2,
/*5*/ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,1,2,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,0,1,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 85
Załącznik C – Analiza podobnych programów
C-1. Ogólny przegląd oprogramowania sortującego obrazy
Istnieje bardzo wiele programów, które sortują cyfrowe obrazy według podstawowych
parametrów plików takich jak nazwa czy rozmiar. Nawet programy sortujące według meta danych
są liczne. Do najbardziej popularnych należą SortPics, Photo Sorter Platinum oraz Sort Photos. Te
dwa ostatnie są przeznaczone głównie do sortowania wszystkich obrazów na dysku twardym
według wybranych cech: rozmiaru, rozdzielczości, czasu wykonania etc. [Sort Photos 2009, Photo
Sorter 2009].
SortPics jest programem bardziej nastawionym na tagowanie zdjęć i opisywanie ich za
pomocą słów kluczowych i kategorii. Główny panel programu ukazano poniżej [SortPics 2009].
Rys. C-1-1 Główny panel SortPics
Jak widać, program korzysta z podobnego sposobu przeglądu katalogów i ładowania zdjęć jak to
zrealizowano w aplikacji Image Organizer.
Kolejnym programem, którego nie można pominąć przy zagadnieniu sortowanie zdjęć, jest Picasa
[Google 2009]. Zapamiętuje on wszystkie obrazy na komputerze i umożliwia ich łatwe przeglądanie
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 86
wyświetlając wiele na raz. Zasadniczym celem tej aplikacji jest umożliwienie łatwego i szybkiego
wgrywania zdjęć na serwer w sieci, jednak zapewnia ona łatwe przeglądanie i przemieszczanie
obrazów także na dysku komputera:
Rys. C-1-2 Główny panel Picasa 3
Picasa umożliwia także stworzenie rankingu zdjęć, obróbkę bądź ukrywanie wybranych
podzbiorów. Kolejną bardzo przydatną cechą programu jest wybranie żądanego stopnia
powiększenia – dzięki czemu użytkownik może sprecyzować ile zdjęć ma być widocznych na raz na
ekranie.
Zasadniczy wniosek jest taki, że choć powyżej wymienione programy oferują co innego niż jest
zamierzone w automatycznym sortowaniu, to demonstrują parę wartościowych pomysłów,
wartych rozważenia także w programie wykonującym automatyczne sortowanie. Są to przede
wszystkim:
Przyjazne do nawigacji drzewo katalogów na komputerze umożliwiające łatwy wybór
zbioru obrazów do załadowania
Prosta możliwość wyboru powiększenia wyświetlanych obrazów
Możliwość klasyfikacji obrazów za pomocą meta danych – tylko ręcznie, ale w przyszłości
można taki proces zautomatyzować
Możliwość sortowania obrazów niezależnie za pomocą różnych kryteriów – można
rozwinąć ten pomysł na niezależne używanie różnych deskryptorów w automatycznym
sortowaniu
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 87
C-2. Program Caliph & Emir
Caliph i Emir są dwoma ściśle powiązanymi programami – pierwszy umożliwia obróbkę i opis
obrazu, podczas gdy drugi umożliwia wyszukiwanie obrazu według określonych kryteriów
[Lux 2007].
Caliph (ang. Common And Lightweight Photo annotation application) jest bardzo potężnym
narzędziem opisu obrazu cyfrowego. Umożliwia różne formy takiego opisu:
1. Edycję tekstu ustrukturyzowanego oraz wolnych komentarze jako meta danych
2. Edycję semantycznych relacji opisujących obrazek
3. Zapis kształtów występujących w obrazie
4. Zapis 4 deskryptorów opisujących obrazek (EdgeHistogram, DominantColor, ColorLayout,
ScalableColor)
Najbardziej innowacyjnym z tych pomysłów jest edycja relacji semantycznych. Umożliwia ona
tworzenie obiektów – np. ludzi, miejsca i określenie jak oni zależą od siebie. Te informacje mogą
być później użyte do wyszukania obrazów pasujących do określonych relacji. Główny panel do
edycji tych relacji wraz z przykładową siecią relacji jest ukazany poniżej:
Rys. C-2-1 Główny panel edycji relacji semantycznych w programie Caliph
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 88
Caliph umożliwia zapis adnotacji dot. obrazów jako plików XML. Te mogą być później użyte przez
EMIR (ang. Experimental Meta data based Image Retrieval application) w celu znalezienia
określonych danych.
Program EMIR umożliwia poszukiwanie obrazów na wiele sposobów: według tekstu
zorganizowanego, wolnych komentarzy, relacji semantycznych a nawet obrazów wzorcowych,
których deskryptory mają odpowiadać tym w szukanym obrazie. Jednakże, najciekawszą
możliwością aplikacji EMIR z punktu widzenia niniejszej pracy jest możliwość wyświetlenia na raz
wielu obrazów na płaszczyźnie według wizualnego podobieństwa. Użyty jest do tego celu algorytm
FastMap, bazujący na deskryptorowym opisie obrazów. Koncepcja jest ukazana poniżej:
Rys. C-2-2 Sortowanie za pomocą FastMap w programie Emir
To właśnie dzięki programowi EMIR autor zdecydował się zbadać algorytm FastMap w
automatycznym sortowaniu. Innym pomysłem zaczerpniętym po części z programu EMIR jest
możliwość łączenia wielu różnych deskryptorów do opisu obrazów, a także filtrowanie obrazów
jako metoda zawężenia zbioru do sortowania.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 89
C-3. System PicSOM
System PicSOM implementuje wyszukiwanie CBIR, tak więc generalnie rzecz biorąc dostaje na
wejście obrazek wzorcowy, a na wyjściu zwraca zbiór obrazów podobnych do obrazu wzorcowego
znajdujących się w cyfrowej bibliotece. Niemniej, system ten jest w paru względach innowacyjny w
porównaniu z tradycyjnym podejściem.
Po pierwsze, PicSOM jest zaprojektowany by zbierać informacje od użytkownika by określić
efektywność wykonanego wyszukiwania. Technika ta jest nazywana z ang. Relevance Feedback
(RF) Gathering [Laaksonen et al. 2002]. Ma ona na celu empiryczne powiązanie nisko-
poziomowego dopasowania cech obrazu do wysoko-poziomowej percepcji człowieka. W
szczególności, niektóre deskryptory mogą definiować zbyt szeroki zakres poszukiwań, podczas gdy
inne mogą okazać się całkiem nieistotne. Gdy opinie użytkownika zostaną zebrane dla każdego
wzorcowego obrazu, program umie dopasować wagi dla różnych deskryptorów tak, by opis za ich
pomocą lepiej odpowiadał preferencjom użytkownika i dawał lepsze wyniki wyszukiwania w
przyszłości. Tak też wyszukiwanie za pomocą programu PicSOM jest procesem iteracyjnym, w
którym system potrafi uczyć się od użytkownika.
Drugą innowacją proponowana w systemie PicSOM, która jest bliżej związana z tematyką
niniejszej pracy, jest sposób w jaki podobne obrazy są wyszukiwane. Jest to wykonywane z
użyciem kilku równoległych struktur SOM. Warto przyjrzeć się temu zagadnieniu nieco bardziej
szczegółowo [Laaksonen et al. 2002].
Po pierwsze, zanim jakiekolwiek wyszukiwanie jest wykonywane, program PicSOM trenuje
szereg dwuwymiarowych map SOM różnymi zbiorami obrazów. Te mapy organizują zbiory
obrazów na płaszczyźnie w taki sposób, że wizualnie podobne obrazy są blisko siebie. W zależności
od tego, jakie obrazy zostały użyte do wyuczenia mapy SOM, oraz jakie deskryptory użyto do opisu
cech, każda z tych map będzie inna. Gdy użytkownik rozpoczyna wyszukiwanie, każda z tych map
jest użyta do znalezienia obrazów podobnych wzorcowi. Następnie po zebraniu opinii użytkownika
system dowiaduje się, które obrazy zostały uznane za trafne dopasowania i może zredefiniować
znaczenie każdej mapy SOM dla takiego wyszukiwania. Dzięki temu, każde kolejne wyszukiwanie
dostarcza lepszych rezultatów.
Najciekawszą właściwością stworzonych map przez system PicSOM jest ich szczególna
forma. Nie są to ‘zwykłe’ SOMy, lecz hierarchiczne 4-poziomowe drzewiaste struktury. Dzięki temu
mapa na samej górze ma małe wymiary, a każdy z jej węzłów ma pod sobą kolejną strukturę SOM,
która zawiera więcej węzłów. Ta prawidłowość powtarza się aż do uzyskania czterech osobnych
warstw SOM. Główną zaletą takiego podejścia jest znacznie większa efektywność wyszukiwania –
złożoność wyszukiwania znalezienia najbardziej podobnego obrazu wynosi (logn) zamiast (n),
tak jak w tradycyjnym przypadku, gdzie n jest liczbą węzłów w SOMie. Więcej informacji na ten
temat jest w [Laaksonen et al. 2002].
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 90
Podsumowując, program PicSOM proponuje szereg interesujących pomysłów, które mogą
potencjalnie pomóc w aplikacji do automatycznego sortowania obrazów. Następujące elementy
powinny zostać rozważone:
Trenowanie map SOM zanim program zostanie po raz pierwszy uruchomiony
Idea hierarchicznej struktury SOM
Użycie różnych cech obrazu do sortowania różnych zbiorów
C-4. Program ImageSorter
ImageSorter jest programem wykonującym automatyczne sortowanie obrazów rozwijanym przez
prof. Kai-Uwe Barthel [Barthel et al. 2005, University of Applied Sciences – Berlin 2008]. Używa
deskryptorów MPEG-7 i Map Samoorganizujących aby wizualizować wszystkie posortowane
obrazy na płaszczyźnie lub powierzchni sfery. Jest to bardzo dobry przykład jak wykonywać
sortowanie obrazów według wizualnego podobieństwa. Ponadto, program posiada bardzo
przyjazne GUI i łatwo się nim posługiwać. Główne okno wersji 3.0 jest przedstawione poniżej:
Rys. C-4-1 ImageSorter ukazujący posortowane obrazy na powierzchni sfery
Poza wygodnym GUI, łatwym powiększaniem wybranych regionów i łatwym ładowaniem obrazów
program ImageSorter może poszczycić się dużą szybkością sortowania map SOM dzięki
zapamiętywaniu wyników wcześniejszego sortowania. Ze względu na liczne zalety, można
powiedzieć że ten program był pewnym pierwowzorem, na którym bazuje aplikacja Image
Organizer.
Adam Strupczewski Automatyczne Sortowanie Obrazów
Strona 91
Załącznik D – Opis zawartości płyty CD
Załączona płyta zawiera następujące katalogi:
DOCS zawiera dwa dokumenty: niniejszą pracę w formacie pdf oraz instrukcję
instalacji i obsługi aplikacji Image Organizer
APP zawiera skompilowaną wersję aplikacji oraz niezbędne biblioteki by ją
uruchomić
SRC zawiera wszystkie kody źródłowe stworzonej aplikacji
TESTSETS zawiera zbiory obrazków używane do testów aplikacji