UNIVERZA V MARIBORU

FAKULTETA ZA ELEKTROTEHNIKO,

RAČUNALNIŠTVO IN INFORMATIKO

Luka Markuš

Konstrukcija vgnezdenih izbočenih lupin

Magistrsko delo

Maribor, maj 2017

KONSTRUKCIJA VGNEZDENIH IZBOČENIH LUPIN

Magistrsko delo

Študent: Luka Markuš

Študijski program: Študijski program 2. stopnje

Računalništvo in informacijske tehnologije

Mentor: red. prof. dr. Borut Žalik, univ.dipl. inž. el.

i

ii

ZAHVALA

Zahvaljujem se mentorju prof. dr. Borutu

Žaliku za pomoč in vodenje pri

opravljanju magistrskega dela.

Zahvaljujem se družini, ki me je

spodbujala v času študija.

iii

Konstrukcija vgnezdenih izbočenih lupin

Ključne besede: izbočene lupine, računalniška geometrija, algoritmi

UDK: 004.925.021(043.2)

Povzetek

V magistrskem delu preučimo različne algoritme za konstrukcijo izbočenih lupin. Najprej

opravimo pregled algoritmov za konstrukcijo izbočenih lupin, nato pa se osredotočimo na

algoritme za konstrukcijo vgnezdenih izbočenih lupin. V praktičnem delu smo za

primerjavo implementirali tri različne algoritme, med njimi tudi optimalni algoritem za

iskanje vgnezdenih izbočenih lupin.

iv

Construction of convex layers

Key words: convex hulls, computational geometry, algorithms

UDK: 004.925.021(043.2)

Abstract

In this thesis, several convex hull algorithms are considered. Algorithms for convex hulls

and convex layers are described at first. In the practical part we implemented the optimal

algorithm for convex layers as well as two other algorithms and compared the results.

v

KAZALO

1 UVOD ............................................................................................ 1

2 IZBOČENE LUPINE ...................................................................... 2

2.1 Vgnezdene izbočene lupine ....................................................................... 2

2.2 Aplikacije izbočenih lupin .......................................................................... 3

3 ALGORITMI ZA TVORBO IZBOČENIH LUPIN ............................. 5

3.1 Naivna metoda ............................................................................................ 6

3.2 Grahamovo preiskovanje ........................................................................... 6

3.3 Jarvisov obhod ........................................................................................... 7

3.4 Hitra izbočena lupina ................................................................................. 8

3.5 Spodnja meja .............................................................................................. 9

3.6 Chanov algoritem ..................................................................................... 10

4 ALGORITMI ZA TVORBO DINAMIČNIH IZBOČENIH LUPIN ..... 12

4.1 Grahamovo preiskovanje ......................................................................... 12

4.2 Optimalni realno-časovni algoritem za izbočene lupine v ravnini ....... 13

4.3 Overmarsov in Van Leeuwenov algoritem ............................................. 18

5 ALGORITMI ZA TVORBO VGNEZDENIH IZBOČENIH LUPIN ... 24

5.1 Ponavljanje Jarvisovega obhoda ............................................................ 24

vi

5.2 Hitra izbočena lupina ............................................................................... 25

5.3 Chazellov algoritem .................................................................................. 27

5.3.1 Direktno brisanje točk .................................................................................... 30

5.3.2 Križno brisanje točk ....................................................................................... 35

6 REZULTATI ................................................................................. 37

7 SKLEP ......................................................................................... 43

8 SEZNAM VIROV .......................................................................... 44

KAZALO SLIK

SLIKA 1: IZBOČENA LUPINA ....................................................................................................................................... 2

SLIKA 2: VGNEZDENE IZBOČENE LUPINE....................................................................................................................... 3

SLIKA 3: SKRAJNE TOČKE IN ROBOVI ........................................................................................................................... 5

SLIKA 4: TOČKE, UREJENE NA ZAČETKU GRAHAMOVEGA PREISKOVANJA [3] ........................................................................ 6

SLIKA 5: JARVISOV OBHOD [3] .................................................................................................................................. 7

SLIKA 6: HITRA IZBOČENA LUPINA [3] ......................................................................................................................... 8

SLIKA 7: TVORJENJE PARABOLE ZA UREJANJE [3] ........................................................................................................... 9

SLIKA 8: CHANOV ALGORITEM [4] ........................................................................................................................... 10

SLIKA 9: TANGENTE OD TOČKE PI DO IZBOČENEGA MNOGOKOTNIKA CI-1 [2] ..................................................................... 13

SLIKA 10: KLASIFIKACIJA TOČKE V GLEDE NA DALJICO PV [2] .......................................................................................... 14

SLIKA 11: KLASIFIKACIJA Α, M IN M [2] .................................................................................................................... 16

vii

SLIKA 12: DVA MOŽNA PRIMERA GLEDE NA TO, ALI SE PREJ POJAVI TOČKA L ALI R [2] ......................................................... 17

SLIKA 13: ČE IZBRIŠEMO TOČKO P3, BOSTA P1 IN P2 NA IZBOČENI LUPINI [2] ..................................................................... 18

SLIKA 14: ZGORNJA IZBOČENA LUPINA MNOŽICE TOČK [2] ............................................................................................ 19

SLIKA 15: DA DOBIMO ZGORNJO LUPINO UNIJE U1 IN U2, MORAMO POISKATI PODPORNO DALJICO (MOST) P1P2 [2] .............. 20

SLIKA 16: KLASIFIKACIJA DALJICE Q1Q2 [2] ................................................................................................................. 21

SLIKA 17: MNOŽICA TOČK V RAVNINI IN PRIPADAJOČA PODATKOVNA STRUKTURA T [2] ...................................................... 23

SLIKA 18: VSTAVLJANJE TOČKE V T [2]...................................................................................................................... 23

SLIKA 19: PONAVLJANJE JARVISOVEGA OBHODA [2] .................................................................................................... 24

SLIKA 20: TOČKA K LAHKO LEŽI ZUNAJ, ZNOTRAJ, NA ALI MED IJ [8] ................................................................................ 25

SLIKA 21: NEKONSISTENTNOST, KI NASTANE PRI IZROJENOSTI [8] ................................................................................... 26

SLIKA 22: PRIMER LUPINSKEGA GRAFA [1] ................................................................................................................ 28

SLIKA 23: TOČKA P IN NJENI SOSEDI [1] .................................................................................................................... 29

SLIKA 24: DIREKTNO BRISANJE [1] ........................................................................................................................... 31

SLIKA 25: TANGENTE SO LAHKO OBLIKE PQ ALI QP [1] .................................................................................................. 32

SLIKA 26: DIREKTNO BRISANJE [1] ........................................................................................................................... 33

SLIKA 27: ISKANJE NASLEDNJE TOČKE ZA ZAVIJANJE [1] ................................................................................................ 34

SLIKA 28: KONČNA PRIMERA Δ = 0 IN Ε = 0 [1] .......................................................................................................... 35

SLIKA 29: KRIŽNO BRISANJE [1]............................................................................................................................... 36

SLIKA 30: PRIMERJAVA IZVAJALNEGA ČASA ISKANJA ENE IZBOČENE LUPINE PRI UNIFORMNI PORAZDELITVI ZNOTRAJ KVADRATA ... 40

SLIKA 31: PRIMERJAVA IZVAJALNEGA ČASA ISKANJA ENE IZBOČENE LUPINE PRI UNIFORMNI PORAZDELITVI ZNOTRAJ KROGA ........ 40

SLIKA 32: PRIMERJAVA IZVAJALNEGA ČASA ISKANJA VGNEZDENIH IZBOČENIH LUPIN PRI UNIFORMNI PORAZDELITVI ZNOTRAJ

KVADRATA .................................................................................................................................................. 41

viii

SLIKA 33: PRIMERJAVA IZVAJALNEGA ČASA ISKANJA VGNEZDENIH IZBOČENIH LUPIN PRI UNIFORMNI PORAZDELITVI ZNOTRAJ KROGA

................................................................................................................................................................ 41

SLIKA 34: PRIMERJAVA IZVAJALNEGA ČASA PRI KONSTANTNEM ŠTEVILU TOČK IN RAZLIČNEM ŠTEVILU IZBOČENIH LUPIN ............. 42

KAZALO TABEL

TABELA 1: VSI MOŽNI PRIMERI KLASIFIKACIJE Α, M IN M. .............................................................................................. 15

TABELA 2: IZVAJALNI ČAS ZA ISKANJE ENE IZBOČENE LUPINE PRI UNIFORMNI PORAZDELITVI ZNOTRAJ KVADRATA [S] .................. 37

TABELA 3: IZVAJALNI ČAS ZA ISKANJE ENE IZBOČENE LUPINE PRI UNIFORMNI PORAZDELITVI ZNOTRAJ KROGA [S] ....................... 38

TABELA 4: IZVAJALNI ČAS ZA ISKANJE VGNEZDENIH IZBOČENIH LUPIN PRI UNIFORMNI PORAZDELITVI ZNOTRAJ KVADRATA [S] ...... 38

TABELA 5: IZVAJALNI ČAS ZA ISKANJE VGNEZDENIH IZBOČENIH LUPIN PRI UNIFORMNI PORAZDELITVI ZNOTRAJ KROGA [S] ........... 39

TABELA 6: IZVAJALNI ČAS ZA ISKANJE VGNEZDENIH IZBOČENIH LUPIN 25000 TOČK PRI RAZLIČNEM ŠTEVILU IZBOČENIH LUPIN [S] 39

1

1 UVOD

Iskanje izbočene lupine množice točk je eden izmed temeljnih problemov računalniške

geometrije. Algoritmi za iskanje izbočenih lupin imajo množico aplikacij [2, 3, 14, 15, 16].

Če primerjamo algoritme za razvrščanje in algoritme za konstrukcijo izbočenih lupin, lahko

najdemo nekaj podobnosti. Na primer, Jarvisov obhod [12] spominja na urejanje z

navadnim izbiranjem (angl. Selection sort) [13], hitre izbočene lupine (angl. Quickhull) [8,

9] pa na hitro urejanje (angl. Quicksort) [2]. Rezultat algoritmov za iskanje izbočenih lupin

je mnogokotnik, ki lahko vsebuje le majhen delež prvotnih točk, zato je možno doseči

boljšo časovno zahtevnost kot pri razvrščanju. Te razlike pa ni, če poiščemo vgnezdene

izbočene lupine [1].

V tej nalogi se bomo osredotočili na 2D izbočene lupine. Cilj naloge je implementirati

optimalni algoritem za iskanje vgnezdenih izbočenih lupin v 2D prostoru in ga primerjati z

nekaterimi drugimi algoritmi. Zanima nas predvsem časovna zahtevnost in kako se bodo

različni algoritmi izkazali pri različno velikih množicah točk ter različnem številu izbočenih

lupin.

Delo je skupaj z uvodom sestavljeno iz sedmih poglavij. V drugem poglavju podamo

definicijo izbočenih lupin in predstavimo nekaj primerov njihove uporabe. V tretjem,

četrtem in petem poglavju podamo različne algoritme za iskanje izbočenih lupin. V šestem

poglavju opišemo rezultate svoje primerjave algoritmov, ki smo jih implementirali. Nalogo

povzamemo v sedmem poglavju.

2

2 IZBOČENE LUPINE

Izbočena lupina množice točk je najmanjši izbočeni mnogokotnik, ki vsebuje vse točke v

množici. V 2D si lahko izbočene lupine predstavljamo tako, da si zamislimo množico

žebljičkov, okoli katerih raztegnemo elastiko in ko jo spustimo, bo elastika tvorila izbočeno

lupino. Točke, ki se jih elastika dotika, so člani izbočene lupine.

Slika 1: Izbočena lupina

2.1 Vgnezdene izbočene lupine

Naj bo S množica točk v 2D prostoru. Vgnezdene izbočene lupine množice S so množica

izbočenih lupin, ki jih dobimo tako, da najprej poiščemo izbočeno lupino množice S in

točke, ki so na tej izbočeni lupini, odstranimo iz S. Nato postopek ponavljamo, dokler S ni

prazna. Ko smo poiskali vgnezdene izbočene lupine, lahko za točke izračunamo globino,

to je število izbočenih lupin, ki obkrožajo točko, kar je pri reševanju nekaterih problemov

zelo koristen podatek [1].

3

Slika 2: Vgnezdene izbočene lupine

2.2 Aplikacije izbočenih lupin

Izbočene lupine se uporabljajo pri razpoznavanju vzorcev [2], obdelavi slik [2], statistiki

[2], izogibanju trkov [3], analizi oblik [3], v mehatroniki [14], in še kje.

Preprost primer uporabe izbočene lupine je iskanje poti robota. Če se izbočena lupina

robota izogne trku z oviro, se bo tudi robot. Ker je iskanje poti veliko lažja za izbočen lik

kot pa neizbočen, je pogosto namesto robota uporabljena njegova izbočena lupina [3]. V

[14] s konstrukcijo izbočenih lupin poiščejo najkrajšo pot, ki jo mora robot prehoditi tako,

da bo obiskal vse dane točke. Ta problem je poznan kot problem trgovskega potnika.

Rešijo ga tako, da točke s pomočjo izbočene lupine razdelijo v neodvisne soseščine in

znotraj njih ločeno poiščejo optimalno pot, delne poti pa na koncu združijo. V prvem

koraku uporabijo Grahamovo preiskovanje, da poiščejo izbočeno lupino dane množice

točk. Nato točke združijo v soseščine tako, da okoli daljic na izbočeni lupini za vsako

daljico tvorijo krog, ki gre skozi točki daljice in ima enak premer, kot je dolžina daljice. Vse

točke znotraj tega kroga dodajo v eno soseščino. Nekatere točke lahko ostanejo izven

vseh krogov, zato postopek ponovijo tako, da naredijo novo izbočeno lupino, ki gre skozi

najbolj oddaljene točke v posameznih soseščinah. Algoritem najprej poišče najboljšo pot

znotraj vsake soseščine, potem pa te poti združi v eno [14]. Še en algoritem, ki rešuje

problem trgovskega potnika s pomočjo vgnezdenih izbočenih lupin, je opisan v [15]. Pri

4

tem algoritmu pa najprej poiščejo vgnezdene izbočene lupine in jih uporabijo kot izhodišče

za nadaljnje algoritme.

V [16] uporabijo vgnezdene izbočene lupine kot značilke za iskanje dvojnikov slik. Hkrati

pokažejo, da lahko vgnezdene izbočene lupine na rastrski mreži tvorimo v linearnem

času. Tako lahko s tem algoritmom hitro poiščemo zelo podobne slike, ki so lahko tudi

zamaknjene, zavrtene ali povečane oz. pomanjšane.

5

3 ALGORITMI ZA TVORBO IZBOČENIH LUPIN

Algoritmi za tvorbo izbočenih lupin morajo poiskati vse skrajne točke ali pa vse skrajne

robove. Skrajne točke so točke na izbočeni lupini, pri katerih je kot striktno manjši od π

(slika 3a). To pomeni, da točke znotraj izbočene lupine in točke med dvema skrajnima

točkama niso skrajne točke. Skrajni robovi so robovi, za katere velja, da so vse točke v

množici ali na robu ali pa na eni strani roba (slika 3b) [3].

Slika 3: Skrajne točke in robovi

6

3.1 Naivna metoda

Pri naivni metodi imamo dve možnosti. Lahko se odločimo poiskati skrajne točke ali pa

skrajne robove. Pri iskanju skrajnih točk množice S samo preverimo za vsako točko, če je

izven vseh trikotnikov, ki jih lahko tvorimo z ostalimi točkami v S. Ta postopek potrebuje

O(n4) časa. Pri iskanju skrajnih robov pa za vsak rob preverimo, ali so vse točke na eni

strani roba. Časovna zahtevnost je v tem primeru O(n3) [3].

3.2 Grahamovo preiskovanje

V enem izmed prvih člankov, ki se ukvarjajo z iskanjem učinkovitih geometričnih

algoritmov, je bilo predstavljeno Grahamovo preiskovanje. Ta članek je bil objavljen leta

1972 [11].

Najprej poiščemo najnižjo točko, ki ji bomo rekli p0. Če jih je več, izberemo najbolj desno

izmed najnižjih točk. Nato vse preostale točke uredimo po kotu, ki ga tvorijo s p0 proti

smeri urinega kazalca. Na sliki 4 je točka p0 označena z 0, vse ostale pa so indeksirane

tako, kot jih uredi algoritem. Skrajne točke hranimo v skladu S. Na začetku v S damo točki

0 in 1. Za ti dve točki vemo, da sta na izbočeni lupini. Točka 0 je vedno na izbočeni lupini,

ker je to najnižja točka, točka 1 pa zato, ker tvori skrajni kot s točko 0. Za vse nadaljnje

točke preverimo, ali tvorijo zasuk v levo od zadnjih dveh točk na skladu. V tem primeru

točko dodamo na sklad. V nasprotnem primeru odstranimo zadnjo točko iz sklada in

ponovno preverimo, ali nova točka z zadnjima dvema tvori zasuk v levo. Ta postopek

ponovimo za vse točke. Pri tem je treba paziti še na kolinearnost. Če imamo kolinearne

točke, potem vse točke, ki imajo po urejanju enak kot, razen najbolj oddaljene, odstranimo

[3].

Slika 4: Točke, urejene na začetku Grahamovega preiskovanja [3]

7

Časovna zahtevnost Grahamovega preiskovanja je O(n log n), ker ima korak razvrščanja

časovno zahtevnost O(n log n), preostali del algoritma pa časovno zahtevnost O(n) [3].

3.3 Jarvisov obhod

Pri naivni metodi iskanja skrajnih robov je časovna zahtevnost O(n3). Jarvisov obhod pa ta

algoritem izboljša tako, da upošteva dejstvo, da si robovi delijo točke. Tako začnemo z

iskanjem novega roba pri drugi točki prejšnjega roba. Jarvisov obhod ima časovno

zahtevnost O(nh) [2].

Jarvisov obhod, podobno kot Grahamovo preiskovanje, začne pri skrajni točki. Nato med

preostalimi točkami poišče tisto, ki s prvo točko tvori najmanjši kot proti smeri urinega

kazalca. Nadaljnje robove poiščemo na enak način, le da začnemo pri drugi točki

prejšnjega roba. Na sliki 5 je prikazan primer, kjer za točko x poiščemo naslednji rob, to je

rob med x in y [2, 3].

Ker so lahko vse točke na izbočeni lupini in ker Jarvisov obhod potrebuje linearni čas, da

najde vsako točko na izbočeni lupini, je časovna zahtevnost v najslabšem primeru O(n2),

kar je slabše od Grahamovega preiskovanja. Jarvisov obhod pa je hitrejši, kadar je število

točk na izbočeni lupini majhno [2].

Slika 5: Jarvisov obhod [3]

8

3.4 Hitra izbočena lupina

Hitro izbočeno lupino (angl. Quickhull) je neodvisno odkrilo več raziskovalcev v poznih

sedemdesetih letih prejšnjega stoletja, ime pa je dobila po algoritmu hitro urejanje (angl.

Quicksort), ker je osnovna ideja obeh algoritmov zelo podobna. Pri algoritmu hitro urejanje

imamo polje števil in to polje razdelimo na dva dela tako, da bodo vsa števila v prvem delu

manjša od vseh števil v drugem delu. Nato oba dela urejamo rekurzivno. Hitra izbočena

lupina pa v prvem koraku množico točk razdeli na dva dela, nato pa vedno na tri dele in v

zunanjih dveh delih ločeno nadaljuje iskanje skrajnih točk [2].

V prvem koraku točke razdelimo na dve podmnožici. Najprej določimo premico, ki gre

skozi dve skrajni točki, a in b. Nato v eno podmnožico damo točke, ki ležijo nad to

premico, v drugo podmnožico pa točke pod njo. Ti dve množici potem obdelamo

rekurzivno. Vsak naslednji korak deluje nad eno podmnožico, ki ji bomo rekli S. V S

poiščemo najbolj oddaljeno točko od premice ab, to bo točka c. Točka c je zagotovo na

izbočeni lupini. Nato konstruiramo daljici med a in c ter c in b. Točke znotraj trikotnika

Δabc niso skrajne točke. Ostale točke v S razdelimo v dve novi podmnožici. V prvo

podmnožico damo točke levo od daljice ac, v drugo pa točke desno od daljice cb. Nato na

enak način nadaljujemo s tema podmnožicama. Postopek ponavljamo, dokler niso vse

točke ali na izbočeni lupini ali pa zavržene. Ko rekurzivno obdelamo levo podmnožico,

premico ab zamenjamo z ac, pri desni podmnožici pa ac zamenjamo s cb [2, 3].

V najboljšem primeru je časovna zahtevnost hitre izbočene lupine O(n log n), v

najslabšem pa O(n2), enako kot časovna zahtevnost algoritma hitro urejanje [2].

Slika 6: Hitra izbočena lupina [3]

9

3.5 Spodnja meja

Za probleme v računalništvu je zelo težko vzpostaviti netrivialne spodnje meje za časovno

zahtevnost. Težava je v tem, da mora dokaz pokriti prav vse možne vhodne podatke.

Eden izmed problemov, za katere takšen dokaz obstaja, je razvrščanje, ki ima spodnjo

mejo Ω(n log n). V [2] pa je dokazano, da je možno tvorbo izbočenih lupin v linearnem

času pretvoriti v problem razvrščanja. Iz tega sledi, da za tvorbo izbočenih lupin ni možno

doseči boljše časovne zahtevnosti kot O(n log n), ker bi v nasprotnem primeru lahko s

tvorbo izbočenih lupin urejanje izvedli v manj kot O(n log n). Ta dokaz predpostavlja, da

so vse točke na izbočeni lupini, kar dopušča možnost, da imamo boljšo časovno

zahtevnost, kadar so nekatere točke znotraj izbočene lupine [3]. Primer je Jarvisov obhod,

ki ima časovno zahtevnost O(nh), torej bo časovna zahtevnost boljša od O(n log n), če je

h < log n.

Dokaz, da je tvorbo izbočenih lupin možno v linearnem času pretvoriti v urejanje, je

preprost. Imamo N pozitivnih števil, ki jih želimo urediti po vrsti. Za vsako število xi

ustvarimo točko (xi, xi2). Vse točke bodo tako na paraboli y = x2 (slika 7). Izbočena lupina

teh točk bo seznam točk, urejenih po koordinati y. Z enim prehodom seznama bomo dobili

točke po vrsti [2].

Slika 7: Tvorjenje parabole za urejanje [3]

246810

100

80

60

40

20

10

3.6 Chanov algoritem

Naj bo P množica točk v ravnini. Pri Jarvisovem obhodu se izračuna h točk izbočene

lupine, vsaka posebej, proti smeri urinega kazalca. Če sta pk-1 in pk zadnji dve točki,

potem je naslednja točka pk+1 tista p ∈ P, ki maksimizira ∠pk-1pkp, p ≠ pk. Ta korak iskanja

naslednje točke se imenuje zavijanje in zahteva O(n) časa [4].

Chanov algoritem [4] poskuša ta korak pohitriti tako, da točke prej obdela. Najprej

izberemo m tako, da je vrednost med 1 in n, ter razdelimo P v n/m podmnožic. Nato

poiščemo izbočeno lupino vsake podmnožice v O(m log m) času z Grahamovim

preiskovanjem (lahko uporabimo tudi kateri drug algoritem z enako časovno zahtevnostjo,

na primer hitro izbočeno lupino). Sedaj imamo n/m izbočenih mnogokotnikov, ki se lahko

prekrivajo. Vsak mnogokotnik ima največ m točk. Ta predobdelava točk potrebuje O(𝑛

𝑚(m

log m)) = O(n log m) časa [4].

Nato lahko zavijanje opravimo tako, da za vseh n/m mnogokotnikov izračunamo tangente

skozi točko pk, kot je prikazano na sliki 8. Iskanje tangent izbočenih mnogokotnikov z

dvojiškim ali Fibonnacijevim iskanjem ima logaritmično časovno zahtevnost, zato je čas,

potreben za en korak zavijanja, O(n log m + H(𝑛

𝑚 log m)) = O (n(1 + H/m) log m) [4].

Slika 8: Chanov algoritem [4]

11

Najprej definiramo točko p0, ki jo uporabimo samo na začetku in njeno vrednost nastavimo

na (0, -∞). Za točko p1 pa izberemo najbolj desno točko v P. Vsako naslednjo točko na

izbočeni lupini pk+1 poiščemo tako, da poiščemo točko q iz množice Q, ki tvori največji kot

∠pk-1pkq. Množico Q dobimo tako, da za vsako podmnožico P1, …, P[n/m] z dvojiškim

iskanjem poiščemo točko qi, ki tvori največji kot ∠pk-1pkqi in ni enaka pk. Z iskanjem točk

na izbočeni lupini zaključimo, ko je pk+1 enaka p1 ali pa je k+1 > H. V slednjem primeru to

pomeni, da je bil H premajhen in vrnemo le del izbočene lupine [4].

Ta algoritem deluje s časovno zahtevnostjo O(n(1 + H/m) log m) in bo uspešno vrnil točke

izbočene lupine, urejene proti smeri urinega kazalca, kadar je H ≥ h. Z izbiro m = H, bo

časovna zahtevnost O(n(1 + H/m) log m) = O(n log H). Ker pa h ni vnaprej poznan,

uporabimo zaporedje H-jev, da uganemo njegovo vrednost. Zaporedje H-jev dobimo z

(3.1), kjer je t najprej enak 1 in ga povečujemo za 1, dokler nam algoritem ne vrne celotne

izbočene lupine [4].

𝐻 = min{22𝑡 , 𝑛} (3.1)

Algoritem se zaključi in nam vrne seznam točk na izbočeni lupini takoj, ko vrednost H v

zanki, kjer iščemo točke na izbočeni lupini, preseže h. Število iteracij te zanke je [log log

h] in t-ta iteracija potrebuje O(n log H) = O(n2t) časa. Zato je časovna zahtevnost

algoritma O(∑ 𝑛2𝑡⌈log log ℎ⌉

𝑡=1) = O(𝑛2⌈log log ℎ⌉+1) = O(n log h). Prostorska zahtevnost

algoritma pa je linearna [4].

Chanov algoritem ni bil prvi razvit algoritem s časovno zahtevnostjo O(n log h). Leta 1986

sta Kirkpatrick in Seidel [5] odkrila algoritem, ki ima prav tako časovno zahtevnost O(n log

h), je pa Chanov algoritem preprostejši [4].

12

4 ALGORITMI ZA TVORBO DINAMIČNIH IZBOČENIH LUPIN

Veliko težji problem kot iskanje izbočene lupine je vzdrževanje izbočene lupine, ko je

dovoljeno vstavljanje in brisanje posameznih točk. Algoritem za dinamične izbočene

lupine mora vzdrževati predstavitev izbočene lupine in jo posodobiti, ko na vhodu dobi

novo točko. Vprašanje je, kako to vpliva na časovno zahtevnost. Spodnja meja algoritmov

za dinamične izbočene lupine je enaka, kot pri algoritmih za tvorbo izbočene lupine, kar je

Ω(n log n). Spodnja meja za dodajanje ali brisanje posamezne točke pa je Ω(log n) [2].

Med prvimi algoritmi za vzdrževanje dinamične izbočene lupine v ravnini je bil algoritem

Overmarsa in Van Leeuwna [6]. Ta algoritem v najslabšem primeru za vstavljanje

potrebuje O(log2 n) časa. Razvitih je bilo več algoritmov, ki pod določenimi pogoji

dosežejo optimalni čas O(log n) za vstavljanje ali brisanje. Recimo algoritem, ki dovoljuje

samo vstavljanje točk avtorja Preparata [7] in algoritem, ki dovoljuje samo brisanje točk, ki

ga je razvil Chazelle [1]. Chazellov algoritem nam z brisanjem posameznih točk v

optimalnem času omogoča tvorbo vgnezdenih izbočenih lupin z optimalno časovno

zahtevnostjo.

4.1 Grahamovo preiskovanje

Za vstavljanje točk lahko uporabimo Grahamovo preiskovanje. Če Grahamovo

preiskovanje uporabimo vsakič, ko na vhod pride nova točka, bo časovna zahtevnost O(n2

log n). Z nekaj spremembami pa se da ta postopek izboljšati [2].

Najprej dodajamo točke, dokler ne najdemo treh, ki so nekolinearne. Težišče teh treh točk

bo vedno znotraj izbočene lupine, zato ga je smiselno uporabiti za računanje kota pri

Grahamovem preiskovanju. Za izbočeno lupino vzdržujemo dvojno-povezan seznam točk.

Ko na vhodu prejmemo novo točko pi, jo dodamo v seznam na mesto glede na polarni kot

v času O(i). Sedaj nad seznamom izvedemo Grahamovo preiskovanje, tudi ta korak

potrebuje O(i) časa. Pri tem koraku imamo tri možnosti:

- pi je skrajna točka in dodajanje te točke povzroči, da so nekatere druge

odstranjene;

- pi je skrajna točka, ampak nobena druga ni izločena;

- pi je znotraj izbočene lupine in se odstrani.

13

V vsakem primeru se seznam poveča za največ ena. Končni čas algoritma je v

najslabšem primeru O(n2), kar se zgodi, ko so vse točke na izbočeni lupini. Algoritem se

da še pohitriti, če bi uporabili dvojiško vstavljanje, ki ima časovno zahtevnost O(log n) [2].

4.2 Optimalni realno-časovni algoritem za izbočene lupine v ravnini

Problem vstavljanja točk lahko rešimo učinkovito tako, da poiščemo le obe tangenti od

točke do izbočenega mnogokotnika. Če je izbočeni mnogokotnik sestavljen iz točk p1, p2,

… in je pi trenutna točka, Ci-1 pa izbočen mnogokotnik točk {p1, p2, ..., pi-1}, moramo

poiskati obe tangenti od pi do Ci-1, če obstajata. Če ne obstajata, to pomeni, da je pi

znotraj Ci-1. Če je pi znotraj Ci-1, pi izločimo, v nasprotnem primeru pa izločimo točke na Ci-

1, ki se nahajajo med tangentama in vstavimo pi. Primer je prikazan na sliki 9. Leva

tangenta je tista, ki bo na levi strani, če se postavimo v točko pi in obrnemo proti Ci-1 [2, 7].

Slika 9: Tangente od točke pi do izbočenega mnogokotnika Ci-1 [2]

Sedaj bomo opisali postopek za iskanje tangent izbočenega mnogokotnika C, ki gresta

skozi točko p. Vsako točko v na mnogokotniku C, klasificiramo glede na daljico p̅v̅, kot je

prikazano na sliki 10. Za točko v rečemo, da je vbočena glede na daljico p̅v̅, če daljica p̅v̅

seka notranjost C. Točka v je podporna glede na p̅v̅, če sosednji točki od v na

mnogokotniku C ležita na isti strani premice skozi p in v. Če pa v ni vbočena ali podporna

glede na p̅v̅, potem je vdrta [2].

14

Slika 10: Klasifikacija točke v glede na daljico pv [2]

Če je točka v podporna, potem smo z iskanjem končali. V nasprotnem primeru pa, recimo,

iščemo levo tangento. Da bomo poiskali podporno točko, moramo prehoditi točke na

mnogokotniku C proti smeri urinega kazalca, kadar je točka v vbočena glede na

mnogokotnik C oz. v smeri urinega kazalca, kadar je točka v vdrta [2, 7].

Podatkovna struktura, uporabljena pri tem algoritmu, je združljiva vrsta (angl.

concatenable queue), ki je realizirana z uravnoteženim iskalnim drevesom. Ta podatkovna

struktura nam omogoča izvedbo naslednjih operacij v najslabšem primeru v O(log i) času,

kjer je i število vozlišč v drevesu:

- iskanje po urejenem nizu točk, da najdemo tangente točke pi;

- delitev niza točk in združevanje niza točk;

- vstavljanje točke.

V tem drevesu, imenovanem T, so točke na izbočeni lupini predstavljene kot veriga, kjer

sta prvi in zadnji element povezana, torej sta sosednja. Z m bomo označili najbolj levi

element, z M pa korenskega. Kot α, definiran kot ∠(mpiM), je izbočen (≤π) ali vdrt (˃π).

Odvisno od klasifikacije m in M (vbočena, podporna, vdrta) in kota α imamo 18 možnih

15

primerov, ki pa jih lahko zmanjšamo na 8, kot je povzeto v tabeli 1 in prikazano na sliki 11

[2, 7].

Tabela 1: Vsi možni primeri klasifikacije α, m in M.

Primer α m M

1 izbočen vbočena vbočena

2 izbočen vbočena nevbočena

3 izbočen nevbočena vdrta

4 izbočen nevbočena nevdrta

5 vdrt vdrta vdrta

6 vdrt vdrta nevdrta

7 vdrt nevdrta vbočena

8 vdrt nevdrta nevbočena

16

Slika 11: Klasifikacija α, m in M [2]

Na sliki 11 krog predstavlja izbočeni mnogokotnik P, urejeno zaporedje točk se začne pri

m in nadaljuje proti smeri urinega kazalca. L(M) in R(M) sta zaporedji točk, shranjeni v

levem in desnem poddrevesu korena drevesa T. Vsak primer, podan v tabeli 1, zahteva

drugačen pristop za iskanje leve in desne podporne točke označene z l oziroma r [2, 7].

17

V primerih 2, 4, 6 in 8 v tabeli 1 vemo, da l in r obstajata, ker p ne more biti znotraj P (m ali

M zagotovo ni izbočen) in jih najdemo v ločenih poddrevesih T (eno poddrevo razširimo,

da vsebuje tudi M). Točko l poiščemo tako, da začnemo pri korenu drevesa T, se

pomikamo navzdol, dokler ne najdemo podporne točke. Če je točka v drevesu vdrta,

gremo po drevesu levo, če pa je vbočena pa desno [2, 7].

V primerih 1, 3, 5 in 7 se l in r nahajata v istem poddrevesu M, če obstajata. V primerih 1

in 7 je možno, da sta m in M hkrati izbočena in v tem primeru je p znotraj P, kar pomeni,

da l in r ne obstajata. V vseh primerih se iskanje izvaja rekurzivno v poddrevesu

trenutnega drevesa, dokler ne pridemo do primera 2, 4, 6 ali 8. Če pa pridemo do lista

drevesa, brez da bi imeli primer 2, 4, 6 ali 8, to pomeni, da je p znotraj mnogokotnika [2,

7].

Postopek iskanja tangent točke p si lahko predstavljamo kot sledenje poti od korena

drevesa T do točke c, kjer se začneta dve ločeni poti. Ker je drevo uravnoteženo in

vsebuje največ i < N točk in ker vsako vozlišče obdelamo v konstantnem času, ta

postopek porabi O(log i) časa [2, 7].

Ostane le še posodobitev mnogokotnika Ci-1, kadar je p na zunanji strani. Točke med l in r

odstranimo in na njihovo mesto vstavimo pi. Imamo dva možna primera, prikazana na sliki

12, kako bomo to opravili. V prvem primeru se v zaporedju točk v T pojavi točka l, v

drugem pa točka r. V prvem primeru moramo T dvakrat razcepiti in nato združiti, v drugem

pa samo dvakrat razcepiti. Operaciji razcepa in združenja opravimo v času O(log i). Ta

algoritem torej poišče izbočeno lupino množice točk v času O(n log n), za posodobitev po

dodajanju nove točke pa O(log n) [2, 7].

Slika 12: Dva možna primera glede na to, ali se prej pojavi točka l ali r [2]

18

4.3 Overmarsov in Van Leeuwenov algoritem

Algoritem, opisan v prejšnjem podpoglavju, si lahko predstavljamo kot vzdrževanje

podatkovne strukture, ki opisuje izbočeno lupino množice točk, kjer je dovoljeno le

vstavljanje novih točk. Če pa poleg vstavljanja dovolimo tudi brisanje točk, pa bomo

potrebovali podatkovno strukturo, ki bo hranila vse točke, ker se bodo lahko točke, ki so

znotraj izbočene lupine, pojavile na njej, kadar bomo izbrisali točko na izbočeni lupini [2].

Slika 13: Če izbrišemo točko p3, bosta p1 in p2 na izbočeni lupini [2]

Izbočena lupina je unija dveh izbočenih monotonih verig. Običajno sta ti dve verigi

sestavljeni med točkama z najmanjšo in največjo koordinato x. Ti dve verigi sta zgoraj oz.

spodaj izbočeni, zato ju imenujemo zgornja in spodnja lupina. Zgornjo lupino množice točk

dobimo kot navadno izbočeno lupino množice točk S ∪ {∞L}, kjer je ∞L točka (0, -∞).

Primer je prikazan na sliki 14. Izbočeno lupino množice točk dobimo tako, da enostavno

združimo zgornjo in spodnjo lupino, zato se lahko v nadaljevanju omejimo na iskanje le

zgornje lupine [2, 6].

19

Slika 14: Zgornja izbočena lupina množice točk [2]

Pri tem algoritmu je uporabljena podatkovna struktura uravnoteženo iskalno dvojiško

drevo, ki ga imenujemo T. Točke hranimo v listih tega drevesa, urejene po koordinati x

tako, da nam prehod skozi liste od leve proti desni da točke, urejene v vodoravni smeri.

Točke na zgornji lupini so tudi urejene po osi x, zato je zgornja lupina podzaporedje

globalnega zaporedja točk, shranjenega v listih.

Naj bo v vozlišče v T, LSON[v] in RSON[v] pa sta levi in desni potomec tega vozlišča.

Želimo tvoriti zgornjo lupino točk, ki so shranjene v listih poddrevesa s korenom v. Ker je

verigo točk treba deliti in združevati, predpostavimo, da je veriga predstavljena kot

združljiva vrsta. Naj bo U(v) zgornja lupina množice točk, shranjenih v listih poddrevesa s

korenom v. Sedaj pa predpostavimo, da sta nam na voljo U(LSON[v]) in U(RSON[v]),

zgornji lupini potomcev v, mi pa želimo tvoriti U(v). Za to potrebujemo funkcijo

BRIDGE(U1, U2), ki bo poiskala tangento med U1 in U2. Funkcija BRIDGE nam bo

omogočila delitev U1 v urejen par verig (U11, U12) in podobno U2 v (U21, U22), kot je

prikazano na sliki 15. Točki na tangenti p1 ϵ U1 in p2 ϵ U2 dodamo v U11 oz. U22, obe torej v

zunanjo podverigo. Zgornjo lupino U(U1 ∪ U2) dobimo tako, da združimo U11 ∪ U22. V

vozlišča drevesa T shranimo kazalce na združljive vrste, ki predstavljajo del zgornje lupine

v, ki ne pripada zgornji lupini očeta vozlišča v [2, 6].

20

Slika 15: Da dobimo zgornjo lupino unije U1 in U2, moramo poiskati podporno daljico (most) p1p

2̅̅ ̅̅ ̅̅ [2]

Kadar pa že imamo U(v) in želimo z obratno operacijo dobiti U(LSON[v]) in U(RSON[v]),

pa potrebujemo le informacijo o daljici 𝑝1𝑝2̅̅ ̅̅ ̅̅ , kar je število J[v], ki označuje položaj točke p1

v verigi točk U(v). S to informacijo lahko U(v) razdelimo na verigi U11 in U22, ki jih lahko

nato združimo z verigami, shranjenimi v LSON[v] in RSON[v]. Končno podatkovno

strukturo dobimo tako, da v vsako vozlišče v drevesa T dodamo naslednje podatke:

- kazalec na združljivo vrsto Q[v], ki hrani del U(v), ki ne pripada zgornji lupini očeta

U(FATHER[v]); če je v koren, potem je Q[v] = U(v);

- število J[v], ki označuje položaj leve podporne točke U(v).

Ta podatkovna struktura zavzame le O(n) prostora, kjer je n velikost množice točk. Drevo

T ima n listov in n – 1 vozlišč, točke, shranjene v združljivih vrstah, pa predstavljajo del

množice točk [2, 6].

Funkcijo BRIDGE lahko nad dvema ločenima izbočenima verigama n točk izvedemo v

času O(log n). Če imamo dve zgornji lupini U1 in U2 in dve točki q1 ϵ U1 in q2 ϵ U2, lahko

vsako izmed teh dveh točk klasificiramo glede na daljico 𝑞1𝑞2̅̅ ̅̅ ̅̅ kot vdrto, podporno ali

vbočeno. Odvisno od te klasifikacije imamo devet možnih primerov, prikazanih na sliki 16

(a). Verige, označene z vijugasto črto, lahko izločimo iz kandidatk za podporno točko. Vsi

primeri so razumljivi sami po sebi, razen primera, kjer sta q1 in q2 oba vbočena. Ta primer

je posebej prikazan na sliki 16 (b). Naj premica l1 vsebuje q1 in njenega desnega soseda

na U1, podobno naj l2 vsebuje q2 in njenega levega soseda na U2, p pa naj bo presečišče

med l1 in l2. Predpostavimo, da je p desno od l. Iz tega sledi, da je lahko podporna točka

p1 samo v osenčenem delu in da ima u manjšo ordinato kot v. To pa pomeni, da je vsaka

točka q'' na podverigi desno od q2 vbočena glede na daljico 𝑞′𝑞′′̅̅ ̅̅ ̅̅ , kjer je q' katerakoli

21

točka na U1. Verigo točk desno od q2 lahko izločimo, za verigo točk levo od q1 pa to ne

velja. Če pa je presečišče p levo od l, potem pa lahko izločimo verigo točk levo od q1 [2].

Slika 16: Klasifikacija daljice q1q2 [2]

Na sliki 17 je prikazan primer podatkovne strukture T, kjer so točke indeksirane po

vrstnem redu vstavljanja. Vsak list pripada eni točki, vsako vozlišče pa mostu med dvema

zgornjima lupinama, hkrati pa vsebuje podatke Q[v] in J[v]. Podatkovna struktura T

opisuje drevo nad trenutno vzdrževano množico točk in se imenuje lupinsko drevo (angl.

hull tree) [2]

Pri vstavljanju točk v T moramo T ponovno uravnotežiti in hkrati zagotoviti, da bodo

združljive vrste povezane z vsako točko še vedno v skladu z definicijo podatkovne

strukture T. Uravnoteževanje T ne bo znatno povečalo števila vozlišč in potrebuje le O(n

log n) korakov, zato se lahko osredotočimo na vstavljanje točke. Naj bo p13 točka, ki jo

bomo vstavili v množico točk, prikazano na sliki 17. Postopek vstavljanja je prikazan na

sliki 18, kjer vidimo stanje T po vstavljanju točke p13. Točka p13 unikatno določa pot od

korena T do lista, kjer bo vstavljena. Da točko p13 vstavimo v T, gremo od korena proti

listu, pri vsakem vozlišču sestavimo zgornjo lupino U(v), ki temu vozlišču pripada, in jo

nato razstavimo s parametrom J[v], da podamo del te lupine sinu vozlišča. Ko pridemo do

dna drevesa, vstavimo nov list in gremo po isti poti navzgor do korena. Pri vsakem

vozlišču v na tej poti že imamo celo zgornjo lupino. Na voljo nam je tudi zgornja lupina

22

dvojčka, zato ju združimo tako, da zgornjo lupino U[v] razdelimo na dela Q1 in Q2, enako

storimo tudi pri dvojčku U[SIBLING[v]], ki ga razdelimo na Q3 in Q4. Q2 shranimo pri v, Q3

pa pri bratu od v. Q1 in Q4 podamo očetu, kjer bosta združena, da bomo dobili zgornjo

lupino očeta od v [2, 6].

Delitev in združevanje niza točk ima časovno zahtevnost O(log k), kjer je k velikost

združljive vrste, preden jo delimo oz. združimo. Ker je k ≤ N, nas vsak obisk vozlišča

stane O(log n). Globina T je prav tako O(log n), zato je časovna zahtevnost potovanja po

drevesu navzdol O(log2 n). Ker ima BRIDGE časovno zahtevnost O(log n), je tudi časovna

zahtevnost potovanja navzgor O(log2 n) [2].

Brisanje točke je zelo podobno vstavljanju. Na enak način kot pri vstavljanju gremo od

korena do lista, kjer je točka shranjena in ta list odstranimo. Nato pa gremo tudi na enak

način kot pri vstavljanju nazaj do korena in pri vsakem vozlišču posodobimo stanje [6].

23

Slika 17: Množica točk v ravnini in pripadajoča podatkovna struktura T [2]

Slika 18: Vstavljanje točke v T [2]

24

5 ALGORITMI ZA TVORBO VGNEZDENIH IZBOČENIH LUPIN

Najpreprostejši način tvorbe vgnezdenih izbočenih lupin je z uporabo poljubnega

algoritma za tvorbo izbočenih lupin. Z izbranim algoritmom najprej poiščemo izbočeno

lupino dane množice točk in točke, ki so na izbočeni lupini iz vhodne množice, odstranimo.

Nato nadaljujemo iskanje izbočene lupine preostalih točk in postopek ponavljamo, dokler

nam ne zmanjka točk. To je naivna metoda, ki ima visoko časovno zahtevnost in v

najslabšem primeru potrebuje O(n2 log n) operacij, če uporabimo Grahamovo

preiskovanje ali hitro izbočeno lupino. Ta postopek odstranjevanja izbočenih lupin

imenujemo lupljenje [2].

5.1 Ponavljanje Jarvisovega obhoda

S ponavljanjem Jarvisovega obhoda je možno doseči časovno zahtevnost O(n2). Dano

imamo množico točk S. Zaradi enotnosti najprej v S, dodamo točko p0 = (x0, y0), kjer sta x0

in y0 enaka najmanjši abscisi oz. ordinati v S. Nato pri tej točki začnemo Jarvisov obhod.

Na sliki 19 je začetek Jarvisovega obhoda označen s START. Obhod potem gre proti

smeri urinega kazalca in vsako obiskano točko, razen START, odstrani iz S. Ko pridemo

nazaj do točke START, pomeni, da do zdaj obiskane točke tvorijo izbočeno lupino. Točko

START odstranimo in predhodnik točke START prevzame vlogo točke p0. Postopek nato

ponavljamo, dokler S ni prazna [2].

Slika 19: Ponavljanje Jarvisovega obhoda [2]

25

5.2 Hitra izbočena lupina

Kot je že povedano v poglavju 3.4, je več raziskovalcev neodvisno odkrilo zelo podobne

algoritme, ki jih poznamo pod skupnim imenom hitra izbočena lupina. Enega izmed teh

algoritmov je leta 1977 odkril Eddy [9], leta 1979 pa sta Green in Silverman [8] razvila

algoritem, ki je nadgradnja Eddyjevega algoritma in ga bomo imenovali GS. GS je zelo

podoben ostalim algoritmom hitre izbočene lupine in ima časovno zahtevnost v

najslabšem primeru O(n2). Z GS pa lahko tvorimo tudi vgnezdene izbočene lupine v času

O(n2), kar ni boljše od ponavljanja Jarvisovega obhoda, a se je v praksi izkazal bolje [2,

6].

Najprej bomo definirali nekaj geometrijskih pojmov, prikazanih na sliki 20. Za točko k

rečemo, da je na zunanji strani roba ij, če je trikotnik ijk orientiran negativno (v smeri

urinega kazalca, točka k1). Če je pa ijk orientiran pozitivno (proti smeri urinega kazalca,

točka k2), pa je k na notranji strani ij. Točke ijk so kolinearne, če je k na premici, ki gre

skozi ij (točka k3) oz. k je med i in j, če se točke pojavijo v zaporedju ikj (točka k4).

Slika 20: Točka k lahko leži zunaj, znotraj, na ali med ij [8]

Testni seznam [ij] je par točk ij skupaj z množico točk med ali na zunanji strani ij, najbolj

oddaljena točka od ij pa je v testnem seznamu še posebej označena. Testni seznam je

rob na izbočeni lupini, če ni nobenih točk med ali na zunanji strani ij. Torej, če je testni

seznam sestavljen samo iz para ij, potem je ta par potrjen kot skrajni rob.

Edini aritmetični operaciji, ki ju ta algoritem zahteva, sta računanje in primerjava

predznačene ploščine trikotnikov, določenih s koordinatami njihovih točk. Te lahko vodijo

do problemov natančnosti numeričnih rezultatov, posebej v primeru izrojenosti. Tipičen

primer je prikazan na sliki 21. Zato v implementaciji algoritma točke, pri katerih nismo

26

povsem prepričani, ali so kolinearne, vseeno dodamo v testni seznam, ki ga obravnavamo

nekoliko drugače.

Slika 21: Nekonsistentnost, ki nastane pri izrojenosti [8]

Za implementacijo algoritma potrebujemo dve polji realnih števil, imenovani LIST in NWK

ter sklad M velikosti (3, m). Vrednost m je težko predvideti, je pa v večini primerov manjša

od n.

Med izvedbo algoritma GS moramo hraniti informacije o že obdelanih zunanjih lupinah in

o testnih seznamih trenutne lupine. V obeh primerih informacije shranimo z oznako fiksne

dolžine, trojicami celih števil v skladu M in s seznamom s spremenljivo dolžino, ki je

naslovljen z oznako. V primeru že obdelane lupine je ta seznam shranjen v LIST in

vsebuje indekse točk, ki sestavljajo to lupino, urejene proti smeri urinega kazalca. Oznaka

je v tem primeru oblike [naslov v LIST, dolžina v LIST in zastavica izrojenosti]. Te

vrednosti zasedajo zaporedne elemente na začetku LIST, preostanek polja pa zasedajo

točke v notranjosti te lupine.

Oznake zasedajo zaporedne vrstice na začetku sklada M, preostali prostor v skladu pa je

uporabljen za označevanje testnih seznamov trenutne lupine. Za testni seznam [ij] je

oznaka v obliki [i, j, naslov], kjer je naslov kazalec na podatek v polju NWK. Če je testni

seznam potrjen kot skrajni rob, je ta naslov nastavljen na nič. Podatek v NWK je

spremenljive dolžine in se začne pri elementu, na katerega kaže naslov oznake. Ta

element vsebuje dolžino in preostanek točk, ki so na zunanji strani roba ij, začne pa se pri

najbolj oddaljeni točki. Če je testni seznam izrojen, potem ima dolžino vsaj dve in je

označen z negativnim predznakom.

Algoritem GS je sestavljen iz šestih korakov, ki nam dajo eno lupino. V 1. koraku

preverimo, ali je preostalih točk manj ali enako 3. V tem primeru je rešitev trivialna in

27

skočimo na 6. korak. V 2. koraku poiščemo točki z minimalno in maksimalno koordinato x.

Če sta ti skrajni koordinati enaki, potem so vse točke kolinearne in skočimo na 6. korak. V

3. koraku skrajni točki označimo z i in j ter ustvarimo testna seznama [ij] in [ji]. Nato

izračunamo dolžini (število točk izven roba) in poiščemo najbolj oddaljeno točko ter

vstavimo oznake v sklad. Sedaj je celoten NWK zaseden za prvo lupljenje, v NWK sta

shranjeni dve dolžini in n – 2 indeksov točk. V 4. koraku so vsi preostali nepotrjeni testni

seznami [ij]:

- dolžine ena: v tem primeru je trivialno tvoriti nova testna seznama [ik] in [kj] in oba

sta potrjena kot skrajna roba;

- izrojeni z dolžino, večjo od ena: točke uredimo po primerni koordinati in tvorimo

nove testne sezname [ik1], [k1k2], …, [kmj] ter vse potrdimo kot skrajne robove;

- neizrojeni z dolžino, večjo od ena: najbolj oddaljeno točko označimo s k; tvorimo

nova testna seznama [ik] in [kj] tako, da delimo NWK v:

o točke izven ik (te prepišejo začetek elementa v NWK),

o točke izven kj (te prepišejo konec) in

o točke, ki niso izven ik ali kj (te se zapišejo nazaj na konec NWK).

Nato zaključimo testni seznam z dolžino in najbolj oddaljeno točko ter zapisom

nove oznake v sklad. V najslabšem primeru (kadar so vse točke izven ik ali kj) bo

celoten stari seznam prepisan v NWK. Zapisati moramo eno točko manj (točko k),

a eno dolžino več.

V 5. koraku so vsi preostali testni seznami potrjeni kot skrajni robovi, zato gremo skozi

sklad in tvorimo seznam, urejen proti smeri urinega kazalca v LIST, ki vsebuje indekse

točk na lupini. V 6. koraku dodamo nov vnos v M, za sklic na primerni element v LIST in

nastavimo zastavico izrojenosti, če je prišlo do izrojenosti v kateremkoli primeru [8].

5.3 Chazellov algoritem

Chazellov algoritem [1] temelji na algoritmu Overmarsa in Van Leeuwna, ki omogoča

vstavljanje in brisanje točk v času O(log2 n). Chazellov algoritem se osredotoči na brisanje

in z združevanjem brisanj doseže optimalno časovno zahtevnost za brisanje ene točke, to

je v času O(log n). S tem algoritmom lahko v O(n log n) času poiščemo izbočeno lupino

množice točk in nato z brisanjem posameznih točk na izbočeni lupini, v skupnem času

O(n log n), poiščemo vgnezdene izbočene lupine.

28

Vgnezdene izbočene lupine množice točk S označimo s C(S). Vsaka izbočena lupina v

C(S) je sestavljena iz zgornje in spodnje verige. Naj bo a točka z najmanjšo koordinato x

in b točka z največjo koordinato x. Zgornja veriga gre od a proti b v protiurni smeri,

spodnja lupina pa obratno. Ker algoritem deluje na enak način pri iskanju zgornje in

spodnje verige, se bomo osredotočili le na iskanje zgornje verige [1].

Predpostavimo brez izgube splošnosti, da se točke p0, …, pn-1 pojavijo v tem zaporedju po

nepadajočih koordinatah x. Dvojiško drevo T ima v listih točke p0, …, pn-1 od leve proti

desni (slika 22). S S(v) označimo množico točk, ki je shranjena v listih poddrevesa, ki ima

koren pri vozlišču v, z U(v) pa označimo zgornjo verigo izbočene lupine S(v), ki jo

imenujemo tudi zgornja veriga S(v). Unija vseh povezav v U(v) za vsa vozlišča v drevesa

T tvori ravninski graf G, ki je povezan in acikličen, torej tvori drevo. G se imenuje lupinski

graf množice S. Podobno kot G, za spodnje verige definiramo G'. Na sliki 22 je prikazan

lupinski graf in pripadajoče dvojiško drevo T. Vsaka povezava v lupinskem grafu je

tangenta dveh izbočenih verig in ima pripadajoče vozlišče v T [1].

Slika 22: Primer lupinskega grafa [1]

29

Lupinski graf G implementiramo s seznamom sosednosti, kjer ima vsaka točka p z njo

povezan seznam V(p) z imeni sosednjih točk. Vsak seznam V(p) je sestavljen iz dveh

podseznamov V1(p) in V2(p). V1(p) je dvojno-povezan seznam, ki vsebuje sosednje točke

od p, ki imajo manjšo koordinato x od p. V1(p) vsebuje tudi kazalec na zgornji rob, to je

rob z najmanjšim naklonom. V2(p) je definiran na enak način, le da so v njem shranjene

točke z večjo koordinato x in zgornji rob je tisti z maksimalnim naklonom. Primer je

prikazan na sliki 23.

Slika 23: Točka p in njeni sosedi [1]

G izračunamo s postopkom deli in vladaj. Če smo že poiskali lupinska grafa za množici

točk {p0, …, p⌊n/2⌋} in { p⌊n/2⌋+1, …, pn-1}, moramo poiskati le tangento zgornjih verig teh

dveh množic, ki ju imenujemo U in V. Tangenta med U in V je unikaten rob, ki povezuje

zgornji verigi tako, da dobimo zgornjo verigo U ∪ V. Postopek za iskanje tangent je opisan

v [10], v tem algoritmu pa tangente iščemo na zelo podoben način. Imamo dve množici

točk U in V, ki sta urejeni po koordinati x in predstavljata dve zgornji verigi. Vse točke v U

imajo manjšo koordinato x od vseh točk v V. Naklon roba med točkama u in v izračunamo

z (5.1).

𝑠𝑙(𝑢, 𝑣) = (𝑣𝑦 − 𝑢𝑦) / (𝑣𝑥 − 𝑢𝑥) (5.1)

Nato definiramo tri naklone v (5.2), (5.3) in (5.4).

𝛼𝑖,𝑖+1 = 𝑠𝑙(𝑢𝑖, 𝑢𝑖+1) (5.2)

𝛽𝑗,𝑗+1 = 𝑠𝑙(𝑣𝑗, 𝑣𝑗+1) (5.3)

𝛾𝑖,𝑖+1 = 𝑠𝑙(𝑢𝑖, 𝑣𝑗) (5.4)

30

Iskanje tangente množic U = {u1, …, um} in V = {v1, …, vp} začnemo pri skrajnih levih

točkah u1 in v1. Nato se po V pomikamo desno, dokler ne najdemo vj, kjer bosta vj-1 in vj+1

obe pod daljico 𝑢𝑖𝑣𝑗. Sedaj se pomaknemo za eno v desno v U ter nadaljujemo pomikanje

v desno po V, dokler spet ne najdemo vj, kjer bosta vj-1 in vj+1 obe pod daljico 𝑢𝑖𝑣𝑗.

Postopek ponavljamo, dokler ne najdemo ui in vj tako, da bodo ui-1, ui+1, vj-1 in vj+1 vse pod

daljico 𝑢𝑖𝑣𝑗. Da ugotovimo, po kateri verigi se moramo pomakniti desno, moramo

izračunati le kote iz enačb (5.2), (5.3) in (5.4). Če je βj, j+1 ≥ γij, se pomaknemo naprej po V,

če je αi, i+1 ≥ γij, se pomaknemo desno po U, v nasprotnem primeru pa smo končali.

Časovna zahtevnost tega postopka je O(m + p), kjer sta m in p število točk na U oz. V [1].

Ko smo izračunali G, so nam znane točke na zgornji verigi. Zato si shranimo imena teh

točk in jih nato vsako posebej izbrišemo iz G, po vsakem brisanju pa lupinski graf G

posodobimo. Vrstni red brisanja točk ni pomemben. Podobno storimo tudi za G', kjer

brišemo točke na spodnji verigi. Za ta brisanja rečemo, da so direktna. Naslednji korak pa

je križno brisanje, kjer iz G izbrišemo točke na spodnji verigi in iz G' točke na zgornji

verigi. Križno brisanje točk je v bistvu le preprost primer direktnega brisanja. Pri teh

operacijah lahko brisanje ene točke povzroči velike spremembe v lupinskem grafu in

posodobitev lahko potrebuje n operacij. Ta algoritem pa nam zagotovi, da so te

spremembe v povprečju manjše in v najslabšem primeru dobimo časovno zahtevnost O(n

log n) [1].

Algoritem izvajamo, dokler nista G in G' prazna. Najprej poiščemo zgornjo in spodnjo

verigo. Na izhod damo unijo teh dveh verig, preden pa poiščemo novi verigi, moramo

posodobiti lupinska grafa G in G'. Najprej direktno izbrišemo vsako točko v zgornji lupini iz

G, nato direktno izbrišemo vsako točko v spodnji lupini iz G', nato še križno izbrišemo

vsako točko v spodnji lupini iz G in križno izbrišemo vsako točko v zgornji lupini iz G' [1].

5.3.1 Direktno brisanje točk

Direktno brisanje točk je brisanje točk na zgornji verigi iz G in brisanje točk na spodnji

verigi iz G'. Primer direktnega brisanja je prikazan na sliki 24, kjer želimo izbrisati točko

p29. Vse sosednje točke od p29 povlečemo navzdol proti y = -∞. Vrstni red tangent je

pomemben in v tem primeru je to p29p28, p29p31, p29p24, p29p16, p29p10.

31

Slika 24: Direktno brisanje [1]

Globina vozlišča v T je določena s številom njegovih prednikov. Zaporedje tangent tvori

podzaporedje poti od lista do korena drevesa T, torej je vrstni red določen s padajočo

globino vozlišč. Pri tangenti p29p16 moramo še upoštevati točko p22, ki ni sosednja točki

p29.

Recimo, da smo v poljubnem delu postopka brisanja točke p iz zgornje lupine. Naj bodo

v1, …, vl vozlišča, ki jih obiščemo na poti od p do korena. Vsako vozlišče vl pripada

32

tangenti ti, ki povezuje dve zgornji lupini. Točka p leži na natanko eni izmed teh dveh

zgornjih lupin. Prejšnja brisanja so lahko povzročila, da je ena izmed teh dveh zgornjih

lupin tudi prazna. V tem primeru zaradi konsistentnosti predpostavimo, da prazna zgornja

lupina vsebuje navpično tangento, ti. Naj bo w1, …, wk podzaporedje zaporedja {v1, …, vl},

ki vsebuje tista vozlišča, pri katerih je p na pripadajoči tangenti. To podzaporedje še nato

delimo na dve podzaporedji, in sicer glede na to, na kateri strani tangente je p. Če je p na

levi strani, rečemo, da je tangenta »oblike pq«, v nasprotnem primeru pa »oblike qp«. Na

sliki 25 sta t4 in t1 oblike qp, t2 in t5 pa oblike pq. Podzaporedje točk oblike pq se ujema z

V1(p), podzaporedje točk oblike qp pa z V2(p). V primeru iz slike 24 je V1(p29) = {p10, p16,

p24, p28} in V2(p29) = {p31}. Čeprav se bosta G in G' ves čas spreminjala, bo T vedno enak

in ga nam ni niti potrebno eksplicitno implementirati [1].

Slika 25: Tangente so lahko oblike pq ali qp [1]

Prvi korak direktnega brisanja je pridobitev tangent ti1, …, tik, ki pripadajo vozliščem w1, …,

wk. To storimo tako, da združimo V1(p) in V2(p) v V(p). Vrstni red je določen tako, da damo

q1 pred q2, kadar je vozlišče v T, ki pripada tangenti pq1 potomec vozlišča, ki pripada

tangenti pq2. V1(p) in V2(p) lahko združimo v O(l) operacijah tako, da gremo po poti od v1

do vl. V praksi ne potrebujemo drevesa T, ker lahko za točko p = pi določimo pot do

korena z zaporedjem bitov od leve proti desni, ki jih dobimo z dvojiško predstavitvijo

33

števila i, kjer 0 predstavlja pot levo navzdol po drevesu, 1 pa desno. Zato lahko

združevanje V1(p) in V2(p) zapišemo tudi drugače. Točka q1 je pred q2, kadar ima njen

indeks večjo skupno predpono z i kot indeks točke q2. Zaradi konsistentnosti še

definiramo tangento t0, ki je navpična in gre od p proti y = -∞. Tangento t0 obravnavamo

kot oblike pq ali qp odvisno od situacije, da zagotovimo, da imamo za obe obliki vsaj eno

tangento [1].

Za poljubno vozlišče v drevesa T definiramo G(v) kot podgraf od G, ki ga dobimo iz listov

poddrevesa od T, ki ima koren pri v. Brisanje točke p iz G vsebuje posodabljanje

zaporedja grafov G(w1), …, G(wk) v tem vrstnem redu. Recimo, da želimo posodobiti

G(wi). Brez izgube splošnosti lahko predpostavimo, da je pripadajoča tangenta t = pc

oblike pq. Naj bosta ap in bp zadnji tangenti oblike qp oz. pq, ki smo ju obdelali. Za zdaj

predpostavimo, da sta a in b natančno opredeljeni točki. G(wi-1) smo že izračunali, zato

nam je njegova zgornja lupina na voljo. Del zgornje lupine od G(wi-1), ki se nahaja med a

in b, leži pod (pa, pb), kar lahko vidimo na sliki 26.

Slika 26: Direktno brisanje [1]

Naj bodo a', b' in c' točke na izbočenih lupinah, ki jih trenutno obdelujemo, in ki sledijo a v

smeri urinega kazalca, b in c pa proti smeri urinega kazalca. Primere, kjer je a' = b', a = b'

ali a' = b, rešimo na enak način, zato nam teh primerov ni potrebno obdelati ločeno. Sedaj

definirajmo še kote α = ∠(aa', ap), β = ∠(bp, bb'), γ = ∠(cp, cc'), δ = ∠(pc, ap), ε = ∠(pb,

pc). Posodobitev G(wi) si lahko predstavljamo kot vlečenje točke p navzdol, dokler ne

izgine iz zgornje lupine točk v G(wi). To naredimo tako, da poiščemo prvi kot med α, β, γ,

34

δ in ε, ki bo enak nič. Računanju kotov se lahko izgonemo, če poiščemo presečišča med

navpično premico, ki gre skozi p in premicami skozi aa', bb' in cc'. Najvišje presečišče

nam pove, katero točko izmed a', b' in c' bomo zavili. To pomeni, da se bomo pri tisti točki

pomaknili za eno naprej. V primeru na sliki 27 je najvišje presečišče v točki c*, zato

zavijemo točko c'. Torej bo v naslednjem koraku točka c' prevzela vlogo točke c, točka c''

pa vlogo točke c'. Če bi najvišje presečišče bilo v točki a* ali b*, bi zavili a' oz. b'. Ta

postopek ponavljamo, dokler ni eden izmed kotov δ ali ε enak nič. Ta dva primera pa sta

prikazana na sliki 28 [1].

Slika 27: Iskanje naslednje točke za zavijanje [1]

35

Slika 28: Končna primera δ = 0 in ε = 0 [1]

5.3.2 Križno brisanje točk

Križno brisanje točk je brisanje točk iz G, ki so na spodnji in brisanje točk iz G', ki so na

zgornji lupini. Naj bo p točka, ki jo želimo križno izbrisati iz G. Oba zgornja robova v V(p)

(pa v V1(p) in pb v V2(p)) vedno tvorita izbočen kot, ali drugače rečeno ∠(pa, pb) < π. Ker

pa je p na izbočeni lupini množice točk S, sledi, da je eden izmed seznamov V1(p) in V2(p)

prazen, oz. vsebuje le navpično premico, ki smo jo dodali zaradi konsistentnosti

(prikazano na sliki 29). To dejstvo velja za vse točke na spodnji lupini tudi, če smo že

katere druge križno izbrisali. To pomeni, da je križno brisanje poenostavljeno direktno

brisanje [1].

Recimo, da je V(p) = V1(p) = {pa1, …, pau}, kjer je pa1 zgornji rob. Pomembno je, da lahko

v konstantnem času dostopamo do lokacije, kjer je p shranjena v seznamih V2(a1), …,

V2(au). To je pogoj, če želimo zagotoviti, da je čas križnega brisanja proporcionalen številu

zavijanj. A pri križnem brisanju ni rečeno, da je rob pa1 zgornji rob v V2(a1), ker p ni na

zgornji lupini. Zato moramo ta seznam preiskati linearno. Ker velikost seznama nikoli ne

preseže log2 n, nam to doda časovno zahtevnost O(log n) pri času križnega brisanja [1].

36

Slika 29: Križno brisanje [1]

37

6 REZULTATI

V tej nalogi smo implementirali tri algoritme za tvorbo vgnezdenih izbočenih lupin. To so

Grahamovo preiskovanje, Jarvisov obhod za iskanje vgnezdenih izbočenih lupin (kot je

opisan v poglavju 5.1) in Chazellov algoritem. Algoritme smo implementirali v

programskem jeziku C++. Testiranje smo izvedli na računalniku s procesorjem Intel i5-

4690, 16 GB pomnilnika in operacijskim sistemom Windows 10.

Algoritme smo testirali pri uniformni porazdelitvi različnega števila točk v kvadratu in

krogu. Najprej smo testirali izvajalni čas za iskanje ene izbočene lupine, nato pa še za

iskanje vgnezdenih izbočenih lupin. Na koncu smo še testirali, kako se pri iskanju

vgnezdenih izbočenih lupin spreminja izvajalni čas, če imamo konstantno število točk in

različno število izbočenih lupin.

Tabela 2: Izvajalni čas za iskanje ene izbočene lupine pri uniformni porazdelitvi znotraj kvadrata [s]

N GRAHAM JARVIS CHAZELLE

64.000 0,013 0,032 0,129

128.000 0,026 0,070 0,269

256.000 0,059 0,124 0,579

512.000 0,124 0,197 1,208

1.024.000 0,248 0,523 2,404

2.048.000 0,524 1,126 4,963

4.094.000 1,094 2,070 10,168

38

Tabela 3: Izvajalni čas za iskanje ene izbočene lupine pri uniformni porazdelitvi znotraj kroga [s]

N GRAHAM JARVIS CHAZELLE

64.000 0,018 0,130 0,134

128.000 0,026 0,333 0,273

256.000 0,060 0,882 0,596

512.000 0,122 2,174 1,316

1.024.000 0,262 5,542 2,862

2.048.000 0,567 14,991 6,516

4.094.000 1,162 38,079 17,075

Tabela 4: Izvajalni čas za iskanje vgnezdenih izbočenih lupin pri uniformni porazdelitvi znotraj

kvadrata [s]

N GRAHAM JARVIS CHAZELLE

2.000 0,005 0,028 0,008

4.000 0,018 0,111 0,018

8.000 0,056 0,441 0,046

16.000 0,212 1,748 0,118

32.000 0,845 6,941 0,337

64.000 4,209 27,733 1,07

128.000 32,433 111,058 3,671

39

Tabela 5: Izvajalni čas za iskanje vgnezdenih izbočenih lupin pri uniformni porazdelitvi znotraj

kroga [s]

N GRAHAM JARVIS CHAZELLE

2.000 0,005 0,029 0,01

4.000 0,015 0,112 0,018

8.000 0,05 0,446 0,05

16.000 0,176 1,767 0,125

32.000 0,685 7,036 0,348

64.000 3,647 28,203 1,101

128.000 28,694 112,532 3,666

Tabela 6: Izvajalni čas za iskanje vgnezdenih izbočenih lupin 25000 točk pri različnem številu

izbočenih lupin [s]

M GRAHAM JARVIS CHAZELLE

1 0,0025 3,846 0,3115

5 0,0686 3,8188 0,2191

10 0,1304 3,8642 0,2212

15 0,1941 3,86 0,2237

20 0,262 3,9086 0,2267

25 0,3282 3,9149 0,2305

30 0,3965 3,8928 0,2303

35 0,4634 3,8846 0,2309

40 0,531 3,8856 0,2313

45 0,5996 3,893 0,2309

50 0,6795 3,984 0,2344

40

Slika 30: Primerjava izvajalnega časa iskanja ene izbočene lupine pri uniformni porazdelitvi znotraj

kvadrata

Slika 31: Primerjava izvajalnega časa iskanja ene izbočene lupine pri uniformni porazdelitvi znotraj

kroga

Na slikah 30 in 31 primerjamo izvajalne čase za iskanje ene izbočene lupine. Pri obeh

porazdelitvah se je Grahamovo preiskovanje izkazalo najbolje. Chazellov algoritem pa je

bil hitrejši od Jarvisovega obhoda pri uniformni porazdelitvi znotraj kroga in počasnejši pri

0,0

0,5

1,0

1,5

2,0

2,5

3,0

64000 128000 256000 512000 1024000 2048000 4096000

Čas

[s]

Število točk

Izvajalni čas

Graham Jarvis Chazelle

0,0

0,5

1,0

1,5

2,0

2,5

3,0

64000 128000 256000 512000 1024000 2048000 4096000

Čas

[s]

Število točk

Izvajalni čas

Graham Jarvis Chazelle

41

uniformni porazdelitvi znotraj kvadrata, kar je posledica tega, da imamo pri uniformni

porazdelitvi znotraj kvadrata manj točk na izbočeni lupini kot pri uniformni porazdelitvi

znotraj kroga.

Slika 32: Primerjava izvajalnega časa iskanja vgnezdenih izbočenih lupin pri uniformni porazdelitvi

znotraj kvadrata

Slika 33: Primerjava izvajalnega časa iskanja vgnezdenih izbočenih lupin pri uniformni porazdelitvi

znotraj kroga

0

1

2

3

4

5

6

2000,000 4000,000 8000,000 16000,000 32000,000 64000,000 128000,000

Čas

[s]

Število točk

Izvajalni čas

Graham Jarvis Chazelle

0

1

2

3

4

5

6

2000 4000 8000 16000 32000 64000 128000

Čas

[s]

Število točk

Izvajalni čas

Graham Jarvis Chazelle

42

Na slikah 32 in 33 primerjamo izvajalne čase pri iskanju vgnezdenih izbočenih lupin.

Chazellov algoritem je najhitrejši in ima pri več točkah bistveno boljši čas. Pri iskanju

vgnezdenih izbočenih lupin pri nobenem algoritmu ni bistvene razlike pri različnih

porazdelitvah točk.

Slika 34: Primerjava izvajalnega časa pri konstantnem številu točk in različnem številu izbočenih

lupin

Primerjali smo tudi izvajalni čas iskanja vgnezdenih izbočenih lupin pri 25.000 točk in

številu izbočenih lupin 1, 50, 100, 150, 200, 250, 300, 350, 400, 450 in 500, rezultat je

prikazan na sliki 34. Točke smo generirali na krožnicah, tako da smo dobili želeno število

izbočenih lupin. Število izbočenih lupin nima velikega vpliva na izvajalni čas Jarvisovega

algoritma. Chazellov algoritem je nekoliko počasnejši pri samo eni izbočeni lupini, pri več

lupinah pa ni bistvene razlike. Pri Grahamovem preiskovanju pa je pri več izbočenih

lupinah izvajalni čas daljši, ker moramo algoritem večkrat izvesti, da poiščemo vse lupine.

0

1

2

3

4

5

6

1 5 10 15 20 25 30 35 40 45 50

Čas

[s]

Število izbočenih lupin

Izvajalni čas

Graham Jarvis Chazelle

43

7 SKLEP

V tem magistrskem delu smo preučili nekatere algoritme za iskanje vgnezdenih izbočenih

lupin. Tri izmed njih smo implementirali in primerjali njihov izvajalni čas. Chazellov

algoritem ima optimalno časovno zahtevnost za iskanje vgnezdenih izbočenih lupin in se

je tudi pri naši implementaciji izkazal najbolje.

Če pa iščemo samo eno izbočeno lupino, je Chazellov algoritem počasnejši od drugih.

Pomembno pa je tudi dejstvo, da je Chazellov algoritem bistveno težje implementirati od

algoritmov za iskanje ene izbočene lupine, zato je odločitev o izbiri algoritma odvisna od

zahtev aplikacije.

44

8 SEZNAM VIROV

[1] Chazelle B., On the convex layers of a planar set, IEEE Transactions on Information

Theory, IT-31(4), (1985), str. 509–517

[2] Preparata F., Shamos M. Computational geometry (an introduction). Berlin: Springer-

Verlag, 1985

[3] O'Rourke J. Computational geometry in C (second edition). Cambridge University

Press, 1998

[4] Chan T. Optimal Output-Sensitive Convex Hull Algorithms in Two and Three

Dimensions. Discrete & Computational Geometry, 16, (1996), 4, str. 361–368

[5] Kirkpatrick D., Seidel R. The Ultimate Planar Convex Hull Algorithm?. SIAM Journal on

Computing, 15, (1986), 1, str. 287–299

[6] Overmars M., Van Leeuwen J. Maintenance of Configurations in the Plane. Journal of

computer and system sciences, 23, (1981), 2, str. 166–204

[7] Preparata F. An Optimal Real-Time Algorithm for Planar Convex Hulls.

Communications of the ACM, 22, (1979), 7, str. 402–405

[8] Green P, Silverman B. Constructing the convex hull of a set of points in the plane. The

Computer Journal, 22, (1979), 3, str. 262–266

[9] Eddy W. A. new convex hull algorithm for planar sets, ACM Transactions on

Mathematical Software, 3, (1977), 4, str. 398–403 in 411–412

[10] Preparata F., Hong S. Convex Hulls of Finite Sets of Points in Two and Three

Dimensions. Communications of the ACM, 20, (1977), 2, str. 87–93

[11] Graham R. L., An efficient algorithm for determining the convex hull of a finite planar

set. Information Processing Letters, 1, (1972), str. 132–133

[12] Jarvis R. A., On the identification of the convex hull of a finite set of points in the

plane. Information Processing Letters, 2, (1973), str. 18–21

[13] Knuth D. E., The Art of Computer Programming, Volume III: Sorting and Searching,

Reading, Massachusetts: Addison-Wesley, 1973

45

[14] Meeran S., Shafie A. Optimum path planning using convex hull and local search

heuristic algorithms, Mechatronics, 7, (1997), 8, str. 737–756

[15] Liew S. Introducing convex layers to the traveling salesman problem, The Computing

Research Repository, (2012)

[16] Šinjur S., Zazula D., Žalik B., Fast Convex Layers Algorithm for Near-Duplicate Image

Detection, Informatica, 23(4), (2012), str. 645–663