Upload
others
View
7
Download
0
Embed Size (px)
Citation preview
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
Symulator radaru statku powietrznego
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
Symulator radaru statku powietrznego
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
Praca inżynierska - Pawłowski Michał
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
Symulator radaru statku powietrznego
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ę
Praca inżynierska - Pawłowski Michał
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.
Symulator radaru 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.
Praca inżynierska - Pawłowski Michał
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
Symulator radaru statku powietrznego
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].
Praca inżynierska - Pawłowski Michał
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.
Symulator radaru statku powietrznego
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.
Praca inżynierska - Pawłowski Michał
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.
Symulator radaru statku powietrznego
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);
glVertex3f(x1,y1,z1);
glVertex3f(x2,y2,z2);
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
Praca inżynierska - Pawłowski Michał
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
Symulator radaru statku powietrznego
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]
Praca inżynierska - Pawłowski Michał
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].
Symulator radaru statku powietrznego
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.
Praca inżynierska - Pawłowski Michał
19
Rysunek 3.1. Widok podstawowy graficznego interfejsu użytkownika.
Rysunek 3.2. W przypadku wykrycia przeszkody strefa zostaje oznaczona kolorem czerwonym.
Symulator radaru statku powietrznego
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
Praca inżynierska - Pawłowski Michał
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).
Symulator radaru statku powietrznego
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).
Praca inżynierska - Pawłowski Michał
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.
Symulator radaru statku powietrznego
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],
Praca inżynierska - Pawłowski Michał
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.
Symulator radaru statku powietrznego
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.
Praca inżynierska - Pawłowski Michał
27
3.5 Struktura programu
3.5.1 Diagram przypadków użycia
Symulator radaru statku powietrznego
28
3.5.2 Diagram klas
Praca inżynierska - Pawłowski Michał
29
3.5.3 Diagram czynności
Symulator radaru statku powietrznego
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
Praca inżynierska - Pawłowski Michał
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.
Symulator radaru statku powietrznego
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ą.
Praca inżynierska - Pawłowski Michał
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.
Symulator radaru statku powietrznego
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)
Praca inżynierska - Pawłowski Michał
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].
Symulator radaru statku powietrznego
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.
Praca inżynierska - Pawłowski Michał
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)
Symulator radaru statku powietrznego
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
Praca inżynierska - Pawłowski Michał
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.
Symulator radaru statku powietrznego
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.
Praca inżynierska - Pawłowski Michał
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*)
- Tworzy obiekt reprezentujący
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)
- Tworzy obiekt reprezentujący
statek powietrzny
Airplane::
draw()
- - Wizualizuje obiekt przy pomocy
biblioteki OpenGL
Tabela 4. Metody publiczne klasy Airplane.
Symulator radaru statku powietrznego
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)
- Tworzy obiekt reprezentujący
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.
Praca inżynierska - Pawłowski Michał
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)
- Tworzy obiekt reprezentujący
mapę cyfrową o podanych
parametrach i wartościach
równych NODATA_value
DigitalMap::
DigitalMap()
Nazwa pliku z mapą
cyfrową
(std::string)
- Tworzy obiekt reprezentujący
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.
Symulator radaru statku powietrznego
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)
- Tworzy obiekt reprezentujący
punkt o podanych współrzędnych
Point::
Point()
Punkt
(Point*)
- Tworzy obiekt reprezentujący
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
Praca inżynierska - Pawłowski Michał
45
Point::
isEqual()
Współrzędne punktu
(float, float, float)
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)
Sprawdza, czy współrzędne
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()
- - Tworzy obiekt reprezentujący
odcinek
LineSegment::
LineSegment()
Punkt, Punkt
(Point*, Point*)
- Tworzy obiekt reprezentujący
odcinek o punktach początkowym
i końcowym równym podanym
pounktom
LineSegment::
LineSegment()
Odcinek
(LineSegment*)
- Tworzy obiekt reprezentujący
odcinek o identyczny do
podanego
LineSegment::
glDraw()
- - Wyświetla linię przy pomocy
biblioteki OpenGL
Tabela 7. Metody publiczne klasy LineSegment.
Symulator radaru statku powietrznego
46
Nazwa klasy::
Nazwa metody
Argumenty
(typy)
Wartość zwracana
(typy)
Opis
Vector::
Vector()
- - Tworzy obiekt reprezentujący
wektor o współrzędnych (0, 0, 0)
Vector::
Vector()
Współrzędne punktu
(float, float, float)
- Tworzy obiekt reprezentujący
wektor o podanych
współrzędnych
Vector::
Vector()
Punkt, Punkt
(Point*, Point*,
Point*)
- Tworzy obiekt reprezentujący
wektor o początku w punkcie
pierwszym i końcu w punkcie
drugim
Vector::
Vector()
Wektor
(Vector*)
- Tworzy obiekt reprezentujący
wektor o współrzędnych równych
współrzędnym podanego wektora
Vector::
isEqual()
Współrzędne wektora
(float, float, float)
Prawda/Fałsz
(bool)
Sprawdza, czy współrzędne
wektora są równe podanym
współrzędnym
Vector::
isEqual()
Wektor
(Vector*)
Prawda/Fałsz
(bool)
Sprawdza, czy współrzędne
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.
Praca inżynierska - Pawłowski Michał
47
Nazwa klasy::
Nazwa metody
Argumenty
(typy)
Wartość zwracana
(typy)
Opis
Line::
Line()
- - Tworzy obiekt reprezentujący
prostą
Line::
Line()
Punkt, Punkt
(Point*, Point*)
- Tworzy obiekt reprezentujący
prostą przechodzącą przez podane
punkty
Line::
Line()
Punt, Wektor
kierunkowy prostej
(Point*, Vector*)
- Tworzy obiekt reprezentujący
prostą o podanym wektorze
kierunkowym, która przechodzi
przez dany punkt
Line::
Line()
Linia
(Line*)
- Tworzy obiekt reprezentujący
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.
Symulator radaru statku powietrznego
48
Nazwa klasy::
Nazwa metody
Argumenty
(typy)
Wartość zwracana
(typy)
Opis
Plane::
Plane()
- - Tworzy obiekt reprezentujący
płaszczyznę
Plane::
Plane()
Parametry równania
ogólnego płaszczyzny
(float, float, float)
- Tworzy obiekt reprezentujący
płaszczyznę o podanych
parametrach równania ogólnego
Plane::
Plane()
Punkt, Punkt, Punkt
(Point*, Point*,
Point*)
- Tworzy obiekt reprezentujący
płaszczyznę przechodzącą przez
podane punkty
Plane::
Plane()
Płaszczyzna
(Plane*)
- Tworzy obiekt reprezentujący
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.
Praca inżynierska - Pawłowski Michał
49
Nazwa klasy::
Nazwa metody
Argumenty
(typy)
Wartość zwracana
(typy)
Opis
Triangle::
Triangle ()
- - Tworzy obiekt reprezentujący
trójkąt
Triangle::
Triangle ()
Punkt, Punkt, Punkt
(Point*, Point*,
Point*)
- Tworzy obiekt reprezentujący
trójkąt składający się z podanych
punktów
Triangle::
Triangle ()
Trójkąt
(Triangle *)
- Tworzy obiekt reprezentujący
trójkąt identyczny do podanego
Triangle::
getNormal()
- Wektor prostopadły
do trójkąta
(Vector*)
Zwraca wektor prostopadły do
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.
Symulator radaru statku powietrznego
50
Nazwa klasy::
Nazwa metody
Argumenty
(typy)
Wartość zwracana
(typy)
Opis
Quadrilateral::
Quadrilateral()
- - Tworzy obiekt reprezentujący
czworokąt
Quadrilateral::
Quadrilateral()
Punkt, Punkt, Punkt,
Punkt
(Point*, Point*,
Point*, Point*)
- Tworzy obiekt reprezentujący
czworokąt składający się z
podanych punktów
Quadrilateral::
Quadrilateral()
Czworokąt
(Quadrilateral*)
- Tworzy obiekt reprezentujący
czworokąt identyczny do
podanego
Quadrilateral::
belongs()
Punkt
(Point*)
Prawda/Fałsz
(bool)
Sprawdza, czy punkt należy do
czworokąta
Quadrilateral::
getNormal()
- Wektor prostopadły
do czworokąta
(Vector*)
Zwraca wektor prostopadły do
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.
Praca inżynierska - Pawłowski Michał
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)
- Tworzy obiekt reprezentujący
liczbę zespoloną o części
rzeczywistej i urojonej równej
podanym
Complex::
Complex()
Liczba zespolona
(Complex&)
- Tworzy obiekt reprezentujący
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&)
Odległość pomiędzy
dwoma liczbami
zespolonymi
(float)
Oblicza odległość pomiędzy
dwoma liczbami zespolonymi
Complex::
distance()
Liczba zespolona,
Liczba zespolona
(Complex&,
Complex&)
Odległość pomiędzy
dwoma liczbami
zespolonymi
(float)
Oblicza odległość pomiędzy
dwoma liczbami zespolonymi
Tabela 13. Metody publiczne klasy Complex.
Symulator radaru statku powietrznego
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.
Praca inżynierska - Pawłowski Michał
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.