Opracowanie modułu wyznaczania i wizualizacji obwiedni ruchu bryły sztywnejprzemyslawczatrowski.com/wp-content/uploads/2011/02/... · 2011. 2. 18. · Bryła sztywna jest wczytywana

POLITECHNIKA WARSZAWSKA

WYDZIAŁ MATEMATYKI

I NAUK INFORMACYJNYCH

PRACA DYPLOMOWA MAGISTERSKA

Opracowanie modułu wyznaczania

i wizualizacji obwiedni ruchu

bryły sztywnej

Autor: Przemysław Czatrowski

Promotor: prof. dr hab. inż. Krzysztof Marciniak

WARSZAWA, GRUDZIEŃ, 2010

Opracowanie modułu wyznaczania i wizualizacji obwiedni ruchu bryły sztywnej

Przemysław Czatrowski

1

………………………… ………………………

podpis promotora podpis autora



2

Streszczenie

Celem pracy było opracowanie biblioteki pozwalającej na wyznaczanie

i wizualizację obwiedni ruchu bryły sztywnej.

Biblioteka pozwala na wczytanie bryły sztywnej z siatki, a następnie

jej aproksymację skończonym zbiorem sfer. Trajektoria, po której porusza się

bryła zostaje zdefiniowana krzywą Beziera składającą się ze skończonej ilości

segmentów Beziera 3-go stopnia. Początkowa oraz końcowa orientacja bryły

jest opisana kwaternionami.

W pracy wykorzystano algorytmy do aproksymacji brył zbiorem sfer

oraz przybliżoną metodę tworzenia obwiedni dającą w wyniku obliczeń

skończony ciąg kapsuł przybliżających obwiednię. Zaprezentowano również

teorię dotyczącą obliczania obwiedni dla parametrycznego opisu sfer.



3

Spis treści

1. Wstęp ....................................................................................................................................................................... 4

1.1. Cel pracy ................................................................................................................................................................. 4

1.2. Problematyka .......................................................................................................................................................... 4

2. Opis problemu .......................................................................................................................................................... 5

2.1. Algorytm de Casteljau ............................................................................................................................................. 5

2.2. Krzywa Beziera ........................................................................................................................................................ 6

2.3. Kwaterniony ............................................................................................................................................................ 6

2.3.1. Właściwości kwaternionów ........................................................................................................................... 6

2.3.2. Obrót wektora o kwaternion ......................................................................................................................... 7

2.3.3. Interpolacja kwaternionów ........................................................................................................................... 8

2.4. Obwiednia ruchu – implicite ................................................................................................................................... 8

2.4.1. Definicja......................................................................................................................................................... 9

2.5. Struktura „winged-edge” ...................................................................................................................................... 10

3. Przegląd metod aproksymacji bryły sferami ............................................................................................................ 14

3.1. Metoda O’Rourke’a i Badlera ................................................................................................................................ 14

3.2. Metody oparte na osi medialnej ........................................................................................................................... 14

4. Zastosowane rozwiązanie ....................................................................................................................................... 15

4.1. Aproksymacja wielościanu sferami. ...................................................................................................................... 15

4.2. Generowanie obwiedni ......................................................................................................................................... 16

4.2.1. Metoda implicite ......................................................................................................................................... 16

4.2.2. Przykład działania klasy ............................................................................................................................... 18

4.3. Metoda przybliżona .............................................................................................................................................. 20

5. Omówienie wyników .............................................................................................................................................. 20

5.1. Aplikacja testowa .................................................................................................................................................. 20

5.2. Przebieg testów .................................................................................................................................................... 21

5.2.1. Mniejsze siatki („Cup” oraz „Bunny”) .......................................................................................................... 22

5.2.2. Większe siatki („Frez kulisty” oraz „Frez toroidalny”) ................................................................................. 24

5.2.3. Tworzenie obwiedni ruchu dla sfery ........................................................................................................... 26

5.3. Zrzuty ekranu z aplikacji oraz wynikowych obwiedni ........................................................................................... 28

6. Wnioski z testów .................................................................................................................................................... 31

6.1. Aproksymacja bryły sferami .................................................................................................................................. 31

6.1.1. Złożoność pamięciowa: ............................................................................................................................... 31

6.1.2. Złożoność obliczeniowa: .............................................................................................................................. 32

6.2. Generowanie obwiedni ......................................................................................................................................... 32

6.2.1. Złożoność obliczeniowa ............................................................................................................................... 32

6.2.2. Złożoność pamięciowa ................................................................................................................................ 33

6.3. Propozycje udoskonaleń ....................................................................................................................................... 33

7. Bibliografia ............................................................................................................................................................. 35



4

1. Wstęp

1.1. Cel pracy

Celem pracy było opracowanie biblioteki pozwalającej na wyznaczanie

i wizualizację obwiedni ruchu bryły sztywnej. Bryła sztywna jest wczytywana jako

siatka (w formacie OBJ), a następnie aproksymowana skończonym zbiorem sfer.

Trajektoria jest definiowana jako krzywa, po której porusza się punkt referencyjny

oraz początkowa i końcowa orientacja opisana kwaternionami.

1.2. Problematyka

Problem poruszającej się bryły sztywnej jest często spotykany w technice

od strony teoretycznej, jak i praktycznej. Wśród zastosowań można wymienić

chociażby wszelkiego rodzaju symulacje fizyczne, jak i zagadnienia przemysłowe,

np. frezowanie. W każdym z tych zastosowań interesującym zagadnieniem jest

kształt obwiedni zataczanej podczas ruchu badanego obiektu.

Wyznaczenie dokładnego lub przybliżonego z dużą dokładnością kształtu

obwiedni ruchu obiektu może posłużyć do wyznaczenia kolizji z pozostałymi

obiektami sceny (podczas symulacji fizycznej). W procesie frezowania można

wyznaczyć i ewentualnie w czasie rzeczywistym skorygować trajektorię ruchu całego

freza.

W pracy przedstawiono algorytm pozwalający przeprowadzić jednokrotną

aproksymację bryły, po czym zapisać rezultaty do ponownego użycia. Aplikacja

przykładowa zawiera implementację przybliżonego tworzenia triangulacji obwiedni.

Teoria zawarta w pracy pozwala też opracować algorytm wyznaczania obwiedni

dla parametrycznego opisu bryły, co pozwoliłoby na dokładne wyznaczenie kształtu

i poprawę jakości uzyskiwanych wyników.

Opracowanie m

2. Opis problemu

2.1. Algorytm de Casteljau

Niech dane będzie n+1 punktów kontrolnych p

łamaną, której kolejnymi wierzchołkami są punkty p

algorytmu jest podział wszytkich odcinków łamanej w odpowiedniej proporcji,

opisanej parametrem t. Każdy z odcinków powinien zostać podzielony w stosunku

t : 1 – t. Po wykonaniu pierwszego kroku wynikiem jest zbiór n nowych punkt

kontrolnych oraz łamana je łącząca, składająca się z n

Należy wykonywać podział w ustalonej proporcji do czasu, gdy pozostanie jeden

punkt. Pseudokod algorytmu przedstawiony jest poniżej:

{ pi(0) = pi dla i = 0, .. , n

for j := 1 to n do

for i := 0 to n – j do

pi(j) := (1 – t) * p

{ p(t) = p }

Rys. 2.1 Przykład zastosowania algorytmu deCasteljau. Liczby w nawiasach oznaczają łamane otrzymywane

w kolejnych krokach algorytmu. Wynikiem działania



5

Algorytm de Casteljau

ech dane będzie n+1 punktów kontrolnych p0, … , pn. Należy rozważyć

łamaną, której kolejnymi wierzchołkami są punkty pi. Każdym kolejnym krokiem



t. Po wykonaniu pierwszego kroku wynikiem jest zbiór n nowych punkt

kontrolnych oraz łamana je łącząca, składająca się z n – 1 odcinków.


punkt. Pseudokod algorytmu przedstawiony jest poniżej:

dla i = 0, .. , n }

j do

t) * pi(j - 1) + t * pi + 1

(j - 1);


w kolejnych krokach algorytmu. Wynikiem działania jest punkt �� otrzymany dla parametru t = 0.57.

wyznaczania i wizualizacji obwiedni ruchu bryły sztywnej


Należy rozważyć

. Każdym kolejnym krokiem



t. Po wykonaniu pierwszego kroku wynikiem jest zbiór n nowych punktów

1 odcinków.



otrzymany dla parametru t = 0.57.



6

2.2. Krzywa Beziera

Krzywą Beziera jest krzywa p, której każdy punkt p(t) można uzyskać przez

zastosowanie przedstawionego powyżej algorytmu de Casteljau.

Rys. 2.2. Przykładowa krzywa Beziera stopnia 3-go wraz z łamaną kontrolną (wyznaczoną przez punkty

kontrolne P0, .. , P3).

2.3. Kwaterniony

Kwaterniony są strukturą algebraiczną będącą rozszerzeniem ciała liczb

zespolonych. Algebra kwaternionów jest oznaczana przez H. Przedstawia się je

jako liczby postaci q = a + bi + cj + dk, gdzie a to część skalarna, natomiast część

urojona jest trójwymiarowym wektorem v = bi + cj + dk, a, b, c, d ∈ R. W grafice

trójwymiarowej kwaterniony dobrze nadają się do reprezentowania obrotów.

Obliczenia na nich są szybsze niż w reprezentacji macierzowej (operacje na 4 liczbach

rzeczywistych, zamiast 9), nie występuje też problem utraty jednego stopnia

swobody podczas obrotu (tzw. „gimbal lock”).

2.3.1. Właściwości kwaternionów

Mnożenie elementów bazowych

�� = � = �� = � ∗ ∗ � = −1 (1.1)

Używając bazy 1, i, j, k można użyć zapisu w postaci czwórek:

� = ��, �, �, ��|�, �, �, � ∈ �� (1.2)



7

Wtedy bazę można zapisać jako:

1 = �1,0,0,0�� = �0,1,0,0� = �0,0,1,0�� = �0,0,0,1� (1.3)

Podstawowe operacje na kwaternionach (w przykładach będą przyjęte

następujące oznaczenia: �� = ��, ��, ��, �� oraz �� = ��, ��, ��, ��

Dodawanie kwaternionów

�� + �� = �� + ��, �� + ��, �� + ��, �� + �� (1.4)

Mnożenie kwaternionów

�� ∗ �� = �w� ∗ w� − x� ∗ x� − y� ∗ y� − z� ∗ z�, x� ∗ w� + x� ∗ w� + y� ∗ z� − z� ∗ y�, y� ∗ w� + y� ∗ w� + z� ∗ x� − x� ∗ z�, z� ∗ w� + z� ∗ w� + x� ∗ y� − y� ∗ x��

(1.5)

Sprzężenie

��&&& = ��, −��, −��, −�� (1.6)

Iloczyn skalarny

�� ∙ �� = w� ∗ w� + x� ∗ x� + y� ∗ y� + z� ∗ z� (1.7)

2.3.2. Obrót wektora o kwaternion

Kwaterniony w intuicyjny sposób nadają się do reprezentacji obrotów

w przestrzeni trójwymiarowej. Obrót o kąt θ wokół osi reprezentowanej

przez znormalizowany wektor ())* = ��, ��, �� jest wyrażony

przez kwaternion

� = +cos /2 , �� ∗ sin /2 , �� ∗ sin /2 , �� ∗ sin /23 (1.8)



8

Aby wykonać transformację (obrót) wektora 4��5, �5 , �5� o kąt θ wokół

osi ())* należy wykonać następujące mnożenie (korzystając z właściwości

podanych w 2.3.1)

�5 = �0, �5, �5 , �5� �56 = � ∗ �5 ∗ �&

(1.9)

Wynikiem (przekształconym wektorem) jest część wektorowa

kwaternionu �56 .

2.3.3. Interpolacja kwaternionów

Bardzo ważną zaletą kwaternionów jest ich łatwa interpolacja.

Krzywa interpolacyjna sferycznej interpolacji tworzy łuk na kole wielkim

jednostkowej sferze kwaternionowej. Interpolacja sferyczna zachowuje stałą

prędkość kątową i jest uważana za optymalną krzywą interpolacji pomiędzy

dwoma obrotami określonymi kwaternionem. Dla dwóch danych

kwaternionów q1, q2 oraz parametru t z przedziału [0; 1] interpolacja

sferyczna pomiędzy q1 a q2 jest definiowana następująco:

789:��, ��, ;� = sin<�1 − ;�Ω>sin Ω ∗ �� + sin<;Ω>sin Ω ∗ �� (1.10)

gdzie Ω spełnia warunek �� ∙ �� = cos Ω

2.4. Obwiednia ruchu – implicite

Powierzchnie zwane obwiedniami są definiowane przez poruszające się

płaszczyzny. Płaszczyzny mogą być zdefiniowane parametrycznie lub w postaci

implicite.



9

Następujące odwzorowanie:

�� × � ⊃ A ∋ �C, 4, ;� ⇾ ��C, 4, ;� ∈ �E (1.11)

jest opisem parametrycznym poruszającej się w przestrzeni powierzchni

parametrycznej rozumianym przez serię położeń parametryzowanym czasem t.

Dla ustalonych wartości u oraz v odwzorowanie p(u, v, t) jest położeniem w chwili

t punktu o współrzędnych (u, v). Idąc dalej, następująca pochodna

F�F; �C, 4, ;� (1.12)

oznacza prędkość punktu p(u, v, t) w chwili t.

2.4.1. Definicja

Obwiednia E składa się ze wszystkich punktów p(u, v, t) spełniających

następujący warunek:

F�F; �C, 4, ;� ∈ GH�I,5,J� (1.13)

Oznacza to, że prędkość punktu p(u, v, t) leżącego na powierzchni jest

w przestrzeni liniowej Tp(u, v, t) styczna w punkcie p(u, v, t) do powierzchni

p(u, v, t = const.). Przestrzeń styczna Tp(u, v, t) jest rozpięta na wektorach

KHKI �C, 4, ;� oraz KHKI �C, 4, ;�, warunek (1.13) można zatem zapisać inaczej.

Można wyrazić wektor KHKJ �C, 4, ;� jako kombinację liniową wektorów

KHKI �C, 4, ;� oraz KHK5 �C, 4, ;� z odpowiednimi współczynnikami ��,� ∈ �.

Zabieg ten daje w efekcie trzy równiania:

F�F; = �� F�FC + �� F�F4 ∈ GH�I,5,J� (1.14)



10

z pięcioma niewiadomymi: p, k1, k2. Pojedyncze równianie uzyskujemy

przez wyeliminowanie współczynników k1 oraz k2:

�9; LF�F; F�FC F�F4M = 0 (1.15)

Rozpatrujemy punkty w przestrzeni trójwymiarowej, posiadające trzy

współrzędne: (px, py, pz), równianie (1.15) zapisujemy więc następująco:

�9;NOOOOPF�QF; F�QFC F�QF4F�RF; F�RFC F�RF4F�SF; F�SFC F�SF4 TU

UUUV = 0 (1.16)

2.5. Struktura „winged-edge”

Struktura danych zaproponowana przez Bruce’a Baumgarta służy

do przechowywania informacji o bryłach. Każda bryła złożona jest z trzech zbiorów:

wierzchołków, krawędzi oraz ścian. Struktury punktów, krawędzi oraz ścian

są zaprojektowane w taki sposób, aby łatwo można było sprawdzić otoczenie

przetwarzanego obiektu. W dalszej części przyjęto założenie, że siatka wczytywana

do postaci struktury „winged-edge” nie ma dziur (każda krawędź ma parę),

każda ściana jest trójkątem, w którym krawędzie skierowane są przeciwnie do ruchu

wskazówek zegara.

Opracowanie m

Rys. 2.3 Struktura „winged

W strukturze krawędzi przechowywane są następujące informacje:

• Wierzchołek początkowy i końcowy

• Wskazanie na następną krawędź

• Wskazanie na krawędź skierowaną przeciwnie

• Wskazanie na ścianę, do której należy krawędź

W strukturze wierzchołka przechowywane są jego pozycja oraz wskazanie na jedną

z krawędzi (dowolną) wychodzącą z

Struktura ściany zawiera wskazanie na jedną z krawędzi (dowolną) otaczającą ścianę.

Takie zależności dają możliwość łatwego podziału krawędzi z zachowaniem

aktualności wszystkich wskazań, przykładowy pseudoko

przedstawiony poniżej.



11

Rys. 2.3 Struktura „winged-edge”, rozpatrywana jest krawędź pogrubiona.

krawędzi przechowywane są następujące informacje:

Wierzchołek początkowy i końcowy (v:Start oraz v:End)

następną krawędź (e:Next)

Wskazanie na krawędź skierowaną przeciwnie (e:Pair)

Wskazanie na ścianę, do której należy krawędź (f:Face)


z krawędzi (dowolną) wychodzącą z wierzchołka.



aktualności wszystkich wskazań, przykładowy pseudokod podziału krawędzi został



edge”, rozpatrywana jest krawędź pogrubiona.




d podziału krawędzi został

Opracowanie m

Rys. 2.4. Ilustracja podziału krawędzi w strukturze „winged

Pseudokod algorytmu:

1) Stwórz wierzchołek vCenter w połowie długości między vStart a vEnd i dodaj

go do zbioru wierzchołków bryły

2) Stwórz cztery ściany: fTopLeft, fTopRight,

dodaj je do zbioru ścian bryły

3) Stwórz osiem krawędzi: eT, eL, eB, eR, eTPair, eLPair, eBPair, eRPair a następnie

dodaj je do zbioru krawędzi bryły

4) Usuń ze zbioru krawędzi bryły krawędzie Edge oraz EdgePair

5) Usuń ze zbioru ścian bryły ściany fFaceLeft oraz fFaceRight

6) Uaktualnij powiązania:

a. eT.Face = eNext.Face = eLPair.Face := fTopLeft;

b. eL.Face = eNextNext.Face = eBPair.Face := fBottomLeft;

c. eB.Face = ePairNext.Face = eRPair.Face := fBottomRight;

d. eR.Face = ePairNextNext.F

e. eT.Next := eNext

f. eL.Next := eNextNext; e

g. eB.Next := ePairNext; ePairNext.Next := eRPair; eRPair.Next := eB;



12

Rys. 2.4. Ilustracja podziału krawędzi w strukturze „winged-edge”

Stwórz wierzchołek vCenter w połowie długości między vStart a vEnd i dodaj

go do zbioru wierzchołków bryły

Stwórz cztery ściany: fTopLeft, fTopRight, fBottomLeft , fBottomRight a następnie

dodaj je do zbioru ścian bryły

Stwórz osiem krawędzi: eT, eL, eB, eR, eTPair, eLPair, eBPair, eRPair a następnie

dodaj je do zbioru krawędzi bryły

Usuń ze zbioru krawędzi bryły krawędzie Edge oraz EdgePair

oru ścian bryły ściany fFaceLeft oraz fFaceRight

Uaktualnij powiązania:

eT.Face = eNext.Face = eLPair.Face := fTopLeft;

eL.Face = eNextNext.Face = eBPair.Face := fBottomLeft;

eB.Face = ePairNext.Face = eRPair.Face := fBottomRight;

eR.Face = ePairNextNext.Face = eTPair.Face := fTopRight;

eT.Next := eNext; eNext.Next := eLPair; eLPair.Next := eT;

eL.Next := eNextNext; eNextNext.Next := eBPair; eBPair.Next := e

eB.Next := ePairNext; ePairNext.Next := eRPair; eRPair.Next := eB;



Stwórz wierzchołek vCenter w połowie długości między vStart a vEnd i dodaj

fBottomLeft , fBottomRight a następnie

Stwórz osiem krawędzi: eT, eL, eB, eR, eTPair, eLPair, eBPair, eRPair a następnie

Pair.Next := eL;

eB.Next := ePairNext; ePairNext.Next := eRPair; eRPair.Next := eB;



13

h. eR.Next := ePairNextNext; ePairNextNext.Next := eTPair; eTPair.Next :=

eR;

i. eT.Pair := eTPair; eTPair.Pair := eT;

j. eL.Pair := eLPair; eLPair.Pair := eL;

k. eB.Pair := eBPair; eBPair.Pair := eB;

l. eR.Pair := eRPair; eRPair.Pair := eR;

m. vCenter.Edge := eT; vStart.Edge := eBPair;

n. fTopLeft.Edge := eT; fBottomLeft.Edge := eL; fBottomRight.Edge := eB;

fTopRight.Edge := eR;

Zaletami algorytmu są prostota i intuicyjność.



14

3. Przegląd metod aproksymacji bryły sferami

3.1. Metoda O’Rourke’a i Badlera

W 1979 roku Badler i O’Rourke zaprezentowali jedną z pierwszych metod

aproksymacji brył sferami. Parametrem wejściowym metody jest błąd aproksymacji.

Polegała ona na wylosowaniu skończonego zbioru równomiernie rozłożonych

na powierzchni bryły punktów, oznaczmy ten zbiór przez P. Do każdego z tych

punktów zostanie przypisana jedna sfera. Na początku lista sfer jest pusta,

a wszyskie punkty nieprzypisane. Następnie, dla każdego nieprzypisanego punktu

(oznaczmy do przez ps) wyznaczany jest wektor normalny bryły w tym punkcie

oraz przeciwnie skierowana półprosta. Na tej półprostej (począwszy od wartości

maksymalnej promienia) szukany jest punkt będący środkiem sfery o takim

promieniu. Warunkiem utworzenia sfery jest jej styczność do punktu ps oraz to,

że nie sfera nie zawiera w środku żadnego punktu ze zbioru P. Po utworzeniu sfery,

jej promień zostaje powiększony o podany przez użytkownika błąd aproksymacji,

a do aktualnie generowanej sfery zostają przypisane wszystkie punkty, które po tej

operacji znalazły się w jej wnętrzu.

Metoda ma dobre zastosowanie dla gładkich powierzchni, dla brył o większej

ilości szczegółów warunek o nie zawieraniu punktów ze zbioru P może prowadzić

do nadmiernego zmniejszania promieni generowanych sfer, a w rezultacie

do zwiększenia ich liczby w wynikowym zbiorze.

3.2. Metody oparte na osi medialnej

Oś medialna bryły to zbiór takich punktów wewnętrznych, że największa kula

o środku w danym punkcie i zawarta w bryle jest do niej styczna w przynajmniej

trzech różnych punktach. Konstrukcję osi medialnej, która jest zbyt kosztowna

obliczeniowo, zastępuje się diagramem Voronoi dla zbioru wierzchołków

P równomiernie rozłożonych na powierzchni bryły. Diagram Voronoi

to dekompozycja przestrzeni R3 na komórki. Każda komórka jest związana z jednym

z punktów z P (oznaczmy go przez p) tak, że dowolny punkt komórki leży bliżej



15

punktu p niż dowolnego innego punktu ze zbioru P. Tworzenie diagramu Voronoi

jest mniej kosztowne obliczeniowo, a zbiór wierzchołków leżący wewnątrz bryły

dobrze aproksymuje jej oś medialną. Aproksymację bryły kulami można otrzymać

ze zbioru kul o środkach w wierzchołkach diagramu Voronoi i promieniach równych

odległości do najbliższego punktu ze zbioru P. Metody Hubbarda oraz Bradshawa

korzystają również z liczniejszego niż P zbioru punktów do określenia błędu

aproksymacji. Parametrem wejściowym jest dla nich liczność wynikowego zbioru kul,

dążąc do tej wartości minimalizują one błąd aproksymacji. Pierwszy etap obu metod

jest podobny – następuje stworzenie początkowego zbioru kul na podstawie

diagramu Voronoi. W metodzie Hubbarda redukuje się liczbę kul za pomocą

zachłannego wyboru pary, a następnie zastąpienie jej pojedynczą kulą. Kryterium

wyboru jest minimalizacja błędu aproksymacji nowej kuli. Bradshaw zaczyna

od małego zbioru P, z którego konstruuje diagram Voronoi. Następnie dodaje nowe

punkty do zbioru P w miejscach, gdzie błąd aproksymacji jest największy

(rozbudowywany jest diagram Voronoi). Zbiór kul redukowany jest dwojako;

kula jest usuwana, a kule w jej otoczeniu odpowiednio powiększane albo wszystkie

kule są powiększane do osiągnięcia jednakowego błędu aproksymacji dla każdej

z nich, a następnie usuwany jest podzbiór kul nie mający wpływu na pokrycie zbioru

P.

Wadami tych metod jest długi czas obliczeń oraz fakt, że błąd aproksymacji

zależy od obliczeń przeprowadzanych przez metodę (parametrem metod Hubbarda

i Bradshawa jest liczność wynikowego zbioru kul).

4. Zastosowane rozwiązanie

4.1. Aproksymacja wielościanu sferami.

W pracy został użyty algorytm zaproponowany przez p. Michała Nowakiewicza

w pracy [1]. Parametrem wejściowym metody jest błąd aproksymacji δ.

Na powierzchni bryły wybierany jest skończony zbiór punktów P. Dla każdego punktu

p ∈ P, który nie został jeszcze przypisany do żadnej z kul tworzona jest nowa kula,



16

dla której błąd aproksymacji nie przekracza δ. Środki kul umieszczane są na regularnej

siatce otaczającej bryłę, przy ustalaniu pozycji środka generowanej kuli brana jest pod

uwagę odległość ze znakiem od powierzchni bryły.

Wejście

Wejściem algorytmu jest bryła wielościenna w postaci grafu oraz dodatnia

liczba całkowita l, która definiuje też wyjściowy błąd aproksymacji wyrażony

równaniem W = �X . Przyjęto założenie, że krawędzie grafu mają długość nie większą

niż δ, kod źródłowy zawiera funkcje do zagęszczenia grafu do odpowiedniego

poziomu. Przed uruchomieniem właściwego algorytmu aproksymacji tworzona jest

dodatkowa regularna siatka z potencjalnymi środkami sfer aproksymujących bryłę.

Dla każdego jej punktu zostaje obliczona odległość od bryły (ze znakiem). Podążając

za opisem przedstawionym w [1], siatka ta będzie oznaczana przez S,

natomiast odległość dowolnego jej punktu x od bryły przez STD(x).

Wyjście

Algorytm tworzy zbiór sfer będący aproksymacją wejściowej bryły w taki

sposób, że błąd aproksymacji nie przekracza W = �X .

Pełen opis algorytmu oraz jego pseudokod dostępny jest w [1].

4.2. Generowanie obwiedni

4.2.1. Metoda implicite

Korzystając ze wzorów z rozdziału 2.4 można stworzyć opis implicite

sfery poruszającej się po krzywej Beziera. Należy zdefiniować funkcję p(u, v, t).

W tym rozdziale przyjęto inne oznaczenia. Ze względu

na podaną poniżej parametryzację sfery, zamiast parametrów (u, v) będą

stosowane parametry (α, β).



17

Sfera w przestrzeni parametryzowana jest w następujący sposób:

Y� = � ∗ �Z[\ ∗ [�]^ + �_� = � ∗ [�]\ ∗ [�]^ + �_� = � ∗ �Z[^ + �_` (1.17)

Parametrami są α ∈ <0; 2π> oraz β ∈ <0; π>, R jest stałą oznaczającą

promień. Współrzędne (xc, yc, zc) oznaczają środek sfery.

Każdy z segmentów Beziera opisywany jest w następujący sposób:

efffgfffh�_�;� = i �jkjl�;�l

jm��_�;� = i �jkjl�;�l

jm��_�;� = i �jkjl�;�l

jm�

` (1.18)

gdzie B jest odpowiednim wielomianem bazowym Bernsteina (stopień

krzywej, jak już zostało to napisane wynosi 3, więc n = 3)

kjl�;� = no]� p ;j�1 − ;�lq� �8� � = 0. . ]0 �8� � < 0, � > ] ̀ (1.19)

Podstawiając do (1.17) zmienione równanie na środek poruszającej się

sfery otrzymamy następujący wzór

efffgfffh�Q�\, ^, ;� = � ∗ �Z[\ ∗ [�]^ + i �jkjl�;�l

jm��R�\, ^, ;� = � ∗ [�]\ ∗ [�]^ + i �jkjl�;�l

jm��S�\, ^, ;� = � ∗ �Z[^ + i �jkjl�;�l

jm�

` (1.20)

Tak zdefiniowaną funkcję p(α, β, t) można zastosować w równaniu (1.16).

Do rozwiązania został użyty pakiet Mathematica. Aplikacja posiada klasę

wydzieloną do eksportu trajektorii do skryptu Mathematica, jest to klasa



18

SphereTrajectoryExporter, pozwalająca stworzyć skrypt dla pojedynczej sfery

poruszającej się po krzywej Beziera złożonej z dowolnej ilości segmentów

Beziera stopnia trzeciego.

4.2.2. Przykład działania klasy

Zdefiniowano sferę o środku w punkcie C = (1.0, 1.5, -2.0) i promieniu

r = 3.0 oraz trajektorię określoną przez dwa segmenty krzywej Beziera stopnia

trzeciego połączonych z ciągłością C1 zdefiniowane przez następujące punkty:

T1 = {(1, 1.5, -2), (1, 3, 0), (0, 2.5, 1), (-0.5, 1.5, 3)}

T2 = {(-0.5, 1.5, 3), (-1, 0.5, 5), (4, 0.5, 2), (5, -1.5, -3)}

Wynikiem działania metody

SphereTrajectoryExporter.ToMathematicaScript jest następujący kod gotowy

do wklejenia do pakietu Mathematica:

(* Sphere trajectory export *)

(* Variables section *)

R = 3

(* Degrees And Control Points Of 2 Bezier Segments *)

(* 0-th segment *)

Degree0 = 3

Points0 = {{1, 1.5, -2}, {1, 3, 0}, {0, 2.5, 1}, {-0.5, 1.5, 3}}

(* 1-th segment *)

Degree1 = 3

Points1 = {{-0.5, 1.5, 3}, {-1, 0.5, 5}, {4, 0.5, 2}, {5, -1.5, -3}}

(* end of Variables Section *)

(* Formulas Section *)

basis[degree_,i_,t_] = Binomial[degree, i] * t^i * (1 - t)^(degree - i);

(* Sphere *)

sphFx[alfa_, beta_] = R * Cos[alfa] * Cos[beta];

sphFy[alfa_, beta_] = R * Cos[alfa] * Sin[beta];

sphFz[alfa_, beta_] = R * Sin[alfa];

(* 0-th segment *)

bernFx0[t_] = Sum[Points0[i + 1][1] * basis[degree, i, t], {i, 0, degree, 1}];



19

bernFy0[t_] = Sum[Points0[i + 1][2] * basis[degree, i, t], {i, 0, degree, 1}];

bernFz0[t_] = Sum[Points0[i + 1][3] * basis[degree, i, t], {i, 0, degree, 1}];

fx0[alfa_, beta_, t_] = sphFx[alfa, beta] + bernFx0[t];

fy0[alfa_, beta_, t_] = sphFy[alfa, beta] + bernFy0[t];

fz0[alfa_, beta_, t_] = sphFz[alfa, beta] + bernFz0[t];

envMatrix0 = {{D[fx0[alfa,beta,t], alfa], D[fx0[alfa,beta,t], beta], D[fx0[alfa,beta,t], t]},

{D[fy0[alfa,beta,t], alfa], D[fy0[alfa,beta,t], beta], D[fy0[alfa,beta,t], t]},

{D[fz0[alfa,beta,t], alfa], D[fz0[alfa,beta,t], beta], D[fz0[alfa,beta,t], t]}

}

CForm[Det[envMatrix0]==0]

(* 1-th segment *)

bernFx1[t_] = Sum[Points1[i + 1][1] * basis[degree, i, t], {i, 0, degree, 1}];

bernFy1[t_] = Sum[Points1[i + 1][2] * basis[degree, i, t], {i, 0, degree, 1}];

bernFz1[t_] = Sum[Points1[i + 1][3] * basis[degree, i, t], {i, 0, degree, 1}];

fx1[alfa_, beta_, t_] = sphFx[alfa, beta] + bernFx1[t];

fy1[alfa_, beta_, t_] = sphFy[alfa, beta] + bernFy1[t];

fz1[alfa_, beta_, t_] = sphFz[alfa, beta] + bernFz1[t];

envMatrix1 = {{D[fx1[alfa,beta,t], alfa], D[fx1[alfa,beta,t], beta], D[fx1[alfa,beta,t], t]},

{D[fy1[alfa,beta,t], alfa], D[fy1[alfa,beta,t], beta], D[fy1[alfa,beta,t], t]},

{D[fz1[alfa,beta,t], alfa], D[fz1[alfa,beta,t], beta], D[fz1[alfa,beta,t], t]}

}

CForm[Det[envMatrix1]==0]

Exit[]

Plik wynikowy zawiera sekcje danych globalnych dla skryptu (promień

sfery), informacje o kolejnych segmentach Beziera, sekcje zbudowanych

równań (1.18) dla każdego segmentu oraz finalne macierze pochodnych

po kolejnych parametrach.

Rozwiązania równań powstałych z obliczenia wyznaczników

przykładowych macierzy były zbyt złożone, aby zastosować

je w prezentowanej pracy. Zastosowano podejście przybliżone.



20

4.3. Metoda przybliżona

Obwiednia ruchu wyznaczana jest metodą przybliżoną. Wejściem metody

są krzywa Beziera składająca się z segmentów Beziera oraz kula o zadanym (stałym)

promieniu, której środek porusza się po wspomnianej wcześniej krzywej. Wynikiem

jest lista kapsuł, które dobrze aproksymują obwiednię ruchu kuli.

Współrzędne dowolnego punktu krzywej można uzyskać używając parametru

t ∈ [0; 1]. Niech C(t) oznacza punkt krzywej dla parametru t. Ustalając podział krzywej

na N części (N > 0) generowane są punkty Pi = C(ti), gdzie i = 0, .. , N - 1 natomiast

;j = ju. Lista N kapsuł (każda z kapsuł oznaczona jest przez capsi) przybliżających

obwiednię ruchu kuli tworzona jest w następujący sposób: kapsuła capsi aproksymuje

fragment krzywej od punktu Pi do Pi+1. Dla każdej kapsuły tworzona jest

jej triangulacja o zadanej złożoności.

5. Omówienie wyników

5.1. Aplikacja testowa

Wszystkie algorytmy, czyli: algorytm aproksymacji bryły zbiorem kul, algorytm

tworzenia przybliżenia obwiedni ruchu kuli po krzywej sumą kapsuł oraz aplikacja

testowa zostały napisane w języku C# w wersji 4.0 przy użyciu biblioteki graficznej

XNA w wersji 4.0. Implementacja nie jest optymalna, dodatkowe narzuty czasowe

oraz pamięciowe są spowodowane użyciem języka programowania z automatycznym

zarządzaniem pamięcią. Optymalizacja kodu oraz wybranie innych (bardziej

niskopoziomowych) technologii znacznie przyspieszyłoby działanie algorytmu.

Zaletami wybranego języka są prosty i czytelny kod, łatwe zastosowanie

równoległości (przez wykorzystanie Parallel Extensions z C# w wersji 4.0), oraz duże

możliwości biblioteki graficznej XNA.

Ogólny czas tworzenia obwiedni ruchu składa się z dwóch części. Pierwszą

z nich jest czas aproksymacji wejściowej siatki reprezentującej bryłę sumą kul. Sumuje



21

się na to czas zagęszczania siatki do odpowiedniego poziomu oraz czas tworzenia

wynikowego zbioru kul. Drugą częścią jest tworzenie listy kapsuł dla każdej kuli

ze zbioru. Czas tej operacji zależy od dokładności podziału krzywej (ilości kapsuł

dla każdej z kul) oraz samej liczby kul powstałej w części pierwszej.

Algorytm aproksymacji siatki kulami został zaimplementowany na podstawie

pseudokodu zamieszczonego w [1]. W tym dokumencie są również przedstawione

uzyskane w trakcie testów czasy aproksymacji.

Wszystkie testy zostały przeprowadzone na komputerze o następującej

konfiguracji: procesor Intel Core i7 4 x 1.6 GHz, 4 GB pamięci RAM, karta graficzna

nVidia GeForce GTX 260M, system operacyjny Windows 7 Home Premium.

5.2. Przebieg testów

Ze względu na przedstawioną w poprzednim podrozdziale specyfikę podziału

zagadnienia na dwie części, testy były przeprowadzane oddzielnie dla każdej części.

Pierwsza część polegała na uruchomieniu algorytmu aproksymacji

dla przykładowych siatek o różnym stopniu zagęszczenia (przez stopień zagęszczenia

rozumiana jest długość najdłuższej krawędzi siatki – im jest mniejsza, tym większy jest

stopień zagęszczenia siatki). Metoda została uruchomiona 10-krotnie dla każdej

z siatek oraz każdej zakładanej dokładności (L = 30, 60, 90, 120, 150, 180). Następnie

uzyskane czasy uśredniono.

Druga część mierzyła czas tworzenia triangulacji aproksymującej obwiednię

ruchu dla pojedynczej sfery oraz ilość trójkątów w stworzonej aproksymacji.

Zmiennymi parametrami były dokładność podziału krzywej Beziera (ilość fragmentów

łamanej przybliżającej krzywą Beziera, po której porusza się środek sfery)

oraz dokładność triangulacji pojedynczej kapsuły. Dla każdej pary parametrów

oraz ustalonej krzywej złożonej z dwóch segmentów Beziera tworzenie triangulacji

było uruchamiane 100-krotnie, następnie czasy uśredniono.



22

5.2.1. Mniejsze siatki („Cup” oraz „Bunny”)

Jak widać, dla brył wejściowych o małej złożoności (małej liczbie trójkątów,

która dla powyższych danych przykładowych podana jest w nawiasach) średni czas

działania algorytmu aproksymacji nie przekraczał 0.15s. Dla tak prostych przypadków

czas nie zależy od zadanej dokładności, dokładność ma jedynie wpływ na długość

obliczeń wartości STD punktów siatki S. Ilość tych punktów jest nie większa niż L3,

lecz już dla L = 90, czas obliczania odległości około 720 000 punktów od bryły

nie może być uznawany za pomijalny.



23

W przypadku dwóch mniejszych testowanych brył ilości kul aproksymujących

je nie zmieniała się (lub zmieniała nieznacznie) wraz ze wzrostem zadanej dokładności

parametru L.



24

5.2.2. Większe siatki („Frez kulisty” oraz „Frez toroidalny”)

Kolejnymi testowanymi obiektami były dwie bryły będące modelami freza

kulistego oraz toroidalnego. Zostały stworzone w programie Blender 2.5 Beta,

a ich złożoności są dużo większe niż w przypadku poprzednich siatek (odpowiednio

24064 i 34560 trójkątów dla modeli freza kulistego i toroidalnego).

Czas działania algorytmu aproksymacji zmienił się znaczniew porównaniu

do mniejszych brył, widać również zależność między rosnącym czasem aproksymacji

w stosunku do zwiększającej się dokładności. Nadal jednak czas działania algorytmu

pozostaje akceptowalny (poniżej ¾ minuty dla każdego modelu i każdej dokładności).



25

Dla brył wejściowych składających się z dużej ilości trójkątów ilość sfer

będących wyjściem algorytmu rośnie w dużym tempie już od dokładności L = 90.



26

5.2.3. Tworzenie obwiedni ruchu dla sfery

Jak widać, czas potrzebny na stworzenie triangulacji jest liniowo

zależny od ilości kapsuł, co jest wynikiem oczekiwanym, ponieważ w założeniu

czas tworzenia triangulacji pojedynczej kapsuły dla ustalonej jej dokładności

jest stały.



27

Na pierwszy rzut oka, czas tworzenia obwiedni dla ustalonej liczby

kapsuł jest funkcją kwadratową dokładności triangulacji pojedynczej kapsuły.

Potwierdzają to obliczenia przedstawione w 6.2.2. Jednak nawet dla wysokich

dokładności czas tworzenia triangulacji jest akceptowalny.

Ilość wynikowych trójkątów (wartość interesująca, ponieważ

to trójkąty składające się na aproksymację obwiedni są elementami finalnymi

algorytmu) jest liniowo zależna od ilości kapsuł składających się na obwiednię

pojedynczej kuli. Potwierdza to jedynie wniosek zaobserwowany przy czasie

tworzenia triangulacji.



28

Zgodnie z obliczeniami zaprezentowanymi w 6.2.2, ilość trójkątów

w można ograniczyć z góry funkcją kwadratową, której argumentem

jest dokładność triangulacji. Testy pokazały, że dokładność triangulacji

na poziomie 20-24 jest wystarczająca.

5.3. Zrzuty ekranu z aplikacji oraz wynikowych obwiedni

Poniższe zrzuty ekranowe prezentują działanie aplikacji na różnych etapach

jej działania. Siatką użytą do ich wygenerowania jest siatka „Cup” dołączona

do aplikacji.



29

Rysunek 5.3.1. Załadowana bryła wejściowa w postaci siatki.

Rysunek 5.3.2. Zbiór sfer będących aproksymacją wejściowej bryły.



30

Rysunek 5.3.3. Pozycja początkowa (po lewej) i końcowa (po prawej) bryły opisana przez kwaterniony.

Rysunek 5.3.4. Obliczona i wyświetlona obwiednia w postaci listy kapsuł dla każdej sfery.



31

Rysunek 5.3.5. Obliczona i wyświetlona obwiednia w postaci listy kapsuł dla każdej sfery.

6. Wnioski z testów

6.1. Aproksymacja bryły sferami

6.1.1. Złożoność pamięciowa:

Przygotowanie siatek do algorytmu aproksymacji wiązało się z dużym

zapotrzebowaniem na pamięć. Wejściowe siatki liczyły ponad 17000 punktów.

Jedną z testowanych metod zapewnienia odpowiedniej dokładności siatki było

dzielenie zbyt długich krawędzi przez podział na pół i wstawienie

dodatkowego punktu.

W przypadku dokładności 1/180 powodowało to zwiększenie się liczby

punktów nawet do 1.800.000. Dodatkową strukturą danych tworzoną

na potrzeby algorytmu jest regularna siatka, w węzłach której mogą się

znajdować środki generowanych sfer. Najdłuższa krawędź tej siatki jest zawsze

podzielona na L części, gdzie L = 1 / δ. Dwie pozostałe krawędzie są krótsze

i mają długość proporcjonalną do długości odpowiednich krawędzi



32

prostopadłościanu otaczającego bryłę. Górnym ograniczeniem ilości

wierzchołków dodatkowej siatki jest jednak N = L3. Dla testowanych brył

rozmiary siatek dodatkowych nie przekraczały wartości

N = L * (2/3) * L * (2/3) * L = 4/9 * L3, jednak dalej jest to oszacowanie O(L3).

6.1.2. Złożoność obliczeniowa:

Ponownie najkosztowniejsze obliczeniowo okazało się przygotowanie

dodatkowej siatki. Dla każdego jej wierzchołka należało obliczyć,

czy wierzchołek znajduje się wewnątrz, czy na zewnątrz bryły,

po czym następowało obliczenie odległości od bryły. Złożoność obliczeniową

udało się nieco obniżyć przez umieszczenie ścian oraz wierzchołków bryły

w drzewie ósemkowym. Kolejnym etapem skrócenia obliczeń było

zrównoleglenie kodu odpowiedzialnego za powyższe zadania.

Czas potrzebny na stworzenie siatki dodatkowej zależy

też proporcjonalnie od ilości wierzchołków składającej się na bryłę,

które definiują ilość trójkątów umieszczonych w drzewie ósemkowym

i z którymi liczone są przecięcia promieni.

6.2. Generowanie obwiedni

Opisany zostanie przypadek dla pojedynczej kuli, czas obliczeń oraz ilość

wygenerowanych trójkątów dla zbioru N sfer zwiększy się N razy.

6.2.1. Złożoność obliczeniowa

Czas potrzebny na obliczenie ciągu siatek kapsuł przybliżających

trajektorię sfery po krzywej Beziera liniowo zależy od dokładności przybliżenia.

Jeżeli krzywą Beziera podzieli się na M części, zostanie stworzony ciąg

M kapsuł przybliżających ruch sfery na odpowiednich fragmentach krzywej

(od punktu v�; ∗ �w� do v��; + 1� ∗ �w�, t = 0..M – 1). Czas obliczania siatki dla



33

pojedynczej kapsuły zależy od dokładności przybliżania kapsuły, czasy

dla przykładowych dokładności zostały podane w 5.2.3.

6.2.2. Złożoność pamięciowa

Każda kapsuła składa się z trzech siatek – dwóch półsfer oraz cylindra.

Niech parametrem określającym dokładność będzie n (n = 4, 5, 6..). Obliczenia

ilości generowanych trójkątów pokazały, że:

• Ilość generowanych trójkątów dla siatki cylindra wynosi 2 * n,

• Ilość generowanych trójkątów dla każdej z siatek półsfer wynosi

n * (n/2 - 1) = n2/2 – n (uwaga, wynik z dzielenia n/2 jest faktycznie

częścią całkowitą tego dzielenia, więc dla n niepodzielnych przez 4 ilość

trójkątów będzie mniejsza niż n2/2 – n)

Sumując, ilość trójkątów siatki kapsuły określonej z dokładnością n

nie będzie przekraczała:

2 * n + 2 * (n2/2 - n) = 2 * n + n2 – 2 * n = n2

6.3. Propozycje udoskonaleń

Poza optymalizacją implementacji, można wymienić następujące propozycje

udoskonaleń aplikacji:

• Zastosowanie języka niższego poziomu (C, C++). Wpłynie to zdecydowanie

na złożoność pamięciową (ręczne zarządzanie pamięcią) a także

obliczeniową (brak narzutu związanego z kodem zarządzanym)

• Zastosowanie CUDA do części algorytmu aproksymacji. Autor w [1]

wspomina o zastosowaniu możliwości karty graficznej do obliczania

wartości STD dla siatki S. Przedstawiona implementacja (mimo obliczania

wartości dokładnej, a nie przybliżonej) nie stosuje CUDA, lecz jedynie

zrównoleglenie kodu dostarczone przez Parallel Extensions z C# 4.0.



34

• Tworzenie obwiedni metodą implicite. Większość kodu jest gotowa,

jednak stopień skomplikowania równań 1.16 oraz analiza wyników

dostarczonych przez pakiet Mathematica wykroczyłoby poza czas

przeznaczony na pracę.

• Opytmalizacja tworzenia siatek kapsuł. W tej chwili triangulacja każdej

z kapsuł jest tworzona w taki sam sposób. Można zredukować liczbę

wynikowych trójkątów przez eliminowanie części trójkątów z półsfer

dwóch kolejnych kapsuł i umiejętne łączenie ich w zależności

od wzajemnego położenia.

• Opracowanie optymalniejszego algorytmu do zagęszczania siatki.

Na tym etapie algorytm liniowo wyszukuje każdą zbyt długią krawędź

i dzieli ją na pół (nie sprawdzając, czy wynikowe połówki spełniają

warunek bycia krótszymi od 1 / δ). Można poprawić jakość działania

algorytmu przez zastosowanie kolejki krawędzi do podzielenia

i odpowiednią jej aktualizację w trakcie wykonywanych opaeracji.



35

7. Bibliografia

1. Nowakiewicz M.: Planowanie ruchu bryły sztywnej przez wąskie przejścia

w przestrzeni konfiguracji. Fragment pracy doktorskiej.

2. Bradshaw G., O’Sullivan C.: Sphere-tree construction using dynamic medial axis

approximation. ACM SIGGRAPH / Eurographics Symposium on Computer

Animation, 2002.

3. O’Rourke J., Badler N.: Decomposition of three-dimensional objects into spheres.

IEEE Transactions on Pattern Analysis and Machine Intelligence, 1(3):295-305,

1979.

4. Kiciak P.: Podstawy modelowania krzywych i powierzchni. Zastosowania w grafice

komputerowej. Wydanie drugie, zmienione i rozszerzone. Wydawnictwa

Naukowo-Techniczne, Warszawa, 2005.

5. Ericson C.: Real-time collision detection. Elsevier Inc., 2005.



36

Warszawa, dnia ...............

Oświadczenie

Oświadczam, że pracę magisterską pod tytułem: „Opracowanie modułu

wyznaczania i wizualizacji obwiedni ruchu bryły sztywnej”, której promotorem

jest prof. dr hab. inż. Krzysztof Marciniak wykonałem samodzielnie,

co poświadczam własnoręcznym podpisem.

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

Documents

Opracowanie modułu wyznaczania i wizualizacji obwiedni ruchu bryły sztywnejprzemyslawczatrowski.com/wp-content/uploads/2011/02/... · 2011. 2. 18. · Bryła sztywna jest wczytywana