PRACA DYPLOMOWA MAGISTERSKA - Serwer...

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 ..............................

........................................................................................


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.


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


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


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.


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.


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.


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


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


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


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].


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


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].


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


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


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


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ć:


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]


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:


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


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].


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


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].


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:


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


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


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.


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ę


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


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


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:


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)


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


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


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)


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


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:


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


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.


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ą.


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.


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ą


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


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.


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


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.


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.


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:


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


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.


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


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.


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


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ą.


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


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.


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.


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.


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.


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.


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.


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.


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:


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


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.


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.


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.


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.


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.


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.


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



3. Dla obrazów niepodobnych

3 gdy obrazy są oddalone o mniej niż 2 wymiar obrazu




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


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


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)


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.


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.


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


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ść.


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.

http://ieeexplore.ieee.org/xpl/RecentCon.jsp?punumber=4556856

http://ieeexplore.ieee.org/xpl/RecentCon.jsp?punumber=4556856

http://www.alglib.net/

http://www.analytictech.com/borgatti/mds.htm

http://www.codeproject.com/KB/graphics/iptc.aspx

http://www.digicamsoft.com/bmp/bmp.html

http://www.english.ucsb.edu/grad/student-pages/jdouglass/coursework/hyperliterature/soms/

http://www.english.ucsb.edu/grad/student-pages/jdouglass/coursework/hyperliterature/soms/

http://www.sis.pitt.edu/~ktech/IR_Project/Documents/fastmap.pdf

http://davis.wpi.edu/~matt/courses/soms/

http://picasa.google.co.uk/support/bin/answer.py?answer=93773

http://www.chmaas.handshake.de/delphi/freeware/xvi32/xvi32.htm

http://mlab.taik.fi/~timo/som/thesis-som.html

http://www.cis.hut.fi/projects/somtoolbox/theory/somalgorithm.shtml

http://www.cis.hut.fi/projects/somtoolbox/documentation/somalg.shtml


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]

http://www.semanticmetadata.net/features/

http://home.dei.polimi.it/matteucc/Clustering/tutorial_html/kmeans.html

http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/AV0506/s0567178.pdf

http://tiger.ire.pw.edu.pl/asm/lab/lab5/MPEG7-XM.zip

http://www.chiariglione.org/mpeg/standards/mpeg-7/mpeg-7.htm

http://static.photo.net/attachments/bboard/00C/00C0CJ-23143884.jpg

http://doc.trolltech.com/

http://www.qtsoftware.com/

http://doc.trolltech.com/4.4/qcolor.html#the-hsv-color-model

http://www.photosorter.us/about_photo_sorter_platinum.html

http://www.mirrorservice.org/sites/www.libpng.org/pub/png/spec/1.2/PNG-Structure.html

http://www.python.org/doc/

http://savvash.blogspot.com/2009/03/hmmd-color-space.html

http://www.sortphotos.org/about_sort_photos.html


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]

http://www.sortpics.com/

http://www.acemedia.org/aceMedia/files/document/wp7/2005/icann05-iti.pdf

http://www.statsoft.com/textbook/principal-components-factor-analysis/

http://www.statsoft.com/textbook/multidimensional-scaling/

http://pluton.pol.lublin.pl/lafi/referaty/2004/algorytmy_metody_systemy/2_11.pdf

http://mmk.f4.fhtw-berlin.de/Projekte/ImageSorter/

http://www.w3.org/Graphics/GIF/spec-gif89a.txt

http://davis.wpi.edu/~matt/courses/nland/cgi93.html

http://en.wikipedia.org/wiki/Comparison_of_Java_and_C%2B%2B

http://en.wikipedia.org/wiki/Discrete_cosine_transform

http://en.wikipedia.org/wiki/Principal_component_analysis

http://en.wikipedia.org/wiki/Multidimensional_scaling

http://en.wikipedia.org/wiki/HSL_color_space#Conversion_from_RGB_to_HSL_or_HSV

http://en.wikipedia.org/wiki/K-means_clustering

http://en.wikipedia.org/wiki/Multidimensional_scaling


Strona 83

Załącznik A – Porównanie bibliotek do tworzenia GUI


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,

};


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


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


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


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.


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].


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.


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

PRACA DYPLOMOWA MAGISTERSKA - Serwer...

Documents

Transcript of PRACA DYPLOMOWA MAGISTERSKA - Serwer...