This commit is contained in:
andrzej 2020-05-03 21:42:22 +02:00
commit 39e162df68

95
route_planning.md Normal file
View File

@ -0,0 +1,95 @@
#### Definicja pętli głównej przeszukiwania:
W algorytmie znajdowania najlepszej ścieżki wykorzystana została kolejka priorytetowa *PriorityQueue()* służąca do przechowywania wierzchołków do odwiedzenia. Dopóki nie jest ona pusta, działa pętla główna przeszukiwania. W pętli kolejno:
1. z kolejki wybierany jest wierzchołek o najniższym priorytecie
```python
while self.open:
_, current_node = self.open.get()
```
2. dodawany jest on do listy już przeszukanych wierzchołków
```python
self.closed.append(current_node)
```
3. sprawdzane jest czy aktualny wierzchołek jest jednocześnie celem, który miał zostać osiągnięty przez agenta
```python
if current_node.x == self.dest.x and current_node.y == self.dest.y:
while current_node.x != start_node.x or current_node.y != start_node.y:
self.path.append(current_node)
current_node = current_node.parent
return True
```
>(jeśli tak, od strony celu odtwarzana jest najkrótsza ścieżka prowadząca z aktualnego punktu do celu)
4. znajdowani są sąsiedzi danego wierzchołka, a następnie dla każdego z nich:
+ liczony jest koszt za pomocą funkcji heurystyki
```python
cost = current_node.g_cost + self.heuristic(current_node, neighbour)
```
+ sprawdane jest czy nie należy on do listy już przeszukanych wierzchołkow (jeśli tak, zostaje on pominięty)
```python
if self.check_if_closed(neighbour):
continue
```
+ jeśli znajduje się on już w kolejce priorytetowej ale z większym kosztem niż ten obecnie wyliczony, uaktualniony zostaje jego koszt oraz rodzic
```python
if self.check_if_open(neighbour):
if neighbour.g_cost > cost:
neighbour.g_cost = cost
neighbour.parent = current_node
```
+ w przeciwnym przypadku, zostaje on dodany do kolejki priorytetowej wraz ze swoim rodzicem oraz wyliczonym kosztem.
```python
else:
neighbour.g_cost = cost
neighbour.h_cost = self.heuristic(neighbour, self.dest)
neighbour.parent = current_node
self.open.put((neighbour.g_cost, neighbour))
```
#### Definicja funkcji następnika:
```python
def get_neighbours(self, node: Node):
neighbours = []
if self.check_if_can_move(Coordinates(node.x + 1, node.y)):
neighbours.append(Node(node.x + 1, node.y))
if self.check_if_can_move(Coordinates(node.x - 1, node.y)):
neighbours.append(Node(node.x - 1, node.y))
if self.check_if_can_move(Coordinates(node.x, node.y + 1)):
neighbours.append(Node(node.x, node.y + 1))
if self.check_if_can_move(Coordinates(node.x, node.y - 1)):
neighbours.append(Node(node.x, node.y - 1))
return neighbours
```
Funkcja zwracająca następników w naszym projekcie wykorzystuje sąsiedztwo von Neumanna. Sąsiadami danej płytki, są 4 najbliższe płytki znajdujące się od niej powyżej, poniżej, na prawo oraz na lewo.
Dla każdego z 4 potencjalnych sąsiadów sprawdzane jest najpierw czy takowy istnieje za pomocą funkcji *check_if_can_move*:
```python
def check_if_can_move(self, next_coords: Coordinates):
tile_on_map = 0 <= next_coords.x < self.warehouse.width and 0 <= next_coords.y < self.warehouse.height
if not tile_on_map:
return False
next_tile = self.warehouse.tiles[next_coords.x][next_coords.y]
tile_passable = isinstance(next_tile, Tile) and next_tile.category.passable
return tile_passable
```
Funkcja ta sprawdza czy wybrany sąsiad znajduje się w obrębie magazynu i czy jest on płytką po której może przemieszczać się agent.
#### Definicja funkcji heurystyki:
```python
def heuristic(self, start: Node, goal: Node):
diff_x = pow(goal.x - start.x, 2)
diff_y = pow(goal.y - start.y, 2)
return round(sqrt(diff_x + diff_y), 3)
```
w naszym projekcie jako heurystyki używamy funkcji liczącej odległość euklidesową pomiędzy dwoma wybranymi punktami, z których drugi jest aktualnym celem który agent ma osiągnąć.