PRACA DYPLOMOWA INŻYNIERSKA...PODSTAWY TEORETYCZNE W tym rozdziale omówione zostaną podstawy...

Rok akademicki 2011/2012

Politechnika Warszawska

Wydział Elektroniki i Technik Informacyjnych

Instytut Informatyki

PRACA DYPLOMOWA INŻYNIERSKA

Michał Pawłowski

Symulator radaru statku powietrznego

mgr inż. Zbigniew Szymański

Ocena: .....................................................

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

Podpis Przewodniczącego

Komisji Egzaminu Dyplomowego


2

Specjalność: Inżynieria Systemów Informatycznych

Data urodzenia: 1989.07.02

Data rozpoczęcia studiów: 2008.10.01

Życiorys

Urodziłem się 2 lipca 1989 roku w Warszawie. Po ukończeniu szkoły podstawowej oraz

gimnazjum kontynuowałem naukę w Liceum Ogólnokształcącym im. I Dywizji

Kościuszkowskiej w Piasecznie w klasie o profilu matematyczno - fizyczno - geograficznym.

W 2008 roku zdałem egzamin maturalny i rozpocząłem studia na Wydziale Elektroniki i

Technik Informacyjnych Politechniki Warszawskiej. W trakcie studiów wyjechałem na 4

miesiące do Korei Południowej w ramach wymiany studenckiej, w trakcie której odbyłem

praktyki w firmie Duck Yang Industry. W kwietniu 2012 roku rozpocząłem pracę jako

programista w firmie Business Management Software.

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

Podpis studenta

EGZAMIN DYPLOMOWY

Złożył egzamin dyplomowy w dniu .................................................................................. 20__ r

z wynikiem ..................................................................................................................................

Ogólny wynik studiów: ...............................................................................................................

Dodatkowe wnioski i uwagi Komisji: .........................................................................................

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

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

Praca inżynierska - Pawłowski Michał

3

STRESZCZENIE

W pracy przedstawiono zaprojektowany symulator radiowego detektora przeszkód

wchodzącego w skład systemu unikania kolizji AURA (autonomiczny układ antykolizyjny

przeznaczony dla bezzałogowych środków latających wykorzystujący aktywną metodę

teledetekcji obiektów), który może zostać użyty w bezzałogowych środkach latających.

Symulator może posłużyć do testowania skuteczności algorytmów antykolizyjnych oraz

metody tworzenia modelu otoczenia. Ponadto symulator pozwala na dostosowanie

parametrów pracy detektora, dzięki czemu możliwe jest przeprowadzenie testów, których

wykonanie byłoby bardzo trudne lub niemożliwe przy użyciu rzeczywistego statku

powietrznego. W pracy opisano również podstawowe urządzenia wchodzące w skład systemu

antykolizyjnego, układ współrzędnych w którym wykonane zostały używane mapy cyfrowe

oraz graficzny interfejs użytkownika przedstawiający animację lotu.

Słowa kluczowe: symulator, radar, bezzałogowy, statek powietrzny, samolot, AURA,

OpenGL, wykrywanie kolizji

PC simulator of radar and environment model for

unmanned flying vehicles

SUMMARY

This papers describes designed simulator of radar, which is part of AURA (Autonomous

collision avoidance system for unmanned flying vehicles based on active teledetection

method) collision avoidance system that can be used in unmanned aerial vehicles. The

simulator can be used to generate data required for testing of collision avoidance algorithms

and environment model creation methods. The program allows adjusting operating parameters

of the simulated device to provide possibility of preparing such test cases which would be

very difficult or even impossible to prepare when using real aircraft. Moreover, the paper

includes description of basic modules of the device, coordinate system in which digital maps

used in the program were created and graphical user interface.

Keywords: simulator, radar, unmanned, flying vehicle, aircraft, AURA, OpenGL, collision

detection


4

SPIS TREŚCI

ROZDZIAŁ 1 WSTĘP .......................................................................................... 6

1.1 Wprowadzenie ................................................................................................................. 6

1.2 Cel pracy ......................................................................................................................... 7

1.3 Podział pracy ................................................................................................................... 8

ROZDZIAŁ 2 PODSTAWY TEORETYCZNE ................................................... 9

2.1 Sposób działania radaru .................................................................................................. 9

2.1.1 Elementy radaru ................................................................................................... 9

2.1.2 Parametry działania ............................................................................................ 10

2.2 Wykonanie symulatora .................................................................................................. 11

2.2.1 Przyjęte założenia ............................................................................................... 11

2.2.2 Parametry działania symulatora ......................................................................... 12

2.2.3 Algorytm wykrywania kolizji ............................................................................ 12

2.2.4 Sposób wyświetlania obiektów .......................................................................... 14

2.2.5 Mapy cyfrowe .................................................................................................... 15

ROZDZIAŁ 3 OPIS SYMULATORA ............................................................... 17

3.1 Środowisko i wybrane narzędzia ................................................................................... 17

3.2 Informacje o GUI .......................................................................................................... 18

3.3 Pliki wejściowe ............................................................................................................. 20

3.3.1 Pliki konfiguracyjne ........................................................................................... 20

3.3.2 Mapy cyfrowe .................................................................................................... 22

3.3.3 Plik trajektorii ..................................................................................................... 24

3.4 Pliki wyjściowe ............................................................................................................. 25

3.4.1 Plik z wykrytymi obiektami ............................................................................... 25

3.4.2 Mapa percepcyjna .............................................................................................. 25

3.5 Struktura programu ....................................................................................................... 27

3.5.1 Diagram przypadków użycia .............................................................................. 27

3.5.2 Diagram klas ...................................................................................................... 28

3.5.3 Diagram czynności ............................................................................................. 29

3.6 Testowanie .................................................................................................................... 30

3.6.1 Wykrywanie omijanej przeszkody ..................................................................... 30

3.6.2 Przelatywanie nad przeszkodami ....................................................................... 30


5

3.6.3 Kolizja z przeszkodą .......................................................................................... 32

ROZDZIAŁ 4 INSTRUKCJA OBSŁUGI .......................................................... 33

4.1 Instalacja ........................................................................................................................ 33

4.2 Okno główne ................................................................................................................. 34

4.3 Obsługa symulatora ....................................................................................................... 34

ROZDZIAŁ 5 ZAKOŃCZENIE ......................................................................... 35

5.1 Podsumowanie .............................................................................................................. 35

5.2 Perspektywy kontynuacji .............................................................................................. 36

BIBLIOGRAFIA ................................................................................................. 37

DODATEK A OPIS KLAS ORAZ METOD ..................................................... 38


6

ROZDZIAŁ 1

WSTĘP

1.1 Wprowadzenie

Samoloty są obecnie jednym z najbardziej rozpowszechnionych środków transportu.

Na co dzień są one sterowane przez pilotów, jednak od jakiegoś czasu coraz częściej słyszy

się o samolotach bezzałogowych, które mogą być kontrolowane przez człowieka z ziemi lub

nawet zdolnych do podejmowania samodzielnych decyzji. Najczęściej są one

wykorzystywane do celów militarnych, takich jak obserwacja i rozpoznanie terenu, a także do

celów naukowych w sytuacjach, w których wykonanie pomiaru normalnymi metodami nie

jest proste (np. w przypadku wykonywania pomiarów grubości warstwy ozonowej na

Antarktydzie). Prowadzone są także prace nad stworzeniem bezzałogowych statków

bojowych.

Obecność bezzałogowych środków latających w ogólnodostępnej przestrzeni

powietrznej zacznie być w najbliższej przyszłość znaczącym problemem. Spowoduje ona

konieczność opracowania nowych metod zarządzania ruchem powietrznym, a także

podniesienie standardów bezpieczeństwa. Ich podstawą będzie zasada Sense and Avoid

będąca odpowiednikiem zasady See and Avoid stosowanej w przypadku jednostek latających

pilotowanych przez ludzi [8]. Przykładem systemu antykolizyjnego realizującego tę zasadę


7

jest system AURA (autonomiczny układ antykolizyjny przeznaczony dla bezzałogowych

środków latających wykorzystujący aktywną metodę teledetekcji obiektów) opracowywany

przez Instytut Lotnictwa oraz Politechniką Warszawską. Składa się on z trzech elementów:

radiowego detektora przeszkód, radiowysokościomierza oraz modułu odpowiedzialnego za

unikanie kolizji [1]. Każdy z nich wyposażony jest w procesor ARM Cortex A8

odpowiedzialny za przetwarzanie danych. Pozycja samolotu ustalana jest przy pomocy

urządzenia Attitude and Heading Reference System (AHRS). System ten jest także

odpowiedzialny za dostarczanie informacji o składowych prędkości liniowej, składowych

przyspieszenia liniowego, składowych prędkości kątowej oraz kątów nachylenia samolotu.

Umożliwia on również synchronizację radiowego detektora przeszkód z

radiowysokościomierzem.

Głównym celem modułu odpowiedzialnego za unikanie kolizji jest tworzenie modelu

otoczenia oraz wykonywanie manewrów antykolizyjnych. Model otoczenia jest generowany

na podstawie map cyfrowych oraz danych zbieranych w czasie wykrywania przeszkód przez

urządzenia znajdujące się na pokładzie samolotu. Zawiera informacje o rozmieszczeniu

obiektów w sąsiedztwie statku powietrznego i jest wykorzystywany przez algorytmy unikania

kolizji.

1.2 Cel pracy

Celem pracy jest zaprojektowanie środowiska testowo symulacyjnego będącego w

stanie wygenerować dane dostarczane przez radiowy detektor przeszkód,

radiowysokościomierz oraz AHRS. Będą one następnie służyły jako dane wejściowe dla

algorytmów wykrywania kolizji. Symulator musi umożliwiać zmianę wszystkich parametrów

pracy detektora przeszkód, aby umożliwić znalezienie optymalnej konfiguracji. Elementem

pracy jest również utworzenie graficznego interfejsu użytkownika, który umożliwi szybką

interpretację uzyskiwanych wyników oraz dostarczy podstawowe informacje na temat lotu i

położeniu statku powietrznego.


8

1.3 Podział pracy

Praca podzielona jest na pięć rozdziałów. W rozdziale drugim omówione zostaną

podstawy budowy symulowanego radaru, algorytmy użyte do wykonania symulatora, różne

metody wyświetlania obiektów przy użyciu biblioteki OpenGL oraz podstawowe informacje

o układzie współrzędnych PUWG 1992, w którym sporządzone zostały zastosowane mapy

cyfrowe.

W trzecim rozdziale przedstawiony zostanie sposób działania utworzonej aplikacji

wraz z dokładnym opisem graficznego interfejsu użytkownika, plików wejściowych

niezbędnych do działania programu oraz generowanych plików wyjściowych. Zawiera on

także diagramy UML modelujące budowę i działanie aplikacji.

Czwarty rozdział zawiera instrukcję użytkownika, w której przedstawiony zostanie

sposób instalacji symulatora, sposób jego obsługi oraz opis dostępnych operacji.

W dodatku A znajduje się opis podziału kodu programu na pliki i funkcje.


9

ROZDZIAŁ 2

PODSTAWY TEORETYCZNE

W tym rozdziale omówione zostaną podstawy budowy symulowanego radaru,

algorytmy użyte do wykonania symulatora, opis różnych metod wyświetlania obiektów przy

użyciu biblioteki OpenGL oraz podstawowe informacje o układzie współrzędnych PUWG

1992, w którym sporządzone zostały zastosowane mapy cyfrowe.

2.1 Sposób działania radaru

2.1.1 Elementy radaru

Podstawowymi elementami radiowego detektora przeszkód są: obrotowa głowica

detektora radarowego, układ napędowy z układem sterowania obrotowej głowicy oraz

zasilacz [1]. Detektor przeszkód realizuje funkcję detekcji obiektów znajdujących się na

drodze statku powietrznego przy pomocy mikrofalowych modułów nadawczo-odbiorczych.

Następnie, na podstawie analizy widma, określana jest ich prędkość oraz odległość od statku

powietrznego.

Na podstawie uzyskanych informacji tworzone są drzewa decyzyjne modelujące

otoczenie samolotu. Stanowią one układ wejściowy dla sieci ARTMAP, która jest


10

odpowiedzialna za podejmowanie decyzji. Jest to ucząca się, rekurencyjna sieć neuronowa.,

składająca się ona z:

klasyfikatora rozpoznanych sytuacji (blok wejściowy)

klasyfikatora manewrów antykolizyjnych (blok wyjściowy)

bloku kojarzenia rozpoznania przeszkody i manewru antykolizyjnego.

2.1.2 Parametry działania

Detekcja przeszkód jest realizowana w przedniej półsferze określonej kątem w

azymucie ±78º i kątem w elewacji od -12º do +36º, co odpowiada 13 strefom o szerokości 12º

w azymucie oraz dwu sektorom o kącie 24º w elewacji (tab. 2.1, rys. 2.1, rys 2.2) [1].

Przestrzeń określoną kątami od 78º do 90º oraz od -78º do -90º w azymucie zajmują dwie

dodatkowe strefy służące do ustalenia warunków pracy oraz do redukcji błędów

wynikających z budowy radaru.

Parametr Wartość

Rozdzielczość skanowania w azymucie 12º

Rozdzielczość skanowania w elewacji 24º

Szerokość skanowanej półsfery w azymucie ±78 º

Szerokość skanowanej półsfery w elewacji -12 º - 36º

Ilość wydzielonych stref w azymucie 13

Ilość wydzielonych stref w elewacji 2

Zasięg 200m

Czas skanowania jednej strefy 11ms

Tabela 2.1. Parametry działania radiowego detektora przeszkód [1].


11

Rysunek 2.1. Układ wydzielonych stref w płaszczyźnie poziomej, cytat [2].

Rysunek 2.2. Układ wydzielonych stref w płaszczyźnie pionowej, cytat [2].

2.2 Wykonanie symulatora

2.2.1 Przyjęte założenia

Głównym zadaniem projektowanego symulatora jest realizacja wykrywania przeszkód

na drodze statku powietrznego. Nie będzie się on zajmował dokładnym odzwierciedleniem

procesów zachodzących podczas skanowania, jak również obliczaniem obecnej pozycji oraz

trajektorii lotu samolotu. Wszystkie informacje niezbędne do działania programu tj. mapy

cyfrowe oraz opis trajektorii przekazywane są do programu przy pomocy plików

wejściowych.


12

2.2.2 Parametry działania symulatora

Parametry pracy symulatora nieznacznie różnią się od parametrów pracy

rzeczywistego urządzenia. Ze względów implementacyjnych skanowanie wszystkich stref

odbywa się jednocześnie, a czas jednego pełnego skanowania można zdefiniować w pliku

konfiguracyjnym radaru. Ponadto ilość stref w azymucie została ograniczona jedynie do stref,

w których zachodzi detekcja przeszkód.

W związku z możliwością zmiany parametrów pracy radiowego detektora przeszkód

symulator umożliwia zmianę ich wartości w pliku konfiguracyjnym (rozdz. 3.3.1).

2.2.3 Algorytm wykrywania kolizji

Wykrywanie obiektów odbywa się przy pomocy promieni wewnętrznych

generowanych w każdej strefie (ich liczba może zostać zdefiniowana w pliku

konfiguracyjnym). Każdy z nich ma swój początek w miejscu położenia głowicy radaru oraz

długość równą jego zasięgowi (rys. 2.3).

Rysunek 2.3. Pojedyncza strefa radaru z zaznaczonymi czterema promieniami wewnętrznymi.


13

Po utworzeniu promieni należy dla każdego obiektu znajdującego się w zasięgu radaru

sprawdzić, czy przynajmniej jedna z jego ścian nie przecina któregoś z nich. Jeśli tak, oznacza

to, że w strefie do której dany promień należał wykryto przeszkodę. Metoda ta umożliwia

również stwierdzenie, jak duża część sfery pokryta przez obiekty. W tym celu należy

sprawdzić, przy użyciu ilu promieni zostały one wykryte.

W celu zbadania, czy promień przecina jedną ze ścian obiektu, należy najpierw

znaleźć równanie płaszczyzny do której ta ściana należy oraz punkt jej przecięcia z

promieniem. Jeśli punkt znajduje się wewnątrz danej ściany, oznacza to, że promień ją

przecina i w odpowiadającej mu strefie został wykryty obiekt (rys. 2.4).

Rysunek 2.4. Sprawdzanie, czy promień przecina ścianę. W powyższym wypadku kolizja nie zostaje

wykryta, ponieważ punkt P znajduje się poza oznaczonym czworokątem.


14

2.2.4 Sposób wyświetlania obiektów

Biblioteka OpenGL udostępnia wiele funkcji pozwalających na wyświetlenie

obiektów [7]. Najprostszą z nich jest funkcja glVertex3f(), która przy każdym wywołaniu

określa położenie kolejnego wierzchołka (tab. 2.2). Nie jest to jednak zachowanie optymalne,

biorąc pod uwagę ilość wierzchołków wyświetlanych podczas tworzenia wizualizacji terenu.

Znacznie wydajniejszym mechanizmem jest tzw. Vertex Array.

glBegin(GL_TRIANGLES);

glVertex3f(x0,y0,z0);



glEnd();

Tabela 2.2. Wyświetlenie trójkąta przy pomocy funkcji glVertex3f()

Dzięki Vertex Array możliwe jest przesłanie informacji o położeniu wielu

wierzchołków przy pomocy pojedynczej funkcji. Informacje o współrzędnych, kolorach i

teksturach wierzchołków oraz o normalnych rysowanych powierzchni przechowywane są w

tablicach, które następnie są przekazywane jako argumenty funkcji rysującej (tab. 2.3).

Ponadto, w przypadku wielokrotnego wykorzystania tego samego wierzchołka, możliwe jest

zdefiniowanie jego współrzędnych tylko raz i odwoływanie się do niego przy pomocy

przypisanego do niego numeru. Pozwala to na optymalizacje przesyłania danych pomiędzy

procesorem a kartą graficzną, co znacznie poprawia wydajność.

GLfloat vertices[] = {x0, y0, z0, x1, y1, z1,

x2, y2, z2, x3, y3, z3};

GLubyte indices[] = {0, 1, 2, 1, 2, 3};

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, vertices);

glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices);

glDisableClientState(GL_VERTEX_ARRAY);

Tabela 2.3. Wyświetlenie czworokąta złożonego z dwóch trójkątów przy pomocy Vertex Array


15

Wadą obu tych metod pozostaje jednak przesyłanie informacji o wyświetlanych

wierzchołkach z procesora do karty graficznej przy każdym wywołaniu funkcji rysującej. Aby

temu zapobiec należy użyć Vertex Buffer Object. Mechanizm ten pozwala na jednorazowe

przesłanie tablic z informacjami o wierzchołkach do karty graficznej, a następnie na

odwoływanie się do nich poprzez przypisane identyfikatory (tab. 2.4).

GLuint vboVerticesId, vboIndicesId;

GLfloat vertices[] = {x0, y0, z0, x1, y1, z1,

x2, y2, z2, x3, y3, z3};

GLubyte indices[] = {0, 1, 2, 1, 2, 3};

glGenBuffers(1, &vboVerticesId);

glGenBuffers(1, &vboIndicesId);

glBindBuffer(GL_ARRAY_BUFFER, vboVerticesId);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesId);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 12, vertices,

GL_STATIC_DRAW);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLubyte) * 6, indices,

GL_STATIC_DRAW);

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, 0);

glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);

glDisableClientState(GL_VERTEX_ARRAY);

Tabela 2.4. Wyświetlenie czworokąta złożonego z dwóch trójkątów przy pomocy Vertex Buffer Object

2.2.5 Mapy cyfrowe

Do utworzenia wizualizacji samolotu oraz jego otoczenia niezbędne są informacje o

terenie nad jakim znajduje się statek powietrzny. Będą one dostarczane przez pliki

zewnętrzne, będące odpowiednio przygotowanymi mapami cyfrowymi zawierającymi dane o

rodzaju terenu nad jakim znajduje się samolot, przewidywanej wysokości względna, poniżej


16

której jego ruch nie jest wskazany oraz ewentualnych przeszkodach lotniczych wraz z

wysokościami na jakich się one znajdują.

Wszystkie mapy są wykonane w układzie współrzędnych PUWG-1992 [4]. Jest to

układ współrzędnych płaskich prostokątnych utworzony przez Państwowy Układ

Współrzędnych Geodezyjnych opracowany w 1992 roku. Jest to obecnie jedyny układ

obowiązujący w Polsce dla opracowań małoskalowych.

Układ ten powstał w wyniku zastosowania odwzorowania Gaussa-Krügera na

elipsoidę WGS-84 (elipsoida określająca kształt kuli ziemskiej, znajdująca szerokie

zastosowanie w kartografii oraz systemach nawigacji satelitarnej). Ze względu na

zniekształcenia sięgające do 90cm/km (rys. 2.5), układ ten jest przeznaczony do sporządzania

map w skalach 1:10 000 i mniejszych.

Rysunek 2.5. Rozkład zniekształceń długości w PUWG 1992 (w cm/km ), cytat [5]


17

ROZDZIAŁ 3

OPIS SYMULATORA

W tym rozdziale przedstawiony zostanie sposób działania utworzonej aplikacji wraz z

dokładnym opisem graficznego interfejsu użytkownika, plików wejściowych niezbędnych do

działania programu oraz generowanych plików wyjściowych. Rozdział zawiera także

diagramy UML modelujące budowę i działanie aplikacji.

3.1 Środowisko i wybrane narzędzia

Symulator jest realizowany w języku C++. Do utworzenia graficznego interfejsu

użytkownika jest używana biblioteka OpenGL. Wybór ten podyktowany jest faktem, że za jej

pomocą można zarówno w prosty sposób tworzyć animacje jak i zrealizować podstawowe

zarządzanie oknami aplikacji [6].


18

3.2 Informacje o GUI

Głównym celem tworzonej wizualizacji jest umożliwienie użytkownikowi szybkiej

interpretacji uzyskiwanych wyników, a także obserwacji aktualnego położenia i trajektorii

lotu statku powietrznego. W jej skład wchodzą:

statek powietrzny

teren znajdujący się w jego najbliższym otoczeniu

siatka przedstawiająca strefy radaru

rzuty perspektywiczne wybranych warstw siatki radaru

informacje o trajektorii lotu przedstawiane w trybie tekstowym

Teren przedstawiony na wizualizacji (rys. 3.1) tworzony jest przy pomocy map

cyfrowych. Jest on budowany z sześcianów, których kolor oraz wysokość zależy od rodzaju

terenu oraz wysokości, na jakiej ruch powietrzny nie jest dla danego terenu wskazany

(wysokość ta będzie uważana przez radar oraz wysokościomierz za poziom ziemi).

Radar wyświetlany jest w postaci siatki zbudowanej z ostrosłupów. każdy z nich

reprezentuje jedną strefę radaru. W przypadku wykrycia obiektu w danej strefie, zostanie ona

oznaczona kolorem czerwonym (rys. 3.2).

Ze względu na rozmiar map cyfrowych, podczas pokazywania całego terenu

niemożliwe okazało się płynne działanie radaru. W związku z tym wprowadzona została

możliwość zmiany promienia pola widzenia w zakresie 1000~2500m, co pozwala znacznie

poprawić efektywność działania aplikacji.


19

Rysunek 3.1. Widok podstawowy graficznego interfejsu użytkownika.

Rysunek 3.2. W przypadku wykrycia przeszkody strefa zostaje oznaczona kolorem czerwonym.


20

3.3 Pliki wejściowe

3.3.1 Pliki konfiguracyjne

Pliki konfiguracyjne stanowią podstawę działania programu. Dzięki nim podczas

uruchamiania ustalane są parametry działania symulatora oraz pozycja startowa statku

powietrznego. Ponadto są w nich zawarte ścieżki plików wejściowych i wyjściowych. Dla

przejrzystości utworzone zostały trzy pliki konfiguracyjne: config.txt zawierający informacje

o lokalizacji wszystkich plików wejściowych i wyjściowych (w tym pozostałych dwóch

plików konfiguracyjnych) (tab. 3.1), plik konfiguracyjny samolotu zawierający informacje o

jego pozycji startowej (tab. 3.2) oraz plik konfiguracyjny radaru umożliwiający zmianę jego

parametrów(tab. 3.3).

Parametry symulatora, które nie są definiowane w pliku konfiguracyjnym tj.

rozdzielczość skanowania w azymucie i w elewacji oraz szerokość skanowanej półsfery w

azymucie wyznaczane są automatycznie.

Tabela 3.1. Przykładowy plik konfiguracyjny config.txt.

AIRPLANE_CONFIG config/airplane_config.dat

RADAR_CONFIG config/radar_config.dat

TERRAIN_TYPE_MAP maps/clutter.txt

TERRAIN_HEIGHT_MAP maps/clutter_h.txt

AIR_OBSTACLE_MAP maps/air_obstacles.txt

PERCEPTION_MAP maps/perception_map.txt

TRAJECTORY trajectory/wynik_zakret50ms.dat

DETECTION_RESULTS detection_results.dat

INCLUDE_TERRAIN_DETECTING false


21

Znaczenie pól w pliku konfiguracyjnym:

AIRPLANE_CONFIG – lokalizacja pliku konfiguracyjnego statku powietrznego,

RADAR_CONFIG – lokalizacja pliku konfiguracyjnego radaru,

TERRAIN_TYPE_MAP – lokalizacja pliku wejściowego zawierającego mapy

cyfrowe z danymi o typie terenu

TERRAIN_HEIGHT_MAP – lokalizacja pliku wejściowego zawierającego mapy

cyfrowe z danymi o wysokości terenu

AIR_OBSTACLE_MAP – lokalizacja pliku wejściowego zawierającego mapy

cyfrowe z danymi o przeszkodach lotniczych

PERCEPTION_MAP - lokalizacja pliku wyjściowego zawierającego mapy cyfrowe z

danymi o prawdopodobieństwie wykrycia przeszkody

TRAJECTORY - lokalizacja pliku wejściowego zawierającego informacje o

trajektorii lotu

DETECTION_RESULTS - lokalizacja pliku wyjściowego zawierajacego infromacje o

wynikach detekcji obiektów

INCLUDE_TERRAIN_DETECTING - informacja dla symulatora, czy w detekcji

obiektów należy uwzględniać elementy terenu (zalecane dla symulacji przy niskim

pułapie lotu). Możliwe wartości: "true", "false".

START_POS_X 698632

START_POS_Y 200000

Tabela 3.2. Przykładowy plik konfiguracyjny statku powietrznego.

Znaczenie pól w pliku konfiguracyjnym statku powietrznego:

START_POS_X – współrzędna x pozycji startowej (w układzie PUWG 1992),

START_POS_Y – współrzędna y pozycji startowej (w układzie PUWG 1992).


22

ZONES_IN_AZIMUTH 13

ZONES_IN_ELEVATION 2

LINES_IN_AZIMUTH 2

LINES_IN_ELEVATION 2

EL_MAX_SPHERE_WIDTH 36

EL_MIN_SPHERE_WIDTH -12

RANGE 200

TIME 0.08

Tabela 3.3. Przykładowy plik konfiguracyjny radaru.

Znaczenie pól w pliku konfiguracyjnym radaru:

ZONES_IN_AZIMUTH – ilość wydzielonych stref w azymucie,

ZONES_IN_ELEVATION – ilość wydzielonych stref w elewacji,

LINES_IN_AZIMUTH – ilość promieni wewnętrznych w azymucie przypadających

na jedną strefę,

LINES_IN_ELEVATION – ilość promieni wewnętrznych w elewacji przypadających

na jedną strefę,

EL_MAX_SPHERE_WIDTH - kąt określający położenie skanowanej półsfery w

elewacji

EL_MIN_SPHERE_WIDTH - kąt określający położenie skanowanej półsfery w

elewacji

RANGE - zasięg radaru

TIME - czas skanowania wszystkich stref

3.3.2 Mapy cyfrowe

Mapy cyfrowe są liczbową reprezentacją terenu, nad którym porusza się statek

powietrzny. Każda z map składa się z nagłówka określającego położenie opisywanego terenu

oraz ciągu wartości liczbowych (tab. 3.4), który określa wysokość lub rodzaj terenu. Każdy

rodzaj terenu posiada numer identyfikacyjny interpretowany przez mapy oraz przypisaną,

typową wysokość względną, przy której ruch powietrzny nie jest wskazany (tab. 3.5).


23

ncols 485

nrows 762

xllcorner 693632.37616363

yllcorner 193146.72739078

cellsize 20

NODATA_value -9999

80 80 80 80 176 176 176 80 80 220 220 220 220 220 220 220 220 ...

80 80 80 80 176 176 176 176 80 220 220 220 220 220 220 220 220 ...

Tabela 3.4. Przykładowy nagłówek mapy cyfrowej wraz z jej fragmentem.

Znaczenie pól w nagłówku mapy:

ncols – rozmiar mapy w poziomie (liczba komórek),

nrows – rozmiar mapy w pionie (liczba komórek),

xllcorner – współrzędna x dolnego lewego rogu mapy(w układzie PUWG1992 jest to

współrzędna y),

yllcorner - współrzędna y dolnego lewego rogu mapy (w układzie PUWG1992 jest to

współrzędna x),

cellsize – rozmiar pojedynczej komórki mapy w metrach,

NODATA_value – wartość oznaczająca brak danych o wysokości/typie terenu w

danej komórce.


24

Oznaczenie Rodzaj terenu Wysokość

1 Woda 0

16 Tereny wyasfaltowane 0

80 Tereny otwarte 5

108 Drzewa/teren otwarty przemiennie 25

112 Lasy mieszane 25

116 Lasy liściaste 25

120 Lasy iglaste 25

176 Zabudowa podmiejska 10

200 Ogródki działkowe 10

208 Zabudowa miejska 15

220 Zabudowa wysoka 30

221 Zabudowa gęsta 30

241 Obszary przemysłowe 20

Tabela 3.5. Rodzaje terenu interpretowane przez symulator.

3.3.3 Plik trajektorii

Do animacji lotu samolotu potrzebne są także informacje o trajektorii lotu. Zawarte są

one w pliku trajektorii, którego pierwsza linia podaje rodzaj i kolejność danych znajdujących

się w pliku, a następne zawierają ciąg wartości liczbowych oddzielanych przecinkiem. W

pliku mogą pojawić się następujące dane:

x1, y1 – położenie liniowe samolotu w płaszczyźnie (względem położenia

początkowego) [m],

z1=-H wysokość samolotu ze znakiem minus [m],

składowa pozioma prędkości liniowej [m/s],

składowa poprzeczna prędkości liniowej[m/s],

składowa pionowa prędkości liniowej [m/s],

składowa prędkości kątowej wzdłuż podłużnej osi samolotu [deg/s],

składowa prędkości kątowej wzdłuż poprzecznej osi samolotu [deg/s],


25

składowa prędkości kątowej wzdłuż pionowej osi samolotu [deg/s],

kąt przechylenia samolotu [deg],

kąt pochylenia samolotu [deg],

kąt odchylenia samolotu [deg].

Do działania symulatora wymagane są jedynie: położenie liniowe samolotu, wysokość

oraz kąt pochylenia w każdej z płaszczyzn, jednak plik trajektorii jest plikiem wyjściowym

innego elementu systemu antykolizyjnego, w związku z czym aplikacja musi być w stanie

wybrać z niego interesujące ją informacje [1].

3.4 Pliki wyjściowe

3.4.1 Plik z wykrytymi obiektami

Podczas animacji symulator zbiera dane o wykrytych obiektach. Są one zapisywane do

pliku wyjściowego, którego każda linia odpowiada jednemu skanowaniu stref radaru. Zawarte

są w niej informacje o aktualnej pozycji i rotacji statku powietrznego oraz numery

identyfikacyjne oraz stopień pokrycia obiektami każdej ze stref (w szczególności 0 oznacza

brak obiektów wykrytych w danej strefie).

3.4.2 Mapa percepcyjna

Drugi z tworzonych plików jest to mapa percepcyjna utworzona o strukturze podobnej

do wcześniej przedstawionych map cyfrowych [2]. Jest ona budowana zgodnie z ideą siatki

pewności (certainty grid) i zawiera informacje o prawdopodobieństwie wykrycia obiektów w

danym miejscu w oparciu o poprzednio wykonywane skanowania (tab 3.6). Za każdym razem

kiedy radar wykryje obiekt w danym obszarze, prawdopodobieństwo wykrycia go ponownie

rośnie. Zebrane w ten sposób informacje mogą sprawić, że przy następnym przelocie system

antykolizyjny zdecyduje się zmienić trajektorię lotu zanim jeszcze przeszkoda zostanie

wykryta przez radar.


26

Możliwe jest wyświetlenie utworzonej przez program mapy percepcyjnej. Jest to mapa

o dokładności i parametrach identycznych jak mapa przeszkód lotniczych, przedstawiona w

skali szarości. Prawdopodobieństwo wykrycia przeszkody w danym obszarze jest tym

wyższe, im ciemniejszy jest jego kolor.

ncols 485

nrows 762

xllcorner 693632.37616363

yllcorner 193146.72739078

cellsize 20

NODATA_value -9999

0 0 0.34 0.82 0.4 0 0 0 0 0 ...

0 0.33 1.0 0.7 0.02 0 0 0 0 0 ...

0 0.98 0.99 0.05 0 0 0 0 0 0 ...

Tabela 3.6. Przykładowy nagłówek mapy percepcyjnej wraz z jej fragmentem.


27

3.5 Struktura programu

3.5.1 Diagram przypadków użycia


28

3.5.2 Diagram klas


29

3.5.3 Diagram czynności


30

3.6 Testowanie

Do testowania programu posłużyły dane zapisane w mapie percepcyjnej. Zostały one

porównane z odpowiadającymi im obszarami mapy przeszkód lotniczych.

3.6.1 Wykrywanie omijanej przeszkody

W tym teście celem radaru było wykrycie przeszkód podczas manewru skręcania (rys.

3.3). Pełne wykrycie pierwszej przeszkody było niemożliwe, ponieważ duża jej część

znajdowała się poza zasięgiem radaru (rys. 3.4).

Rysunek 3.3. Przeszkody lotnicze wykrywane podczas manewru skrętu w lewo.

Rysunek 3.4. Mapa percepcyjna wygenerowana podczas manewru skrętu w lewo.

3.6.2 Przelatywanie nad przeszkodami

W tym teście sprawdzona została efektywność radaru podczas przelatywania tuż nad

przeszkodami podczas identycznego skrętu w lewo (rys. 3.5). W związku z rozmieszczeniem

stref radaru w elewacji przeszkody były widoczne tylko przez chwilę, co spowodowało niską

wartość gęstości prawdopodobieństwa wpisaną do mapy cyfrowej w miejscu położenia


31

przeszkody (rys. 3.6). Po zmianie parametrów pracy radaru na 3 strefy w elewacji

wykrywające w zakresie -35 - 35 uzyskane wyniki dużo lepiej oddają położenie przeszkód

(rys. 3.7).

Rysunek 3.5. Przeszkody lotnicze wykrywane podczas manewru skrętu w lewo podczas przelatywania nad

przeszkodami znajdującymi się po lewej stronie rysunku.

Rysunek 3.6. Mapa percepcyjna wygenerowana podczas manewru skrętu w lewo podczas przelatywania

nad przeszkodami znajdującymi się po lewej stronie rysunku.

Rysunek 3.7. Mapa percepcyjna wygenerowana podczas manewru skrętu w lewo podczas przelatywania

nad przeszkodami znajdującymi się po lewej stronie rysunku po zmianie parametrów pracy radaru.


32

3.6.3 Kolizja z przeszkodą

W tym teście pokazane zostały dane generowane podczas kolizji z przeszkodą podczas

lotu prosto (rys 3.8). W związku z niedużą odległością przeszkody symulator jest w stanie

oznaczyć ją na mapie percepcyjnej dużo lepiej niż w poprzednich testach (rys. 3.9).

Rysunek 3.8. Przeszkody lotnicze znajdujące się w polu widzenia podczas kolizji z przeszkodą znajdującą

się po prawej stronie.

Rysunek 3.9. Mapa percepcyjna wygenerowana podczas kolizji z przeszkodą.


33

ROZDZIAŁ 4

INSTRUKCJA OBSŁUGI

Ten rozdział zawiera instrukcję użytkownika, w której przedstawiony zostanie sposób

instalacji symulatora, sposób jego obsługi oraz opis dostępnych operacji.

4.1 Instalacja

W katalogu, w którym znajduje się program należy utworzyć folder config, a w nim

plik config.dat (o ile nie istnieje) według schematu podanego w rozdziale 3.3.1, w którym

należy uzupełnić wszystkie wymagane pola. Następnie można uruchomić program przy

pomocy pliku wykonywalnego RadarSimulator.exe.


34

4.2 Okno główne

Po uruchomieniu programu użytkownik może zobaczyć okno główne składające się z

widoku perspektywicznego oraz panelu bocznego znajdującego się po prawej stronie ekranu.

W widoku perspektywicznym widoczny jest statek powietrzny wraz z jego najbliższym

otoczeniem oraz siatką symulowanego radaru.

W panelu bocznym znajdują się cztery okna, przedstawiające informacje o aktualnie

wykrywanych obiektach oraz trajektorii lotu. W dwóch górnych oknach znajduje się rzut

perspektywiczny kolejnych stref radaru w azymucie. W trzecim oknie przedstawiany jest

widok radaru z boku, natomiast w czwartym oknie przedstawione są informacje o trajektorii

lotu w trybie tekstowym.

Istnieje możliwość wyświetlenia mapy przeszkód lotniczych oraz utworzonej mapy

percepcyjnej poprzez wybranie odpowiedniego trybu w zakładce "View" menu

kontekstowego. Spowoduje to zatrzymanie animacji i niemożność jej wznowienia, dopóki

program nie zostanie ponownie przełączony w tryb widoku perspektywicznego.

4.3 Obsługa symulatora

Obsługa programu odbywa się przy pomocy menu kontekstowego. Za jego pomocą

możemy:

wznowić/zatrzymać animację (skrót klawiszowy: P)

włączyć/wyłączyć tryb podążania kamery za statkiem powietrznym (skrót

klawiszowy: M)

zwiększyć/zmniejszyć promień widzenia (skróty klawiszowe: +/-)

wybrać tryb wyświetlania (skrót klawiszowy: V)

zakończyć działanie aplikacji (skrót klawiszowy: ESC)


35

ROZDZIAŁ 5

ZAKOŃCZENIE

5.1 Podsumowanie

W ramach pracy inżynierskiej został wykonany symulator radaru statku powietrznego

spełniający wszystkie wymagania funkcjonalne ujęte w zakresie pracy. Umożliwia on

sprawdzenie sposobu działania radaru przy użyciu różnych ustawień i porównanie ich na

podstawie plików wyjściowych. Może on zostać wykorzystany w projekcie AURA bez

potrzeby ingerencji w pliki, ani w strukturę tego systemu.

Poza przeprowadzaniem samych symulacji, utworzona aplikacja może posłużyć także

do zaprezentowania działania całego systemu antykolizyjnego. W tym wypadku jako pliki

wejściowe powinny posłużyć dane wygenerowane podczas lotu. Dzięki temu poza

wykrywanymi obiektami, będzie można także zaobserwować podejmowane przez system

decyzje o zmianie trajektorii lotu.

Temat pracy został zaprezentowany 30 maja na konferencji XXX-th IEEE-SPIE Joint

Symposium Wilga 2012 [3].


36

5.2 Perspektywy kontynuacji

Pomimo spełnienia wszystkich wymagań pracy, nadal istnieje wiele możliwości

ulepszenia utworzonego symulatora. Obecnie program obsługuje tylko jedną mapę cyfrową,

której ścieżka jest podana w pliku konfiguracyjnym. W momencie opuszczenia przez statek

powietrzny terenu opisywanego przez mapę animacja ulega zatrzymaniu. W kolejnej wersji

programu możliwe mogłoby być wykrycie tego typu sytuacji i wczytanie kolejnego pliku z

mapami z odpowiedniego katalogu lub pobranie odpowiednich map z Internetu.

Kolejną możliwą ścieżką rozwoju jest utworzenie narzędzia do samodzielnego

definiowania przeszkód lotniczych oraz prostych trajektorii lotu, dzięki któremu testowanie

zachowania radaru będzie wymagało mniejszego wkładu pracy.

Możliwe jest także poprawienie wydajności programu poprzez minimalizację

informacji przesyłanych z procesora karty graficznej. W tym celu należałby zmienić sposób

wyświetlania elementów terenu w taki sposób, aby analizowane były tylko te widoczne w

scenie oraz zastosować mechanizm Vetrex Buffer Objects.


37

BIBLIOGRAFIA

[1] "Autonomiczny układ antykolizyjny przeznaczony dla bezzałogowych środków

latających wykorzystujący aktywną metodę teledetekcji obiektów - Koncepcja

systemu antykolizyjnego", Instytut Lotnictwa, 2011.

[2] Stanisław Jankowski, Zbigniew Szymański, Jan Szczyrek , "Metoda tworzenia modelu

otoczenia z pomiarów Radarowego Detektora Przeszkód w systemie unikania kolizji",

w druku.

[3] Michał Pawłowski, Zbigniew Szymański, "Environment model for unmanned flying

vehicles based on simulated radar data", w druku.

[4] R. Pażus, J. Bosy , "Państwowy system odniesień przestrzennych. Część 1: systemy i

układy odniesienia w Polsce", Główny Urząd Geodezji I Kartografii

[5] Układ współrzędnych PUWG 1992, http://www.pl.wikipedia.org/, 09.2012

[6] Mark J. Kilgard, "The OpenGL Utility Toolkit (GLUT) Programming Interface",

1996.

[7] Mark Segal, Kurt Akeley, "The OpenGL Graphics System: A Specification (Version

4.2)", 2011.

[8] J. D. Grithy, M. J. Kochenderferz, J. K. Kuchar, "Electro-Optical System Analysis for

Sense and Avoid", AIAA Guidance - Navigation and Control Conference and Exhibit,

American Institute of Aeronautics and Astronautics, 1-11 (2008)


38

DODATEK A

OPIS KLAS ORAZ METOD

W plikach OpenGL.cpp oraz OpenGL.hpp (nagłówkowy) zawarte są funkcje pozwalające

zarządzać budową oraz wyświetlaniem okien. Służą jako kontroler całej aplikacji.

Nazwa funkcji Argumenty

(typy)

Wartość

zwracana

(typy)

Opis

initAnimation() Argumenty wywołania

programu

(int, int**)

- Inicjalizuje zmienne i

wczytuje pliki wejściowe

startAnimation() - - Rozpoczyna animacje przy

pomocy funkcji

glutMainLoop()

close() - - Zamyka program

createMenus()

menu()

menuMap()

menuFollow()

- - Inicjalizacja i zarządzanie

menu kontekstowym


39

createWindows()

init()

idle()

timer()

reshapeSubWindows()

reshapeMainWindow()

displayMain()

- - Inicjalizacja i zarządzanie

podoknami aplikacji

inputKey()

specialKey()

- - Definicja skrótów

klawiszowych

displayTopLayer()

displayBotLayer()

displaySide()

- - Wyświetlenie rzutów

perspektywicznych w

trzech górnych pod oknach

aplikacji

displayPerspective()

displayObjects()

- - Wyświetlenie widoku

perspektywicznego

displayInfo() - - Wyświetlenie żądanych

informacji w dolnym

podoknie aplikacji

drawString Tekst, Kolor, Czcionka

(char*, flaot*, void*)

- Wyświetla podany tekst w

wybranym kolorze oraz

przy użyciu wybranej

czcionki

calculateFPS() - - Oblicza ilosć

wyświetlanych klatek na

sekundę na podstawie

numeru klatki

Tabela 1. Funkcje w plikach OpenGL.cpp oraz OpenGL.hpp.


40

Klasa Radar zawarta jest w plikach Radar.cpp oraz Radar.hpp (nagłówkowy). Pozwala ona

wykrywać obiekty znajdujące się na liście pobliskich przeszkód lotniczych, a także

wyświetlić wyniki detekcji na ekranie.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Radar::

Radar()

Nazwa pliku

konfiguracyjnego

(std::string)

- Tworzy obiekt reprezentujący

radar na podstawie pliku

konfiguracyjnego

Radar::

drawZones()

- - Wyświetla strefy radaru

Radar::

drawInnerLines()

- - Wyświetla promienie wewnętrzne

w każdej ze sfer

Radar::

drawLayer()

Numer warstwy siatki

radaru

(int)

- Wyświetla rzut perspektywiczny

w poziomie wybranej warstwy

siatki radaru

Radar::

drawSide()

- - Wyświetla rzut perspektywiczny

w pionie siatki radaru

Radar::

isInRange()

Odległość w jakiej

znajduje się inny

obiekt

(float)

Prawda/Fałsz

(bool)

Sprawdza, czy podana odległość

jest mniejsza od zasięgu radaru

Radar::

detect()

Lista przeszkód

(Obstacles*)

- Sprawdza, czy przeszkody

znajdujące się na liście zostaną

wykryte przez radar

Tabela 2. Metody publiczne klasy Radar.


41

Klasa Altimeter zawarta jest w plikach Altimeter.cpp oraz Altimeter.hpp (nagłówkowy).

Reprezentuje ona wysokościomierz i pozwala obliczyć wykrywaną przez niego wysokość.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość

zwracana

(typy)

Opis

Altimeter::

Altimeter

Mapa cyfrowa

(DigitalMap*)


wysokościomierz, który będzie

pobierał dane z podanej mapy

cyfrowej

Altimeter::

getDetectedHeight()

Indeksy aktualnej pozycji

w podanej mapie cyfrowej,

aktualna wysokość

(int, int , float)

float Zwraca wartość wysokości

wykrywaną przez

wysokościomierz

Tabela 4. Metody publiczne klasy Altimeter.

Klasa Airplane zawarta jest w plikach Airplane.cpp oraz Airplane.hpp (nagłówkowy).

Przechowuje ona informacje o aktualnym położeniu samolotu w przestrzeni.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Airplane::

Airplane()

Nazwa pliku

konfiguracyjnego

(std::string)


statek powietrzny

Airplane::

draw()

- - Wizualizuje obiekt przy pomocy

biblioteki OpenGL

Tabela 4. Metody publiczne klasy Airplane.


42

Klasa Trajectory zawarta jest w plikach Trajectory.cpp oraz Trajectory.hpp (nagłówkowy).

Przechowuje ona informacje o trajektorii lotu statku powietrznego.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Trajectory::

Trajectory()

Nazwa pliku

konfiguracyjnego

(std::string)


trajektorię lotu

Trajectory::

scale()

Skala

(float)

- Przeskalowanie wszystkich

parametrów trajektorii

wyrażonych w metrach

Trajectory::

reset()

- - Ustawia pozycję początkową jako

aktualną pozycję

Trajectory::

printTrajectory()

Nazwa pliku

(std::string)

- Zapisuje trajektorię do pliku o

wskazanej nazwie

Tabela 3. Metody publiczne klasy Trajectory.


43

Klasa DigitalMap zawarta jest w plikach DigitalMap.cpp oraz DigitalMap.hpp (nagłówkowy).

Służy ona do reprezentacji wszystkich map cyfrowych używanych w czasie działania

aplikacji.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

DigitalMap::

DigitalMap()

Wartości nagłówka

mapy cyfrowej

(int, int, float, float,

float, float)


mapę cyfrową o podanych

parametrach i wartościach

równych NODATA_value

DigitalMap::

DigitalMap()

Nazwa pliku z mapą

cyfrową

(std::string)


mapę cyfrową na podstawie

podanego pliku

DigitalMap::

printMap()

- - Zapisuje mapę cyfrową do pliku o

wcześniej podanej nazwie

DigitalMap::

printMap()

Nazwa pliku

docelowego

(std::string)

- Zapisuje mapę cyfrową do

podanego pliku

DigitalMap::

scale()

Skala

(float)

- Skaluje wartości nagłówka

wyrażone w metrach i wartości

mapy cyfrowej, jeśli są wyrażone

w metrach

Tabela 5. Metody publiczne klasy DigitalMap.


44

Pliki Geometry.cpp oraz Geometry.hpp (nagłówkowy) zawierają klasy reprezentujące punkt,

linię, odcinek, czworokąt, trójkąt, płaszczyznę oraz wektor. Każda z nich umożliwia

wykonywanie operacji matematycznych, dzięki którym realizowany jest algorytm

wykrywania obiektów.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Point::

Point()

- - Tworzy obiekt reprezentujący

punkt o współrzędnych (0, 0, 0)

Point::

Point()

Współrzędne punktu

(float, float, float)


punkt o podanych współrzędnych

Point::

Point()

Punkt

(Point*)


punkt o współrzędnych równych

współrzędnym podanego punktu

Point::

rotate()

Kąty obrotu w osiach

OX, OY oraz OZ

(float, flaot, float)

- Obraca punkt wokół punktu (0, 0,

0)

static Point::

rotate()

Punkt, kąty obrotu w

osiach OX, OY oraz

OZ

(Point*, float, flaot,

float)

- Obraca podany punkt wokół

punktu (0, 0, 0)

Point::

distance()

Punkt

(Point*)

Odległość od

podanego punktu

(float)

Oblicza odległość od podanego

punktu

static Point::

distance()

Punkt, Punkt

(Point*, Point*,

Point*)

Odległość pomiędzy

dwoma punktami

(float)

Oblicza odległość pomiędzy

dwoma punktami


45

Point::

isEqual()



Prawda/Fałsz

(bool)

Sprawdza, czy współrzędne

punktu są równe podanym

współrzędnym

Point::

isEqual()

Punkt

(Point*)

Prawda/Fałsz

(bool)


punktu są równe współrzędnym

podanego punktu

Point::

glDraw()

- - Wykonuje funkcję glVertex3f()

przy użyciu współrzędnych

punktu

Tabela 6. Metody publiczne klasy Point.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

LineSegment::

LineSegment()


odcinek

LineSegment::

LineSegment()

Punkt, Punkt

(Point*, Point*)


odcinek o punktach początkowym

i końcowym równym podanym

pounktom

LineSegment::

LineSegment()

Odcinek

(LineSegment*)


odcinek o identyczny do

podanego

LineSegment::

glDraw()

- - Wyświetla linię przy pomocy

biblioteki OpenGL

Tabela 7. Metody publiczne klasy LineSegment.


46

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Vector::

Vector()


wektor o współrzędnych (0, 0, 0)

Vector::

Vector()




wektor o podanych

współrzędnych

Vector::

Vector()

Punkt, Punkt

(Point*, Point*,

Point*)


wektor o początku w punkcie

pierwszym i końcu w punkcie

drugim

Vector::

Vector()

Wektor

(Vector*)


wektor o współrzędnych równych

współrzędnym podanego wektora

Vector::

isEqual()

Współrzędne wektora


Prawda/Fałsz

(bool)


wektora są równe podanym

współrzędnym

Vector::

isEqual()

Wektor

(Vector*)

Prawda/Fałsz

(bool)


wektora są równe współrzędnym

podanego wektora

Vector::

crossProduct()

Wektor

(Vector*)

Iloczyn wektorowy

(Vector*)

Oblicza iloczyn wektorowy

static Vector::

crossProduct()

Wektor, Wektor

(Vector*, Vector*)

Iloczyn wektorowy

(Vector*)

Oblicza iloczyn wektorowy

dwóch wektorów

Tabela 8. Metody publiczne klasy Vector.


47

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Line::

Line()


prostą

Line::

Line()

Punkt, Punkt

(Point*, Point*)


prostą przechodzącą przez podane

punkty

Line::

Line()

Punt, Wektor

kierunkowy prostej

(Point*, Vector*)


prostą o podanym wektorze

kierunkowym, która przechodzi

przez dany punkt

Line::

Line()

Linia

(Line*)


prostą identyczną do podanej

Line::

belong()

Punkt

(Point*)

Prawda/Fałsz

(bool)

Sprawdza, czy podany punkt

należy do prostej

Line::

project()

Punkt

(Point*)

Punkt będący rzutem

punktu podanego jako

argument funkcji

(Point*)

Rzutuje punkt na prostą

Tabela 9. Metody publiczne klasy Line.


48

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Plane::

Plane()


płaszczyznę

Plane::

Plane()

Parametry równania

ogólnego płaszczyzny



płaszczyznę o podanych

parametrach równania ogólnego

Plane::

Plane()

Punkt, Punkt, Punkt

(Point*, Point*,

Point*)


płaszczyznę przechodzącą przez

podane punkty

Plane::

Plane()

Płaszczyzna

(Plane*)


płaszczyznę identyczną do

podanej

Plane::

belongs()

Punkt

(Point*)

Prawda/Fałsz

(bool)

Sprawdza, czy podany punkt

należy do płaszczyzny

Plane::

crossPoint()

Linia

(Line*)

Punkt przecięcia

prostej z płaszczyzną

(Point*)

Oblicza punkt przecięcia podanej

prostej z płaszczyzną

Plane::

getNormal()

- Wektor prostopadły

do płaszczyzny

(Vector*)

Zwraca wektor prostopadły do

płaszczyzny

Tabela 10. Metody publiczne klasy Plane.


49

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Triangle::

Triangle ()


trójkąt

Triangle::

Triangle ()

Punkt, Punkt, Punkt

(Point*, Point*,

Point*)


trójkąt składający się z podanych

punktów

Triangle::

Triangle ()

Trójkąt

(Triangle *)


trójkąt identyczny do podanego

Triangle::

getNormal()


do trójkąta

(Vector*)


trójkąta

Triangle::

glDraw()

- - Wyświetla trójkąt przy pomocy

biblioteki OpenGL

Triangle::

glDraw ()

Wektor

(Vector*)

- Wyświetla trójkąt przy pomocy

biblioteki OpenGL przyjmując

podany wektor jako jego

normalną

Tabela 11. Metody publiczne klasy Triangle.


50

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Quadrilateral::

Quadrilateral()


czworokąt

Quadrilateral::

Quadrilateral()

Punkt, Punkt, Punkt,

Punkt

(Point*, Point*,

Point*, Point*)


czworokąt składający się z

podanych punktów

Quadrilateral::

Quadrilateral()

Czworokąt

(Quadrilateral*)


czworokąt identyczny do

podanego

Quadrilateral::

belongs()

Punkt

(Point*)

Prawda/Fałsz

(bool)

Sprawdza, czy punkt należy do

czworokąta

Quadrilateral::

getNormal()


do czworokąta

(Vector*)


czworokąta

Quadrilateral::

glDraw()

- - Wyświetla czworokąt przy

pomocy biblioteki OpenGL

Quadrilateral::

glDraw ()

Wektor

(Vector*)

- Wyświetla czworokąt przy

pomocy biblioteki OpenGL

przyjmując podany wektor jako

jego normalną

Tabela 12. Metody publiczne klasy Quadrilateral.


51

Klasa Complex zawarta jest w plikach Complex.cpp oraz Complex.hpp (nagłówkowy).

Pozwala ona na wykonywanie operacji na liczbach zespolonych.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Complex::

Complex()

Część rzeczywista i

część urojona

(float float)


liczbę zespoloną o części

rzeczywistej i urojonej równej

podanym

Complex::

Complex()

Liczba zespolona

(Complex&)


liczbę zespoloną równą podanej

liczbie zespolonej

Operatory

+, -, *, /

Liczba zespolona

(Complex&)

Liczba zespolona

(Complex)

Tworzy obiekt będący wynikiem

podanej operacji na dwóch

liczbach zespolonych

Operatory

+=, -=, *=, /=

Liczba zespolona

(Complex&)

Liczba zespolona

(Complex&)

Wykonuje operację na dwóch

liczbach zespolonych

Complex::

distance()

Liczba zespolona

(Complex&)


dwoma liczbami

zespolonymi

(float)


dwoma liczbami zespolonymi

Complex::

distance()

Liczba zespolona,

Liczba zespolona

(Complex&,

Complex&)


dwoma liczbami

zespolonymi

(float)


dwoma liczbami zespolonymi

Tabela 13. Metody publiczne klasy Complex.


52

Klasa FileWriter zawarta jest w plikach FileWriter.cpp oraz FileWriter.hpp (nagłówkowy).

Służy ona do przechowywania i zapisu do pliku dowolnych operacji.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

FileWriter::

FileWriter()

- - Tworzy nowy obiekt do

przechowywania informacji

FileWriter::

FileWriter()

Nazwa pliku

docelowego

(std::string)

- Tworzy nowy obiekt do

przechowywania informacji

FileWriter::

addLine()

Następna linia pliku

(std::string)

- Dodaje do przechowywanych

informacji kolejną linię

FileWriter::

createFile()

- Tworzy nowy plik o nazwie

podanej podczas tworzenia

obiektu

FileWriter::

createFile()

Nazwa pliku

docelowego

(std::string)

- Tworzy nowy plik o podanej

nazwie

Tabela 14. Metody publiczne klasy FileWriter.


53

Klasa Obstacles zawarta jest w plikach Obstacles.cpp oraz Obstacles.hpp (nagłówkowy).

Służy ona do przechowywania listy znajdujących się w pobliżu przeszkód.

Nazwa klasy::

Nazwa metody

Argumenty

(typy)

Wartość zwracana

(typy)

Opis

Obstacles::

Obstacles()

- - Tworzy nową listę

przeszkód

Obstacles::

begin()

- Pierwsza przeszkoda z listy

(Obstacle*)

Zwraca wskazanie na

pierwszą przeszkodę z

listy

Obstacles::

end()

- Ostatnią przeszkoda z listy

(Obstacle*)

Zwraca wskazanie na

ostatnią przeszkodę z listy

Obstacles::

add()

Punkt, Punkt, Punkt,

Punkt

(Point*, Point*,

Point*, Point*)

- Tworzy nową przeszkodę

o podanych

współrzędnych i dodaje ją

do listy

Obstacles::

add()

Czworokąt

(Quadrilateral*)

- Tworzy nową przeszkodę

o współrzędnych równych

współrzędnym czworokąta

i dodaje ją do listy

Obstacles::

clear()

- - Usuwa wszystkie

przeszkody z listy

Obstacles::

isEmpty()

- Prawda/Fałsz

(bool)

Sprawdza, czy lista

przeszkód jest pusta

Obstacles::

size()

- Ilość obiektów znajdujących

się w liście

Zwraca informację o ilości

przeszkód znajdujących

się na liście

Tabela 15. Metody publiczne klasy Obstacles.

PRACA DYPLOMOWA INŻYNIERSKA...PODSTAWY TEORETYCZNE W tym rozdziale omówione zostaną podstawy...

Documents

Transcript of PRACA DYPLOMOWA INŻYNIERSKA...PODSTAWY TEORETYCZNE W tym rozdziale omówione zostaną podstawy...